Podstawy programowania w języku C i C++. Tematy:

Makrodefinicje, operacje na znakach. Instrukcje warunkowe if … else; switch. Instrukcje iteracji: while, do…while, for.

Cele nauczania: Podstawowe zasady programowania. Praktyczna znajomość elementów programowania w języku C/C++Docelowo : Opracowanie algorytmu wybranego zadania geodezyjnego i przedstawienie go w postaci schematu blokowego. Opracowanie programu w wybranym języku programowania Wykonanie dokumentacji programu .Szczegółowe dla lekcji: Zapoznanie się z makrodefinicjami, podstawowymi operacjami na znakach, instrukcjami warunkowymi i instrukcjami iteracji. Praktyczne wprowadzanie, uruchamianie i kompilacja programów z tymi instrukcjami.

Cele operacyjne lub szczegółowe cele kształceniaPo zakończeniu lekcji uczeń będzie umiał:stosować podstawowe proste makrodefinicje i operacje na znakach w C oraz instrukcje warunkowe i iteracje.

Część wstępnaCzęść wstępna - organizacyjna:

przywitanie, sprawdzenie obecności, wpisanie tematu lekcji. -

Część merytoryczna Ogniwo 1. Uświadomienie uczniom celów – pogadanka

Celem zajęć jest zapoznanie się z pojęciem makrodefinicji, podstawowymi operacjami na znakach i łańcuchach znaków oraz instrukcjami warunkowymi if…else, switch i iteracyjnymi: while, do…while, for.

Po 2 lekcjach : wpisuje i uruchamia programy, stosując proste makrodefinicje, operacje na znakach i instrukcje warunkowe oraz iteracyjne.

Ogniwo 2 Poznanie nowych faktów – pogadanka

• W języku C i C++ można stosować dyrektywy preprocesora #define - tzw. makrodefinicje – stałe symboliczne i makrorozwiniecia.

• Stała symboliczna jest nazwą zastępującą łańcuch znaków. Może być stała numeryczna, znakowa lub tekstowa. Np. #define PI=3.141596.

• Do podejmowania decyzji w programie służą instrukcje warunkowe if, if…else oraz instrukcja wyboru switch…case.

• Do organizacji obliczeń cyklicznych stosuje się pętle while, do…while, for, instrukcję zaniechania break, kontynuowania continue.

Ogniwo 3. Kształtowanie pojęć, poznawanie, systematyzowanie wiedzy -Przypomnienie podstawowych elementów języka C:Programy w C mają rozszerzenia plików C a w C++ rozszerzenie CPP. Po skompilowaniu program ma rozszerzenie EXE.Polecenia kończymy średnikiem. Kod funkcji umieszcza się w nawiasach klamrowych. Rozróżniane są w C duże i małe litery. Stałe oznaczamy zwykle dużymi literami. W definicji poprzedzone słowem constKomentarze typu /* … */ w C i C++ mogą być wielo-liniowe oraz typu // w jednej linii w C++ Program zawiera zawsze: funkcję main(). Na końcu funkcji main jest zwykle return 0;. Zwykle program zawiera nagłówek jako komentarz,, dyrektywy preprocesora , zwłaszcza #include, czasem #define – stałe i makroinstrukcje.Przed funkcją główną mogą być zadeklarowane lub zdefiniowane stałe, zmienne globalne oraz funkcje.Zmienna musi być zadeklarowana prze użyciem. Aby zatrzymać program, używamy funkcji getch();. Do czyszczenia ekranu służy funkcja clrscr();. W tekście możemy używać tzw. znaków specjalnych, np. przejście do następnej linii \n. Program składa się z ciągu instrukcji rozdzielonych średnikami Instrukcje położone są pomiędzy słowami kluczowymi { i }Instrukcje mogą zawierać wyrażenia oraz wywołania funkcji.Wyrażenia składają się ze stałych, operatorów i identyfikatorów (nazwa stałych, zmiennych, funkcji). Identyfikatory są nazwami obiektów składających się na program. Mogą one zawierać litery, cyfry i znaki podkreślenia, nie mogą jednak zaczynać się od cyfr. Mogą zaczynać się od liter lub znaku _

Podstawowe typy danych w jezyku C

• W języku C każda zmienna ma swój typ, który musi być określony przed pierwszym użyciem.

• Istnieją wbudowane i zdefiniowane przez użytkownika typy danych.• W języku C wyróżniamy następujące podstawowe wbudowane typy zmiennych.

– char – typ znakowy - jednobajtowe liczby całkowite, służy do przechowywania znaków (1 Bajt);

– int- liczby całkowite - typ całkowity, o długości domyślnej dla danej architektury komputera (2 B);

– float – liczby rzeczywiste - typ zmiennopozycyjny (zwany również zmiennoprzecinkowym), reprezentujący liczby rzeczywiste (4 Bajty);

– double – liczby rzeczywiste - typ zmiennopozycyjny podwójnej precyzji (8 B);• Specyfikatory – signed, unsigned, short, long - słowa kluczowe, które zmieniają

znaczenie– short - liczby całkowite krótkie – long - liczby całkowite długie – long double - liczby zmiennoprzecinkowe podwójnej precyzji długie

Typy zmiennych, zakresy, rozmiar, zapis

Zapis liczb: dziesiętne, z kropką dziesiętną i ewentualnie E (postać m*10^c)ósemkowe z 0 na początku, szesnastkowe z 0x na początku.

Operatory można pogrupować wg cech funkcjonalnych na grupy:

• operatory arytmetyczne: +, -, *, /, % (dzielenie modulo - reszta)

• operatory porównania – relacyjne: ==, !=, <, >, <=. >+ • operatory logiczne: && (and), || (or), ! (not) • operatory bitowe • operatory przypisania: =, += (a=+b a=a+b), -=, *=, /+, %=… • operatory unarne inkrementacji i dekrementacji: ++, --

np. x++; x--; ++x; --x;• operatory rozmiaru: sizeof(obiekt) • operatory konwersji: (nazwa typu) wyrażenie • operator warunkowy: Op1 ? Op2: Op3; • operator przecinkowy: Op1, Op2, ..., Opn • operatory wskazywania ->

Najczęściej używane operatory:

Inne operatory: • Operator przecinkowy (,), stosowany w instrukcjach cyklu for

a także w wywołaniach funkcji. Para wyrażeń oddzielonych operatorem obliczana jest od lewej do prawej. Rezultatem jest wyrażenie po prawej stronie. Ogólny zapis: wyrażenie po lewej, wyrażenie po prawej

Instrukcja for z operatorem przecinkowym: for (wyr1; wyr2; wyr3a; wyr3b) { instrukcje} np. int i, j; for(i=0; j=10; j>=0; i++; j--) {printf(„\n %2i %2i %6.3f %6.3f, i, j, sqrt((double) i), sin((double) j)); }

Przykład wywołania funkcji: f(a, b, (k=2, k+7), d) – wywołanie funkcji z 4 argumentami, trzeci ma wartość 9.

• Operatory wskazywania: & operator adresu, - adres zmiennej np. &count – adres zmiennej count* operator adresowania pośredniego, . operator składowej, -> operator wskaźnikowy składowej

• Operatory wejścia >> i wyjścia << w C++

Priorytety operatorów, kolejność wykonywania działań:

• Nawiasy mają najwyższy priorytet. • Mnożenie i dzielenie mają pierwszeństwo

przed dodawaniem i odejmowaniem.Dzielenie jest równoprawne z mnożeniem.

• W przypadku jednakowego priorytetu operatorów o priorytecie decyduje kolejność ich występowania w wyrażeniu – od lewej do prawej strony.

Instrukcje wejścia i wyjścia w języku C:

Wejście i wyjście programu• Do podstawowych funkcji języka C, umożliwiających

komunikację z otoczeniem należą:dla operacji wyjścia: putchar, puts, printf;dla operacji wejścia: getchar, gets, scanf;• W DOS, wyniki wysyłane na ekran mogą być przy pomocy znaku

potoku wysłane do pliku lub na drukarkę.Np. program.exe > Wynik.txt do pliku, usunięcie istniejącegoprogram.exe >> wyniki.txt do pliku – dopisanie do istniejącegoprogram.exe > PRN na drukarkę

Kody sterujące

• Kody sterujące: kod nowego wiersza: \n np.

puchar(‘\n’); kod tabulacji: \t kod powrotu karetki \rKod cofania \b kod wysunięcia strony \fkod dzwonka \a

putchar(‘\a’); lub \007

• Znaki specjalne: \’ – wyświetla apostrof, \” – cudzysłów, \\ - backslash, \007 – dzwonek

/* Program dzwonki.c */#include <iostream.h>#include <conio.h>#define BELL 7#define DZWONEK '\007'void main() {int a, b, c;putchar ('\a'); getch();putchar('\007'); getch();putchar('\7'); getch();putchar('\x7'); getch();putchar(DZWONEK); getch();putchar(BELL);getch();}

Funkcja printf() - uniwersalna• Funkcje puts() i puchar() mogą wyświetlić tylko jedną rzecz: łańcuch znaków

