sem. II(język C, cz. I) Dr inż. M. Czyżak

sem. II(język C, cz. I) Dr inż. M. Czyżak

Literatura: 1. A. R. Neibauer, Języki C/C++, Twój pierwszy program, Help, 1995 (obecnie wyd. IV) 2. C. Sexton, Język C - to proste, RM, W-wa, 2001. 3. G. Perry, Język C w przykładach,que, W-wa, 2000. 4. Brian W. Kernighan, Dennis M. Ritchie, Język ANSI C, Programowanie, Helion, Gliwice, 2010 ( wyd.ii) 5. H.Schildt, Programowanie C, RM, wyd.i, W-wa, 2002. 6. K.A. Reek, Język C. Wskaźniki. Vademecum profesjonalisty, Helion, Gliwice, 2003.

- historia 1972 definicja języka C Dennis M. Ritchie Pierwowzór beztypowy język B ( Ken Thompson (1970)) będący adaptacją języka BCPL( Basic Combined Programming Language, Martin Richards(1967) ) dla PDP-7. 1974- opis języka C D.M. Ritchie, B.W. Kernighan, The C programming language, Prentice-Hall. Standard K&R. 1988- unowocześniony standard języka C- język ANSI C. Opis standardu : American National Standard for Information Systems-Programming Language C, X3.159-1989). Później standard ISO 9899:1990. 1999- nowy standard C99

- wstęp Zastosowanie: początkowo systemy operacyjne, oprogramowanie narzędziowe ( kompilatory, edytory) i oprogramowanie sieciowe, później oprogramowanie użytkowe. Kompilatory dostępne w praktycznie każdym systemie operacyjnym. Język C jest podstawowym językiem tworzenia oprogramowania dla procesorów sygnałowych i sterujących różnego typu urządzeniami (przykład - kompilator Keil C dla 8051). Stanowi też podstawę innych nowszych języków takich jak C++, Java, C#, PHP.

- wstęp Cechy języka C (cz. I): Typy: - typy podstawowe: typy znakowe, całkowite i rzeczywiste - typy pochodne : wskaźnikowe, tablice, struktury, unie i inne. Wyrażenia: budowane z operatorów i ich argumentów Wskaźniki: operacje na adresach niezależnie od maszyny

- wstęp Cechy języka C (cz. II) Konstrukcje sterujące: - grupowanie instrukcji (instrukcja złożona) - podejmowanie decyzji ( if, if-else, switch) - realizacja powtarzania ze sprawdzaniem warunku na początku ( for, while), na końcu ( do-while) - przerwanie (break) i kontynuacja pętli (continue)

- wstęp Cechy języka C (cz. III): Ogólna budowa programu - program składa z pewnych jednostek programowych (fragmentów kodu) zwanych funkcjami z dobrze określonymi mechanizmami komunikacji z otoczeniem - program w C posiada tzw. płaską strukturę tzn. funkcje są niezależne i nie można definiować jednych funkcji w drugich.

- wstęp Cechy języka C (cz. IV): Funkcje: -mogą zwracać wartości typów podstawowych, struktury, unie i wskaźniki - zmienne w funkcjach mogą być zmiennymi lokalnymi (automatyczne i statyczne) lub zewnętrznymi -mogą być wywoływane rekurencyjnie -mogą być rozmieszczone w jednym lub większej liczbie plików.

- wstęp Przykład 1. Prosty program w języku C - wersja 1 #include <stdio.h> int main() { printf("pierwszy program w jezyku C"); return 0; }

- wstęp Przykład 2. Prosty program w języku C - wersja 2 (zatrzymywanie wykonania programu) #include <stdio.h> #include <conio.h> int main() { printf("pierwszy program w jezyku C"); getch();/* lub system("pause") lub getchar()*/ return 0; }

- wstęp Przykład 3. Prosty program w języku C - wersja 3 /* program ten jest uzupełniony o wybrane elementy*/ #include <stdio.h> #include <conio.h> int main() { system("cls");/* lub clrscr(), w DevC++ konieczny plik naglowkowy conio2.h*/ printf("pierwszy program w języku C"); printf("\n napisany przez J. Kowalskiego"); getch(); return 0; }

- wstęp Przykład 4. Program z użyciem zmiennych typu int. #include <stdio.h> #include <conio.h> int main() { int a;/* lub int a,b,c;*/ int b; int c; a=1; b=2; c=a+b; printf("\n Suma a+b =%d",c); getch(); return 0; }

- wstęp Zmienna w języku C Zmienna w języku C z punktu widzenia programisty oznacza pewien obszar pamięci komputera, który może być używany przez programistę w określony sposób. Np. dla zmiennej a, rozmiar tego obszaru określa typ int ( skrót od integer-całkowity). Typ ten oznacza, że w zmiennych tego typu można przechowywać wartości całkowite z zakresu [ 2 31, 2 31 1] (w komputerach 32-bitowych typ int zajmuje 4 bajty). Liczby całkowite są przechowywane w kodzie U2.

Operatory w języku C Operatory to znaki lub kombinacje znaków symbolizujące pewne operacje w programie np. =, +, -. Operatory służą wraz i innymi elementami do tworzenia tzw. wyrażeń. Wyrażenie jest pewną kombinacją operatorów i innych elementów takich jak zmienne i stałe. Przykładami wyrażeń mogą być: -a - jest to wyrażenie składające się z operatora minus (-) i argumentu ( zmiennej a ) -b+c wyrażenie to składa się z operatora plus(+) i dwóch argumentów (zmienne a i b)

- wstęp Operator minus(-) w pierwszym wyrażeniu jest operatorem jednoargumentowym, a operator plus(+) w drugim wyrażeniu jest operatorem dwuargumentowym. Ogólnie w języku C operator jednoargumentowy może być użyty w sposób następujący: op argument lub argument op, a operator dwuargumentowy argument1 op argument2

Zakresy i rozmiary typów całkowitych Typ Rozmiar(bity) Zakres liczbowy unsigned char 8 0 do 255 char 8-128 do 127 short int 16-32768 do 32767 unsigned short int 16 0 do 65536 int 32-2147483648 do 2147483647 unsigned int 32 0 do 4294967295 long int 32 zakres int unsigned long int 32 zakres unsigned int long long int 64-2^63 do 2^63-1 unsigned long long int 64 0 do 2^64-1 ( typ wyliczeniowy enum zostanie omówiony w dalszej części) unsigned oznacza typ bez znaku (kod NKB), pozostałe są przechowywane w kodzie U2.

