Katedra Elektrotechniki Teoretycznej i Informatyki. sem. III i IV. Dr inż. M. Czyżak

Katedra Elektrotechniki Teoretycznej i Informatyki sem. III i IV Dr inż. M. Czyżak

Literatura: 1. A.R. Neubauer, Języki C i C++, Twój pierwszy program, Help, W-wa, 1995. 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, WNT, Warszawa, 1994. 5. Andrzej Zalewski, Programowanie w językach C i C++ z wykorzystaniem pakietu Borland C++, Nakom, Poznań, 1999.

Język ANSI C - 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.

Język ANSI C - 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).

Cechy języka C cz I: Język ANSI C - wstęp 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

Cechy języka C cz. II: Język ANSI C - wstęp 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)

Cechy języka C cz III: Język ANSI C - wstęp 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.

Język ANSI C - 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.

Język ANSI C - wstęp Przykład 1. Prosty program w języku C- wersja 1 #include <stdio.h> main() { printf( Pierwszy program w języku C ); }

Język ANSI C - wstęp Przykład 2. Prosty program w języku C- wersja 2 #include <stdio.h> #include <conio.h> main() { printf( Pierwszy program w języku C ); getch(); }

Język ANSI C - 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> main() { clrscr(); printf( Pierwszy program w języku C ); printf( \n napisany przez J. Kowalskiego ); getch(); return 0; }

Język ANSI C - przykład Przykład 4. Prosty program z użyciem zmiennych #include <stdio.h> #include <conio.h> main() { int a; int b; int c; a=1; b=2; c=a+b; printf( \n Suma a+b =%d,c); getch(); return 0; }

Język ANSI C pojęcie zmiennej 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 ( dla kompilatora Borland Builder C++ typ int zajmuje 32 bity i można 31 31 przechowywać wartości z zakresu [ 2, 2 1]. Liczby całkowite są przechowywane w kodzie U2.

Język ANSI C operatory Operatory w jezyku 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 skladają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)

Język ANSI C operatory 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: a operator dwuargumentowy op argument lub argument op, argument1 op argument 2

Język ANSI C operatory Operatory w C można podzielić na następujące grupy: -operatory arytmetyczne ( np. +,-,*,/, %, ++, --) -operatory relacyjne (<,<=, ==, >, >=,!=) -operatory logiczne (&&,,!) -operatory bitowe ( ~, &,, ^) -operator funkcyjny () -operator indeksowania [ ] - operatory adresowy ( &) i dereferencji (*)

Język ANSI C operatory -operator sizeof -operator warunkowy(?) -operatory przypisania ( np. =) -operator rzutowania (typ) -operator przecinkowy -operatory bezpośredniego(. ) i pośredniego odwołania do pola struktury(->)

Język ANSI C typy całkowite 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 ( typ wyliczeniowy enum zostanie omówiony w dalszej części) unsigned oznacza typ bez znaku (kod NKB), pozostałe są przechowywane w kodzie U2.

Język ANSI C operatory 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.

Język ANSI C operatory /*Przykład 5. Program ilustrujący użycie operatorów arytmetyki całkowitej dla liczb ze znakiem*> #include <stdio.h> #include <conio.h> main() { int a,b,c; printf( Podaj a: ); scanf( %d, &a); printf( Podaj 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; }

Język ANSI C typy całkowite 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, mnożenie liczb 65000*40000 da liczbę ujemną. 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.

Język ANSI C typy całkowite /*Przykład 6. Program ilustrujący użycie operatorów arytmetyki całkowitej dla liczb bez znaku*/ #include <stdio.h> #include <conio.h> main() { unsigned int a,b,c; printf( Podaj a: ); scanf( %u, &a); printf( Podaj 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;}

Język ANSI C typy całkowite Przykład 7. Program ilustrujący użycie operatorów arytmetyki całkowitej do obliczania wyrażenia #include <stdio.h> #include <conio.h> #include <math.h> main() { int k,l, licznik, mianownik, wynik; printf( Podaj k: ); scanf( %d, &k); printf( \n Podaj l: ); scanf( %d, &k); 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; } y 3 k + k + l k k+ k+ l = 5