lub znak i nie mogą wyświetlić wartości liczbowych.• Funkcja printf() jest bardziej uniwersalna. Może wyświetlić dane dowolnego

typu i współpracować z wieloma argumentami.• Wyprowadza wynik przetwarzania w różnych formatach.• printf (łańcuch_sterujący, lista _danych_argumentów); lub inaczej

printf(ciag_formatujący, lista parametrów); • Ciąg formatujący jest zwykłym ciągiem znaków do wyświetlenia na ekranie.

Jednak niektóre znaki mają funkcję specjalną i nie zostaną one po prostu wyświetlone. Takim właśnie znakiem jest znak % . Gdy funkcja printf() go napotka to wie, że po nim wystąpi określenie rodzaju argumentu i formatu jego wyświetlenia na ekranie.

/* Przykład: getchar1.c */#include <stdio.h> #include <conio.h>int main(void) { int inicjal; puts("Podaj swoj inicjal "); inicjal=getchar(); putchar(inicjal); putchar('\n'); printf("Twoj inicjal to %c. Jego kod ASCII: %i ",inicjal, inicjal); getch(); }

Formaty realizowane przez funkcję printf() (znaki typu w łańcuchach formatujących)

Wyprowadzanie danych w języku C++: cout <<

• Polecenie cout z operatorem wyjścia << , czyli cout << • W C++ poza powyższymi istnieje dodatkowy sposób wyprowadzania

informacji wszystkich typów:Instrukcja cout << wyświetla wartości literałów, stałych i zmiennych bez konieczności korzystania ze specyfikatorów formatowania.

• Do wykorzystania polecenia cout należy w dyrektywie #include wyspecyfikować plik iostream.h

• Polecenie cout języka C++#include <iostream.h>cout << lista_danych; // np. cout << "Masz " << wiek << "lat " << ‘\n’;cout << „łańcuch”; // cout << "Cześć, nazywam się Jan Nowak. My się znamy "cout << nazwa_stałej; // char nazwisko[]=”Jan Nowak”; cout << nazwisko; cout << nazwa_zmiennej; // cout << wiek;

Operacje wejścia wprowadzanie danych w C i C++• Do wczytywania danych stosuje się instrukcje

getchar(), gets(), scanf() w C i C++ oraz cin >> w C++ • Funkcja gets() służy do wczytania pojedynczej linii.

Np. char linia[80]; gets(linia);• getchar umożliwia wprowadzenie pojedynczego znaku

Np. char znak; znak=getchar(); putchar(znak);• scanf() to uniwersalna funkcja do wprowadzania wszelkiego typu

informacji. Składa się z łańcucha sterującego i listy danych. scanf(„lancuch_sterujacy”,lista_danych);Np. float ilosc; scanf(„%f”,&ilosc);Łańcuch sterujący zawiera specyfikatory formatowania – jak będą interpretowane dane wejściowe.

• Specyfikatory formatowania: %d – wprowadza liczbę całkowitą, %u – liczba bez znaku, %f – liczba float, %e – liczba w systemie wykładniczym, %g – liczba dziesiętna w najkrótszym zapisie, %c – dana znakowa char, %s – łańcuch znaków, %o – liczba ósemkowa, %x – liczba szesnastkowa

Specyfikatory formatowania• %d – wprowadza liczbę całkowitą, • %u – liczbę całkowitą bez znaku, • %f – liczba rzeczywista typu float, • %c – znak, • %s – łańcuch, • %o - liczba ósemkowa, • %x – liczba szesnastkowa, • %e – liczba w zapisie wykładniczym, • %g – liczba dziesiętna w najkrótszym zapisie.• Wzorzec konwersji określa typ zmiennej, którą wpiszemy z

klawiatury lub wypiszemy na ekranie.

Tabela: deklaracje zmiennych określonego typu, wzorce konwersji, przykłady

Typ zmiennej Deklaracja WzorzecPostać funkcji scanf()

Postać funkcji printf()

liczba całkowita int A %d scanf("%d",&A); printf("Liczba A wynosi: %d",A);

liczba rzeczywista float B %f scanf("%f",&B); printf("Liczba B wynosi: %f",B);

ciąg znaków char *C %s scanf("%s",&C); printf("Łańcuch ma postać: %s",C);

pojedynczy znak char D %c scanf("%c",&D); printf("Znak D to: %c",D);

/* Program kalk1.c – prosty kalkulator, dane liczby całkowite*/#include <stdio.h> #include <conio.h> int main() /* funkcja główna */{ int a,b; /* deklaracja zmiennych całkowitych a i b */int suma,roznica,iloczyn; float iloraz; /* deklaracje zmiennych */clrscr(); /* kasowanie ekranu */printf("Prosty kalkulator\n"); /* nagłówek */printf("\nPodaj liczbe a: "); scanf("%d",&a); /* wczytanie liczby a */printf("Podaj liczbe b: "); scanf("%d",&b); /* wczytanie liczby b */suma=a+b; roznica=a-b; iloczyn=a*b; /* obliczenia */iloraz=(float)a/(float)b; /* operator rzutowania w dzieleniu */printf("\nWyniki dzialan:\n"); printf("\nSuma: %d ",suma); printf("\nRoznica: %d ",roznica);printf("\nIloczyn: %d ",iloczyn); printf("\nIloraz: %f ",iloraz); getch(); return 0 ;}

Podsumowanie: operatory, instrukcje wejścia, wyjścia

• Podstawowe typy danych: char, int, float, long double specyfikatory long, signed, unsigned, short, long.