Operatory arytmetyki na liczbach całkowitych (ang. integer arithmetic) - operatory jednoargumentowe + i - operator dodawania + - operator odejmowania - - operator mnożenia * - operator dzielenia całkowitego / - operator obliczania reszty z dzielenia całkowitego % Operatory te są stosowane, gdy argument lub argumenty operatora są typu całkowitego.

Przykład. Program ilustrujący użycie operatorów arytmetyki całkowitej dla liczb ze znakiem. #include <stdio.h> #include <conio.h> int main() { int a,b,c; printf("podaj a:"); scanf("%d", &a); printf("\npodaj b:");scanf("%d", &b); c=a+b; printf("\n Suma %d + %d =%d", a,b,c); c=a-b; printf("\n Roznica %d - %d =%d", a,b,c); c=a*b; printf("\n Iloczyn %d * %d =%d", a,b,c); c=a/b; printf("\n Iloraz calkowity %d przez %d =%d", a,b,c); c=a%b; printf("\n Reszta z dzielenia całkowitego %d przez \ %d =%d", a,b,c); getch(); return 0; }

Uwaga: ani argumenty ani też rezultaty poszczególnych działań nie mogą przekraczać zakresów liczbowych dla poszczególnych typów podanych w tabeli. Przykładowo, dla niektórych kompilatorów mnożenie liczb 65000*40000 da liczbę ujemną ( Borland). Reprezentacja tego iloczynu jest 32-bitowa, stąd najwyższy jej bit wchodzi na pozycję znaku, co powoduje, że otrzymany ciąg bitów jest traktowany jako liczba ujemna w kodzie U2. l1=-1694967296 ( dla typu int) l=2600000000 ( dla typu unsigned int) Press any key to continue..

Przykład. Program ilustrujący użycie operatorów arytmetyki całkowitej dla liczb bez znaku. #include <stdio.h> #include <conio.h> int main() { unsigned int a,b,c; printf("podaj a:"); scanf("%u", &a); printf("\npodaj b:");scanf("%u", &b); c=a+b; printf("\n Suma %u + %u =%u", a,b,c); c=a-b; printf("\n Roznica %u - %u =%u", a,b,c); c=a*b; printf("\n Iloczyn %u * %u =%u", a,b,c); c=a/b; printf("\n Iloraz calkowity %u przez %u =%u", a,b,c); c=a%b; printf("\n Reszta z dzielenia całkowitego %u przez / %u =%u", a,b,c); getch(); return 0; }

Przykład. Program ilustrujący użycie operatorów arytmetyki całkowitej do obliczania wyrażenia. #include <stdio.h> #include <conio.h> y #include <math.h> int main() { int k,l, licznik, mianownik, wynik; printf("podaj k:"); scanf("%d", &k); printf("\n Podaj l:"); scanf("%d", &l); licznik=k*k*k+ k%5 +abs(l); mianownik=k+ k/(k+l); wynik=licznik/mianownik; printf("\n Wartosc wyrazenia=%d", wynik); getch(); return 0; } 3 k + k + l k k+ k+ l = 5

Typy rzeczywiste Zakresy i rozmiary typów rzeczywistych Typ Rozmiar(bity) Zakres liczbowy Liczba cyfr znaczących float 32 38 38 6-7 3.4 10 do 3.4 10 308 308 double 64 0.7 10 do 3.4 10 15-16 4932 3.4 10 do 0.1 4932 long double 80 19-20 10

-typy rzeczywiste Przykład. Program ilustrujący wczytywanie i drukowanie zmiennych rzeczywistych typu float, double i long double. #include <stdio.h> #include <conio.h> int main() {float x; double y; long double z; printf("podaj x:"); scanf("%f", &x); // %f jest deskryptorem formatu //stosowanym przy wczytywaniu // i drukowaniu zmiennych typu float printf("\n Podaj y:"); scanf(" %lf", &y);// %lf deskryptor formatu dla //zmiennych typu double printf("\npodaj z:"); scanf(" %Lf", &z);// %Lf deskryptor formatu dla //zmiennych typu long double printf("\n x= %f", x); printf("\n y= %f", y); printf("\n z= %Lf", z); getch(); return 0; }

- typy rzeczywiste Operatory arytmetyki rzeczywistej Operatory arytmetyki rzeczywistej to: - jednoargumentowy operator ' + ' - jednoargumentowy operator ' - ' - dwuargumentowy operator ' + ' - dwuargumentowy operator ' - ' - dwuargumentowy operator mnożenia '* ' - dwuargumentowy operator dzielenia ' / ' Operatory te występują w trzech wersjach: dla typu float,dla typu double i dla typu long double..

- typy rzeczywiste Przykład. Program ilustrujący użycie operatorów arytmetyki rzeczywistej. #include <stdio.h> #include <conio.h> int main() { double a,b,c; printf("podaj a:"); scanf("%lf", &a); printf("podaj b:"); scanf("%lf", &b); c=a+b; printf("\n Suma %f + %f =%f", a,b,c); c=a-b; printf("\n Roznica %f - %f =%10.2f", a,b,c); c=a*b; printf("\n Iloczyn %f * %f =%.4f", a,b,c); c=a/b; printf("\n Iloraz %e przez %e =%f", a,b,c); getch(); return 0;}

Wartości logiczne w języku C -Wartość logiczna prawda jest reprezentowana przez każdą liczbę różną od zera, np. 1, 2, -5. -Wartość logiczna fałsz jest reprezentowana przez 0.

Operatory relacji w języku C Operatory te to: < - mniejsze < = - mniejsze lub równe > - większe >= - większe lub równe = = - równe!= - różne

Wyrażenie relacyjne Wyrażenie relacyjne to wyrażenie składające się z operandów połączonych pewnym operatorem relacji np. a>b, a!=b, a==b. Język ANSI C op1 operator_relacyjny op2, Wartością wyrażenia relacyjnego jest 1, jeżeli wyrażenie jest prawdziwe albo też 0, gdy wyrażenie jest fałszywe.

Przykład. Prosty program ilustrujący zastosowanie operatorów relacyjnych #include <stdio.h> #include <conio.h> int main(int argc, char * argv[ ]) { int a,b,c; printf(" Podaj a=:"); scanf ("%d", &a); printf(" Podaj b=:"); scanf ("%d", &b); c=a<b; printf ("\n Wartosc wyrazenia %d < %d=%d",a,b,c); c=a<=b; printf ("\n Wartosc wyrazenia %d <= %d=%d",a,b,c); c=a==b; printf ("\n Wartosc wyrazenia %d ==%d=%d",a,b,c); c=a>b; printf ("\n Wartosc wyrazenia %d > %d=%d",a,b,c); c=a>=b; printf ("\n Wartosc wyrazenia %d > =%d=%d",a,b,c); c=a!=b; printf ("\n Wartosc wyrazenia %d!= %d=%d",a,b,c); getch(); return 0; }