Język ANSI C operatory cz. V 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.

Język ANSI C operatory cz. VI Operatory relacji w języku C Operatory te to: < - mniejsze < = - mniejszy lub równe > - większe >= - większe lub równe == - równe!= - rózne

Język ANSI C operatory cz. IV 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. 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.

Język ANSI C -operatory 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; prinf ( \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; prinf ( \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; }

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; prinf ( \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; }

Język ANSI C operatory cz. VII Operatory logiczne w języku C Operatory te to:! - operator negacji && - operator koniunkcji( iloczynu logicznego) - operator alternatywy (sumy logicznej)

Język ANSI C operatory 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; prinf ( \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=1. 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 1

Język ANSI C -operatory 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.

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

Język ANSI C identyfikator Identyfikatory Jeżeli piszemy 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.

Język ANSI C identyfikatory - Służą one do zapisu konstrukcji, jakie są dopuszczalne w języku C. - Identyfikator nie może być słowem kluczowym(niektóre identyfikatory zostały zastrzeżone przez twórców języka). 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 _ ; c) nie może być słowem kluczowym (słowo kluczowe to takie słowo jak for czy while ).

Język ANSI C identyfikatory Przykład. Legalne (dopuszczalne) identyfikatory ilosc ilosc_calkowita _suma kolumna3 ILOSC Zwyjątkiem identyfikatorów zewnętrznych (nazw zewnętrznych), 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 wielkie identyfikatory ilosc i ILOSC są różnymi identyfikatorami.

Język ANSI C identyfikatory Przykład. Identyfikatory nielegalne (niepoprawne). ilosc$ (niedopuszczalny znak $) 2_suma long druga suma (rozpoczyna się cyfrą) (słowo kluczowe) (w identyfikatorze nie może być spacji) ILOSC-CALKOWITA (niedopuszczalny znak -)

Język ANSI C komentarze Komentarze - Komentarze są ciągami znaków ujętych w znaki /* */. - Komentarze są ignorowane przez kompilator. Przykład. /* Komentarz w języku C */ - Komentarze takie mogą obejmować wiele wierszy. - W komentarzach można używać polskie znaki. -Jeśli stosuje się kompilator C++, można też stosować komentarz jednowierszowy rozpoczynający się od znaków //.

Język ANSI C 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

Język ANSI C typ znakowy Typ znakowy -W językach programowania istnieje konieczność reprezentowania, oprócz liczb, także znaków, np. liter. -Znaki są reprezentowane wewnętrznie w postaci pewnych całkowitych nieujemnych liczb zwanych kodami znaków. -Sposób przyporządkowania poszczególnym znakom odpowiednich liczb zwany jest kodem. Przykłady kodów to np. ASCII, EBDIC, Unicode, 8859-2.

Język ANSI C typ znakowy Kod ASCII - Kod ASCII (ang. American Standard Code for Information Interchange) jest standardowym sposobem kodowania znaków. - Standardowy oznacza, że jest powszechnie przyjęty przez wytwórców różnych urządzeń, aby mogły się ze sobą komunikować. - Kodowanie oznacza, że każdemu znakowi odpowiada w tym kodzie pewna liczba będąca jej tzw. kodem ASCII.

- Kody z zakresu [0,31] reprezentują tzw. znaki sterujące np. kod 8 znak BS (ang. backspace), kod 10 znak LF (ang. Line Feed- nowa linia), kod 13 znak CR (ang. Carriage Return- powrót karetki, terminologia pochodzi z maszyn do pisania). Cyfry są reprezentowane przez kody z przedziału [48,57], duże litery z [65,90], a małe litery [97,122]. ( kody pozostałych znaków w dostarczonym materiale). Język ANSI C typ znakowy Kod ASCII - W kodzie ASCII znaki o kodach z zakresu [0,127] należą do tzw. standardowego zestawu znaków. Kodom z tego zakresu odpowiadają te same znaki we wszystkich urządzeniach wykorzystujących kod ASCII. Ogólna budowa kodu ASCII

Język ANSI C typ znakowy Typ znakowy -W języku C istnieje specjalny typ char o zakresie [-128,127] przeznaczony do operacji na znakach. Zmienne i stałe tego typu zajmują 1 bajt. Zmienne są definiowane w sposób następujący: char ch; -W języku C istnieje szereg funkcji istnieje umożliwiających wykonywanie operacji na znakach takich jak wprowadzanie znaków z klawiatury, wyprowadzanie znaków na ekran i klasyfikacja znaków.

Język ANSI C typ znakowy Wejście znakowe(1) - Znaki mogą być wczytywane z klawiatury przy zastosowaniu funkcji pochodzących ze standardowej biblioteki języka C lub też funkcji dostarczanych przez producentów kompilatorów. 1. Funkcja scanf. Przy wczytywaniu znaków konieczne jest zastosowanie deskryptora format %c. printf( Podaj znak : ); scanf ( %c,&ch); 2. Funkcja getchar(). printf( Podaj znak : ); ch=getchar();

Język ANSI C typ znakowy Wejście znakowe (2) - Funkcja getch(); printf( Podaj znak : ); ch=getch(); Wczytywanie znaku przy użyciu scanf i getchar wymaga Enter po wprowadzeniu znaku.

Język ANSI C typ znakowy Wyjście znakowe - Wyprowadzenie znaku na ekran może być zrealizowane w sposób następujący printf( Znak=%c, ch); lub putchar(ch); lub putch (ch);

Język ANSI C typ znakowy Przykład. Drukowanie wybranych znaków i ich kodów ASCII. #include <stdio.h> #include <conio.h> main() { int i ; i=32; clrscr(); while (i<256) { printf( \n \n Znak =%c kod dec=%3d hex =%x oct=%o, i, i, i, i ); getch(); i++; } return 0; }

Język ANSI C typ znakowy Stałe znakowe Stała znakowa ciąg złożony z jednego lub wiekszej liczby znaków ujęty w pojedyncze apostrofy np. x. Stałe jednoznakowe są typu char, a wieloznakowe typu int. Stałe znakowe mogą być używane w operacjach arytmetycznych. W operacjach stosowany jest kod ASCII liczby np.. int cyfra; cyfra= 5-0 ; Faktycznie jest to odejmowanie 53-48, czyli w zmiennej cyfra będzie wartość 5.

Język ANSI C typ znakowy Stałe znakowe Stałe znakowe mogą być zapisywane również przy zastosowaniu kodów heksalnych i oktalnych, np. stałą znakową A można zapisać także jako \x41 albo też \101. Mechanizm ten ma szczególne znaczenie jeżeli chce się drukować znaki, które nie występują na klawiaturze.

Język ANSI C typ znakowy Stałe znakowe Przykładowo, napis Róża bez kolców można wydrukować w sposób następujący: printf("\n R\242\276a bez kolc\242w"); //wersja oktalna printf("\n R\xa2\xbe a bez kolc\xa2w");// wersja heksalna W powyższych instrukcjach zastosowano kody oktalne i heksalne liter ó i ż. 242 i a2 są kodami ó, a 276 i be litery ż.

Język ANSI C typ znakowy Sekwencje ucieczki ( ang. escape sequences) Znaki, które nie mają reprezentacji graficznej na ekranie monitora lub też mają specjalne znaczenia w łańcuchach znaków, mogą być wygenerowane przy użyciu tzw. sekwencji ucieczki złożonych z ukośnika \ i odpowiedniego znaku.

Język ANSI C typ znakowy Tabela sekwencji ucieczki cz. I Nazwa sekwencji Symbol Zapis znakowy Wartość liczbowa Nowy wiersz NL(LF) \n 10 (dec) Tabulacja pozioma Tabulacja pionowa Kasowanie znaku (backspace) HT \t 9(dec) VT \v 11(dec) BS \b 8(dec) Powrót karetki CR \r 13(dec)

Język ANSI C typ znakowy Tabela sekwencji ucieczki cz. II Nazwa sekwencji Symbol Zapis znakowy Wartość liczbowa Nowa strona ( form feed) Dzwonek (alert) FF \f 12 (dec) BEL \a 7(dec) Lewy ukośnik \ \\ 92(dec) Znak zapytania? \? 63(dec) Pojedynczy apostrof Podwójny apostrof \ 39(dec) \ 34(dec) Znak zerowy NUL \0 0

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

Język ANSI C typy rzeczywiste Przykład. Program ilustrujący wczytywanie i drukowanie zmiennych rzeczywistych typu float, double i long double. #include <stdio.h> #include <conio.h> 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; }

Język ANSI C typy rzeczywiste /*Przykład. Program ilustrujący użycie operatorów arytmetyki rzeczywistej*/ #include <stdio.h> #include <conio.h> 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;}

Język ANSI C typy rzeczywiste Formatowanie wydruku liczb rzeczywistych Formatowanie wydruku to kształtowanie zewnętrznej postaci liczb (na ekranie monitora lub na drukarce). Zakres takiego kształtowania zależy od formatu liczby rzeczywistej czyli sposobu jej przechowywania w pamięci komputera. Powszechnie przyjmuje się tzw. formaty standardowe zgodne z pewną normą. Normą tą jest tzw. standard IEEE 754. Standard ten określa cztery podstawowe formaty binarne liczb rzeczywistych: -zwykły o o pojedynczej precyzji (SINGLE) - rozszerzony o pojedynczej precyzji (SINGLE EXTENDED) -zwykły o podwójnej precyzji (DOUBLE) - rozszerzony podwójnej precyzji (DOUBLE EXTENDED) s...... E- wykładnik w e-bitowym kodzie z obciążeniem +N f- ułamek ( m-bitowy kod modułu mantysy bez bitu ukrytego)

Język ANSI C typy rzeczywiste W standardzie IEEE 754 wymaga się, aby reprezentacje liczb były znormalizowane( nie dotyczy to liczb bardzo bliskich 0). Moduł mantysy ma być liczbąm z przedziału 1 M < 2 i obowiązuje konwencja ukrytej jedynki, co oznacza, że najstarszy bit mantysy jest równy 1, jednak nie jest pamiętany. Każdy moduł ma postać 1.bbb...b. Wartość liczby znormalizowanej można wyrazić następującą zależnością: ( ) s 1 (1+ f E F = ) 2

Język ANSI C typy rzeczywiste Wybrane formaty IEEE 754 Parametr Symbol SINGLE DOUBLE DOUBLE EXTENDED Rozmiar formatu n 32 64 >=79 Rozmiar mantysy m 23(+1) 52(+1) >=64 Rozmiar wykładnika e 8 11 >=15 Obciążenie wykladnika N 127 1023 >=16383 Zakres wykładnika E [-126,127] [-1022,1023] [-(N-1),N] Dokładność ulp 2 23 10 7 2 52 10 15 2 m+1 Zakres formatu R 128 38 2 10 1024 308 2 10 16384 4932 2 10

Język ANSI C typy rzeczywiste Maksymalna ilość znaczących cyfr dziesiętnych, które można uzyskać w wydruku wynika z wielkości liczb dziesiętnych, która z kolei wynika z przeliczenia maksymalnych wartości mantysy na postać dziesiętną. Dla typu SINGLE ( w języku C odpowiada mu typ float) mantysa może reprezentować liczbę dziesiętną o wartości 23 7 2 10 co umożliwia uzyskanie 6-7 cyfr dziesiętnych. Podobnie dla typu double mamy co daje 15-16 cyfr dziesiętnych. 52 15 2 10

Język ANSI C typy rzeczywiste Dla typu long double mamy 64 19 2 10 czyli 19-20 cyfr dziesiętnych. Podstawowe formaty wydruku liczb rzeczywistych w języku C to - format stałoprzecinkowy - m.dd..ddd - format zmiennoprzecinkowy ( notacja inżynierska) m.d...d e xx ± lub m.d...d e xxxx ± ( zamiast e może też być stosowane E).

Język ANSI C typy rzeczywiste Wybrane zasady tworzenia opisu formatu w łańcuchu formatującym (pełny opis w B.W. Kernighan, D.M. Ritchie, Język ANSI C, Dodatek B, Pkt. B1.2 Formatowanie wyjście) Przykład. double x=12.348; printf( \n x=%10.2lf, x); Opis formatu rozpoczyna się znakiem %, liczba 10 oznacza minimalną szerokość pola wydruku, liczba 2 ilość drukowanych miejsc po kropce dziesiętnej, a lf oznacza wydruk wartości typu double. W ogólnym przypadku pomiędzy znakiem % a znakiem przekształcenia mogą wystąpić - modyfikatory( umieszczane w dowolnej kolejności), które wpływają na postać wydruku:

Język ANSI C typy rzeczywiste Modyfikatory te to: -znak minus (-) powodujący dosunięcie wydruku do lewego krańca pola - znak plus (+) wypisanie liczby zawsze ze znakiem - odstęp poprzedzenie wyniku znakiem odstępu, jeżeli pierwszym drukowanym znakiem nie jest plus lub minus -znak zero (0) uzupełnienie liczby wiodącymi zerami do pełnego rozmiaru pola Następnym znakiem jest liczba określająca minimalny rozmiar pola. Przekształcony argument zostanie wydrukowany w polu o ilości znaków nie mniejszej niż ta liczba. Jeżeli argument wymaga szerszego pola, to pole wydruku jest rozszerzane. Jeżeli argument jest krótszy, dopełniany jest spacjami z lewej strony (ew. w zależności od modyfikatora z prawej lub zerami). Kolejnym znakiem jest kropka, której następuje liczba oznaczająca precyzję czyli ilość cyfr po kropce dziesiętnej w specyfikacjach f, e i E.

Język ANSI C typy rzeczywiste Uwagi dodatkowe o formatach f, e i E Dla formatu f domyślną precyzją jest 6, przy precyzji zero opuszcza się kropkę dziesiętną. Dla formatu m.dddddde xx lub formatu m.dddddde ± xx domyślną precyzją ± ± jest 6 i przy precyzji zero również opuszcza się kropkę dziesiętną. Przykład. Formaty z zastosowaniem modyfikatorów. x=25.3485; printf( \n x=% 020.4f,x);// uzupełnienie zerami printf( \n x=% +20.4f,x);// drukowanie znaku liczby printf( \n x=% -20.4f,x);//dosunięcie do lewego krańca pola Otrzymane wydruki: x= 000000000000025.3485 x= +25.3485 x= 25.3485

Język ANSI C 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 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

Język ANSI C 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).

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

