Struktura programu dyrektywy preprocesora deklaracje i definicje globalnych danych i struktur danych deklaracje i definicje funkcji definicja funkcji main

Preprocesor # dyrektywa argumenty Dołączanie plików bibliotecznych : #include #include <stdio.h> #include "funkcje.cpp"

.h .h .cpp .obj .cpp .obj .exe .obj .obj .h .h Pliki źródłowe Pliki biblioteczne .obj .h .h Pliki tekstowe Pliki półskompilowane Plik binarny

Zastępowanie tekstów : #define #define ROZMIAR 150 #define moje cena_zakupu – cena_sprzedazy #define EPS 3.5E-8 ........ #undef EPS // usunięcie definicji #define EPS 1.5E-8

Makrogeneracja #define Makro1(x) x = sin(x) + 3 * x; .......................... double akr = 2.544; Makro1(akr) // akr = sin(akr) + 3 * akr; // #define Makro2(x, y) x = x + y - 1; double alfa = -12.74, beta = 0.21; Makro2(alfa, beta) // alfa = alfa + beta - 1

Kompilacja warunkowa #if wyrażenie_stałe_1 tekst_źródłowy_1 #elif wyrażenie_stałe_2 tekst_ źródłowy_2 ........................... #else tekst_ źródłowy_n #endif

Test zdefiniowania #defined identyfikator // 1 : gdy identyfikator był już zdefiniowany // 0 : gdy identyfikator jest nie zdefiniowany #if defined identyfikator /* równoważne */ #ifdef identyfikator #if ! defined identyfikator #ifndef identyfikator

#define WersjaProbna // #ifdef WersjaProbna . . . . . . . . . . . . . . . . . . . . #else #endif

Polecenia dla kompilatora : #pragma #pragma message "WersjaProbna" // podczas kompilacji #pragma once // jednokrotne dołączenie pliku

Funkcja main void main( void ) { ... } void main ( ) int main ( ) { ..... return 0; }

void main ( int liczba_slow, char *tabela_slow [ ] ) { ... } PROG RAZ DWA TRZY liczba_słów : 4 Param, ConvTest

Struktury danych Struktura danych określa układ powiązań występujących w pewnym zestawie danych. tablice struktury (unie)

Tablice Ciąg elementów tego samego rodzaju.

Tablice jednowymiarowe typ identyfikator [ rozmiar ] ; typ : liczbowy, znakowy, wskaźnikowy lub typ struktury rozmiar : wyrażenie stałe, o wartości większej od zera ( w gcc wyrażenie całkowitoliczbowe )

const int sumy = 50, iloczyny = 120; int TAB[5]; // 0, 1, 2, 3, 4 TAB const int sumy = 50, iloczyny = 120; float WYNIKI[ 2 * (sumy + iloczyny)]; int i; i = TAB[3]; // TAB + 3 * sizeof int 0 1 2 3 4

WYNIKI[i + 2] = WYNIKI[i] + WYNIKI[i + 1]; // double TAB_DANYCH [ 7 ] ; for (int ix = 0; ix < 12; ++ix ) TAB_DANYCH [ ix ] = 48.74 ; // ?

// wartości początkowe typ identyfikator[rozmiar] = {lista_ wartości}; lista_wartości : wyrażenia stałe long MM[3] = { 154835L, 337782L, 0L }; /* MM[0] == 154835, MM[1] == 33782, MM[2] == 0 */

const float F1 = 3.5E7F, F2 = 33.E8F; float DANE[ ] = { F1 + F2, F1 / (F1 - F2)}; /* tablica DANE ma 2 elementy */ double PQ[150] = { 1.5, 3.8, 3.8, 2.7 }; /* PQ[0] == 1.5, PQ[1] == 3.8, PQ[2] == 3.8, PQ[3] == 2.7, pozostałe elementy == 0 */ double Empty[1200] = {0}; // zerowanie