• Zapis liczb dziesiętnych, ósemkowych, szesnastkowych, znaków, kody sterujące (\n, \t, \f, \a – BEL, \r, \0 – nul, \’ itd.) Operatory: arytmetyczne, zwiększania i zmniejszania ++, --, relacyjne : <, <=, >, >=, ==, !=, logiczne (!, && - and, || - lub), przypisania =, wieloznakowe operatory przypisania (a#=b; czyli a=a#b; np. a+=b; a=a+b:), operator rozmiaru sizeof, operator konwersji (typ) wyrażenie, np. (float) (21/10);operator warunkowy wyr_warunkowe ? wyr_na_tak: wyr_na_nie (np. z = (a>b)? a:b; /* z=max(a,b) */

• Instrukcje wejścia wyjścia: Wyświetlenie na ekranie: puchar(znak) – znak, puts(napis) - łańcuch znaków, printf(„łańcuch formatu”, argumenty); Wyprowadzanie wyników w C++: cout << lista, np. cout << „Wynik: „ << cout a << endl;Wprowadzanie danych: znak=getchar() – pojedynczy znak; gets(zmienna_łańcuchowa); - napis (do klawisza Enter),scanf(„łańcuch sterujący”, lista_danych) – uniwersalna funkcja do wprowadzania informacji wszelkiego typu.Wprowadzanie danych w C++: cin >> zmienna

Podsumowanie – wejście, wyjście, liczby, zmienne, wzorce konwersji • Aby wczytać liczbę należy użyć funkcji scanf w postaci:

scanf("wzorzec",&zmienna);• Aby wypisać wczytaną w ten sposób liczbę należy użyć funkcji

printf, która służy do wypisywania komunikatów. Postać funkcji: printf("Komunikat wzorzec",zmienna);

• W funkcji scanf zawsze przed nazwą zmiennej używamy znaku &, a nie robimy tego przy używaniu funkcji printf.

• Zmienna służy do przechowania danych, których wartość ustala się w trakcie działania programu i może być zmieniana.

• Każda zmienna musi być zadeklarowana przed jej użyciem jako zmienna odpowiedniego typu: int, float, char itp.

• Do wypisywania komunikatów służy funkcja printf, lub puts a do wczytywania zmiennych funkcja scanf.

• Do poprawnego użycia obu funkcji należy znać podstawowe wzorce konwersji: %d, %f, %s.

Preprocesor, dyrektywy, funkcje biblioteczne CPreprocesor przetwarza wiersze programu rozpoczynające się znakiem #.Taki wiersz nazywamy dyrektywą preprocesora.Podstawową dyrektywą jest #include, umożliwiająca dołączenie do programu pliku o podanej nazwie. Ma 2 postacie: #include <nazwa> i #include „nazwa”Nazwa w nawiasach kwadratowych oznacza plik nagłówkowy dostępny w systemie C, natomiast w cudzysłowie plik zdefiniowany przez użytkownika.W C istnieje duża biblioteka funkcji standardowych, czyli dostępnych bezpośrednio w systemie. Zawarte są w tzw. modułach.

Moduły biblioteczne dołącza się przez instrukcję #include <nazwa>. Standardowo dołączamy stdio.h w C a iostream.h w C++Procedura clrscr() zawarta w module conio.humożliwia wyczyszczenie ekranu. W math.h zdefiniowane jest np. M_PI (czyli PI)Dyrektywa #define , np. #define NMAX 20 definiuje stałą NMAX o wartości 20.

Stałe symboliczne

Stała symboliczna jest nazwą zastępującą ciąg znaków#define NAZWA tekstNp. #define PI 3.1415926#define MIEJSCOWOSC Sosnowiec#define WYNIK printf(("Pole=%d\f %”,pole1)#define WZOR1 (a*b)

Stałe symboliczne - makrodefinicje• Stała symboliczna jest nazwą przedstawiającą inną stałą - numeryczną, znakową

lub tekstową. Definicję stałej symbolicznej umożliwia instrukcja #define:#define NAZWA tekstgdzie NAZWA jest nazwą stałej symbolicznej, a tekst jest związanym z tą nazwą łańcuchem znaków

• Przykłady:

Makrodefinicje proste:#define identyfikator <ciąg-jednostek-leksykalnych>#define PI 3.14159#define TRUE 1#define FALSE 0#define NAPIS1 Siemianowice#define IMIE "Andrzej" // (puts(IMIE) rozwija w tekst puts("Andrzej") #define IMIE_I_NAZWISKO IMIE+"Zalewski" #define WCZYTAJ_IOSTREAM_H #include <iostream.h>

Makrodefinicje parametryczne• #define identyfikator(idPar1, idPar2,...) ciąg_jedn_leksykalnych• Np.• #define ILORAZ(a,b) ((a)/(b))

//- makrodefinicja ILORAZ – parametry a i b w nawiasach!• #define SUMA(a,b) ((a)+(b))• W trakcie kompilacji nazwy stałych symbolicznych są

zastąpione przez odpowiadające im łańcuchy znaków. Ułatwia to parametryzację programu, a także umożliwia zastępowanie często niewygodnych w pisaniu sekwencji programu, tworzenie makrodefinicji

/* Program Szablon1.c */

/* #include - włączenia tekstowe bibliotek */

#include <stdio.h> /* prawie zawsze np. do printf() */

#include <conio.h> /* np. do getch() */

#include <math.h>

/* #define - stale makroinstrukcje */

#define PROGRAM "program.c"

#define NAZWISKO "Nowak Jan"

#define ROK 2011

#define SZKOLA "Sztygarka"

#define KLASA "2BG"

#define NL printf("\n");

#define TAB putchar('\t');

#define PI 3.141592653

#define KRESKA puts("------------------------------")

#define KRESKA2puts("================");

#define KONIEC puts("\n\nNacisnij cos ")

/* zmienne globalne - stale, zmienne */const double pi=3.14159265;const char szkola[]="Sztygarka";/* Przykladowa funkcja - deklaracja */float suma1(float l1, float l2);

/* ========== Funkcja główna * ======== */int main() { clrscr(); printf("Program: %s \n",PROGRAM); KRESKA2; puts(NAZWISKO); puts(KLASA); puts(SZKOLA); KRESKA; /* -- dalszy kod programu głównego */ /* -------------------------------------------- */ KONIEC; getch(); return 0; }

/* =========== Funkcje - definicje ======= */float suma1(float l1, float l2) /* Definicja funkcji */{ return(l1+l2);}

Szablony programu dla ucznia – dane wpisane w #define

/* Schemat programu do obliczeń geodezyjnych *//* Program Szablgeo.c *//* preprocesor: #include - wlaczenia tekstowe bibliotek */#include <stdio.h> /* prawie zawsze c C, np. do printf() */#include <conio.h> /* np. do getch() */#include <math.h>/* #define - stale makroinstrukcje */#define PROGRAM "program.c"#define NAZWISKO "Nowak Jan"#define ROK 2011#define SZKOLA "Sztygarka"#define KLASA "2BG"#define NL printf("\n");#define TAB putchar('\t');#define PI 3.141592653#define ROG 63.66197724#define ROS=57.2957795130;#define KRESKA puts("------------------------------------------------")#define KRESKA2puts("=============================");#define KONIEC puts("\n\nNacisnij cos ")#define KATRAD(g) ((g)/(ROG))#define KATGRAD(r) ((r)/(ROS))

/* zmienne globalne - stale, zmienne */const double pi=3.14159265;const double rograd=63.66197724, rostop=57.2957795130823; /* Ro[grad]=200/PI, Ro[stopn]=180/POconst char szkola[]="Sztygarka";

/* Przykladowa funkcja - deklaracja */float suma1(float l1, float l2);

/* ========== Funkcja glowna * ======== */int main() { clrscr(); printf("Program: %s \n",PROGRAM); KRESKA2; puts(NAZWISKO); puts(KLASA); puts(SZKOLA); KRESKA; printf("63.66198[grad]=%f[rad]",KATRAD(rograd)); /* -- dalszy kod programu, głównego. -- */ KONIEC; getch(); return 0; }

/* =========== Funkcje - definicje ======= */float suma1(float l1, float l2) /* Definicja funkcji */{ return(l1+l2);}

Szablon programu do obliczeń geodezyjnych

Stałe wyliczeniowe (enumeration constant)• Stałe wyliczeniowe tworzą zbiór stałych o określonym zakresie

wartości. • Wyliczenie jest listą wartości całkowitych, np.

enum boolean {NO, YES};Pierwsza nazwa na liście wyliczenia ma wartość 0, następna 1 itd., chyba że nastąpi jawnie podana wartość.

• Przykłady:enum KOLOR {CZERWONY, NIEBIESKI, ZIELONY, BIAŁY, CZARNY}enum KOLOR {red=100, blue, green=500, white, black=700}; red przyjmie wartość 100, blue 101, green 500, white 501, black 700

Operacje na znakach i łańcuchach znaków• Typy znakowe: - deklaracja: char zmienna;

pojedynczy znak: char znak; np. char zn1=‘a’; char litera; litera = ‘F’;łańcuch znaków (napis, słowo) – char *napis; np. char *str1=„Programowanie”;– char napis[n]; np. char linia[80]; gets(linia);

char imie[20]; scanf("%s",imie); – np.char napis[]="Tekst”,

np. char pozdrowienie="Jak się masz”• Wzorzec konwersji przy wyświetleniu lub wczytywaniu zmiennej typu

char– %c dla pojedynczego znaku (łańcucha jednoznakowego)

np. char znak1; scanf("%c",&znak1); – %s dla łańcucha dłuższego niż 1 znak

np. char slowo2[20]; scanf("%s",slowo2);

/* Program znaki1.c */#include <stdio.h> #include <conio.h>#include <string.h>main (void) { char znak1,znak2,znak3; //deklaracja znaków char slowo1[10], slowo2[15]; char slowo3[]="Adam"; // definicjaclrscr(); // czyszczenie ekranuznak1='a'; // inicjalizacja zmiennej znak1znak2=102; // znak w postaci kodu dziesiętnego ASCII - litera fprintf("Podaj znak3: "); scanf("%c",&znak3); // podajemy jakiś znakprintf("\nPodaj slowo1: "); scanf("%s",slowo1); // wpisujemy słowo 1printf("\nPodaj slowo2: "); scanf("%s",slowo2); // wpisujemy słowo 2printf("\nZmienne zawieraja znaki: ");printf("znak1 (a), znak2 (102), znak3 (wprowadzony): %c %c %c ",znak1,znak2,znak3);printf("\noraz slowa: ");printf("slowo1, slowo2, slowo3: %s %s %s ",slowo1, slowo2, slowo3);getch(); return 0 ; }

Przypisanie wartość zmiennej znakowej i napisom• Przypisać wartość zmiennej jednoznakowej możemy

na kilka sposobów: – w apostrofach: zmienna='a'; – poprzez przypisanie kodu znaku: zmienna=97; – poprzez wczytanie znaku z klawiatury funkcją scanf():

scanf("%c",&zmienna); • Przypisanie wartości do zmiennej dla łańcucha

znaków dłuższego niż jeden znak odbywa się podobnie jak w pierwszym przypadku, z tą jednak różnicą, że zamiast apostrofów ' należy używać cudzysłowia " char slowo3[]="Adam"; // definicja

Odczytanie długości łańcucha znaków – strlen(lancuch)/* dluglanc.c */#include <stdio.h> #include <conio.h> #include <string.h> main (void) { int dlugosc; char *lancuch; clrscr();lancuch="Adam Nowak"; dlugosc=strlen(lancuch); printf("Lancuch '%s' ma: %d znaków \n",lancuch, dlugosc); printf("Pierwsza litera łańcucha to: %c \n",lancuch[0]); printf("Ostatnia litera łańcucha to: %c \n",lancuch[dlugosc-1]); getch(); return 0 ; }

Inne funkcje operujące na łańcuchach: strlwr, strupr, strcat, strrv, streset – z biblioteki string.h

/* znaki5.c - operacje na tekstach */#include <stdio.h> #include <conio.h> #include <string.h> main (void) { char *lancuch1, *lancuch2, *lancuch3; char znakwyp='x'; // znak wypełniającyclrscr();puts("Operacje tekstowe\n");lancuch1="Janusz";lancuch2="Kowalski";printf("Lancuch1 to: %s \n",lancuch1); printf("Lancuch2 to: %s \n",lancuch2); printf("\nZmieniamy duze litery na male: \n"); strlwr(lancuch1); printf("Lancuch1 wyglada teraz tak: %s \

n",lancuch1);

printf("\nZmieniamy male litery na duze: \n"); strupr(lancuch2); printf("Lancuch2 wyglada teraz tak: %s \n",lancuch2); printf("\nLaczymy dwa lancuchy: \n" );lancuch3=strcat(lancuch1,lancuch2); printf("Lancuch3 wyglada teraz tak: %s \n",lancuch3); printf("\nOdwracamy kolejnosc znakow w lancuchu: \n" );strrev(lancuch3); printf("Lancuch3 wyglada teraz tak: %s \n",lancuch3); printf("\nWypelniamy lancuch znakiem 'x':\n" );strset(lancuch3,znakwyp);printf("Lancuch3 wyglada teraz tak: %s \n",lancuch3); getch(); return 0 ; }