Język ANSI C 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 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.

Język ANSI C typy rzeczywiste double exp (double num); long double expl (long double num); Funkcja oblicza. e 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 and _matherrl.

Język ANSI C typy rzeczywiste /* _matherr example biblioteka standardowa C++ Builder 6.0*/ // przykład dla zaawansowanych przechwytywanie i korekcja błędu // dziedziny #include <math.h> #include <string.h> #include <stdio.h> int _matherr (struct _exception *a) { if (a->type == DOMAIN) if (!strcmp(a->name,"sqrt")) { a->retval = sqrt (-(a->arg1)); return 1; } return 0; } int main(void) { double x = -2.0, y; y = sqrt(x); printf("_matherr corrected value: %lf\n",y); return 0;

Język ANSI C 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ą resztę z dzielenia a/b.

Język ANSI C 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 całkowity exp, takie że num=mantysa exp 2. Przykład. int exp, mantysa; double num=0.5; mantysa=frexp(num,&exp); double ldexp (double num, exp int exp); 2 long double ldexpl (long double num, int exp); Funkcje obliczają wartość wyrażenia num 2. exp

Język ANSI C 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.

Język ANSI C 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 cz_calkowita,cz_ulamkowa; double num=0.5; cz_ulamkowa=modf(num,&cz_calkowita); double pow(double base, double exp); long double powl (long double base, long double exp ); Funkcje obliczają wartość base podniesioną do potęgi exp. Reguły obliczania takie jak dla funkcji 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..