Przykład. Program uzupełniony o możliwość wielokrotnego wykonania ( nieskończona pętla while) #include <stdio.h> #include <conio.h> int main(int argc, char * argv[ ]) { int a,b,c; while (1) { // początek pętli while printf(" Podaj a=:"); scanf ("%d", &a); printf(" Podaj b=:"); scanf ("%d", &b); c=a<b; printf ("\n Wartosc wyrazenia %d < %d=%d",a,b,c); c=a<=b; printf ("\n Wartosc wyrazenia %d <= %d=%d",a,b,c); c=a==b; printf ("\n Wartosc wyrazenia %d ==%d=%d",a,b,c); c=a>b; printf ("\n Wartosc wyrazenia %d > %d=%d",a,b,c); c=a>=b; printf ("\n Wartosc wyrazenia %d > =%d=%d",a,b,c); c=a!=b; printf ("\n Wartosc wyrazenia %d!= %d=%d",a,b,c); getch(); } // koniec pętli do while return 0; }

Wynik działania programu. Język ANSI C

Przykład. Program uzupełniony o możliwość wielokrotnego wykonania ( pętla while z określoną liczbą wykonań ) #include <stdio.h> #include <conio.h.> int main(int argc, char * argv[ ]) { int a,b,c, n, licznik=0; printf(" Podaj liczbe wykonan petli"); scanf("%d",&n); while (licznik <n) { printf(" Podaj a=:"); scanf ("%d", &a); printf(" Podaj b=:"); scanf ("%d", &b); c=a<b; printf ("\n Wartosc wyrazenia %d < %d=%d",a,b,c); c=a<=b; printf ("\n Wartosc wyrazenia %d <= %d=%d",a,b,c); c=a==b; printf ("\n Wartosc wyrazenia %d ==%d=%d",a,b,c); c=a>b; printf ("\n Wartosc wyrazenia %d > %d=%d",a,b,c); c=a>=b; printf ("\n Wartosc wyrazenia %d > =%d=%d",a,b,c); c=a!=b; printf ("\n Wartosc wyrazenia %d!= %d=%d",a,b,c); licznik=licznik+1; getch(); } return 0; }

Operatory te to: Operatory logiczne w języku C! - operator negacji && - operator koniunkcji (iloczynu logicznego) - operator alternatywy (sumy logicznej)

Tabela wartości dla operatorów logicznych x y x&&y x y!x 0 (fałsz) 0 (fałsz) 0 0 1 0 (fałsz) 1 (prawda) 0 1 1 1 (prawda) 0 (fałsz) 0 1 0 1 (prawda) 1 (prawda) 1 1 0

Przykład. Program ilustrujący najprostsze użycie operatorów logicznych. #include <stdio.h> #include <conio.h> int main(int argc, char * argv[ ]) { int a,b,c, n, licznik=0; printf(" Podaj liczbe wykonan petli"); scanf("%d",&n); while (licznik <n) { printf(" Podaj a=:"); scanf ("%d", &a); printf(" Podaj b=:"); scanf ("%d", &b); c=a&&b; printf ("\n Wartosc wyrazenia %d &&%d=%d",a,b,c); c=a b; printf ("\n Wartosc wyrazenia %d %d=%d",a,b,c); c=!a; printf ("\n Wartosc wyrazenia!%d=%d",a,c); licznik=licznik+1; getch(); } return 0; }

Przykład. Wyrażenia logiczne. Dla obliczenia wartości w poniższych wyrażeniach przyjęto x=1, y=4, z=14. Wyrażenie Wartość wyrażenia x<=1 && y==3 0 x<=1 y==3 1!(x>1) 1!x>1 0!(x<=1 y==3) 0 x>=1&&y==3 z<14 0

Priorytety operatorów cz. I O kolejności stosowania operatorów w wyrażeniu decyduje ich priorytet ( pierwszeństwo). Priorytet operatora decyduje o tym czy będzie on użyty przed innymi operatorami czy też po nich. Przykładowo, w wyrażeniu a+b*c stosowany jest najpierw operator *, a dopiero później operator +. Podobnie w wyrażeniu a>b && c<d e>f stosowane są najpierw operatory relacyjne, później operator && i następnie operator.

Hierarchia operatorów ( dotychczas stosowanych) Poziom 1 (najwyższy), + (jednoargumentowy),! Poziom 2 *, /, % Poziom 3 +, - Poziom 4 <, <=, >, >=, Poziom 5 ==,!= Poziom 6 && Poziom 7 Poziom 8 =

Identyfikatory Pisząc program musimy wybrać nazwy dla zmiennych, funkcji i innych obiektów. - Identyfikator (nazwa) jest sekwencją liter i cyfr o dowolnej długości (niektóre kompilatory wprowadzają tu pewne ograniczenia). - Pierwszy znak identyfikatora musi być literą, przy czym znak podkreślenia '_' jest traktowany jako litera. - Litery duże i małe są rozróżniane.

- Identyfikatory służą one do zapisu konstrukcji, jakie są dopuszczalne w C. - Identyfikator nie może być słowem kluczowym -słowa te to identyfikatory stosowane do tworzenia konstrukcji języka, np. for czy while zastrzeżone przez twórców języka lub kompilatora, Budowa identyfikatora Identyfikator w C musi spełniać następujące wymagania: a) zaczynać od litery (A do Z, a do z) lub też od znaku podkreślenia _ b) składać z liter (A do Z, a do z), cyfr lub też znaków podkreślenia _

Przykład. Legalne (dopuszczalne) identyfikatory ilosc ilosc_calkowita _suma kolumna3 ILOSC topofwindow Długość identyfikatorów nie jest zasadniczo ograniczona. Zgodnie ze standardem C pierwsze 31 znaków każdego identyfikatora to tzw. znaki znaczące. Jeżeli dwa identyfikatory różnią się od 32 znaku, mogą być uznane za ten sam identyfikator. Ze względu na to, że rozróżniane są litery małe i duże, identyfikatory ilosc i ILOSC są różnymi identyfikatorami.

