Język C proceduralny język programowania      koncepcje i rozwiązania podobne do stosowanych w języku Pascal      Denis Richie 1972 dla systemu operacyjnego UNIX      „język wewnętrzny” systemu operacyjnego UNIX standard ANSI - 1989, standard C99 - 1999      liczne kompilatory i zintegrowane systemy programowania   

ostateczna definicja języka programowania  kompilator rozszerzenia obiektowe C++ 1985 - rozszerzono również część nieobiektową   przedmiotem wykładu będzie podzbiór języka C++ przeznaczony do programowania strukturalnego   ostateczna definicja języka programowania  kompilator #include "stdio.h" void main ( ) { printf ( "Hello World!" ); } gcc.pdf, c99status.html, Arytma.ppt

Alfabet Wszystkie znaki 8-bitowego kodu ASCII litery: A B ... Z a b ... z _ cyfry: 0 1 ... 9 pozostałe Kody 32 ... 126 : program Kody 0 ... 31 i większe od 126 : dane tekstowe Na żądanie UNICODE (UTF-8)

Identyfikatory Ciągi znaków alfabetu zaczynające się od litery, dalej litery lub cyfry. Standardowo początkowe 32 znaki, odróżniając duże i małe litery.   alfa Alfa AlfA ALFA Cena_Mleka KosztTransportu Słowa kluczowe - identyfikatory zastrzeżone.

Komentarze /* ...................... bez zagnieżdżania   /* ...................... bez zagnieżdżania ........................ */ // .............................

Typy liczb całkowitych char short int long long long signed unsigned typ signed unsigned bajty char – 128 , + 127 0 , 255 1 short – 32 768 , + 32767 0 , 65535 2 int, long – 2 147 483 648 , + 2 147 483 647 0 , 4 294 967 295 4 – 9 223 372 036 854 775 808 , + 9 223 372 036 854 775 807 18 446 744 073 709 551 615 8

Typy zmiennopozycyjne   float double long double typ zakres cyfry bajty float 3.4*1038 7 4 double, long double 1.7*10308 15 8 IEEE 754

Liczby całkowite Typ liczby : na podstawie wartości (domyślny int) 12 154555 // dziesiętnie 012 03777453 // ósemkowo 0xAB 0x5c5d 0xfff45a // heksadecymalnie   Typ liczby : na podstawie wartości (domyślny int)   12 25467 // signed int 34760548093 // signed long long

wskazany w zapisie liczby 15L 077777l 0xFF4FFFL // signed long 254ll -457LL 0xAB56LL // signed long long 45211u 0xffau // unsigned int 3000000000ul 0xC56AFB44UL // unsigned long -120ULL 78ull // unsigned long long

Liczby zmiennopozycyjne   1.25 0.343 .5 2. 35.56E-12 0.34e2 5e3 17.18E+28 Typ liczby :   na podstawie wartości (domyślny double) wskazany w zapisie liczby 12.545f // float 0.2345676543F // float 0.5e-3l // long double 0.9999998899E456L // long double

Znaki Liczby całkowite typu: char 'a' '5' '+' '.'   Liczby całkowite typu: char 'a' '5' '+' '.' 'A' '\071' '\x41' '\x5F' '\n' '\t' '\r' '\\' '\”'

Łańcuchy "Programowanie w języku C" "Wynik : "   "Programowanie w języku C" "Wynik : " "\tImię\tNazwisko\tMiejsce zamieszkania\n" "\x16\x16\x02" // SYN SYN STX "Spojrzał i powiedział: \"Nie mogę\"."    "ABC" 0x41 0x42 0x43 0x00

Zmienne < identyfikator , wartość > Deklaracje zmiennych char signed char int signed signed int short short int signed short int long signed long long int signed long long signed long long unsigned char unsigned int unsigned unsigned short unsigned short int unsigned long unsigned long int unsigned long long float double long double