Język ANSI C 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.

Język ANSI C 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.

Język ANSI C 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

Język ANSI C typy rzeczywiste Przykład. Obliczanie wyrażenia ( wersja bez sprawdzania danych) #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);

Język ANSI C 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; }

Język ANSI C 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ść e 5 x Graniczną wartość x możemy określić jako e x 5 308 10 x = 5 308 ln10 3.71

Język ANSI C typy rzeczywiste // Fragment programu związany ze sprawdzaniem danych wejsciowych #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);

Język ANSI C typy rzeczywiste Z obliczaniem wyrażeń w języku C wiążą się trzy zagadnienia: a) problem kolejności obliczania podwyrażeń b) konwersja typów w wyrażeniach c) rzutowanie (zmiana typu wyrażenia) Ad a. Język C nie określa kolejności w jakiej są obliczane podwyrażenia danego wyrażenia. Kompilator ma więc swobodę w zmianie kolejności obliczania tak aby uzyskać zoptymalizowany kod. Przykładowo w wyrażeniu x=f1() +f2(); nie można określić czy funkcja f1 będzie wywołana jako pierwsza.

Język ANSI C typy rzeczywiste Ad.b. Jeżeli w wyrażeniu występują zmienne i stałe różnych typów, są one wszystkie przekształcane do jednego wspólnego typu. Kompilator przekształca wszystkie operandy do największego typu występującego w wyrażeniu. W pierwszym rzędzie wartości typu char i short int przekształcane są do typu int. Przekształcenia typów przebiegają zgodnie z powyższymi regułami: -jeżeli operand jest typu long double, to drugi operand jest przekształcany do typu long double, -jeżeli operand jest typu double, to drugi operand jest przekształcany do typu double, -jeżeli operand jest typu unsigned long, to drugi operand jest przekształcany do typu unsigned long, -jeżeli operand jest typu float, to drugi operand jest przekształcany do typu float, -jeżeli operand jest typu long int, to drugi operand jest przekształcany do typu long int,