Nazwy zewnętrzne, czyli nazwy funkcji i zmiennych łączonych zewnętrznie, mogą podlegać dodatkowym ograniczeniom w zależności od programu łączącego ( konsolidatora). Powinny być dobierane w ten sposób, aby znaczenie miało osiem pierwszych znaków. Przykład. Identyfikatory nielegalne (niepoprawne). ilosc$ (niedopuszczalny znak $) 2_suma float druga suma (rozpoczyna się cyfrą) (słowo kluczowe) (w identyfikatorze nie może być spacji) ILOSC-CALKOWITA (niedopuszczalny znak -)

Komentarze - Komentarze są ciągami znaków ujętych w pary znaków /* */. - Komentarze są ignorowane przez kompilator. Przykład. /* Komentarz w języku C */ - Komentarze takie mogą obejmować wiele wierszy. - W komentarzach można używać polskich znaków. - Dla standardu C99 i języka C++ można też stosować komentarz jednowierszowy rozpoczynający się od znaków //.

W języku ANSI C istnieją następujące słowa kluczowe: auto double int struct break else long switch case enum register typedef char extern return union const float short unsigned continue for signed void default goto sizeof volatile do if static while

W standardzie C99 języka C wprowadzono następujące dodatkowe słowa kluczowe: inline restrict _Bool _Complex _Imaginary

Instrukcja złożona (grupująca) Instrukcja złożona składa się z nawiasu klamrowego otwierającego, dowolnych instrukcji (mogą być również kolejne instrukcje złożone) i nawiasu klamrowego zamykającego: Przykład. Instrukcja złożona. { printf("instrukcja 1" ); printf("instrukcja 2\n"); } Wszystkie instrukcje w języku C z wyjątkiem instrukcji złożonej kończą się średnikiem. Instrukcja złożona jest stosowana wtedy, gdy istnieje konieczność zgrupowania kilku instrukcji, tak aby były traktowane jako jedna instrukcja.

Instrukcja while Instrukcja while jest instrukcją iteracyjną, umożliwiającą powtarzanie pewnego ciągu operacji. Instrukcja while ma następującą postać: while (wyrażenie) akcja W instrukcji while najpierw określa się, czy wyrażenie jest prawdziwe czy też fałszywe. C wymaga by wyrażenie było zawarte w nawiasach.. Jeżeli wyrażenie jest prawdziwe, wykonywana jest akcja i następuje powrót do obliczania wyrażenia. wyrażenie jest ponownie testowane i jeżeli jest prawdziwe, znowu wykonywana jest akcja i następuje kolejny powrót do obliczania wyrażenia. Jeżeli jednak przy którymś obliczaniu wyrażenia, stwierdzone zostanie, że wyrażenie jest fałszywe, następuje natychmiastowe przejście do instrukcji znajdującej się po instrukcji while.

Akcja może się składać z jednej instrukcji lub też szeregu instrukcji zawartych w nawiasach { }. Użycie tych nawiasów jest konieczne, jeśli akcja obejmuje więcej niż jedną instrukcję. Przykład. Użycie Instrukcji while. int x=0; while (x!= 2) x = x + 1; printf ("\n x = %d", x);

Fragment ten wydrukuje x = 2 Zmienna x jest inicjalizowana wartością 0 przy definicji. Ponieważ!= jest operatorem relacyjnym różne (nierówne), wyrażenie x!= 2 ma wartość logiczną prawda i wykonywana jest instrukcja x = x + 1, która dodaje 1 do x i wynik umieszcza w x. Następuje powrót do obliczania wyrażenia po while. Wyrażenie x!= 2 jest prawdziwe (gdyż x równa się 1), więc znowu dodawane jest 1 do x i następuje powrót do obliczania wyrażenia po while. Wyrażenie x!= 2 jest teraz fałszywe (bo x równa się 2), więc zostanie wykonana instrukcja printf ("\n x = %d", x); która pisze x = 2

Instrukcja do while Instrukcja do while jest podobna do instrukcji while, z tą różnicą, że wyrażenie kontrolujące pętlę jest na końcu pętli. Cała pętla wykonywana jest przynajmniej raz. do akcja while (wyrażenie); Przy wykonywaniu pętli do while wykonywana jest najpierw akcja, a następnie wykonywane jest sprawdzenie, czy wyrażenie jest prawdziwe czy też nie. Jeżeli jest prawdziwe, następuje powrót do początku pętli. Jeżeli w którymś momencie wyrażenie przyjmuje wartość logiczną fałsz (0), wykonywana jest pierwsza instrukcja występująca po pętli. Część pętli oznaczona jako akcja może być jedną instrukcją lub też grupą instrukcji zamkniętą w nawiasy { }.