Deklaracje zmiennych Definicje zmiennych int i; char a, b, c; unsigned long duza_odleglosc; float KursDolara; double masa, gestosc; Definicje zmiennych int licznik = 125, suma = 0; float dokladnosc = 0.0005, uchyb = 0.001; double moc = 15e6, straty = 1500; // double alfa = 3.34, beta, jota = 15.15, kappa;

Stałe const int dni = 7, tygodnie = 52;    const int dni = 7, tygodnie = 52; const float pi = 3.14159, e = 2.71828; const double Avogadro = 6.022E23;   Operator przypisania   int i, j, k; i = 1; //zmienna i przyjmuje wartość 1 j = i; //zmienna j przyjmuje wartość zmiennej i k = dni; //zmienna k przyjmuje wartość stałej dni

Notacja Węgierska Przedrostek Typ danych Przykład b bool bJeszczeRaz c char cKodPolecenia l long lDuzyKaliber n int nLicznikPierwszy p wskaźnik pAdresNowejCeny a tablica anDaneTestowe s łańcuch znaków sStosownyNapis

Wskaźniki - lokalizacja - typ Zmienne wskaźnikowe : deklaracje   int *pt_i, *pt_j; double *wsk1, *wsk2; float moc1, moc2, *wsk_mocy; void *dowolny, *kazdy; wsk_mocy moc1 25.7

Operator wyznaczania wskaźnika & int lampy, widelce; int *wsk_towaru; wsk_towaru = & lampy; ................ wsk_towaru = & widelce; float Korzysc = 2.54; float *wsk_f; long *wsk_l; void *wsk_v; wsk_f = & Korzysc; // poprawnie wsk_l = & Korzysc; // błąd wsk_v = & Korzysc; // poprawnie

int cena = 25, *wsk_cena, **wsk_wsk_cena; wsk_cena = & cena;     25 wsk_wsk_cena wsk_cena cena

Zmienne wskaźnikowe : definicje   int i = 5, j = 7; int *pt = & i, *pk = & j; double droga, czas = 100, *wsk1, *wsk_param = & droga; char *poczatek = "Początek obliczeń\n", *koniec = "Koniec obliczeń\n", *napis; napis = poczatek; /* wyświetlenie napisu i wykonanie obliczeń */ napis = koniec; /* wyświetlenie napisu i koniec programu */

Operator dostępu pośredniego *   int i = 5, j; int *wsk = & i; j = *wsk; // równoważne j = i; wsk 5 i float x = 1.5, y, *wx = & x, **wwx = & wx; y = **wwx; // równoważne y = x; //  const double dbK7 = 12e5; double *wk = & dbK7; // błąd

Wskaźnik do stałej const long *ws_st; //wskaźnik do stałej   const long *ws_st; //wskaźnik do stałej const long dystans = 5786; ws_st = & dystans; long odleglosc = *ws_st; // poprawnie // odległość == dystans *ws_st = 1298; // błąd long war = 10, ukrop; ws_st = & war; war = 150; // poprawnie ukrop = *ws_st; // poprawnie, ukrop = 150 *ws_st = 150; // błąd

Stała wskaźnikowa float cena = 12.5, netto; float *const swx = & cena;   float cena = 12.5, netto; float *const swx = & cena; // stała wskaźnikowa, wartość początkowa konieczna cena = 15.8; // poprawnie *swx = 15.8; // poprawnie swx = &netto; // błąd swx cena

Referencje   Każda operacja wykonywana na referencji jest identyczna z operacją wykonaną bezpośrednio na reprezentowanej przez tę referencję zmiennej czy strukturze danych. int kwota; int &ref_k = kwota; ref_k = 1254; // równoważne kwota = 1254; //  long a, b, &ref_a = a; ref_a = 12; // równoważne a = 12; b = ref_a; // równoważne b = a;