Język ANSI C typy rzeczywiste Ad. b (ciąg dalszy-przekształcenia typów) -jeżeli operand jest typu unsigned int, to drugi operand jest przekształcany do typu unsigned int, Istnieje jednak pewien specjalny przypadek: jeżeli jeden operand jest typu long a drugi typu unsigned int, i wartości typu unsigned int nie można przedstawić przy użyciu typu long, wtedy oba operandy są przekształcane do typu unsigned int.

Język ANSI C typy rzeczywiste Ad. b (ciąg dalszy-przekształcenia typów) Po zastosowaniu powyższych reguł każda para operandów ma ten sam typ oraz wynik operacji jest tego samego typu, co typ obu operandów. Przykład. char ch=3; int i=5; float f=1.5; double d=2.5,wynik; wynik=(ch / i) + (f * d) - (f + i); int double float int double float double double

Język ANSI C typy rzeczywiste Ad.c. (rzutowanie) Typ wyrażenia można narzucić lub zmienić przy pomocy tzw. rzutowania. Ogólna postać rzutowania to: lub (typ) wyrażenie, typ ( wyrażenie) Rzutowanie jest operatorem o priorytecie takim jak pozostałe operatory jednoargumentowe.

Język ANSI C typy rzeczywiste Przykład. Napisać fragment programu określający procentową ilość udanych prób w stosunku do ogólnej ilości prób. // Przykład. Zmiana typu poprzez rzutowanie #include <stdio.h> #include <conio.h> #include <math.h> int main(int argc, char* argv[]) { int ilosc_prob, ilosc_udanych_prob; double udzial_procentowy; printf("\n Podaj ilosc prob :"); scanf("%d",&ilosc_prob); printf("\n Podaj ilosc udanych prob:"); scanf("%d",&ilosc_udanych_prob); udzial_procentowy= double (ilosc_udanych_prob)/ilosc_prob*100; printf("\n Udzial procentowy udanych prob=%6.2f%", udzial_procentowy); getch(); return 0; }