char NN[5] = { "alfa" }; // NN[4] == 0 char MM[4] = { "beta" }; // błąd, tablica // zbyt mała int i = 1, j = 2, k; int *WW[3] = { &i, &j }; WW[2] = & k; *WW[2] = *WW[0] + *WW[1]; // k == 3 char *TYDZIEN[ ] = { "pon", "wto", "śro", "czw", "pią", "sob", "nie" };

Zapisy *TAB i TAB [ 0 ] są równoważne. char bufor[8]; char *pp; pp = bufor; /* przypisania pp = & bufor[0]; równoważne */ *( TAB + 4 ) i TAB [ 4 ] są równoważne const int ele = 25; short TS[ele]; int TI[ele]; double TD[ele]; for (int i = 0; i < ele; ++i ) { *(TS + i) = 1; *(TI + i) = 1; *(TD + i) = 1.0; }

//wczytywanie elementów tablicy jednowymiarowej int TabLicz [ 125 ]; for (int i = 0; i < 125; ++i) scanf("%d", &TabLicz[ i ]); double Rzeczywiste [ 12 ]; for (i = 0; i < 12; ++i) scanf("%lf", &Rzeczywiste[ i ]); long A[5]; int obszar, element, elementow; obszar = sizeof A; // == 20 element = sizeof A[0]; // == 4 elementow = sizeof A / sizeof A[0]; // == 5

double Tab[ dl ]; // nie można inicjować rozszerzenia gcc int dl; scanf("%d", &dl); double Tab[ dl ]; // nie można inicjować int T[5] = { 3, [2] = 5, [4] = 2 }; for (int i = 0; i < 5; ++i) printf("\t%d", T[i]); // 3 0 5 0 2 Z4-9, TabDemol

Tablice wielowymiarowe float MACIERZ[10][20]; /* 10 wierszy, 20 kolumn */ MACIERZ[nw][nk] const int kwa = 30; long KWADRAT[kwa][kwa]; for (int i = 0; i < kwa; i ++) for (int j = 0; j < kwa; j ++) KWADRAT [ i ] [ j ] = i == j ? 0 : 1; /* główna przekątna zostanie wyzerowana, pozostałe elementy == 1 */

int BB[2][3] = { { 1, 2, 3} , {4, 5, 6} }; /* BB[0][0] == 1, BB[0][1] == 2, BB[0][2] == 3 BB[1][0] == 4, BB[1][1] == 5, BB[1][2] == 6 */ float CC[3][2] = { { 8.5 } , { 3.2 } }; /* CC[0][0] == 8.5, CC[0][1] == 0 CC[1][0] == 3.2, CC[1][1] == 0 CC[2][0] == 0 , CC[2][1] == 0 */ long LL[2][3]; sizeof LL; // 24 sizeof LL[0]; // 12 sizeof LL[0][0]; // 4

// wczytywanie macierzy  wierszami const int Wie = 10, Kol = 5; int MM [ Wie ][ Kol ]; for (int i = 0; i < Wie; ++i) for (int j = 0; j < Kol; ++j) scanf("%d", & MM[ i ][ j ]; // int ile = Wie * Kol, k; int *p = &MM[0][0]; k = 0; while (k++ < ile) scanf("%d", p++);

for (int mac = 0; mac < 5; mac ++) float TTT[5][10][20]; /* tablica trójwymiarowa składająca się z 5-ciu macierzy o 10 wierszach i 20 kolumnach każda */ for (int mac = 0; mac < 5; mac ++) for (int wie = 0; wie < 10; wie ++) for (int kol = 0; kol < 20; kol ++) TTT[mac][wie][kol] = 1.0F; Z0-23,TopBottom, MatMul, CyBuff, Sort

Przetwarzanie tekstów Definiowanie tekstów char *Litery = "ABC"; 0x41 0x42 0x43 0x00

char *Napis = "Waniki.";// tekst stały *(Napis + 1) = 'y'; // błąd char Tekst[16] = { "Pomołka." }; // kopiowanie tekstu stałego do tablicy Tekst[3] = 'y'; // poprawnie *(Tekst + 3) = 'y'; // poprawnie