float moc_x, &ref_x = moc_x, *wsk_x; wsk_x = & ref_x; // równoważne wsk_x = & moc_x; wsk_x = ref_x; // błąd, podobnie jak wsk_x = moc_x;   double &ref_dok = 1.15E-5; // realizacja : XX = 1.15E-5; // pomocnicza zmienna wewnętrzna double &ref_dok = XX; unsigned int bin = 0xCFCF; int &ref_b = bin; // realizacja : int YY = (int) bin; // unsigned int  int int &ref_b = YY; ref_b = 15; // nie zmienia wartości // zmiennej bin

Typy wyliczeniowe enum dni {ni, po, wt, sr, cz, pi, so}; enum id_typu { lista_stałych } id_zmiennej ;   enum dni {ni, po, wt, sr, cz, pi, so}; /* ni == 0, po == 1, ... , so == 6 */ enum dni {ni=1, po, wt, sr, cz, pi, so}; /* ni == 1, po == 2, ... , so == 7 */ dni Egzamin, Dobry = cz; Egzamin = Dobry; // enum TW1 {t1, t2, t3 = 0, t4, t5, t6 = 1, t7}; /* t4 == 1, t5 == 2, t7 == 2 */ enum {A = 0x41, B, C, X = 0x58} znak; // zmienna typu wyliczeniowego znak = C; // poprawnie znak = 0x41; // błąd Enum

Typ logiczny bool stan, obecnosc = true; stan = true; obecnosc = false; //  enum BOOL {FALSE, TRUE}; // 0 , 1 BOOL flaga, status = TRUE; flaga = FALSE; status = flaga;

Nazywanie typów danych   typedef typ nowy_identyfikator typedef char* string; string S1, S2, S3 = "napis"; typedef int num; num k; int l = 5; k = l; // typ num jest równoważny z typem int typedef long BIG; unsigned BIG ww; // błąd

Wprowadzanie danych getch D. int getch ( ); B. conio.h   getch D. int getch ( ); B. conio.h F. Kolejny opis klawisza z klawiatury ( oczekiwanie ), bez echa W. Kod ASCII lub 0 P. char nowy; nowy = getch(); // getche Jak getch + echo

D. int scanf ( const char *format, wskaźnik, wskaźnik, ... );   D. int scanf ( const char *format, wskaźnik, wskaźnik, ... ); B. stdio.h F. Wczytuje kolejne pola (ciągi znaków do SP lub NL) ze stdin z echem (BS). Format - tekst będący ciągiem wzorców konwersji. Wzorzec konwersji:  % [ * ] [ szerokość ] [ prefiks ] znak_konwersji W. Liczba wczytanych pól znaków

P. int liczba_sztuk; scanf ( "%d", &liczba_sztuk ); double szerokosc; scanf( "%lf", &szerokosc ); scanf( "%lf%d", &szerokosc, &liczba_sztuk );

int lampy, krzesla, *wsk = &krzesla; float temp; double cena; char opcja; // scanf( "%d%d%f%lf", &lampy, wsk, &temp, &cena ); // 1 5 SP 3 4 7 Enter - 2 5 . 4 Enter // 3 . 9 9 Enter // lampy == 15 krzesla == 347 // temp == -25.4 cena == 3.99

// wczytywanie pojedynczych znaków fflush(stdin); // oczyszczenie bufora klawiatury scanf( "%c", &opcja ); // A Enter // opcja == 'A' // wczytywanie tekstów char Tekst[16]; // tablica 16 elementowa scanf ( "%15s", Tekst ); // A l f a Enter // Tekst == "Alfa" scanf ( "%15[ -~]", Tekst ); // A l a SP m a SP k o t a . Enter // Tekst == "Ala ma kota."

gets_s   D. char* gets_s ( char *tekst, int rozmiar ) ; B. stdio.h F. Odczytuje ze stdin ciąg znaków (z SP, HT) z echem do NL, liczba znaków ograniczona przez rozmiar W. Tekst lub NULL P. gets_s( Tekst ); In