Instrukcja do while jest użyteczna wtedy, gdy test kontynuacji pętli w sposób naturalny znajduje się na końcu pętli. Przykładem takiej sytuacji może być weryfikacja wartości wprowadzanej przez użytkownika z klawiatury. Po wprowadzeniu wartości, jest ona sprawdzana. Jeżeli wartość jest niedopuszczalna przy danym formacie, użytkownik zachęcany jest do wprowadzenia innej wartości. Przykład. Użycie instrukcji do while do wprowadzenia liczby dodatniej. int wartosc, k; do { printf ("\npodaj liczbe calkowita:"); k = scanf ("%d", &wartosc); fflush(stdin); //Czyszczenie strumienia wejściowego } while (!k wartosc <=0);

Instrukcja warunkowa if (cz.1) Instrukcja warunkowa if umożliwia uzależnienie wykonania instrukcji od spełnienia pewnego warunku. Warunek ten jest reprezentowany przez wyrażenie umieszczone po słowie if. Wyrażenie to przybiera wartość logiczną prawda lub wartość logiczną fałsz (wszystkie wartości różne od 0 są w języku C traktowane jako prawda, wartość 0 jako fałsz). Instrukcja ta ma następującą postać if (wyrażenie) akcja;

Instrukcja warunkowa if (cz.2) Wyrażenie musi być zawarte w nawiasach. Aby wykonać if, najpierw oblicza się wyrażenie i określa się czy jest prawdziwe czy też fałszywe. Jeżeli wyrażenie ma wartość logiczną prawda, zostaje wykonana akcja i sterowanie przechodzi do instrukcji programu umieszczonej po akcji. Jeżeli wyrażenie ma wartość logiczną fałsz, akcja zostaje pominięta i następuje przejście do instrukcji umieszczonej po akcji. Część if określona jako akcja składa się z pojedynczej instrukcji lub instrukcji złożonej (pewnej liczby instrukcji umieszczonych w nawiasach { }).

Przykład. Instrukcja if. int kod; printf("\n Podaj kod:"); scanf("%d",&kod); if (kod= =1) printf ("\n warunek jest spełniony"); Jeżeli z klawiatury podano wartość 1, fragment programu drukuje napis warunek jest spełniony Nie należy mylić znaku = z parą znaków = =. Można wprawdzie napisać if (x=1), jednak wyrażenie po if jest tutaj równe 1 niezależnie od wartości x, więc instrukcja if nie będzie pełnić swojej roli.

Instrukcja if else (cz.1) Instrukcja ta ma następującą postać: if (wyrażenie) akcja1 else akcja2 Podobnie jak dla instrukcji if, najpierw obliczane jest wyrażenie po if. Jeżeli wyrażenie ma wartość logiczną prawda, wykonywana jest akcja1, Natomiast, jeżeli wyrażenie ma wartość fałsz, jest wykonywana akcja2.

Instrukcja if else (cz.2) Przykład. Instrukcja if else int kod; printf("\n Podaj kod"); scanf("%d",&kod); if (kod = = 3245) printf("\n Podano prawidłowy kod"); else printf("\n Kod nie jest poprawny");

Instrukcja if else (cz.3) Przykład. Instrukcja if else ze złożonymi instrukcjami po if i po else. int kod; printf("\n Podaj kod"); scanf("%d",&kod); if (kod!=2) { printf("\n Instrukcje te wykonują się gdy "); printf("\n zmienna kod ma wartość < > od 2"); } else { printf("\n Instrukcje te się wykonuja"); printf("\n gdy zmienna kod ma wartosc 2 "); }

Przykład. Określić napisy drukowane przez poniższy fragment programu dla zmiennej kod=1 i 2. int kod; printf("\n Podaj kod"); scanf("%d",&kod); if (kod==2) { printf("\n Matematyk"); if (kod==2) printf(" artysta"); else printf(" programista"); } else printf("\n Specjalista programista");

Instrukcja if zagnieżdżone W instrukcji takiej po if lub po else występuje kolejna instrukcja warunkowa if lub if else. Instrukcja taka ma budowę następującą: if (wyrażenie1) akcja1; else if (wyrażenie2) akcja2; else if (wyrażenie3)... else if (wyrażenien) akcjan;

Działanie instrukcji if zagnieżdżone Instrukcja taka funkcjonuje w sposób następujący: jeżeli prawdziwy jest warunek pierwszy (wyrażenie1), to wykonywana jest akcja1 i następuje przejście do instrukcji umieszczonej po akcjan. Ogólnie, jeżeli jest prawdziwe wyrażenie i-te, to jest wykonywana i-ta akcja i następuje przejście do instrukcji po wyrażenien. Jest wykonywana tylko jedna akcja (grupa akcji w nawiasie klamrowym), pozostałe akcje są odrzucane.

Przykład. Instrukcja if zagnieżdżone. int kod; printf("\n Podaj kod"); scanf("%d",&kod); if (kod==1) printf("\nakcja ta jest wykonywana, gdy kod jest rowny 1"); /*instrukcja 1*/ else if (kod==2) printf("\nakcja ta jest wykonywana, gdy kod jest rowny\ 2");/*instrukcja 2*/ else if (kod<=3) printf("akcja ta jest wykonywana, gdy kod jest mniejszy lub \ rowny 3");/*instrukcja 3*/ Gdy zmienna kod ma wartość 1, wykonywana jest instrukcja 1, pomimo że wyrażenie kod<=3 jest prawdziwe, jednak sterowanie do niego w tym przypadku nie dochodzi.

if (wyrażenie1) akcja1; else if (wyrażenie2) akcja2; else if (wyrażenie3)... else if (wyrażenien) akcjan; else akcja; Instrukcja if else z akcją domyślną akcja jest tutaj działaniem domyślnym, które jest wykonywane, gdy żadna z akcji od 1 do N nie zostanie wykonana.

Przykład. Instrukcja if else z akcją domyślną. int kod; printf("\n Podaj kod"); scanf("%d",&kod); if (kod==1) printf("akcja ta jest wykonywana, gdy kod jest rowny 1"); else if (kod==2) printf("akcja ta jest wykonywana, gdy kod jest rowny 2"); else if (kod<=3) printf("akcja ta jest wykonywana gdy kod jest mniejszy lub\ else rowny 3"); printf("akcja ta jest wykonywana, gdy " "żadna z akcji 1, 2, 3 nie wykona się");

Operator?: Operator?: pozwala na zastąpienie niektórych instrukcji if-else. Operator ten ma postać: wyrażenie1? wyrażenie2 :wyrażenie3 Operator ten działa w sposób następujący: najpierw jest obliczane wyrażenie1, jeśli ma ono wartość logiczną prawda, wtedy jest obliczane wyrażenie2 i staje się ono wartością całego wyrażenia, jeśli zaś wyrażenie1 ma wartość logiczną fałsz, obliczane jest wyrażenie3 i ono staje się wartością całego wyrażenia. Przykład. int x,y; x=5; y=x>10? 50 : 100;

Operator?: Przykład. z=a>b? a: b; // max(a,b) Powyższa instrukcja wyznacza większą z wartości a i b. Wyrażenie warunkowe może być stosowane wszędzie tam, gdzie w języku C może wystąpić wyrażenie. Priorytet operatora?: jest względnie niski ( tuż nad operatorem przypisania) stąd nie jest konieczne stosowanie nawiasów, aby wymusić odpowiednią kolejność wykonywania operacji.

Operator przecinkowy Użycie operator przecinkowego jest stosowany przedstawić w sposób następujący: wyr1, wyr2,,wyrn Wyrażenia oddzielone przecinkami oblicza się od lewej do przy czym typem i wartością całego wyrażenia są typ i wartość wyrażenia wyrn. Przykład. int x, y; x= (y=15;y+1); Wartość x jest równa 16.

Operatory inkrementacji i dekrementacji Dla operatorów tych stosowane są następujące symbole ++ - dla operatora inkrementacji (zwiększania), oraz -- - dla operatora dekrementacji ( zmniejszania). Operatory te zwiększają wartość swego argumentu o 1 (operator ++), lub też zmniejszają o 1 ( operator --). Operatory te mogą być używane w następujących formach: ++ operand - ++ - operator preinkrementacji, operand++ - ++ - operator postinkrementacji, -- operand - -- - operator predekrementacji, operand -- - -- -operator postdekrementacji,

Operand w powyższych wyrażeniach z operatorami ++ lub -- może być typu arytmetycznego lub wskaźnikowego, musi być jednak tzw. Lwartością (ang. Lvalue), tzn. musi reprezentować pewną lokację pamięci. Użycie powyższych operatorów powoduje dwa efekty: -wartość operandu jest modyfikowana ( zwiększana lub zmniejszana o 1), -wyrażeniu z operandem jest przypisywana pewna wartość.

Działanie operatora postinkrementacji (operand ++). - wartość operandu jest zwiększana o 1, - wartość wyrażenia operand ++ jest równa początkowej wartości operandu. Przykład. x=3; y=x++; y=x++; x jest zwiększany o 1 wartość wyrażenia jest równa (x=4) początkowej wartości x ( y=3)

Działanie operatora preinkrementacji (++operand). - wartość operandu jest zwiększana o 1, - wartość wyrażenia ++operand jest równa zwiększonej o 1 wartości operandu. Przykład. x=3; y=++x; y=++x; x jest zwiększany o 1 (x=4) wartość wyrażenia jest równa zwiększonej wartości x (y=4)

Działanie operatora postdekrementacji (operand - -). - wartość operandu jest zmniejszana o 1, - wartość wyrażenia operand -- jest równa początkowej wartości operandu. Przykład. x=3; y=x--; y=x--; x jest zmniejszany o 1 (x=2) wartość wyrażenia jest równa początkowej wartości x(y=3)

Działanie operatora predekrementacji (- - operand). - wartość operandu jest zmniejszana o 1, - wartość wyrażenia operand -- jest zmniejszonej o 1 wartości operandu. Przykład. x=3; y=--x; y=--x; x jest zmniejszany o 1 (x=2) wartość wyrażenia jest równa zmniejszonej wartości x (y=2)

Przykład. Użycie operatorów preinkrementacji i postinkrementacji. #include <stdio.h> #include <conio.h> int main(int argc, char* argv[]) { int x,y; x= (y=15,y=y+1,y=y+1,++y); printf("\n x=%d",x); x= (y=15,y=y+1,y=y+1,y++); printf("\n x=%d",x); getch(); return 0; }

Instrukcja for Instrukcja for, zwana też pętlą for, jest instrukcją iteracyjną podobnie jak instrukcje while i do while. Stosowana jest ona do wielokrotnego powtarzania pewnego segmentu kodu. Pętla for w języku C jest podobna do pętli for w innych językach programowania, posiada jednak znacznie większe możliwości. Pętla for ma następującą postać: for (wyr1; wyr2; wyr3) akcja

Wyrażenie wyr1 jest stosowane do inicjalizacji pętli, wyrażenie wyr2 jest używane do testowania warunku kontynuacji pętli, wyrażenie wyr3 służy do uaktualniania pętli. akcja stanowi treść (ciało) pętli. Działanie: Krok1. Obliczenie wyrażenia wyr1 (jest ono obliczane jeden raz i tylko jeden raz na początku działania pętli). Krok 2a. Obliczenie wyr2 i sprawdzenie czy wyrażenie wyr2 jest prawdziwe czy też fałszywe. Krok 2b. Jeżeli wyr2 jest fałszywe, zakończenie pętli i przejście do instrukcji umieszczonej bezpośrednio po pętli. Jeżeli wyr2 jest prawdziwe, wykonanie akcji. Krok 3. Obliczenie wyrażenia wyr3, następnie przejście do Kroku 2.

Ciało pętli (akcja) może być pojedynczą instrukcją albo też instrukcją złożoną (grupującą), jeśli jest konieczne wykonanie w pętli więcej niż jednej instrukcji Przykład. Użycie pętli for. int sum=0; int i; for (i=1; i<=4;i=i+1) sum=sum+i; W powyższym przykładzie w pętli for najpierw jest wykonywana instrukcja i=1, następnie sprawdzany jest warunek i<=4, dla i=1 jest on prawdziwy, więc wykonywana jest instrukcja sum=sum+i; i następuje przejście do instrukcji i=i+1, i przyjmuje wartość 2, i wykonywane jest sprawdzenie i<=4, warunek jest prawdziwy, więc ponownie wykonywana jest instrukcja sum=sum+i. Gdy i przybierze wartość 5, warunek i<=4 nie spełniony i pętla kończy się.

Przykład. Użycie pętli for ( typowy zapis) #include <stdio.h> #include <conio.h> int main(int argc, char* argv[]) { int i,sum; // operator przecinkowy for( i=0,sum=0; i<=4;i++) sum=sum+i; printf("\n sum=%d",sum); getch(); return 0; } W wyrażeniu wyr1 użyto operator przecinkowy.

Przykład. #include <stdio.h> #include <conio.h> int main(int argc, char* argv[]) { int x, y; } for( x=0,y=0; x+y<10 ;x++) { y=getch(); // wczytywanie y jako znaku putchar(y); // drukowanie wczytanego znaku y=y -'0'; // wyznaczanie cyfry reprezentowanej przez // wczytany znak } printf("\n x=%d y=%d", x,y); getch(); return 0;

Odmiany pętli for 1. Pętla nieskończona for ( ; ; ) printf ("Pętla ta będzie działać w nieskończoność"); Brak wyr2 uważany jest za wyrażenie o wartości logicznej prawda. 2. Pętla bez treści(ciała) for (i=0;i<100000;i++) ; // pętla taka może realizować //opóźnienie w programie Ogólnie w pętli for może nie być któregoś z wyrażeń albo też wszystkich, jednak zawsze muszą być dwa średniki. Przykład. Pętla bez wyrażenia wyr3. for( i=0,sum=0; i<=4;) { sum=sum+i; i++; }

typy rzeczywiste Arytmetyczne funkcje standardowe ANSI C Standard ANSI/ISO C definiuje zawartość i postać standardowej biblioteki języka ANSI C. Standard określa zestaw funkcji, w który muszą być wyposażone kompilatory zgodne ze standardem. Kompilatory mogą też zawierać funkcje, które nie są określone w standardzie. Każda funkcja zdefiniowana w standardowej bibliotece języka C ma odpowiadający jej nagłówek, nagłówki te są zawarte w plikach nagłówkowych włączanych dyrektywą #include. Standard C89 (ANSI C) zawiera następujące 22 standardowe funkcje arytmetyczne: acos cos fmod modf tan asin cosh frexp pow tanh atan exp ldexp sin atan2 fabs log sinh ceil floor log10 sqrt

typy rzeczywiste acos double acos (double arg); long double acosl (long double arg); Funkcje te obliczają arcus cosinus arg. Argument musi należeć do przedziału [-1,1]. Jeżeli argument nie należy do tego przedziału, pojawi się błąd dziedziny (ang. domain error). asin double asin (double arg); long double asinl (long double arg); Funkcje te obliczają arcus sinus arg. Argument musi należeć do przedziału [-1,1]. Jeżeli argument nie należy do tego przedziału, pojawi się błąd dziedziny (ang. domain error).

typy rzeczywiste atan double atan (double arg); long double atanl (long double arg); Funkcje atan i atanl dla argumentu rzeczywistego obliczają wartość arcusa tangensa (wynik w zakresie -pi/2 do pi/2). atan2 double atan2 (double y, double x); long double atan2l (long double y, long double x); Funkcje atan2 i atan2l dla argumentu rzeczywistego obliczają wartość arcusa tangensa y/x (wynik w zakresie -pi/2 do pi/2).

typy rzeczywiste double ceil (double num); long double ceill (long double num); Funkcje zwracają (obliczają) najmniejszą liczbę całkowitą typu double nie mniejszą niż num. Np. dla num równego 1.05 funkcja zwraca wartość 2.0, a dla -1.05, zwraca -1.0. double cos (double arg); double cosl (long double arg); Funkcja ta zwraca cosinus arg. Kąt jest podawany w radianach. Zwracana wartość w zakresie [-1,1]. double cosh (double arg); long double coshl (long double arg); Funkcja ta zwraca cosinus hiperboliczny arg.

typy rzeczywiste double exp (double num); long double expl (long double num); e Funkcja oblicza. x W pewnych sytuacjach argumenty przekazane do tych funkcji powodują nadmiar arytmetyczny lub wynik nie może zostać obliczony. Gdy powstaje nadmiar arytmetyczny, funkcja exp zwraca HUGE_VAL, a expl zwraca _LHUGE_VAL. Rezultaty o bardzo dużej wartości powodują ustawienie zmiennej globalnej errno na ERANGE Result out of range. Przy niedomiarze arytmetycznym funkcje te zwracają 0.0, errno nie jest zmieniana. Traktowanie błędu dla tych funkcji może być zmienione poprzez funkcje _matherr i _matherrl.

typy rzeczywiste double fabs (double num); long double fabsl (long double num); Funkcje obliczają wartość bezwzględną argumentu num. double floor (double num); long double floorl (long double num); Funkcje te zwracają (obliczają) największą liczbę całkowitą nie większą niż num. Np. dla 1.05 funkcja zwraca wartość 1.0, a dla -1.05, zwraca -2.0. double fmod (double a, double b); long double fmodl (long double a, long double b); Funkcje obliczają rzeczywistą resztę z dzielenia a/b ( w matematyce takie działanie nie jest określone)

typy rzeczywiste double frexp (double num, int *pexp); long double frexpl (long double num, int *pexp); Funkcje te rozkładają liczbę num na mantysę z przedziału [0.5,1.0] oraz wykładnik * exp całkowity *pexp, takie że num= mantysa 2 p. Mantysa jest zwracana przez przez każdą z funkcji. Przykład. int eksponent; double num=0.5, mantysa; mantysa=frexp(num,&eksponent); double ldexp (double num, int exp); long double ldexpl (long double num, int exp); 2 exp Funkcje obliczają wartość wyrażenia num.

typy rzeczywiste double log (double num); long double logl (long double num); Funkcje obliczają logarytm naturalny z num. Jeżeli num<0, występuje błąd dziedziny, dla num=0 błąd zakresu. double log10 (double num); long double log10l (long double num); Funkcje obliczają logarytm dziesiętny z num. Jeżeli num<0, występuje błąd dziedziny, dla num=0 błąd zakresu.

typy rzeczywiste double modf (double num, int *pi); long double modfl (long double num, int *pi); Funkcje te rozkładają liczbę num na część całkowitą i część ułamkową. Funkcja zwraca część ułamkową, a część całkowitą wstawia do zmiennej wskazywanej przez wskaźnik pi. Przykład. int czcalkowita; double num=0.5,czulamkowa; cz_ulamkowa=modf(num,&czcalkowita); double pow(double base, double exp); long double powl (long double base, long double exp ); Funkcje obliczają wartość base podniesioną do potęgi exp. Jeżeli argument odpowiadający base przekazany do pow lub powl jest rzeczywisty i mniejszy od 0, a argument odpowiadający exp nie jest całkowity lub jeśli argument odpowiadający base jest równy 0 a argument odpowiadający exp jest mniejszy od 0, lub stosuje się wywołanie pow(0,0), zmienna globalna errno jest ustawiana na wartość EDOM Domain error..

typy rzeczywiste double sin (double arg); long double sinl (long double arg); Funkcje te zwracają sinus arg. Kąt jest podawany w radianach. Zwracana wartość w zakresie [-1,1]. double sinh (double arg); long double sinhl (long double arg); Funkcje te zwracają sinus hiperboliczny arg. double sqrt (double arg); long double sqrtl (long double arg); Funkcja ta zwraca dodatni pierwiastek kwadratowy z arg. Jeżeli arg mniejszy od 0, zmienna globalna errno jest ustawiana na wartość EDOM Domain error.

typy rzeczywiste double tan (double arg); long double tanl (long double arg); Funkcje te zwracają tangens arg. Wartość arg jest podawana w radianach. double tanh (double arg); long double tanhl (long double arg); Funkcje te zwracają tangens hiperboliczny arg.

typy rzeczywiste Przykład. Napisać program obliczający dane wyrażenie dla zmiennych x i z typu double wprowadzanych z klawiatury. Przy wprowadzaniu danych sprawdzać czy dane reprezentują liczby, czy należą do dziedziny oraz czy nie nastąpi przekroczenie zakresu typu double. y = log sin x + tgx log ( x 1) + 2 3 + e x ctgz 5 + + π 3 x x

typy rzeczywiste #include <stdio.h> #include <conio.h> #include <math.h> int main(int argc, char* argv[]) { double x,z,p1,p2,p3,p4,p5,p6,q1,q2,q3,licznik,mianownik,wynik; int k; printf("\n Podaj x:"); scanf("%lf",&x); printf("\n Podaj z:"); scanf("%lf",&z); p1=fabs(sin(x)); p2=log10(p1); p3=fabs(tan(x)); p3=sqrt(p3); p4=fabs(pow(x,5)); p5=exp(p4); p6=floor(pow(3,x)); q1=log10(x-1)/log10(2); q2=pow(1/tan(z),1/3.0); q3=pow(m_pi,x); Przykład. Obliczanie wyrażenia ( wersja bez sprawdzania danych)

typy rzeczywiste // cz.2 programu obliczającego wyrażenie licznik=p2+p3+p5+p6; mianownik=q1+q2+q3; if (mianownik) { wynik=licznik/mianownik; printf("\n Wartosc wyrazenia wynosi=%f",wynik); getch(); } else { printf("\n Dzielenie przez zero"); getch(); } return 0; }

typy rzeczywiste Dziedzina: a) ze względu na funkcję logarytm w liczniku x musi być różny od wielokrotności pi. b) ze względu na funkcję logarytm w mianowniku, musi być x>1. Ograniczenie na x wynika też z wartości przybieranych przez człon Musi być spełniona zależność x e 5 e 5 x 308 10 Graniczną wartość x możemy określić jako x = 5 308 ln10 3.71