Przetwarzanie tekstów char Napis [ 16 ] = "Kopytko."; int i = 0; while( Napis[i] != 0 ) { if ( Napis[i] == 'o') Napis[i] = 'a'; ++i; }

// char *ptr = Napis; while( *ptr != 0 ) { if ( *ptr == 'o') *ptr = 'a'; ++ptr; } Szyfr

Biblioteka string.h char* strcat( char* Destination, const char* Source ); // Dodaje (konkatenuje) łańcuchy Source // i Destination. Wynik: wskaźnik // łańcucha, do którego dołączany jest tekst char* strncat( char* Dest, const char* Source, size_t Count ); // Analogicznie jak strcat lecz kopiuje // nie więcej niż Count znaków

char* strchr( const char* String, int C ); // Wyszukuje pierwsze wystąpienie znaku C // w łańcuchu String . Wynik: wskaźnik // znalezionego znaku bądź NULL // jeśli nie znaleziono char* strrchr( const char* String, int C ); // Analogicznie jak strstr lecz od końca

char* strpbrk( const char* String, const char* CharSet ); // Wyszukuje pierwsze wystąpienie jednego // ze znaków z łańcucha CharSet // w łańcuchu String size_t strlen( const char* String ); // Oblicza długość łańcucha String

int strcmp( const char* String1, const char* String2 ); // Porównanie dwóch łańcuchów. Wynik funkcji: < 0 - String1 mniejszy niż String2 = 0 - String1 i String2 identyczne > 0 - String1 większy niż String2 int strncmp( const char* String1, const char* String2, size_t Count ); // Analogicznie jak strcmp lecz nie więcej // niż Count znaków

char* strcpy( char* Destination, const char* Source ); // Kopiuje łańcuch Source do Destination // usuwając poprzednią wartość Destination. // Wynik: wskaźnik łańcucha, do którego // kopiowany jest tekst char* strncpy( char* Dest, const char* Source, size_t Count ); // Analogicznie jak strcpy lecz nie więcej // jak Count znaków Z2-12

Struktury struktura : zestaw pól pole : dana lub struktura danych struct typ_struktury { lista_pól } lista_identyfikatorów ; struct { int szerokosc; int dokladnosc; char konwersja; } wzorzec; float re; float im; } z0, z1, z2;

struct osoba { char *imie; char *nazwisko; int rok_urodzenia; }; struct osoba Ala, Ola, Ela; struct adres char miejscowosc[16]; char ulica[32]; int dom; int mieszkanie; adres AAla, AOla, AEla;

Ala "Alicja" imie nazwisko "Nowak" AAla miejscowosc "Koło" 16 ulica 32 rok_ur 1990 "Alicja" "Nowak" AAla miejscowosc ulica nr_domu nr_mieszkania "Koło" 16 32 "Mała" 5 11

struct silnik { float pojemnosc; char *paliwo; }; struct samochod struct char *producent; char *model; } marka; silnik naped;

struct S1 { int i; float f; } es1; struct S2 long l; } es2; struct S1 *wst1; S2 *wst2;

wst1 = &es1; wst2 = &es2; wst1 = &es2; // błąd, // nieodpowiedni typ struktury wst2 = wst1; // błąd, // nieodpowiedni typ wskaźnika struct AZ { char z1; char z2; int lz; } p1 = { 'a', 'b', 37 }, p2 = { 'x', 'y', 35 }; AZ p3 = { 'k', 'l', 36 };

Dostęp do pól : identyfikator . referencja . wskaźnik -> struct podpis { char *Imie; char Inicjal; char *Nazwisko; }; podpis st, *wst = &st ; st . Imie = "Andrzej" ; wst -> Inicjal = 'K' ;

Przypisanie struktur podpis AK = {"Anna", 'M', "Kowalska"}, NN; NN = AK ; // gdy typy równe // NN . Imie = AK . Imie ; // NN . Inicjal = AK . Inicjal ; // NN . Nazwisko = AK . Nazwisko ; // AK.Imie i NN.Imie wskazują // ten sam tekst stały // AK.Nazwisko i NN.Nazwisko wskazują