Wyprowadzanie danych putchar D. int putchar ( int c ) ; B. stdio.h   D. int putchar ( int c ) ; B. stdio.h F. Znak do stdout W. Argument c lub EOF P. char cc = 'R'; putchar ( cc ); // 'R' na ekran

puts   D. int puts ( char *napis ); B. stdio.h F. Do stdout ciąg znaków + NL W. !0 lub EOF P. #include <stdio.h> void main( ) { char *nn = "Napis ćwiczebny."; puts(nn); }

D. int printf ( const char *format, wyrażenie, wyrażenie, ... );   D. int printf ( const char *format, wyrażenie, wyrażenie, ... ); B. stdio.h F. Do stdout ciągi znaków reprezentujących wartości wyrażeń Format :   - znaki przesyłane bezpośrednio do stdout    - wzorce konwersji

printf( "%d", liczba_kolorow ); int liczba_kolorow = 256; printf( "%d", liczba_kolorow ); double odjetosc = 15.72; printf( "%lf", objetosc ); char *Tekst = "Dokumentacja."; printf ( "%s", Tekst);

Wzorzec konwersji : % [ opis ] [ szerokość ] [ precyzja ] [ prefiks ] znak_konwersji opis : - uzupełnianie znakami spacji z prawej strony + wyprowadzanie znaku liczby SP znak spacji zamiast znaku plus   szerokość : - minimalna liczba znaków dla liczb - maksymalna liczba znaków dla ciągów znaków precyzja : . liczba_miejsc_po_kropce

int Alfa = 5; float Beta = 12.45; printf ( "Wynik: \n Alfa = %d,\t Beta = %f\n", Alfa, Beta + 500); // Wynik: // Alfa = 5, Beta = 512.450000 char opcja = 'X'; char *Napis = "Opis programu."; printf("Wybrano opcję %c : %31s", opcja, Napis ); // Wybrano opcję X : Opis programu.

int koty = 2, *wsk_k = &koty; float test = 23.345678; double wynik = -0.01234567; // printf("Liczba kotów : %d", *wsk_k ); printf("\nWynik testu = %12.3f\n" "Razem = %.5lf\n", test + 5, wynik ); // Liczba kotów : 2 // Wynik testu = 28.345 // Razem = -0.01234 Out

Wyrażenia   Wyrażenia elementarne : liczby, znaki, zmienne, stałe, wywołania funkcji Operatory : jedno- dwu- lub trójargumentowe o ustalonych priorytetach Nawiasy okrągłe dla ustalenia kolejności obliczeń. operator przypisania = operator dostępu pośredniego * operator wyznaczania wskaźnika &

Konwersja wartości lewy Ø prawy  typ ( lewy ) == typ ( prawy )   Konwersja rozszerzająca  zwiększenie liczby bajtów Konwersja zawężająca  zmniejszenie liczby bajtów int li32 = 21212345; long long li64 = li32; // konwersja rozszerzająca short li16 = li32; // konwersja zawężająca // strata danych li16 == -21319 Dla operatora = konwersja na typ lewej strony ( możliwa strata informacji ) char c; c = 258; // c == ?

Konwersja typu na życzenie programisty  rzutowanie   typ ( wyrażenie ) ( typ ) wyrażenie int ile = 27; float tyle = 1.4; ile = ile + tyle; /* konwersja 27 na 27.0, dodawanie zmiennopozycyjne, konwersja 28.4 na 28, przypisanie */ ile = ile + (int) tyle; /* konwersja 1.4 na 1, dodawanie całkowitoliczbowe, przypisanie */ int i, *wsk_i = & i; float *wsk_f; wsk_f = ( float* ) & i; wsk_f = ( float* ) wsk_i;