strcat() - łączy dwa łańcuchy, strcmp() - porównuje dwa łańcuchy rozróżniając małe i duże litery, strlwr() i strupr() - zamienia w danym łańcuchu duże litery na małe i odwrotnie, strrev() - odwraca kolejność znaków w łańcuchu, strset() - wypełnia łańcuch danym znakiem.

Podsumowanie – znaki, łańcuchy znaków 1. Zmienne liczbowe mogą zawierać się w pewnych zakresach, których nie można

przekraczać. 2. Deklaracja zmiennej znakowej: char znak; a zmiennej łańcuchowej: char *slowo; 3. Wartość zmiennej znakowej można przypisać w programie poprzez umieszczenie

znaku w apostrofach lub przez napisanie jego kodu. 4. Wartość zmiennej łańcuchowej można przypisać w programie poprzez umieszczenie

napisu w cudzysłowie. 5. Zmienne znakowe i łańcuchowe można wczytywać z klawiatury używając funkcji

scanf() i odpowiednich wzorców konwersji: %s dla ciągu znaków i %c dla pojedynczego znaku.

6. Każdy znak posiada swój kod ASCII. 7. Kod ASCII mają również znaki nie przedstawione na klawiaturze komputera. np. ß, ö. 8. Łańcuch, który wygląda jak liczba nie jest liczbą.

Istnieją funkcje, które potrafią przekonwertować łańcuch liczbowy do postaci liczby. 9. Mając dany łańcuch, możemy odczytać dowolny jego znak używając nawiasów

kwadratowych. Pierwszy wpisany znak ma numer 0, a nie 1. 10. Każdy ciąg kończy znak '\0'. 11. Długość łańcucha można ograniczyć przy deklaracji, np.: char slowo[10]; 12. Łańcuchy można ze sobą porównywać, łączyć, odwracać w nich kolejność liter,

zmieniać małe litery na duże i odwrotnie, a także przeszukiwać, kopiować na siebie itp. Nazwy funkcji, które to wykonują zawsze zaczynają się na 'str' (z angielskiego: string).

Zasięg zmiennej• Zmienne globalne - obejmujące zasięgiem cały program – mogą być

dostępne dla wszystkich funkcji programu. Deklaruje się je przed wszystkimi funkcjami programu:

• Zmienne globalne, jeśli programista nie przypisze im innej wartości podczas definiowania, są inicjalizowane wartością 0.

• Zmienne lokalne – o zasięgu obejmującym pewien blok.Zmienne, które funkcja deklaruje do “własnych potrzeb” nazywamy zmiennymi lokalnymi.

• Pytanie: Czy jest błędem nazwanie tą samą nazwą zmiennej globalnej i lokalnej?. Nie. Natomiast w danej funkcji da się używać tylko jej zmiennej lokalnej. Tej konstrukcji należy, unikać.

int a=1; /* zmienna globalna */int main(){int a=2; /* to już zmienna lokalna – gdyby nie ta definicja to a =1 */printf("%d", a); /* wypisze 2 (gdyby nie było powyższej instrukcji to 1)*/}

Biblioteki, procedura, funkcja

• Biblioteki (moduły) - zapisane są w nich różne funkcje i procedury do użycia w programie.

• Funkcja - jest to podobnie jak procedura, pewien wyraz, który nie dość że coś wykona to również zwróci nam rezultat tego co zrobił, przykładowymi funkcjami są: pierwiastkowanie, sinus, cosinus. Zwracaną wartością niekoniecznie musi być liczba może to być również inny rodzaj zmiennych.

Typy char (C) bool, string (C++)• TYP ZNAKOWY - CHAR - typ ten przyjmuje dowolny pojedynczy

znak o kodach ASCII (0..255) np. znak ‘A’ czy ‘!’

• W C łańcuchy reprezentuje się jako tablice znaków char slowo[dlug] a operacje na nich wykonuje z użyciem wskaźników.

• TYP LOGICZNY - bool- typ ten może przyjmować jedynie dwie wartości: true (prawda) – 1 lub false (fałsz) - 0 #include <stdbool.h> int main(){ bool b = false; b = true; }

• W C++ oprócz tradycyjnych ciągów znaków w stylu C istnieje w bibliotece standardowej klasa std::string. Ukrywa ona niewygodne aspekty używania napisów w stylu C: zarządzanie pamięcią, określanie długości, łączenie napisów, wstawianie, usuwanie i inne manipulacje na napisie. Dodatkowo pozbyto się problemu znaku kończącego - znak o kodzie \0.

INSTRUKCJE STERUJĄCE

• PODEJMOWANIE DECYZJI W PROGRAMIE– Instrukcja warunkowa if…else;– Instrukcja wyboru switch

• ORGANIZACJA OBLICZEŃ CYKLICZNYCH - INSTRUKCJE PĘTLI:– Instrukcja pętli while– Instrukcja pętli do … while– Instrukcja pętli for

Instrukcja warunkowa if… [else...] • Pozwala na wykonanie lub zaniechanie wykonania pewnych czynności, w

zależności od konkretnego warunku logicznego.

• Instrukcja ma następującą składnię: if (warunek) instrukcja;np. if (x>30) y=20;If (warunek) {instrukcja_1; instrukcja_2; … instrukcja_N;}np. if (min <x) {min=x; nr=i;}

• Instrukcja ta sprawdza czy jest spełniony warunek postawiony po „if", jeżeli tak to wykonywana jest instrukcja lub ciąg instrukcji w nawiasach { }

• Można jeszcze też użyć słowa else oznaczającego "w przeciwnym wypadku” If (warunek) instrukcja_1; else instrukcja_2; np. if (a>0) c=b+2; else c=b-3;If (warunek) {instrukcja_1; instrukcja_2; … instrukcja_N;}else {instrukcja_A; instrukcja_B; … instrukcja_Z;}

// if1a.c – instrukcja if#include <stdio.h>#include <conio.h>#include <math.h>Int main (void){float liczba1, x;clrscr();x=0;printf("Podaj liczbe dodatnia: \n");scanf("%f",&liczba1); if (liczba1 >=0) x=sqrt(liczba1);

printf ("Pierwiastek z %f = %f", liczba1, x);getch();return 0 ; }

jesli Warunek to Instrukcja; if (W) I;

jeśli W to Instrukcja1 w przeciwnym przypadku Instrukcja2; if (W) I1; else I2;

// program if1b.cpp#include <iostream.h>int Latka;int main() { cout << "Program dla dorosłych \n Ile ty masz lat?\n"; cin >> Latka; if (Latka < 18) cout << "Jesteś, małolatem \n"; else cout << "Jesteś dorosły; \n";return 0;}

// program if1.c #include <stdio.h> #include <conio.h> Int main () { int liczba1,liczba2; clrscr();  printf("Podaj pierwszą liczbę: \n"); scanf("%d",&liczba1);  printf("Podaj drugą liczbę: \n"); scanf("%d",&liczba2);  if (liczba2==0) // operator ==printf("Nie wolno dzielić przez 0!\n"); elseprintf("Wynik dzielenia: %f\ n", (float) liczba1/liczba2); getch(); return 0 ; }

Przykłady programów z if

/* Program If1cpp. cpp C++*/;#include <iostream.h>#include <conio.h>int main()

{int a;

cout << "Podaj liczbe calkowita >0 "; cin >> a; if (a<0) return 1; //wyjscie awaryjne z

systemu cout << "OK"; getch(); return 0; // wyjscie normalne}

/* Program If-else1.cpp */;#include <iostream.h>#include <conio.h>int main(){int a;cout << "Podaj liczbe calkowita > 0 ==> "; cin >> a;if (a<0) cout << "a < 0";else cout << "a >=0 ";getch();return 0;}

/* Program if1c.c język C */#include <stdio.h>#include <conio.h>int main(){ int a; printf("Podaj liczbe calkowita >0 "); scanf("%d",&a); if (a<=0) return 1; /* wyjście awaryjne z systemu */

printf("OK! a = %d >=0",a); getch(); return 0; }

/* Program if-else1.c */;#include <stdio.h>#include <conio.h>int main(){int a;puts("Podaj liczbe calkowita > 0 ");scanf("%i", &a);if (a<=0) printf("a = %d <= 0",a);else printf("a = %d >= 0",a);getch();return 0;}