Język ANSI C instrukcje 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.

Język ANSI C instrukcje 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.

Język ANSI C instrukcje 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. Instrukcja while. int x=0; while (x!= 2) x = x + 1; printf ( \n x = %d, x);

Język ANSI C instrukcje 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ść prawda i wykonywane 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

Język ANSI C instrukcje 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 staje się fałszywe, 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 { }.

Język ANSI C instrukcje Instrukcja do while jest użyteczna wtedy, gdy test 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);

Język ANSI C instrukcje Instrukcja warunkowa if Instrukcja warunkowa if umożliwia uzależnienie wykonania pewnej instrukcji od spełnienia pewnego warunku. Warunek ten jest reprezentowany przez wyrażenie umieszczone po słowie if. Wyrażenie to przybiera wartość prawda lub wartość 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;

Język ANSI C instrukcje 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 jest prawdziwe, zostaje wykonana akcja i sterowanie przechodzi do instrukcji programu umieszczonej po akcji. Jeżeli wyrażenie jest fałszywe, 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 {}).

Język ANSI C instrukcje 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.

Język ANSI C instrukcje Instrukcja if else Instrukcja ta ma następującą postać: if (wyrażenie) else akcja1 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.

Język ANSI C instrukcje 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 );

Język ANSI C instrukcje 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ść rozna od 2 ); } else { printf( \n Instrukcje te się wykonuja ); printf( \n gdy zmienna kod ma wartosc 2 ); }

