Podstawy programowania w języku C i C++ 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łcenia Po zakończeniu lekcji uczeń będzie umiał: stosować podstawowe proste makrodefinicje i operacje na znakach w C oraz instrukcje warunkowe i iteracje.

Część merytoryczna Część wstępna Część 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 const Komentarze 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ącego program.exe >> wyniki.txt  do pliku – dopisanie do istniejącego program.exe > PRN  na drukarkę

Kody sterujące Kody sterujące: Znaki specjalne: kod nowego wiersza: \n np. puchar(‘\n’); kod tabulacji: \t kod powrotu karetki \r Kod cofania \b kod wysunięcia strony \f kod 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); }

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 Wzorzec Postać 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 C Preprocesor 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.h umoż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 tekst Np. #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 tekst gdzie 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

Szablony programu dla ucznia – dane wpisane w #define /* 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);

Szablon programu do obliczeń geodezyjnych /* zmienne globalne - stale, zmienne */ const double pi=3.14159265; const double rograd=63.66197724, rostop=57.2957795130823; /* Ro[grad]=200/PI, Ro[stopn]=180/PO const 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); /* 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))

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"; // definicja clrscr(); // czyszczenie ekranu znak1='a'; // inicjalizacja zmiennej znak1 znak2=102; // znak w postaci kodu dziesiętnego ASCII - litera f printf("Podaj znak3: "); scanf("%c",&znak3); // podajemy jakiś znak printf("\nPodaj slowo1: "); scanf("%s",slowo1); // wpisujemy słowo 1 printf("\nPodaj slowo2: "); scanf("%s",slowo2); // wpisujemy słowo 2 printf("\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 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. /* 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ący clrscr(); 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("\nWypelniamy lancuch znakiem 'x':\n" ); strset(lancuch3,znakwyp); getch(); return 0 ; }

Podsumowanie – znaki, łańcuchy znaków Zmienne liczbowe mogą zawierać się w pewnych zakresach, których nie można przekraczać. Deklaracja zmiennej znakowej: char znak; a zmiennej łańcuchowej: char *slowo; Wartość zmiennej znakowej można przypisać w programie poprzez umieszczenie znaku w apostrofach lub przez napisanie jego kodu. Wartość zmiennej łańcuchowej można przypisać w programie poprzez umieszczenie napisu w cudzysłowie. 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. Każdy znak posiada swój kod ASCII. Kod ASCII mają również znaki nie przedstawione na klawiaturze komputera. np. ß, ö. Łańcuch, który wygląda jak liczba nie jest liczbą. Istnieją funkcje, które potrafią przekonwertować łańcuch liczbowy do postaci liczby. 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. Każdy ciąg kończy znak '\0'. Długość łańcucha można ograniczyć przy deklaracji, np.: char slowo[10]; Ł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;}

jesli Warunek to Instrukcja; if (W) I; // 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 ; }

jeśli W to Instrukcja1 w przeciwnym przypadku Instrukcja2;  if (W) I1; else I2; // 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"); else printf("Wynik dzielenia: %f\ n", (float) liczba1/liczba2); getch(); return 0 ; } // 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; }

Przykłady programów z if /* 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 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 */; { int a; cout << "Podaj liczbe calkowita > 0 ==> "; cin >> a; if (a<0) cout << "a < 0"; else cout << "a >=0 "; 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.. else if (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 // 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 false Za 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).

if (a !=0) if (delta==0 … else Równanie kwadratowe if (a !=0) a*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); if (delta>0) cout << "x1= " << (-b+sqrt(delta))/(2*a) << endl; cout << "x2= " << (-b-sqrt(delta))/(2*a) << endl; } if ((a==0) && (b==0)) cout << "Rownanie ma nieskonczenie wiele rozwiazan."; 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 - podsumowanie Jeżeli do rozpatrzenia mamy kilka przypadków, stosujemy instrukcję warunkową if. Instrukcję zapisujemy: if (warunek) instrukcja1; else instrukcja2; Dla więcej niż jednej instrukcji należy zgrupować je za pomocą nawiasów klamrowych. W warunku logicznym instrukcji if zawsze stosujemy operator porównania ==, a nie przypisania =. 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ów switch – case – przypadek W spośród (I1, I2, … In)

Instrukcja wyboru switch (przełącznik) to tzw 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: 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. switch (wyrażenie_kluczowe) { case wartosc_1: instrukcje; break; case wartosc_2: instrukcje; break; // ... default: cout << "Błąd"; }

/* 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 switch case '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 roku cout << "Podaj numer miesiaca w roku: "; cin>> miesiac; // wprowadzenie nru m-ca switch (miesiac) { // switch case 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.

Instrukcje switch case , goto - 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 koniec printf("\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 switch case '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 ;

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.

Pętla while (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) }

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 27 main() /* 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.141593 int 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 a while (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; cin >> a; // wczytanie a } // while system("PAUSE"); return EXIT_SUCCESS; }

/** Pole prostokąta – obliczenia w pętli while, zapis wyników do pliku pprost.txt **/ /* 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; }

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ęściej for (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 */ int main() { for (i=5; i>= 1; i--) cout << i << endl; 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 break Pozwala 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(); }

#include <stdio.h> #include <conio.h> #define ML 100 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() 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 10 main() /* goto (dla kierowcow) */ { float v, vm; printf("\n-------------------------------------"); printf("\n Predkosc [km/h] Predkosc [m/s] "); 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: 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ą.