Ogólna składnia if.. elseif (warunek_logiczny) { instrukcje_do_wykonania } else if (inny_warunek_logiczny) { instrukcje_do_wykonania } else { instrukcje_do_wykonania }• Po słowie kluczowym if, w nawiasie umieszcza się warunek.

Jeśli jest prawdziwy, program przechodzi do wykonywania kodu w klamrach. Co jeśli warunek jest fałszywy? Wtedy program sprawdza kolejne warunki (każdy następny to już nie if, lecz else if) aż do napotkania wartości prawdziwej, po której wykonywany jest kod w klamrach. Jeśli wszystkie wartości będą fałszywe, program wykona kod umieszczony w klamrach po instrukcji else.

// Program if2.cpp C++#include <iostream.h> int main(){ int wiek = 0; char a; cout << "Podaj ile masz lat "; cin >> wiek;

if (wiek > 18) // Jeśli wprowadzona liczba jest większa od 18 { cout << "Jesteś już dorosły!" << endl; } else if (wiek < 18) // Jeśli wprowadzona liczba jest mniejsza od 18 { cout << "Nie jesteś jeszcze dorosły!" << endl; } else // Jeśli wprowadzona liczba jest równa 18 { cout << "Masz równo 18 lat więc jesteś już dorosły!" << endl; } cin >> a; // wprowadzenie jakiegoś znaku return 0;}

Przykładowy program - zagnieżdżone instrukcje if - obliczenie podatku

/* Program podatek.c */#include <stdio.h> /* brackets.c */ void main() {

float income; printf("Podaj sumę przychodów: "); scanf("%f", &income);

if (income < 20000.00) puts("Podatek wynosi 15%"); else // >= 20000

if (income < 100000.00) // [20000, 100000) puts("Podatek wynosi 22%");

else // od 100000 puts("Podatek wynosi 35%");

}

Instrukcja if

i operatory  logiczne: && (and), || (or), ! (not) • Mogą one przyjmować wartości

true czyli 1 lub 0 czyli falseZa ich pomocą możemy skonkretyzować nasz warunek. Np. if (warunek1) && (warunek2) instrukcja;

• Operator &&(koniunkcja) sprawia, że instrukcja zostanie wykonana tylko w przypadku gdy spełnione są oba warunki. Gdybyśmy zastąpili go operatorem || (alternatywa), to wystarczyłby tylko jeden spełniony.

• Drugi przypadek if (! Warunek) instrukcja;W tym przypadku instrukcja będzie wykonana jeśli warunek nie jest spełniony (ma wartość false). Do tego właśnie służy operator ! (czyli negacja).

Równanie kwadratowea*x2 + b*x +c = 0

Instrukcje:

if (a !=0)if (delta==0 … else

if ((a==0) && (b==0)) … if ((a==0) && (b!=0))

/* program rowkwadr.cpp */#include <iostream.h>#include <conio.h>#include <math.h>int main(){float a, b, c, delta;clrscr();cout << "Program oblicza pierwiastki rownania

kwadratowego." << endl;cout << "Podaj wspolczynniki: " << endl;cout << "a= " ; cin >>a;cout << "b= "; cin >> b;cout << "c= "; cin >> c;delta=b*b-4*a*c;

if (a !=0)

{ if (delta<0) cout << "Delta ujemna - brak rozwiazan.\n" ; else if (delta==0) cout << "x= " << (-b+sqrt(delta))/(2*a); else if (delta>0) { cout << "x1= " << (-b+sqrt(delta))/(2*a) << endl; cout << "x2= " << (-b-sqrt(delta))/(2*a) << endl; }}else{ if ((a==0) && (b==0)) cout << "Rownanie ma nieskonczenie wiele rozwiazan."; else if ((a==0) && (b!=0)) {

cout << "Rownanie o podaneych wspolczynnikach jest liniowe.\n";

cout << "jego pierwiastek jest rowny: " << -c/b << endl; } }

getch(); return 0;}

If - podsumowanie1. Jeżeli do rozpatrzenia mamy kilka przypadków, stosujemy

instrukcję warunkową if. 2. Instrukcję zapisujemy:

if (warunek) instrukcja1; else instrukcja2; 3. Dla więcej niż jednej instrukcji należy zgrupować je za

pomocą nawiasów klamrowych. 4. W warunku logicznym instrukcji if zawsze stosujemy

operator porównania ==, a nie przypisania =. 5. Jeśli jednocześnie powinno być sprawdzone kilka warunków,

łączymy je za pomocą operatorów logicznych && (and) , || (or) lub ! (nie)

Instrukcja switch - instrukcja wyboru • Instrukcja switch jest wykorzystywana kiedy zachodzi

konieczność podjęcia kilku decyzji, gdy wykonanie różnych części programu jest uzależnione od stanu pewnej zmiennej.

• Podstawą podjęcia decyzji jest wyrażenie typu całkowitego, znakowego lub logicznego

• Instrukcja switch ma postać:

switch (zmienna lub wyrażenie) {case wartosc_1: Instrukcje_1; break; // break nie musi być

.................... case wartosc_N: Instrukcje_N; break;default Instrukcje_domyslne;

}

Instrukcja wyboru switch dla wielu warunkówswitch – case – przypadek W spośród (I1, I2, … In)

• Instrukcja wyboru switch (przełącznik) to tzw. zwrotnica wielokierunkowa. Instrukcja ta pozwala na zdefiniowanie działań dla różnych wyników jednego wyrażenia.Jej konstrukcja pozwala na łatwiejsze od zwykłej pętli definiowanie przypadków (większej ich liczby).

• Instrukcją decyzyjną switch zastąpić można wielokrotne wywoływanie instrukcji warunkowej if np. dla różnych wartości tej samej zmiennej – przykładowo, gdy zmienna może przyjąć 10 różnych wartości, a dla każdej z nich należy podjąć inne działanie.

• Składnia:

switch (wyrażenie_kluczowe){ case wartosc_1: instrukcje; break; case wartosc_2: instrukcje; break; // ... default: cout << "Błąd"; }

Wyrażenie najczęściej jest zmienną o określonej wartości. Jeśli tą wartością jest wartość 1, wykonywane są instrukcje następujące po odpowiedniej etykiecie case, aż do następnej instrukcji przerywającej, z reguły break (instrukcja opuszczenia nie musi występować na zakończenie każdego bloku rozpoczętego przez case – wykonany zostanie wtedy kod następnych przypadków). Przypadek default jest opcjonalny, określa instrukcje wykonywane, gdy wartość zmiennej nie jest równa żadnemu z wyszczególnionych przypadków.

/* Przykład programu ze switch case *//* case_2. c */#include <stdio.h> #include <conio.h> main (void) { char znak; clrscr(); printf("Wciśnij cyfrę od 0 do 5\n"); scanf("%c",&znak); switch (znak){case '0': pritntf("nacisnąłeś klawisz 0");break; //przerwanie switchcase '1': pritntf("nacisnąłeś klawisz 1");break;case '2': pritntf("nacisnąłeś klawisz 2");break;case '3': pritntf("nacisnąłeś klawisz 3");break;case '4': pritntf("nacisnąłeś klawisz 4");break;case '5': pritntf("nacisnąłeś klawisz 5");break;default: pritntf("nacisnąłeś jakiś inny klawisz"); // pozostałe

przypadki}getch(); return 0 ; }