typy rzeczywiste // Fragment programu związany ze sprawdzaniem danych wejściowych #include <stdio.h> #include <conio.h> #include <math.h> int main(int argc, char* argv[]) { double x,z,p1,p2,p3,p4,p5,p6,q1,q2,q3,licznik,mianownik,wynik; int k; do { printf("\n Podaj x:"); k= scanf("%lf",&x); fflush(stdin); if (k==0) printf("\n Niewlasciwy format liczby"); else if (x<=1 x==m_pi x>3.7) printf("\n x nie należy do\ dziedziny"); } while (k==0 x<=1 x==m_pi x>3.7 ); do { printf("\n Podaj z:"); k=scanf("%lf",&z); } while(!k fmod(z,m_pi)==0);

Instrukcja break Instrukcja break powoduje natychmiastowe przerwanie wykonywania pętli, w której została umieszczona. Przykład. Użycie instrukcji break w pętli. int i; for (i=0;i<5;i++) { printf("\n i=%d ",i); if (i==3) break; printf("\n Koncowa instrukcja petli"); } printf("\n Poza petla"); W przykładzie powyższym, gdy zmienna i osiągnie wartość 3, warunek po if ma wartość logiczną prawda, co powoduje wykonanie jest instrukcja break, która daje natychmiastowe przerwanie wykonywania pętli.