Operatory arytmetyczne   * / + – % int liczba, nieparzystosc; nieparzystosc = liczba % 2; // 0 - p, 1 - np (3 * x * x + 5 * x - 1) / (7 * x * ((2 * x + 3) * (1 - x) + 5) + 3) int a = 1700000000, b = 1900000000, suma; suma = a + b; // nadmiar stałopozycyjny float x = 0.5e35, y = 0.2e5, z; z = x * y; // nadmiar zmiennopozycyjny  OverHole, Wielkanoc

Operatory zmniejszania i zwiększania   ++ –– ++alfa ––beta // przed obliczeniem wyrażenia alfa++ beta–– // po obliczeniu wyrażenia float x = 2.5, y; x ++ ; // równoważne x = x + 1; ++ x ; // równoważne x = x + 1; x -- ; // równoważne x = x - 1; -- x ; // równoważne x = x - 1; y = ++(2 * x); // błąd int i = 3, j = 4, s; s = j++ + i; // s == 7 j == 5 j = 4; s = ++j + i; // s == 8 j == 5

Operatory relacyjne 0 : false nie 0 : true < <= == != >= >   < <= == != >= > bool mniejsze, rowne, nierowne, wiekszerowne; int i = 5; float x = 12.3; mniejsze = i < x; // true rowne = i == x; // false nierowne = i != x; // true wiekszerowne = i >= x; // false double x = 1.5E-5, y = x; double *wsk_x = & x, *wsk_y = & y; rowne = wsk_x == wsk_y; // false wsk_x = & y; rowne = wsk_x == wsk_y; // true

Operatory logiczne int a, b, c; bool z;   ! && || int a, b, c; bool z; z = a < b && b < c; // a < b < c int rok = 2000; bool przestepny; przestepny = !(rok % 4) && rok % 100 || !(rok % 400); ( a > b ) && ( k <= f++ ) // optymalizacja ( k > 5 ) || (c < ( b = 7 ) )

Operatory bitowe ~ & | ^ << >>   Wi = Ai  Bi ~ & | ^ << >> int i = 35, przeciwna, parzystosc, r, s; przeciwna = ~ i + 1; // równoważne - i; nieparzystosc = i & 1; r = i << 2; // równoważne r = i * 4; s = i >> 3; // równoważne s = i / 8; char a = 'r', b = 8; a = a & 0x5F; // zamiana małych liter ASCII na duże b = b | 0x30; // zamiana wartości binarnej 0-9 // na kod znaku ASCII

Złożone operatory przypisania   *= /= %= += –= <<= >>= &= ^= |= double kurs, zwyzka; kurs += zwyzka; // kurs = kurs + zwyzka; int x = 10; x -= 5 – 2 ; // ? int i, j, k; i = (j = 5) + 1; // równ. j = 5; i = j + 1; i = j = k = 0; // równ. i = 0; j = 0; k = 0;

Operator warunkowy Operator rozmiaru   wyrażenie_1 ? wyrażenie_2 : wyrażenie_3    float x, y, max; max = x > y ? x : y; Operator rozmiaru long liczba_1; dlugosc_1 = sizeof liczba_1; // == 4 dlugosc_1 = sizeof long; // == 4

Operator wyliczenia long a1, a2, a3, s;   long a1, a2, a3, s; s = ( a1 = 52700, a2 = 31300, a3 = a1 + a2 ); // a3 == 84000 s == 84000 s = a1 = 52700, a2 = 31300, a3 = a1 + a2; // s = ? float x, y ,z; z = ( x = 5.3, y = 2.5, y++ ); // y == 3.5 z == 2.5

Priorytety i łączność operatorów // lewostronnie łączny   // prawostronnie łączny char a,b,c,d,e; a + b - c - d + e; /* lewostronnie łączne czyli (((a + b) - c) - d) + e; */  a ? b : c ? d : e; /* prawostronnie łączny czyli a ? b : (c ? d : e); */ P1, P2, P3, P4