Przykład: Wydruk w postaci słownej wczytanej oceny/* program oceny.c */include <iostream.h> void main() { int ocena; cout << "Podaj ocene (1..6) : "; cin >> ocena; switch (ocena) { // switch case 6: cout << "celujacy:"; break; case 5: cout << "bardzo dobry"; break; case 4: cout << "dobry"; break; case 3: cout << "dostateczny"; break; case 2: cout << "mierny"; break; case 1: cout << "niedostateczny"; break; default: cout << "blad danych"; break; } // switch } // main

Instrukcja wyboru switch .. case – przykłady programów// Program Miesiace.cpp - //podaje nazwe miesiaca na podstawie jego

numeru #include <iostream.h>#include <conio.h>int main(){int miesiac; // numer miesiąca w rokucout << "Podaj numer miesiaca w roku: ";cin>> miesiac; // wprowadzenie nru m-caswitch (miesiac) { // switchcase 1: cout << "Styczen"; break;case 2: cout << "Luty"; break;case 3: cout << "Marzec"; break;case 4: cout << "Kwiecien"; break;case 5: cout << "Maj"; break;case 6: cout << "Czerwiec"; break;case 7: cout << "Lipiec"; break;case 8: cout << "Sierpien"; break;case 9: cout << "Wrzesien"; break;case 10: cout << "Pazdziernik"; break;case 11: cout << "Listopad"; break;case 12: cout << "Grudzien"; break;default: cout << "Numer nie poprawny";} // switch getch(); return 0; }

/* switchpf.cpp – switch – pola figur#include <cstdlib> #include <iostream>using namespace std; int main(int argc, char *argv[]){ float x, y, pole; int decyzja; cout << "Pole jakiej figury chcesz obliczyć? Podaj numer figury." << endl; cout << "1 - prostokat" << endl << "2 - trojkat" << endl << "3 - kolo" << endl; cin >> decyzja; // wprowadzenie decyzji switch (decyzja) { case 1: cout << "Podaj dlugosci bokow: "; cin >> x >> y; pole = x * y; break; case 2: cout << "Podaj dlugosc podstawy i wysokosci: "; cin >> x >> y; pole = 0.5 * x * y; break; case 3: cout << "Podaj promien: "; cin >> x; pole = 3.14 * x * x; break; default: cout << "Zly wybor. Koniec programu" << endl;; pole = 0; } cout << "Pole figury wynosi " << pole << endl; cout << endl << endl; system("PAUSE"); return EXIT_SUCCESS; }

switch … case i instrukcja skoku goto• Przy omawianiu instrukcji switch-case należy wspomnieć również

o instrukcji skoku: goto. Jest to bardzo przydatna instrukcja przy skomplikowanych programach. W programach z instrukcją case, po naciśnięciu odpowiedniego klawisza zostaje wykonana odpowiednia instrukcja. A gdybyśmy chcieli, żeby wykonana została nie jedna czy dwie instrukcje, a więcej? Można wypisywać instrukcje jedna po drugiej, ale kod szybko straciłby na czytelności. Można się więc posłużyć instrukcją skoku, aby program na chwilę przeszedł do innego miejsca kodu, wykonał to co jest tam napisane i z powrotem powrócił do miejsca początkowego. Jak oznaczyć miejsce, do którego program ma wyskoczyć? Służą do tego etykiety.

/* Program goto1.c - switch..case z etykietami*/#include <stdio.h>#include <conio.h>main (void){char znak;clrscr(); jeszcze_raz: //to jest etykieta o nazwie jeszcze_raz printf("Wciśnij cyfrę od 0 do 5\n");scanf("%c",&znak); switch(znak){case '0': goto koniec; break;case '1': goto jeden; break;case '2': printf("nacisnąłeś klawisz 2"); goto koniec; break;case '3': printf("nacisnąłeś klawisz 3"); goto koniec; break;case '4': printf("nacisnąłeś klawisz 4"); goto koniec; break;case '5': goto jeszcze_raz; break;default: printf("nacisnąłeś jakiś inny klawisz");} jeden: //to jest etykieta o nazwie jeden{printf("\nEtykieta 1 ");getch();}koniec: //to jest etykieta o nazwie koniecprintf("\nEtykieta koniec "); getch();return 0 ;}

/* Przykład programu ze switch case bez etykiet - bez goto *//* case_2. c */#include <stdio.h> #include <conio.h> main (void) { char znak; clrscr(); printf("Wciśnij cyfrę od 0 do 5\n"); scanf("%c",&znak); switch(znak){case '0': pritntf("nacisnąłeś klawisz 0"); break;

//przerwanie switchcase '1': pritntf("nacisnąłeś klawisz 1");break;case '2': pritntf("nacisnąłeś klawisz 2");break;case '3': pritntf("nacisnąłeś klawisz 3");break;case '4': pritntf("nacisnąłeś klawisz 4");break;case '5': pritntf("nacisnąłeś klawisz 5");break;default: pritntf("nacisnąłeś jakiś inny klawisz");

// pozostałe przypadki}getch(); return 0 ; }

Instrukcje switch case , goto - etykiety

Działanie programu goto1.c – switch…case z etykietami

• Działanie tego programu wciśnij klawisz => jaki klawisz został wciśnięty? =>jeśli 0 => idź do etykiety 'koniec' i zacznij wykonywać wszystko od tego miejsca;jeśli 1 => idź do etykiety 'jeden' i zacznij wykonywać wszystko od tego miejsca;jeśli 2 => napisz komunikat a potem idź do etykiety 'koniec' i zacznij wykonywać wszystko od tego miejsca;jeśli 3 => napisz komunikat a potem idź do etykiety 'koniec' i zacznij wykonywać wszystko od tego miejsca;jeśli 4 => napisz komunikat a potem idź do etykiety 'koniec' i zacznij wykonywać wszystko od tego miejsca;jeśli 5 => idź do etykiety 'jeszcze_raz' i zacznij wykonywać wszystko od tego miejsca;

Podsumowanie: instrukcje warunkowe if, switch, skoku goto • Instrukcję if stosujemy dla mniejszej ilości warunków do

sprawdzenia, lub dla bardziej skomplikowanych warunków - wtedy stosujemy operatory logiczne np. && lub ||.

• Instrukcję case stosujemy dla dużej ilości prostych warunków. • Określenia else w instrukcji if i default w instrukcji case

znaczą: "dla pozostałych przypadków" • Instrukcja goto jest to instrukcja skoku do pewnego miejsca w

kodzie programu. • Miejsce skoku należy oznaczyć odpowiednią etykietą. • Za pomocą goto można robić pętle programowe lub szybko

skończyć działanie.

Instrukcje iteracyjne. Organizacja obliczeń cyklicznych

Instrukcje iteracyjne służą do wielokrotnego wykonywania pewnych

sekwencji instrukcji i zazwyczaj są one nazywane po prostu pętlami.

Instrukcja while - dopóki Warunek wykonuj Instrukcję;Składnia: while (wyrazenie) instrukcja;Instrukcja do while – powtarzaj Instrukcję dopóki Warunek

Składnia: do instrukcja while (wyrazenie);

Instrukcja for: np. dla i od 1 do N lub dla i=W1 do W2 wykonuj Instrukcję

for (i=W1; i<W2; i++) Instrukcja;

Składnia:

for (wyrażenie1; wyrażenie2; wyrażenie3) instrukcja; for (wyrażenie1; wyrażenie2; wyrażenie3) { lista instrukcji} Instrukcję for stosuje się w przypadkach, gdy z gór można określić liczbę wykonań pętli.

Instrukcja while

• Instrukcja ma postać:while (warunek) instrukcja;

• Powoduje wykonywanie instrukcji tak długo, dopóki spełniony jest warunek

• Warunek jest najczęściej dowolnym wyrażeniem porównania, które powinno w wyniku dać wartość logiczną (true lub false). Można posłużyć się tutaj operatorami relacyjnymi: ==, !=, <, >, <=, >=

• Instrukcja wykonywana jest tak długo, dopóki warunek ma wartość true.

(warunek) // dopóki warunek prawdziwy{ instrukcja_1; instrukcja_2; ... Instrukcja_N;}; // wykonuj te instrukcje (listę instrukcji lub jedną instrukcję)

while (wyrażenie) instrukcja; // instrukcja pojedyncza (lub złożona)

while (wyrażenie) { lista instrukcji // instrukcja złożona (lista instrukcji) }

Pętla while

• Z pętli while korzystamy, kiedy nie znana jest liczba powtórzeń i być może pętla ta wcale nie będzie wykonana. Warunek jest testowany przed każdym, nawet pierwszym wykonaniem pętli, Najpierw jest obliczana wartość wyrażenia (wyrażenie) i jeżeli ma ono wartość różną od zera (prawda), to jest wykonywana instrukcja, która może być instrukcją złożoną. Instrukcja może nie być nigdy wykonana, jeżeli przy pierwszym obliczeniu wartości wyrażenia (wyrażenie) będzie ono miało wartość zero (fałsz).

Przykłady programów z while/* Program NWD-dev.c Najwieksza wspolna wielokrotnosc */#include <stdio.h> #include <conio.h>int a,b,a1,b1, nwd; char ch;int main (void) { nwd=0; a=0; b=0;printf("===== Program NWD-dev.C ============= \n");printf("\nProgram oblicza NWD 2 liczb naturalnych, met. Euklideasa");printf("\nprzez pomniejszanie wiekszej liczby o mniejsza az do rownosci");printf("\n\nWprowadz liczby oddzielone spacja: ");scanf("%i %i",&a, &b); fflush(stdin); /* flush the input stream in case of bad input */printf("\na=%i b=%i\n",a,b);a1=a; b1=b;

while (a != b){ if (a > b) { a=a-b; printf("\na=%i",a); } else { b=b-a; printf("\nb=%i",a); } }; /* while */nwd=a; printf("\n\nNWD liczb %i i %i = %i\n",a1,b1,nwd); printf("\nNacisnij cos ");ch = getche(); // lub getch();// clrscr();return 0;}

Przykład programu z while – suma 6 podanych liczb

// Program Suma6.cpp; Oblicza sumę 6 podanych liczb

#include <iostream.h>

#include <conio.h>

int main()

{ int i; float suma, x;

i=1; // Nadanie wartości początkowej i - licznik

suma=0; // Nadanie wartości początkowej suma

cout << "Program oblicza sume podanych 6 liczb " << endl;

while (i<=6)

{ // while

cout << i << " Podaj liczbę x="; cin >> x; suma=suma+x;

cout << "\Aktualna suma=" << suma << endl;

i++;

} // while

cout << "\nSuma koncowa =" << suma << "\nNacisnij Enter" << endl;

getch();

return 0;

}

Przykład - obliczenie sumy i iloczynu ciągu liczb zakończonych liczbą zero.

/* Program sumilocz.c * - while / #include <iostream.h> #include <conio.h>void main(void){ int s, i, l, n; // suma, iloczyn ciągu liczb, ilość liczb w ciągu s=0; i=1; n=0; cout << "Podaj liczby (zero kończy)\n "; cin >> l;

while ( l != 0 ) // while (l) – podczas gdy liczba różna od zera { s += l; i *= l; n++; cin >> l; // s=s+l; i=i*l; n=n+1; } cout << "Ilość liczb: " << n << "\n"; cout << "Suma liczb wynosi " << s << endl; cout << "Iloczyn liczb = " << i; getch();}

Przykład 2 - wyprowadzenie kilku znaków (cyfry i kody ASCII):

/* while_3.c - cyfry kody */#include <stdio.h> #include <conio.h> #define LIMIT 6#define KOD_P 64 #define PODKR 27main() /* wyprowadzenie kilku znakow o kodach obliczonych */{ int i = 1, k = 1, j = KOD_P; printf("\ni j znak o kodzie (j)\n"); while (k < PODKR) { putchar('-'); k++; } // linia podkreslenia

while (i <= LIMIT ) printf("\n%i %i %c", i++, j+i, j+i); //lp liczba kod ASCII

getch();}

/* Przykład 3 - program zamlit.c -zamiana liter małych na duże */

#include <stdio.h> #include <ctype.h> #include <conio.h>#define EOL '\n'main() /* zamiana malych liter na duze */{ char linia[80]; int i = 0, max; /* wprowadzenie 1 linii tekstu z klawiatury */ while ( (linia[i] = getchar()) != EOL ) ++i ; max = i;

/* wyprowadzenie 1 linii tekstu (DUZE LITERY) */ i = 0; while (i < max) { putchar ( toupper(linia[i])); ++i; }

getch();}

Pole prostokąta – schemat blokowy

** Pole prostokąta – while – wersja C **/* polpr1a.c Pole prostokąta - while *//* Dyrektywy */#include <stdio.h> #include <conio.h> #include <math.h>/* Bliblioteka math.h - jeśli potrzebna, np. M_PI *//* Makrodefinicja */#define PI 3.141593int main(){ float a, b, p; /* deklaracje zmiennych */puts("Program polpr1a.c\n"); puts("Obliczenie pola prostokata: dane dlugosci a i b\n");printf("PI=%lf (do innych obliczen, np. kola)",PI); printf("\n\nPodaj a (0 - koniec) => " );scanf("%f",&a); /* wczytanie a */while (a > 0) { // while printf("Podaj b lub 0 gdy b=a => " ); scanf("%f",&b); /* wczytanie b */ if (b==0) b=a; p=a*b; /* pole */ printf("Pole prostokata o bokach " ); printf("%.3f i %.3f = %7.3f", a, b, p); printf("\n\nPodaj a (0 - koniec) => " ); scanf("%f",&a); /* wczytanie a */ } // while // getch(); return 0; /* powrot do systemu - main() zwraca 0 */}

** Pole prostokąta – while - wersja C++ Dev C++**// polpr1.cpp Pole prostokata CPP Dev C++#include <cstdlib> #include <iostream> #include <math.h>using namespace std;int main(int argc, char *argv[]) // funkcja glowna{ float a, b, p;cout << "Program polpr1.cpp" << endl << endl;cout << "Obliczenie pola prostokata: dane dlugosci a i b" << endl << endl;cout << "Podaj a (0 - koniec) => " ;cin >> a; // wczytanie awhile (a > 0) { // while cout << "Podaj b => "; // napis cin >> b; // wczytanie b p=a*b; // pole cout << "Pole prostokat o bokach " << a << " i " \ << b << " = "<< p << endl << endl; cout << "Podaj a (0 - koniec) => " ; cin >> a; // wczytanie a } // whilesystem("PAUSE"); return EXIT_SUCCESS;}

/* polpr1a.c Obliczenie pola prostokąta, zapis do pliku */#include <stdio.h>#include <conio.h>#include <math.h>#define PI 3.141593/* Plik wynikow */#define WYN "pprost.txt"

int main(){float a, b, p;int nr=0;char nazwisko[20]; /* nazwisko obliczającego */FILE *fp; /* zmienna plikowa */

puts("Obliczenie pola prostokata: dane dlugosci a i b\n");printf("Wyniki zapisywane w pliku ");puts(WYN);printf("PI=%lf (do innych obliczen)",PI);printf("\n\nPodaj a (0 - koniec) => " );scanf("%f",&a); /* wczytanie a */

// otwarcie pliku z kontrola if ( (fp = fopen(WYN, "w"))==NULL ) { puts("Nie mozna otworzyc pliku do zapisu"); exit(1); }/* wydruk do pliku */ fprintf(fp, "Obliczenie pola prostokata o bokach a i b\n"); fprintf(fp, "Lp a b pole \n");

while (a > 0) { // while nr++; fprintf(fp,"%3d %6.3f",nr, a); // wydruk do pliku printf("Podaj b lub 0 gdy b=a => " ); scanf("%f",&b); // wczytanie b if (b==0) b=a; fprintf(fp,"%10.3f",b); p=a*b; // pole printf("Pole prostokata o bokach " ); printf("%.3f i %.3f = %7.3f", a, b, p); fprintf(fp,"%10.2f\n",p); printf("\n\nPodaj a (0 - koniec) => " ); scanf("%f",&a); // wczytanie a } // while

printf ("\nNazwisko obliczajacego: "); fflush(stdin); gets(nazwisko); // wczytanie nazwiska fprintf(fp,"\nObliczyl: %s", nazwisko);

fclose(fp); // zamkniecie pliku

// getch(); return 0;}

/** Pole prostokąta – obliczenia w pętli while, zapis wyników do pliku pprost.txt **/

Programy z do … while// Program ilosc.cpp wyznacza długość ciągu liczb zakończonych 0

#include <iostream.h>

#include <conio.h>

int main()

{ int dlug, liczba, suma=0;

clrscr();

cout << "Wprowadzaj liczby, 0 koniec \n"; dlug=0;

do

{

cin >> liczba;

dlug = ++dlug; suma=suma+liczba;

}

while (liczba!=0);

cout << "Dlug. ciagu wynosi " << --dlug << endl; // 0 nie wliczamy – odejmujemy 1

cout << "Suma ciagu wynosi " << suma << endl;

getch();

}

Wyświetlenie czasu C++ - program w Dev C++

// Program czas.cpp w jezyku C++ - wyświetlenie czasu - komentarz w C++// instrukcja do…while#include <cstdlib>#include <iostream>#include <time.h>using namespace std;

int main (int argc, char *argv[]){ int a; time_t czas; do { cout << "1 - Wyswietl aktualny czas" << endl;

cout << "2 - Zakoncz program" << endl; cout << "Twoj wybor?"; cin >> a; if (a == 1) { time(&czas); cout << ctime(&czas); }

} while (a != 2); cout << "Do zobaczenia" << endl; system("PAUSE"); return EXIT_SUCCESS;}

Instrukcja for

Instrukcja jest wygodna, gdy z góry można określić liczbę powtórzeń.Postać instrukcji:Dla zmienna=wart_pocz do wart_konc do instrukcja;W zapisie w C najczęściejfor (wart_pocz; zmienna<wart_konc; zmienna++) instrukcja;

Zapis instrukcji w postaci ogólnej w C / C++: for (wyrażenie1; wyrażenie2; wyrażenie3) { lista instrukcji}Np. for (int i=1; i<11; i++) cout << i << endl;

Zmienna nazywana jest zmienną sterującą instrukcji for. Musi być typu całkowitego, znakowego lub logicznego. Instrukcja po słowie kluczowym do wykonywana jest tyle razy ile wartości znajduje się w zakresie

wart_pocz .. wart_konc.

Programy z for/* Program for1.cpp

Wydruk cyfr od 1 do 5 */#include <iostream.h>

#include <conio.h>

int main() {

int i;

for (i=1; i<= 5; i++) cout << i << endl;

getch();

return 0;

}

/* Program for2.cpp Wydruk cyfr od 5 do 1 */

#include <iostream.h>

#include <conio.h>

int main() {

int i;

for (i=5; i>= 1; i--) cout << i << endl;

getch();

return 0; }

/* Program for3.c *//* Wydruk liczb 16, 10, 8 */ #include <stdio.h> #include <conio.h>main(){ int i;printf("Wydruk liczb 0 ... 50\n"); printf("Hex(duze)\tHex(male)\tDziesietne \Osemkowe\n");printf("16-Duze litery \t16-male litery \t 10 \t\t 8 \n");

for ( i=0; i<=50; i++ ) printf("%X \t\t %x \t\t %d \t\t %o \n", i, i, i, i);

getch(); return 0;}

Przykład programu z instrukcją for -tabliczka mnożenia

/* tablmnoz.c */#include <stdio.h> #include <conio.h>main(){ int row, column; puts ("\t\t Tabliczka mnozenia \n");

for (row=1; row <=10;row++) { for (column=1; column<=10;column++) printf("%6d", row*column);

putchar('\n'); // nowy wiersz }

getchar(); }

Opis przykładowego zapisu for

Przykład: for (licznik=0; licznik<=10; licznik++) { instrukcje... }

• Wytłumaczenie dosłownie zapisu :– zmienna sterująca użyta przez nas do zliczania wykonań

pętli ma nazwę licznik – licznik zaczyna zliczać od wartości 0 – pętla ma się wykonywać, kiedy licznik pokazuje wartość

mniejsza lub równa 10 – licznik ma się zwiększać o 1 po każdorazowym wykonaniu

pętli – instrukcje, które mają się powtarzać, ujęte są w nawias

klamrowy { }– jeżeli byłaby to jedna instrukcja, nawias można by

pominąć.

Podsumowanie: for • for(licznik=StanPocz; licznik<=WartKonc; licznik++)

{instrukcje...}; • Instrukcji for używamy, jeżeli chcemy wykonać kilka instrukcji

określoną ilość razy. • Przy użyciu instrukcji for należy ustawić warunki na licznik:

stan początkowy, warunek wykonywania pętli i wartość o jaką zmienia się wartość licznika po wykonaniu pętli.

• Licznik jest to dodatkowa zmienna typu int. • Licznik nie musi być zwiększany, równie dobrze może liczyć w

odwrotną stronę. Licznik nie musi zmieniać się o 1, lecz o dowolną wartość, aczkolwiek pierwszy przypadek jest częściej wykorzystywany w praktyce

Podsumowanie instrukcji pętli: while , do while, for

• Pętle while i do-while stosujemy, gdy powtarzanie pętli chcemy uzależnić od spełnienia pewnego warunku i nie wiemy ile razy będzie trzeba ja powtórzyć.

• Pętla while najpierw sprawdza warunek, instrukcje w niej zawarte mogą nigdy nie zostać wykonane.

• Pętla do-while najpierw wykonuje instrukcje, a potem sprawdza warunek, więc instrukcje zostaną wykonane co najmniej raz.

• Pętlę for stosujemy, gdy wiemy ile razy ma się ona powtórzyć.

Instrukcja breakPozwala na opuszczenie aktualnie wykonywanej pętli for, while oraz do i przejście do instrukcji znajdującej się po zakończonej pętli. Daje możliwość wcześniejszego opuszczenia pętli.//* Program break1.c - wyjście z pętli for gdy wprowadzono 0 */#include <iostream.h> #include <conio.h>void main(void){ int dlug, liczba, poprawny=1, iloczyn=1; cout << "Podaj ilosc liczb (dlugosc ciagu) " << endl; cin >> dlug; cout << "\nPodaj liczby:\n";

for ( int i=0; i<dlug; i++ ) { cin >> liczba;

if (liczba == 0) { poprawny=0; break; } iloczyn *= liczba;

} // for

if (poprawny) cout << "Iloczyn = " << iloczyn; else cout << "Blad danych "; getch(); }

Przykład 2 instrukcji break. Wyjście z pętli, gdy licznik osiągnie wartość BL=20/* Program break2.c */

#include <stdio.h>#include <conio.h>#define ML 100#define BL 20 int main() {int a; for (a=1 ; a != ML ; ++a) { if (a == BL) break; /* Przerwanie gdy a=BL = 20 */ printf ("%d\n", a); } getch(); return 0; }

Instrukcja kontynuowania - continue

• Instrukcja powoduje zakończenie bieżącej iteracji aktualnie wykonywanej pętli for, while oraz do. Powoduje wykonanie od początku następnego kroku pętli, w której się znajduje.

• Instrukcja break kończy wykonywanie pętli, a instrukcja continue kończy jedynie bieżącą iterację.

• Przykład fragmentu programu:for (i=0; i<n; i++) { if (tab[i] = 0) // pominięcie elementów continue; // przetwarzanie elementów <> 0 }

Przykłady z continue - program continue1.c

/* continue1.c */#include <stdio.h>#include <conio.h>int main(){int i, maks1, maks2;printf("Podaj 2 liczby: maks1 i maks2 (maks1 < maks2) : ");scanf("%d %d", &maks1, &maks2);printf("maks1=%d maks2=%d \n\n", maks1, maks2 ); for (i = 1 ; i <= maks2 ; ++i) { printf ("i=%d Wyswietlam do %d \n",i, maks2); if (i > maks1 ) continue; // opuszczenie iteracji printf ("i=%d Wyswietlam do %d - potem opuszcze -> continue \n",i, maks1); printf("\n"); }getch();}

Prz. 2 z continue. Wyświetlenie liczb, które nie są podzielne przez 4 i przez 5/* continue2.c */#include <stdio.h>#include <conio.h>#define ML 100 int main() { int i, j=0; puts("Wyswietlenie liczb 1 .. 100, ktore nie sa podzielne przez 4 lub 5"); for (i = 1 ; i <= ML ; ++i) { if ( (i%4==0) || (i%5==0) ) continue; // opuszczenie bieżącej iteracji – nie wyświetla i j++; if (j%5==0) printf("\n"); printf ("%5d ", i); } getch(); return 0; }

Instrukcja wywołania funkcji

• Postacie wywołania funkcji:– w instrukcji przypisania, np. c=getchar(); y=sin(x);– samodzielnie, np. printf(...), scanf(...), puts(...); itd..

Instrukcja powrotu - return i skoku goto

• Instrukcja powrotu return ma 2 postacie:– return; // nie wyprowadza wyniku funkcji – return wyrazenie; // udostępnia rezultat funkcji o wartości

jaką ma wyrażenie (po ewentualnej konwersji) • Instrukcja skoku - goto - skok bezwarunkowy

Instrukcja skoku ma postać:goto etykieta;

Etykieta jest ciągiem znaków, zakończonych dwukropkiem. Zakresem widzialności etykiety jest blok instrukcji, w którym

została zadeklarowana.Instrukcja może być używana sporadycznie (awaryjnie). Są języki, które jej nie posiadają.

return - objaśnienie• return zmienna

Wynik funkcji musi być tego samego typu co funkcja, czyli:int funkcja() { int a = 5; return a; }

• W przypadku próby zwrócenia wyniku innego typu niż funkcja kompilator zgłosi błąd:• int funkcja()

{ char a[] = "abcdefg"; return a; /* powinien być zwrócony wynik typu int, więc kompilator pokaże błąd */}

• Możliwe jest także zwrócenie wyniku w postaci innej niż zmienna, np.:int funkcja(){ return 5; }

• return przydaje się też do zakończenia wykonywania dowolnej procedury (funkcji, która zwraca void)#include <iostream> void sprawdz_wiek(int wiek){ if (wiek < 18) return; // poniższa linijka zostanie tylko jeżeli wiek >= 18 std::cout << "Witaj dorosły człowieku!" << std::endl;}

Przykład programu z return – w funkcji pomocniczej dodaj() i funkcji głównej main()

/* return1. c*/#include <iostream.h>#include <conio.h>int dodaj(int a, int b){ int wynik = 0; wynik = a + b; return wynik;}

int main(){ int wynik = 0; wynik = dodaj(2,3); std::cout << wynik << endl; getch(); return 0;}

W sekcji głównej programu main() zadeklarowano zmienną wynik, do której przypisano wynik działania funkcji dodaj.

Skąd wiadomo jaką liczbę zwróci funkcja? Do tego służy funkcja return. Dzięki niej funkcja może dać wynik.

Funkcja int main() zwraca 0 jeśli program wykona się poprawnie.

/* Program goto1.c - instrukcja skoku goto *//* Program goto1.c ( instrukcja goto ) */#include <stdio.h> #include <stdio.h>#define VPOCZ 70 #define VKONC 240 #define KROK 10main() /* goto (dla kierowcow) */{ float v, vm; printf("\n-------------------------------------");

printf("\n Predkosc [km/h] Predkosc [m/s] "); printf("\n-------------------------------------"); v = VPOCZ;

pocz: vm = v / 3.6 ; printf("\n %3i %6.2f", (int) v, vm); v += KROK; if (v > VKONC) goto kon; /* skok warunkowy */ goto pocz; /* skok bezwarunkowy */

kon: printf("\n-------------------------------------");

getch();}

Podsumowanie: return i goto • return to instrukcja powrotu - return - słowo kluczowe; zwraca się za jego

pomocą wartość funkcji.• Instrukcja powrotu return ma 2 postacie:

– return; // nie wyprowadza wyniku funkcji – return wyrazenie;

// udostępnia rezultat funkcji o wartości jaką ma wyrażenie (po ewentualnej konwersji)

• Instrukcja goto jest to instrukcja skoku – skok bezwarunkowy do pewnego miejsca w kodzie programu.

• Instrukcja skoku ma postać: goto etykieta;• Miejsce skoku należy oznaczyć odpowiednią etykietą.

Etykieta jest ciągiem znaków, zakończonych dwukropkiem• Za pomocą goto można robić pętle programowe lub szybko skończyć jego

działanie. • Zakresem widzialności etykiety jest blok instrukcji, w którym została

zadeklarowana.• Instrukcja może być używana sporadycznie (awaryjnie).

Są języki, które jej nie posiadają.