Instrukcja continue Instrukcja continue jest podobna do instrukcji break w tym sensie, że również przerywa działanie pętli, jednak pętla nie ulega zakończeniu, lecz następuje przeskok do wykonania wyrażeń sterujących pętlą. Dla pętli for mamy for (wyr1;wyr2;wyr3) { blok instrukcji_1 if (warunek) continue; blok instrukcji_2 } Jeżeli warunek po if jest prawdziwy, to wykonanie continue powoduje natychmiastowe przejście, bez wykonania bloku instrukcji_2, do obliczenia wyrażenia wyr3 i następnie do obliczenia wyrażenia wyr2. Jeżeli wyrażenie wyr2 ma wartość logiczną prawda, wykonanie pętli jest kontynuowane..

Dla pętli while i pętli do while następuje natychmiastowe przejście do obliczenia wyrażenia sterującego pętlą, czyli dla pętli while na początek pętli, a dla pętli do while na koniec pętli. Przykład. Program oblicza średnią liczb dodatnich podawanych na wejście, liczby ujemne są odrzucane przy użyciu instrukcji continue. #include <stdio.h> #include <conio.h> int main() {double x, suma=0; int ilosc=0; while ( printf ("\n Podaj liczbe :"), scanf("%lf",&x)!=0) { if (x<0.0) continue; suma=suma+x; ilosc++; } if (ilosc>0) printf("\n Srednia=%f", suma/ilosc); else printf("\n Nie podano zadnych liczb dodatnich"); getch(); return 0;}