Język ANSI C instrukcje 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 );

Język ANSI C instrukcje Instrukcje 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żenie n) akcja n;

Język ANSI C instrukcje 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 akcji n-tej. 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żeniu n-tym. Jest wykonywana tylko jedna akcja (grupa akcji w nawiasie klamrowym), pozostałe akcje są odrzucane.

Język ANSI C instrukcje Przykład. Instrukcja if zagnieżdżone. int kod; printf( \n Podaj kod ); scanf( %d,&kod); if (kod= =1) printf("akcja ta jest wykonywana gdy kod jest równy 1");/*instrukcja 1*/ else if (kod= =2) printf("akcja ta jest wykonywana gdy kod jest równy 2");/*instrukcja 2*/ else if (kod<=3) printf("akcja ta jest wykonywana gdy kod jest mniejszy równy 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.

Język ANSI C instrukcje if (wyrażenie1) akcja1; else if (wyrażenie2) akcja2; else if (wyrażenie3)... else if (wyrażenie n) akcja n; 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.

Język ANSI C instrukcje 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ę");

Język ANSI C operator? (wyrażenie warunkowe) 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;

Język ANSI C operator? (wyrażenie warunkowe) 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.

Język ANSI C 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.

Język ANSI C 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,

Język ANSI C operatory inkrementacji i dekrementacji 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ść.

Język ANSI C operatory inkrementacji i dekrementacji 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 o1 wartość wyrażenia jest równa (x=4) początkowej wartości x ( y=3)

Język ANSI C operatory inkrementacji i dekrementacji 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 o1 wartość wyrażenia jest równa (x=4) zwiększonej wartości x ( y=4)

Język ANSI C operatory inkrementacji i dekrementacji 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 o1 wartość wyrażenia jest równa (x=2) początkowej wartości x ( y=3)

Język ANSI C operatory inkrementacji i dekrementacji 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 o1 wartość wyrażenia jest równa (x=2) zmniejszonej wartości x ( y=2)

Język ANSI C instrukcje 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;

Język ANSI C instrukcje 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

Język ANSI C instrukcje 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.

Język ANSI C instrukcje 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ę.