char PiekneImie[20] = { "Teofil" }; AK.Imie = PiekneImie; NN = AK; // kopiowanie tablicy AK.Imie[0] = 'M'; printf("%s, %s", AK.Imie, NN.Imie); // Meofil, Teofil

int T1[3], T2[3] = { 1, 2, 3 }; T1 = T2; // błąd // struct TT { int T[3]; }; TT T1, T2 = { { 1 , 2, 3} }; T1 = T2; // poprawnie // ale int a = T1.T[1];

Tablice struktur struct kartoteka { char nazwa [ 16 ] ; int liczba ; } komputery [ 100 ] ; kartoteka drukarki [ 100 ] ;

int ile_k = 0, ile_d = 0; for ( int i = 0 ; i < 100 ; ++i ) { ile_k += komputery [ i ] . liczba ; ile_d += drukarki [ i ] . liczba ; }

struct zakres { float poczatek; float koniec; } fm; sizeof fm; // == 8 sizeof (zakres); // == 8 typedef struct int p1; float p2; } wynik; wynik w1, w2, w3; EwTel

Listy struct lista { char etykieta[8]; struct lista *poprzedni; struct lista *nastepny; } E0 = { "AA", NULL, NULL }; lista E1 = { "BB" }, E2 = { "CC", NULL, NULL }; E0.nastepny = &E1; E1.nastepny = &E2; E2.poprzedni = &E1; E1.poprzedni = &E0; RevList, CyBuff

Unie Wszystkie pola w tym samym obszarze pamięci.

union { char p1 ; // 1 bajt int p2 ; // 4 bajty long long p3 ; // 8 bajtów } u1; // 8 bajtów u1.p1 = 'A'; // pola p2, p3 // niezdefiniowane u1.p2 = 1357; // pola p1, p3 // niezdefiniowane u1.p3 = 15432678LL; // pola p1, p2 // niezdefiniowane union umaszczenie char kolor_pior [ 64 ] ; char kolor_siersci [ 64 ] ; }

struct artykuł { char autor[64]; char tytul[64]; int rok; union struct char tytuł[64]; int numer; int strona; } czasopismo; char nazwa[64]; } konferencja; } miejsce; } a1; // string.h strcpy ( a1.miejsce.konferencja.nazwa, "Polman" );

Dynamiczny przydział pamięci new delete Zmienne int *p; p = new int; delete p;

float *taba = new float [ 150 ]; delete [ ] taba; int rozmiar; Tablice float *taba = new float [ 150 ]; delete [ ] taba; int rozmiar; scanf( "%d" , &rozmiar ); long *Tablica = new long [ rozmiar ];

double *TD1 = new double[150]; double x = TD1[53]; // poprawnie // double *TD2 = new double [20][30];// błąd double *TD2 = new double [600]; // ok double y = TD2[3][21]; // błąd double z = TD2[3 * 30 + 21]; // ok

for (int i = 0; i < 20; ++i) WW[i] = new int[30]; WW[4][5] = 17; · tablica dwuwymiarowa - tablica wierszy int** WW = new int*[20]; for (int i = 0; i < 20; ++i) WW[i] = new int[30];   WW[4][5] = 17; int x = WW[4][5]; // poprawne

WW 0 29 . . . 19 . . 0 29 . . .

int N = sizeof(DL) / sizeof(DL[0]); int** WW = new int*[N]; · tablica dwuwymiarowa nierównomierna int DL [ ] = {5, 15000, 7, 2000, 3}; int N = sizeof(DL) / sizeof(DL[0]); int** WW = new int*[N]; for (int i = 0; i < N; ++i) WW[i] = new int[DL[i]];   WW[1][12547] = 17; int x = WW[1][12547];

struct pies { char *smycz; char *obroza; char *pies_wlasciwy; }; Struktury struct pies { char *smycz; char *obroza; char *pies_wlasciwy; }; pies *Morus; Morus = new pies; delete Morus; TopBottomP, EwRowDyn