Instrukcja switch switch( wyrazeniecalkowite) { case etykieta_1: instrukcja 1; case etykieta_2: instrukcja 1;... case etykieta_n: instrukcja_n; default: instrukcje; } Wyrażenie po słowie switch, zwane wyrażeniem wyboru lub selektorem, musi przyjmować wartości całkowite. Etykiety są całkowitymi wartościami stałymi lub wyrażeniami stałymi. Jeśli podczas wykonywania instrukcji switch jedna z etykiet ma wartość równą wartości selektora (oznaczonego jako wyrazenie_calkowite), to wykonanie instrukcji switch rozpoczyna się od wykonania instrukcji znajdującej się przy tej etykiecie.

Jeżeli w instrukcji switch występuje słowo default (ang. domyślny), to instrukcje umieszczone po słowie default są wykonywane, gdy żadna z etykiet nie ma wartości równej selektorowi. Etykieta default jest opcjonalna, i jeżeli nie występuje, to następuje przejście do pierwszej instrukcji po instrukcji switch. Jeżeli chce się uzyskać wykonanie tylko jednej konkretnej instrukcji, należy po każdym wariancie umieścić słowo break wraz ze średnikiem. Spowoduje to natychmiastowe przerwanie wykonywania instrukcji switch po zrealizowaniu instrukcji związane z danym wariantem.

Przykład. W przykładzie wczytywana jest liczba całkowita i jeżeli jest to liczba 0,1,2 lub 3, drukowany jest komunikat informujący o wartości liczby. Jeżeli jest podaną liczbą jest inna liczba, drukowany jest komunikat Inna liczba. #include <stdio.h> #include <conio.h> int main() { int liczba; printf("podaj liczbe:"); scanf("%d", &liczba); switch(liczba) { case 0: printf("\n Liczba 0"); break; case 1: printf("\n Liczba 1"); break; case 2:case 3: printf("\n Liczba 2 lub 3"); break; default : printf("\n Inna liczba"); } getch(); return 0; }

Instrukcja goto (cz.1) Instrukcja goto to tzw. instrukcja skoku powodująca bezwarunkowe przejście sterowania do pewnego punktu w programie opatrzonego etykietą. Etykieta jest identyfikatorem i zakończona jest dwukropkiem. Etykietę można umieścić przed każdą instrukcją w funkcji, w której występuje instrukcja goto. Przykład. int j=1; E1: j++; if (j<=100) goto E1; printf("\n j=%d", j);

Instrukcja goto (cz.2) Stosowanie instrukcji goto nie jest zalecane, gdyż zwykle jej wielokrotne użycie powoduje, iż program staje się mniej czytelny jak również trudniejszy do modyfikacji. Istnieją jednak sytuacje, gdzie instrukcja goto jest wygodnym rozwiązaniem. Przykład. int i,j,k; for ( i=0;i<100;i++) for (j=0;j<100;j++) for (k=0;k<50;k++) if (i+j+k>10000) goto E2; E2: printf ("\n Instrukcja poza petlami");