Ukazatele #2, dynamická alokace paměti
|
|
- Jaroslava Veselá
- před 6 lety
- Počet zobrazení:
Transkript
1 Ukazatele #2, dynamická alokace paměti BI-PA1 Programování a Algoritmizace 1 Miroslav Baĺık, Ladislav Vagner a Josef Vogel Katedra teoretické informatiky a Katedra softwarového inženýrství Fakulta informačních technologíı České vysoké učení technické v Praze xvagner@fit.cvut.cz, vogeljos@fit.cvut.cz 21. a 30. listopadu 2017 a 1. prosince 2017
2 Přehled Ukazatelová aritmetika. Ukazatele a pole. Ukazatele a řetězce. Dynamická alokace paměti. Dynamická alokace vícerozměrných poĺı. M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 2/43
3 Aritmetika ukazatelů motivace Chceme-li v C implementovat výstupní parametr, deklarujeme funkci např. takto: void foo ( int * outparam,... ) Chceme-li v C předat funkci pole, máme dvě ekvivalentní možnosti deklarace: void foo ( int * array,... ) void foo ( int array [],... ) Výše uvedené zápisy jsou shodné, tedy v C se pole chová (téměř) stejně jako ukazatel. Protože můžeme pomocí indexů přistupovat k jednotlivým prvků pole, musí tuto možnost v nějaké formě nabízet i ukazatel máme k dispozici ukazatelovou aritmetiku. M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 3/43
4 Aritmetika ukazatelů K ukazateli je možno přičíst (nebo odečíst) celočíselnou hodnotu, ukazatele je možno dále odečítat a porovnávat. Následuje přehled povolených operací: T* + int -> T* T* - int -> T* T* - T* -> int T* rel op T* -> int Když je celé číslo n přičteno k ukazateli T*, výsledná adresa je zvětšena o n * sizeof ( T ) bajtů. Podobné je to pro odečtení celočíselné hodnoty. Jestliže jsou dva ukazatele odečteny, je výsledkem celé číslo, jehož hodnotou je počet prvků typu (T) mezi ukazateli. Výsledek porovnání ukazatelů je dán hodnotami adres (větší, stejné, menší). M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 4/43
5 Ukazatele aritmetika int a[10], *p = &a[0]; *(p + 3) = 10; /* hodnota a[3] je ted 10 */ /* jak vynulovat pole */ for ( p = &a[0]; p <= &a[9]; p++ ) *p = 0; /* nebo */ for ( p = &a[0]; p <= &a[9]; *p++ = 0 ); /* nebo ještě lépe */ for ( p = &a[0]; p <= &a[9]; *p++ = 0 ) {} M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 5/43
6 Ukazatele a pole C má speciální zpracování staticky alokovaných poĺı. Staticky alokované C pole může pouze: vyhodnotit svou velikost použitím operátoru sizeof, implicitně se zkonvertovat na konstantní ukazatel ukazující na nultý prvek pole. int a[10], *pa; pa = a; /* ekvivalentní pa = &a[0] */ *(pa + 2) = 10; /* a[2] = 10; */ *(a + 3) = 5; /* a[3] = 5; */ pa[4] = 100; /* a[4] = 100 */ for (pa = a; pa <= a + 9; *pa++ = 0) {} a++; /* Chyba. Proč? */ když a je pole (nebo ukazatel) a i je celé číslo, tak platí: a[i] = *(a+i) = *(i+a) = i[a] M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 6/43
7 Ukazatele a pole Problém přečíst vektor, který má n komponent. /* verze s "polem" */ void readvector1 ( int v[], int n ) { int i; printf ( "Napis %d cisel:\n", n ); for ( i = 0; i < n; i ++ ) scanf ( "%d", &v[i] ); } /* verze s "ukazatelem" (vylepšená) */ void readvector2 ( int * p, int n ) { int * q = p + n; printf ( "Napis %d cisel:\n", n ); for ( ; p < q; p++ ) scanf ( "%d", p ); } M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 7/43
8 Ukazatele a řetězce Palindrom je text (dlouhý nejméně dva znaky), který se čte stejně zepředu jako zezadu. Několik příkladů: kayak, murder for a jar of red rum, don t nod.... Vytvoříme funkci, která testuje palindromy. M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 8/43
9 Ukazatele a řetězce #define MAX_LEN 100 int ispalindrome ( char *s ); int main ( void ) { char phrase[max_len+1]; printf ( "Napis frazi, max %d znaku:\n", MAX_LEN ); scanf ( "%100s", phrase ); printf ( "Fraze %s ", phrase ); if ( ispalindrome(phrase) ) printf ( "je" ); else printf ( "neni" ); printf ( " palindrom\n"); return 0; } M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 9/43
10 Ukazatele a řetězce Jak otestujeme palindrom? Fráze je uložena v poli znaků od indexu 0, poslední použitý index je l-1, kde l je délka fráze, znak s indexem l je zakončovací nula. Potřebujeme porovnávat znaky: s[0] a s[l-1] s[1] a s[l-2]... porovnávání končí ve středu fráze. int ispalindrome ( char *s ) { int l = strlen ( s ), half = l/2, i; for ( i = 0; i < half; i++) if (s[i]!= s[l-i-1]) return 0; return 1; } M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 10/43
11 Ukazatele a řetězce Jiné řešení: Použijeme dva ukazatele, první ukazatel bude na počátku referencovat první znak a bude postupovat směrem ke konci fráze, druhý ukazatel bude na počátku referencovat poslední znak a bude postupovat směrem k začátku fráze, pokud se znaky referencované ukazateli shodují, je to palindrom int ispalindrome ( char *s ) { char * e; for ( e = s + strlen ( s ) - 1; s < e; s ++, e-- ) if ( *s!= *e ) return 0; return 1; } M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 11/43
12 Dynamická alokace paměti Hlavní použití ukazatelů v jazyce C: předání výstupních (referencovaných) parametrů funkci, předání poĺı jako parametrů funkci, manipulace s poli (zejména s řetězci), přístup k dynamicky alokované paměti. Dynamicky alokovaný objekt (proměnná) nevzniká deklarací. Místo toho vzniká dynamicky, v době běhu programu, pomocí speciálních funkcí (operátorů). Dynamicky alokovaná proměnná nemá jméno. Pro přístup k proměnné slouží její adresa (ukazatel). V C dynamickou alokaci poskytuje funkce malloc: funkce má jeden parametr velikost alokované paměti v bajtech, funkce rezervuje souvislý blok požadované velikosti v paměti počítače, funkce vrací ukazatel (adresu) takto připraveného bloku, návratový ukazatel je typu void*, obvykle je třeba jej přetypovat (typecast). M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 12/43
13 Dynamická alokace paměti Příklad dynamické alokace: int main( void ) { int *p; } p = (int*)malloc( sizeof(int) ); *p = 10; printf ( "*p=%d\n", *p ); return 0; Proměnná p je ukazatel. Tento ukazatel je normální lokální proměnná (tj. alokovaná kompilátorem na zásobníku). Ukazatel referencuje blok dynamicky alokované paměti: blok je anonymní v programu nemá jméno, přístup k němu je možný jen prostřednictvím ukazatele p. M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 13/43
14 Dynamická alokace paměti Dynamická alokace primitivních datových typů je třeba jen zřídka: primitivní datové typy jsou malé, režie přidělování bloku paměti je mnohem větší než vlastní blok. Dynamická alokace paměti je dobře využitelná pro alokaci větších (strukturovaných) proměnných poĺı nebo struktur. Příklad: funkce čte obsah vektoru dané dimenze n. int * readvector( int n ) { int i, *p; p = (int*)malloc ( sizeof(int)*n ); printf("napis %d cisel:\n", n); for ( i = 0; i < n; i ++ ) scanf( "%d", &p[i] ); return p; } M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 14/43
15 Dynamická alokace paměti Co se stane, když malloc špatně předáme velikost? int i, n = 5; double * a = (double *) malloc ( n ); /*!!! */ for ( i = 0; i < n; i ++ ) a[i] = 0; i n... 5 a reserved size: 5B... a[0] a[1]... Předpokládáme sizeof (int) = 4 a sizeof (double) = 8. M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 15/43
16 Dynamická alokace paměti Co se stane, když malloc špatně předáme velikost? int i, n = 5; double * a; a = (double *) malloc ( n * sizeof ( int ) ); /*!!! */ for ( i = 0; i < n; i ++ ) a[i] = 0; i n... 5 a reserved size: 20B a[0] a[1] a[2] a[3] a[4] M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 16/43
17 Dynamická alokace paměti Co se stane, když malloc špatně předáme velikost? int i, n = 5; double * a; a = (double *) malloc ( n * sizeof ( double ) ); for ( i = 0; i < n; i ++ ) a[i] = 0; i n... 5 a reserved size: 40B a[0] a[1] a[2] a[3] a[4] M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 17/43
18 Dynamická alokace paměti Starost o velikost prvku můžete nechat na kompilátoru. Místo: int n =...; int * array; array = (int*) malloc ( n * sizeof ( int ) ); Je lepší zapsat: array = (int*) malloc ( n * sizeof ( *array ) ); Je to takový rozdíl? M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 18/43
19 Dynamická alokace paměti Co je správně? int ** a, n =...; a = (int**) malloc ( n * sizeof (int) ); M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 19/43
20 Dynamická alokace paměti Co je správně? int ** a, n =...; a = (int**) malloc ( n * sizeof (int) ); /* ERROR */ a = (int**) malloc ( n * sizeof (int *) ); M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 19/43
21 Dynamická alokace paměti Co je správně? int ** a, n =...; a = (int**) malloc ( n * sizeof (int) ); /* ERROR */ a = (int**) malloc ( n * sizeof (int *) ); /* OK */ a = (int**) malloc ( n * sizeof ( *a ) ); /* OK */ M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 19/43
22 Dynamická alokace paměti int (* a)[5], n =...; a = (int(*)[5]) malloc ( n * sizeof (int) ); M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 20/43
23 Dynamická alokace paměti int (* a)[5], n =...; a = (int(*)[5]) malloc ( n * sizeof (int) ); /* ERROR */ a = (int(*)[5]) malloc ( n * sizeof (int *) ); M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 20/43
24 Dynamická alokace paměti int (* a)[5], n =...; a = (int(*)[5]) malloc ( n * sizeof (int) ); /* ERROR */ a = (int(*)[5]) malloc ( n * sizeof (int *) ); /* ERROR */ a = (int(*)[5]) malloc ( n * sizeof (int (*)[5]) ); M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 20/43
25 Dynamická alokace paměti int (* a)[5], n =...; a = (int(*)[5]) malloc ( n * sizeof (int) ); /* ERROR */ a = (int(*)[5]) malloc ( n * sizeof (int *) ); /* ERROR */ a = (int(*)[5]) malloc ( n * sizeof (int (*)[5]) ); /* ERROR */ a = (int(*)[5]) malloc ( n * sizeof (int [5]) ); M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 20/43
26 Dynamická alokace paměti int (* a)[5], n =...; a = (int(*)[5]) malloc ( n * sizeof (int) ); /* ERROR */ a = (int(*)[5]) malloc ( n * sizeof (int *) ); /* ERROR */ a = (int(*)[5]) malloc ( n * sizeof (int (*)[5]) ); /* ERROR */ a = (int(*)[5]) malloc ( n * sizeof (int [5]) ); /* OK */ a = (int(*)[5]) malloc ( n * sizeof ( *a ) ); /* OK */ M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 20/43
27 Dynamická alokace paměti int * (**a)(int *), n =...; a = (int * (**)(int*)) malloc ( n * sizeof(int) ); M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 21/43
28 Dynamická alokace paměti int * (**a)(int *), n =...; a = (int * (**)(int*)) malloc ( n * sizeof(int) ); /* ERROR */ a = (int * (**)(int*)) malloc ( n * sizeof(int *) ); M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 21/43
29 Dynamická alokace paměti int * (**a)(int *), n =...; a = (int * (**)(int*)) malloc ( n * sizeof(int) ); /* ERROR */ a = (int * (**)(int*)) malloc ( n * sizeof(int *) ); /* ERROR */ a = (int * (**)(int*)) malloc ( n * sizeof(int **) ); M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 21/43
30 Dynamická alokace paměti int * (**a)(int *), n =...; a = (int * (**)(int*)) malloc ( n * sizeof(int) ); /* ERROR */ a = (int * (**)(int*)) malloc ( n * sizeof(int *) ); /* ERROR */ a = (int * (**)(int*)) malloc ( n * sizeof(int **) ); /* ERROR */ a = (int * (**)(int*)) malloc ( n * sizeof (int * (*)(int*) ) ); M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 21/43
31 Dynamická alokace paměti int * (**a)(int *), n =...; a = (int * (**)(int*)) malloc ( n * sizeof(int) ); /* ERROR */ a = (int * (**)(int*)) malloc ( n * sizeof(int *) ); /* ERROR */ a = (int * (**)(int*)) malloc ( n * sizeof(int **) ); /* ERROR */ a = (int * (**)(int*)) malloc ( n * sizeof (int * (*)(int*) ) ); /* OK */ a = (int * (**)(int*)) malloc ( n * sizeof ( *a ) ); /* OK */ Proč si přidělávat starosti s určením správného zápisu datového typu, když to kompilátor dokáže automaticky a bez chyb? M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 21/43
32 Dynamická alokace paměti Čím je alokovaný blok vyplněn (inicializován)? obsah není definovaný (neinicializováno), při prvních alokacích bývá obsah vyplněn nulovými bajty, ale NELZE se na to spolehnout. Proč malloc obsah vždy nevynuluje? vyplnění nulami stojí nenulový čas, vyplnění nulami není potřeba vždy. Pokud ihned po alokaci prostor vyplníme novým užitečným obsahem, bylo nulování zbytečné, pokud by se nulovalo vždy, bylo by zpracování např. obrazu, videa a zvuku zbytečně neefektivní a zbytečně by vyžadovalo výkonnější HW, pokud záměrně chcete mít prostor vždy vynulovaný, použijte calloc místo malloc. M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 22/43
33 Proč je potřeba přetypování a co vlastně dělá Funkce malloc je obyčejná funkce ve std. knihovně. Její rozhraní je: void * malloc ( size_t size ); Návratový typ je void*, tedy ukazatel (adresa) bez udaného typu. Pokud použijeme funkci malloc přímo, nebude v přiřazení souhlasit datový typ ukazatelů: int * array = malloc ( 1000 * sizeof ( int ) ); /* levá strana int * vs. pravá strana void * */ Kompilátor takové přiřazení odmítne přeložit, případně u něj generuje varování. Není si jist, zda se nejedná o programátorskou chybu (z minulé přednášky víme, že přiřazení mezi ukazateli různých typů může vést k těžko odhalitelným chybám). M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 23/43
34 Proč je potřeba přetypování a co vlastně dělá Přetypování zde říká kompilátoru, že jsme si vědomi nesouladu typů a že tento nesoulad je zamýšlený (protože je daný deklarací funkce malloc). Odpojíme tím tedy dobře míněné kontroly kompilátoru a přebíráme zodpovědnost za veškerá rizika! Přetypování ukazatelů je za běhu prázdná (no-op) operace. Adresa z návratové hodnoty je beze změn uložena do proměnné na levé straně. Vždy si bud te jisti, že funkci malloc používáte správně. Zvláštní péči věnujte velikosti alokovaného prostoru. Pokud alokujete n prvků, nezapomeňte hodnotu n vynásobit velikostí prvku (operátor sizeof). Uvědomte si, že kompilátor Vám zde případné chyby nenahlásí, protože přetypováním jsme jej úmyslně odpojili. M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 24/43
35 Dynamická alokace paměti Dynamicky alokovaná pamět je rezervována až do okamžiku, kdy ji programátor dealokuje. Co když dynamicky alokovaná pamět není dealokována? int *p, *q; p = (int*) malloc ( ); q = (int*) malloc ( ); *p = 10; *q = 20; p = q; p? q? M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 25/43
36 Dynamická alokace paměti Dynamicky alokovaná pamět je rezervována až do okamžiku, kdy ji programátor dealokuje. Co když dynamicky alokovaná pamět není dealokována? int *p, *q; p = (int*) malloc ( ); q = (int*) malloc ( ); *p = 10; *q = 20; p = q; p q?? M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 25/43
37 Dynamická alokace paměti Dynamicky alokovaná pamět je rezervována až do okamžiku, kdy ji programátor dealokuje. Co když dynamicky alokovaná pamět není dealokována? int *p, *q; p = (int*) malloc ( ); q = (int*) malloc ( ); *p = 10; *q = 20; p = q; p q?? M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 25/43
38 Dynamická alokace paměti Dynamicky alokovaná pamět je rezervována až do okamžiku, kdy ji programátor dealokuje. Co když dynamicky alokovaná pamět není dealokována? int *p, *q; p = (int*) malloc ( ); q = (int*) malloc ( ); *p = 10; *q = 20; p = q; p q? 10? M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 25/43
39 Dynamická alokace paměti Dynamicky alokovaná pamět je rezervována až do okamžiku, kdy ji programátor dealokuje. Co když dynamicky alokovaná pamět není dealokována? int *p, *q; p = (int*) malloc ( ); q = (int*) malloc ( ); *p = 10; *q = 20; p = q; p q 20? 10? M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 25/43
40 Dynamická alokace paměti Dynamicky alokovaná pamět je rezervována až do okamžiku, kdy ji programátor dealokuje. Co když dynamicky alokovaná pamět není dealokována? int *p, *q; p = (int*) malloc ( ); q = (int*) malloc ( ); *p = 10; *q = 20; p = q; 20? 10? p q inaccessible, cannot free M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 25/43
41 Dynamická alokace paměti Dynamicky alokovaná pamět je rezervována až do okamžiku, kdy ji programátor dealokuje. Co když dynamicky alokovaná pamět není dealokována? int *p, *q; p = (int*) malloc ( ); q = (int*) malloc ( ); *p = 10; *q = 20; p = q; 20? 10? p q inaccessible, cannot free Ztracené bloky stále patří programu. Když se program nestará o ztracené bloky, může vyčerpat celou pamět. M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 25/43
42 Dynamická alokace paměti Bloky paměti je potřeba před ztrátou reference uvolnit. V C není automatická správa volné paměti (garbage collector). int *p, *q; p = (int*) malloc ( ); q = (int*) malloc ( ); *p = 10; *q = 20; free ( p ); p = q; free ( q ); p q M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 26/43
43 Dynamická alokace paměti Bloky paměti je potřeba před ztrátou reference uvolnit. V C není automatická správa volné paměti (garbage collector). int *p, *q; p = (int*) malloc ( ); q = (int*) malloc ( ); *p = 10; *q = 20; free ( p ); p = q; free ( q ); p q 20 marked as unused... M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 26/43
44 Dynamická alokace paměti Bloky paměti je potřeba před ztrátou reference uvolnit. V C není automatická správa volné paměti (garbage collector). int *p, *q; p = (int*) malloc ( ); q = (int*) malloc ( ); *p = 10; *q = 20; free ( p ); p = q; free ( q ); p q 20 marked as unused... M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 26/43
45 Dynamická alokace paměti Bloky paměti je potřeba před ztrátou reference uvolnit. V C není automatická správa volné paměti (garbage collector). int *p, *q; p = (int*) malloc ( ); q = (int*) malloc ( ); *p = 10; *q = 20; free ( p ); p = q; free ( q ); p q marked as unused... M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 26/43
46 Dynamická alokace paměti Každý alokovaný blok by měl být uvolněn. Blok je potřeba uvolnit právě jednou. Pokus o vícenásobné uvolnění bloku může vést k pádu programu. int *p, *q; p = (int*) malloc ( ); q = (int*) malloc ( ); *p = 10; *q = 20; free ( p ); p = q; free ( p ); /* note: p */ free ( q ); p q M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 27/43
47 Dynamická alokace paměti Každý alokovaný blok by měl být uvolněn. Blok je potřeba uvolnit právě jednou. Pokus o vícenásobné uvolnění bloku může vést k pádu programu. int *p, *q; p = (int*) malloc ( ); q = (int*) malloc ( ); *p = 10; *q = 20; free ( p ); p = q; free ( p ); /* note: p */ free ( q ); p q 20 marked as unused... M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 27/43
48 Dynamická alokace paměti Každý alokovaný blok by měl být uvolněn. Blok je potřeba uvolnit právě jednou. Pokus o vícenásobné uvolnění bloku může vést k pádu programu. int *p, *q; p = (int*) malloc ( ); q = (int*) malloc ( ); *p = 10; *q = 20; free ( p ); p = q; free ( p ); /* note: p */ free ( q ); p q 20 marked as unused... M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 27/43
49 Dynamická alokace paměti Každý alokovaný blok by měl být uvolněn. Blok je potřeba uvolnit právě jednou. Pokus o vícenásobné uvolnění bloku může vést k pádu programu. int *p, *q; p = (int*) malloc ( ); q = (int*) malloc ( ); *p = 10; *q = 20; free ( p ); p = q; free ( p ); /* note: p */ free ( q ); p q marked as unused... M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 27/43
50 Dynamická alokace paměti Každý alokovaný blok by měl být uvolněn. Blok je potřeba uvolnit právě jednou. Pokus o vícenásobné uvolnění bloku může vést k pádu programu. int *p, *q; p = (int*) malloc ( ); q = (int*) malloc ( ); *p = 10; *q = 20; free ( p ); p = q; free ( p ); /* note: p */ free ( q ); p q CRASH, double free M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 27/43
51 Dynamická alokace paměti Kdy musíme použít dynamickou alokaci paměti: v době kompilace neznáme velikost pole, známe velikost pole, ale pole je veliké (např. stovky KiB), tedy nemusí se vejít na zásobník jako lokální proměnná, pro alokaci velkých struktur, potřebujeme pole (či strukturu) vytvořit ve funkci a předat ji volajícímu. V ostatních případech může být lepší použít alokace statické (lokální proměnné). Statická alokace je vhodná pro: alokaci jednotlivých proměnných primitivních typů (int, double,... ). Tyto proměnné jsou velmi malé (několik bajtů), režie dynamická alokace bude násobně větší, malá pole s omezením velikosti známým v době kompilace, které není potřeba předávat volajícímu. Taková pole lze alokovat staticky a oželet část případně nevyužitého prostoru, malé struktury, které není potřeba předávat volajícímu. M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 28/43
52 Vícerozměrná pole Vícerozměrná pole lze v C alokovat plně staticky, plně dynamicky nebo kombinací statické a dynamické alokace. Každý z přístupů má své výhody a nevýhody. Postupy si ukážeme pro 2D pole (matice), nechají se použít i pro vícerozměrná pole (3D, 4D,... ). M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 29/43
53 Vícerozměrná pole plně statická Známe-li velikost matice v době kompilace, lze ji alokovat staticky: #define ROWS 3 #define COLS 2 int mat[rows][cols]; Kompilátor takovou matici ukládá do paměti po řádcích: řádky jsou uložené těsně za sebou, prvky v řádce jsou také uložené těsně za sebou. mat[2][1] mat[0] mat[1] mat[2] M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 30/43
54 Vícerozměrná pole plně statická Chceme-li takovou matici předat do funkce jako parametr, musíme předat ukazatel na její počátek: matice je vlastně pole o 3 prvcích, prvkem tohoto pole jsou dvouprvková pole, předáváme tedy ukazatel na dvouprvková pole hodnot typu int. void foo ( int (*mat)[cols], int rows )... Alternativou je zápis pomocí hranatých závorek: void foo ( int mat[][cols], int rows )... Vždy se předává ukazatel na počátek matice v paměti. Protože ukazatel nenese informaci o délce (zde o počtu řádek), je potřeba přidat další parametr. Matici nelze předat pomocí typu int* ani int **. Typ int* umožní předávat 1D pole, typ int** umožní předat dynamicky alokované 2D pole. M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 31/43
55 Vícerozměrná pole dynamicky alokovaná Neznáme-li rozměry matice v době kompilace, musíme matici alokovat dynamicky. Jednotlivé řádky alokujeme jako 1D pole, odkazy na tyto řádky umístíme do pomocného pole: cols rows M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 32/43
56 Vícerozměrná pole dynamicky alokovaná Alokace matice: int ** mat = (int **) malloc (rows * sizeof (*mat)); for ( i = 0; i < rows; i ++ ) mat[i] = (int *) malloc (cols * sizeof (**mat)); Uvolnění matice: for ( i = 0; i < rows; i ++ ) free ( mat[i] ); free ( mat ); M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 33/43
57 Vícerozměrná pole dynamicky alokovaná Chceme-li dynamicky alokovanou matici předat funkci, musíme předat ukazatel na počátek pomocného pole odkazů. Protože předávaný ukazatel nemá informaci o délce pole odkazů, musíme předat i počet řádek. Dále, protože ukazatele v pomocném poli odkazů nemají informace o délce řádky, musíme předat další parametr počet sloupců. void foo ( int ** mat, int rows, int cols )... Pro takovou matici může být vhodné vytvoření struktury se třemi složkami: ukazatel na pomocné pole odkazů, počet řádek, počet sloupců. M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 34/43
58 Vícerozměrná pole kombinace Je-li počet řádek fixní a počet sloupců proměnný, je řešení podobné dynamicky alokované matici. Pomocné pole odkazů však lze alokovat staticky: #define ROWS... int * mat[rows]; /* pole ukazatelů */ for ( i = 0; i < ROWS; i ++ ) mat[i] = (int *) malloc (cols * sizeof (**mat)); Uvolnění matice spočívá v uvolnění jednotlivých řádek: for ( i = 0; i < ROWS; i ++ ) free ( mat[i] ); /* free ( mat ); - zde NE */ Funkci se matice předává stejně jako kdyby byla dynamicky alokovaná (int ** ukazatel). M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 35/43
59 Vícerozměrná pole kombinace Je-li počet sloupců fixní a počet řádek proměnný, je řešení podobné staticky alokované matici. Pracujeme s ukazatelem, který ukazuje na řádek, kde řádek je pole s fixním počtem prvků. Zápis takového ukazatele je méně obvyklý: #define COLS... int (*mat)[cols]; /* ukazatel na prvek typu pole */ /* závorky jsou zde nutné */ mat = (int(*)[cols]) malloc (rows * sizeof (*mat)); Uvolnění matice je triviální: free ( mat ); Funkci se matice předává stejně jako kdyby byla staticky alokovaná (int (*)[COLS] ukazatel). M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 36/43
60 Pamět programu Správa paměti dnešního počítače je velmi komplikovaná. OS musí řešit následující požadavky: virtuální pamět, stránkování, segmentace, pamět ově mapované I/O, sdílení paměti mezi procesy, dynamicky linkované knihovny, vlákna a jejich oddělené zásobníky, DMA, TLS,... Více o této problematice bude řečeno v předmětu BI-OSY. Následující model správy paměti jednoho procesu je velmi zjednodušený, uvažuje pouze jediné vlákno (typický program v PA1) a nezabývá se dynamicky linkovanými knihovnami. Přesnější model získáte například takto (OS Linux): > cat /proc/<pid>/maps M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 37/43
61 Pamět programu Typický OS (Linux, Windows, Solaris,... ) vytváří běžícímu programu iluzi, že běží na počítači sám: dostane k dispozici plný adresní prostor (4 GiB pro 32 bitový systém, 16 EiB pro 64 bitový systém), v tomto adresním prostoru není jiný program, do tohoto prostoru si program umístí data, která potřebuje pro svůj běh. Program v C typicky potřebuje následující úseky paměti: pamět pro kód (instrukce programu), pamět pro konstanty, pamět pro globální proměnné, pamět pro zásobník (volání funkcí, lokální proměnné), pamět pro haldu (dynamicky alokované proměnné). M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 38/43
62 Pamět programu 4 GiB / 16 EiB stack limit stack, rw- unused uninitialized global variables (zero filled), rw-.bss heap, rw- initialized global variables, rw- constants, r--.data data segment program code, r-x.text executable file constants code standard libraries (libc, libm,...), r-x 0x OS overhead M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 39/43
63 Pamět programu Při spuštění připraví OS segmenty pro: kód, konstanty a globální proměnné (fixní velikost), halda je po spuštěni prázdná nebo velmi malá, halda se rozšiřuje podle požadavků na alokace. Zásobník je vyhrazen v horní části paměti: malá počáteční velikost (kilobajty), další pamět je přidána podle potřeby, velmi omezená max. hloubka (jednotky MiB), překročení limitu vede k pádu programu (např. při nekonečné rekurzi). Většina adresního prostoru je neobsazená: typický program v PA1 má kód velikosti řádově desítek KiB, při spuštění se k němu přidávají standardní knihovny (cca 10 MiB) a mělký zásobník, zbytek adresního prostoru (4 GiB - 10 MiB, resp. 16 EiB - 10 MiB) je neobsazen, pokus o přístup do neobsazené části pamět ového prostoru vede k pádu programu. M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 40/43
64 Pamět programu Důsledky tohoto rozdělení paměti: Globální proměnné jsou alokované stále. Použitelné pouze pro data, která program potřebuje uchovávat po celou dobu běhu. Globální proměnné mají fixní velikost danou při kompilaci. Tedy nejsou vhodné pro data, která mají velké rozpětí velikosti (program vždy požaduje mnoho paměti při startu, i když zpracovává málo dat). Globální proměnné se hodí pro konstanty a předpočítané tabulky, které se během výpočtu nemění. Na zásobník nepatří velké proměnné. Zásobník je mělký. Tedy lokální proměnné se nehodí např. pro velká pole. Lokální proměnné se nedají použít, pokud na ně chceme vytvořit odkaz a ten předat volajícímu. Velké proměnné patří na haldu (dynamická alokace). M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 41/43
65 Pamět programu Kde se alokují proměnné? int a = 10; int b; static int c; int main ( void ) { int x; int y = 10; static int z; static int w = 10; int * p; p = (int *) malloc ( 100 * sizeof (*p) ); free ( p ); return 0; } M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 42/43
66 Pamět programu Kde se alokují proměnné? int a = 10; /*.data */ int b; static int c; int main ( void ) { int x; int y = 10; static int z; static int w = 10; int * p; p = (int *) malloc ( 100 * sizeof (*p) ); free ( p ); return 0; } M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 42/43
67 Pamět programu Kde se alokují proměnné? int a = 10; /*.data */ int b; /*.bss */ static int c; int main ( void ) { int x; int y = 10; static int z; static int w = 10; int * p; p = (int *) malloc ( 100 * sizeof (*p) ); free ( p ); return 0; } M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 42/43
68 Pamět programu Kde se alokují proměnné? int a = 10; /*.data */ int b; /*.bss */ static int c; /*.bss */ int main ( void ) { int x; int y = 10; static int z; static int w = 10; int * p; p = (int *) malloc ( 100 * sizeof (*p) ); free ( p ); return 0; } M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 42/43
69 Pamět programu Kde se alokují proměnné? int a = 10; /*.data */ int b; /*.bss */ static int c; /*.bss */ int main ( void ) { int x; /* stack */ int y = 10; static int z; static int w = 10; int * p; p = (int *) malloc ( 100 * sizeof (*p) ); free ( p ); return 0; } M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 42/43
70 Pamět programu Kde se alokují proměnné? int a = 10; /*.data */ int b; /*.bss */ static int c; /*.bss */ int main ( void ) { int x; /* stack */ int y = 10; /* stack */ static int z; static int w = 10; int * p; p = (int *) malloc ( 100 * sizeof (*p) ); free ( p ); return 0; } M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 42/43
71 Pamět programu Kde se alokují proměnné? int a = 10; /*.data */ int b; /*.bss */ static int c; /*.bss */ int main ( void ) { int x; /* stack */ int y = 10; /* stack */ static int z; /*.bss */ static int w = 10; int * p; p = (int *) malloc ( 100 * sizeof (*p) ); free ( p ); return 0; } M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 42/43
72 Pamět programu Kde se alokují proměnné? int a = 10; /*.data */ int b; /*.bss */ static int c; /*.bss */ int main ( void ) { int x; /* stack */ int y = 10; /* stack */ static int z; /*.bss */ static int w = 10; /*.data */ int * p; p = (int *) malloc ( 100 * sizeof (*p) ); free ( p ); return 0; } M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 42/43
73 Pamět programu Kde se alokují proměnné? int a = 10; /*.data */ int b; /*.bss */ static int c; /*.bss */ int main ( void ) { int x; /* stack */ int y = 10; /* stack */ static int z; /*.bss */ static int w = 10; /*.data */ int * p; /* stack */ p = (int *) malloc ( 100 * sizeof (*p) ); free ( p ); return 0; } M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 42/43
74 Pamět programu Kde se alokují proměnné? int a = 10; /*.data */ int b; /*.bss */ static int c; /*.bss */ int main ( void ) { int x; /* stack */ int y = 10; /* stack */ static int z; /*.bss */ static int w = 10; /*.data */ int * p; /* stack */ p = (int *) malloc ( 100 * sizeof (*p) ); /* 100 * sizeof(*p) byte alokováno na haldě */ free ( p ); return 0; } M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 42/43
75 Pamět programu Kde se alokují proměnné? int a = 10; /*.data */ int b; /*.bss */ static int c; /*.bss */ int main ( void ) { int x; /* stack */ int y = 10; /* stack */ static int z; /*.bss */ static int w = 10; /*.data */ int * p; /* stack */ p = (int *) malloc ( 100 * sizeof (*p) ); /* 100 * sizeof(*p) byte alokováno na haldě */ free ( p ); /* blok na haldě označen jako volný */ /* halda se může, ale nemusí zmenšit */ return 0; } M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 42/43
76 Otázky a odpovědi Otázky... M. Baĺık, L. Vagner a J. Vogel, ČVUT FIT Ukazatele, BI-PA1 43/43
IUJCE 07/08 Přednáška č. 6
Správa paměti Motivace a úvod v C (skoro vždy) ručně statické proměnné o datový typ, počet znám v době překladu o zabírají paměť po celou dobu běhu programu problém velikosti definovaných proměnných jak
Struktura programu v době běhu
Struktura programu v době běhu Miroslav Beneš Dušan Kolář Struktura programu v době běhu Vztah mezi zdrojovým programem a činností přeloženého programu reprezentace dat správa paměti aktivace podprogramů
Pointery II. Jan Hnilica Počítačové modelování 17
Pointery II 1 Pointery a pole Dosavadní způsob práce s poli zahrnoval: definici pole jakožto kolekce proměnných (prvků) jednoho typu, umístěných v paměti za sebou int pole[10]; práci s jednotlivými prvky
Ukazatele, dynamická alokace
Ukazatele, dynamická alokace Karel Richta a kol. katedra počítačů FEL ČVUT v Praze Přednášky byly připraveny s pomocí materiálů, které vyrobili Ladislav Vágner, Pavel Strnad, Martin Mazanec Karel Richta,
BI-PA1 Programování a Algoritmizace 1. Miroslav Baĺık, Ladislav Vagner a Josef Vogel. 7., 9. a 10. listopadu 2017
Pole, Řetězce BI-PA1 Programování a Algoritmizace 1 Miroslav Baĺık, Ladislav Vagner a Josef Vogel Katedra teoretické informatiky a Katedra softwarového inženýrství Fakulta informačních technologíı České
BI-PA1 Programování a algoritmizace 1, ZS Katedra teoretické informatiky
Příprava studijního programu Informatika je podporována projektem financovaným z Evropského sociálního fondu a rozpočtu hlavního města Prahy. Praha & EU: Investujeme do vaší budoucnosti Ukazatele BI-PA1
Střední škola pedagogická, hotelnictví a služeb, Litoměříce, příspěvková organizace
Střední škola pedagogická, hotelnictví a služeb, Litoměříce, příspěvková organizace Předmět: Vývoj aplikací Téma: Pole Vyučující: Ing. Milan Káža Třída: EK3 Hodina: 14 Číslo: V/5 Programování v jazyce
Správné vytvoření a otevření textového souboru pro čtení a zápis představuje
f1(&pole[4]); funkci f1 předáváme hodnotu 4. prvku adresu 4. prvku adresu 5. prvku hodnotu 5. prvku symbolická konstanta pro konec souboru je eof EOF FEOF feof Správné vytvoření a otevření textového souboru
Správa paměti. Karel Richta a kol. Katedra počítačů Fakulta elektrotechnická České vysoké učení technické v Praze Karel Richta, 2016
Správa paměti Karel Richta a kol. Katedra počítačů Fakulta elektrotechnická České vysoké učení technické v Praze Karel Richta, 2016 Objektové modelování, B36OMO 10/2016, Lekce 2 https://cw.fel.cvut.cz/wiki/courses/xxb36omo/start
IUJCE 07/08 Přednáška č. 4. v paměti neexistuje. v paměti existuje
Konstanty I možnosti: přednostně v paměti neexistuje žádný ; o preprocesor (deklarace) #define KONSTANTA 10 o konstantní proměnná (definice) const int KONSTANTA = 10; příklad #include v paměti
Ukazatele #1, struktury
Ukazatele #1, struktury BI-PA1 Programování a Algoritmizace 1 Miroslav Baĺık, Ladislav Vagner a Josef Vogel Katedra teoretické informatiky a Katedra softwarového inženýrství Fakulta informačních technologíı
Více o konstruktorech a destruktorech
Více o konstruktorech a destruktorech Více o konstruktorech a o přiřazení... inicializovat objekt lze i pomocí jiného objektu lze provést přiřazení mezi objekty v původním C nebylo možné provést přiřazení
Mělká a hluboká kopie
Karel Müller, Josef Vogel (ČVUT FIT) Mělká a hluboká kopie BI-PA2, 2011, Přednáška 5 1/28 Mělká a hluboká kopie Ing. Josef Vogel, CSc Katedra softwarového inženýrství Katedra teoretické informatiky, Fakulta
BI-PA1 Programování a algoritmizace 1 Katedra teoretické informatiky
Příprava studijního programu Informatika je podporována projektem financovaným z Evropského sociálního fondu a rozpočtu hlavního města Prahy. Praha & EU: Investujeme do vaší budoucnosti Ukazatele BI-PA1
Př. další použití pointerů
Př. další použití pointerů char *p_ch; int *p_i; p_ch = (char *) p_i; // konverze int * na char * 8 int i = 5; int *p_i; p_i = &i; POZOR!!!! scanf("%d", p_i); printf("%d", *p_i); Obecný pointer na cokoliv:
6. lekce Úvod do jazyka C knihovny datové typy, definice proměnných základní struktura programu a jeho editace Miroslav Jílek
6. lekce Úvod do jazyka C knihovny datové typy, definice proměnných základní struktura programu a jeho editace Miroslav Jílek 1/73 https://en.cppreference.com internetová stránka s referencemi https://gedit.en.softonic.com/download
for (int i = 0; i < sizeof(hodnoty) / sizeof(int); i++) { cout<<hodonoty[i]<< endl; } cin.get(); return 0; }
Pole Kdybychom v jazyce C++chtěli načíst větší počet čísel nebo znaků a všechny bylo by nutné všechny tyto hodnoty nadále uchovávat v paměti počítače, tak by bylo potřeba v paměti počítače alokovat stejný
Správa paměti. doc. Ing. Miroslav Beneš, Ph.D. katedra informatiky FEI VŠB-TUO A-1007 /
Správa paměti doc. Ing. Miroslav Beneš, Ph.D. katedra informatiky FEI VŠB-TUO A-1007 / 597 324 213 http://www.cs.vsb.cz/benes Miroslav.Benes@vsb.cz Obsah přednášky Motivace Úrovně správy paměti. Manuální
Michal Krátký. Úvod do programovacích jazyků (Java), 2006/2007
Úvod do programovacích jazyků (Java) Michal Krátký 1 Katedra informatiky VŠB Technická univerzita Ostrava Úvod do programovacích jazyků (Java), 2006/2007 c 2006 Michal Krátký Úvod do programovacích jazyků
Práce s pamětí a předávání parametrů. Úvod do programování 1
Práce s pamětí a předávání parametrů Úvod do programování 1 Motivace Zatím jsme se setkali s následjícími problémy : Proměnná existje / je dostpná jen v blok, kde vznikla Pole existje v blok, kde bylo
Pokročilé programování v jazyce C pro chemiky (C3220) Operátory new a delete, virtuální metody
Pokročilé programování v jazyce C pro chemiky (C3220) Operátory new a delete, virtuální metody Dynamická alokace paměti Jazyky C a C++ poskytují programu možnost vyžádat si část volné operační paměti pro
Dynamická vícerozměrná pole. Základy programování 2 Tomáš Kühr
Dynamická vícerozměrná pole Základy programování 2 Tomáš Kühr Statická pole připomenutí Příklad definice: int polea[2][3]; Nejjednodušší způsob vytvoření pole Pole je statické oba rozměry se zadávají konstantou
Základy programování (IZP)
Základy programování (IZP) Deváté počítačové cvičení Brno University of Technology, Faculty of Information Technology Božetěchova 1/2, 612 66 Brno - Královo Pole Petr Veigend, iveigend@fit.vutbr.cz 27.11.2017,
Práce s polem a pamětí
3 Práce s polem a pamětí Inicializace jednorozměrného pole Jednorozměrné pole lze inicializovat přímo v deklaraci. int array[length] = {1, 5, 8, 9; array1d Prvky pole umístíte do složených závorek a oddělíte
Základy programování (IZP)
Základy programování (IZP) Jedenácté počítačové cvičení Brno University of Technology, Faculty of Information Technology Božetěchova 1/2, 612 66 Brno - Královo Pole Gabriela Nečasová, inecasova@fit.vutbr.cz
Střední škola pedagogická, hotelnictví a služeb, Litoměříce, příspěvková organizace
Programování v jazyce C a C# část I. Střední škola pedagogická, hotelnictví a služeb, Litoměříce, příspěvková organizace Předmět: Algoritmizace a programování Téma: Programování Vyučující: Ing. Milan Káža
Funkce, procedury, složitost
Funkce, procedury, složitost BI-PA1 Programování a Algoritmizace 1 Miroslav Baĺık, Ladislav Vagner a Josef Vogel Katedra teoretické informatiky a Katedra softwarového inženýrství Fakulta informačních technologíı
ZPRO v "C" Ing. Vít Hanousek. verze 0.3
verze 0.3 Hello World Nejjednoduší program ukazující vypsání textu. #include using namespace std; int main(void) { cout
09. Memory management. ZOS 2006, L.Pešička
09. Memory management ZOS 2006, L.Pešička Správa paměti paměťová pyramida absolutní adresa relativní adresa počet bytů od absolutní adresy fyzický prostor adres fyzicky k dispozici výpočetnímu systému
Programování v jazyce C a C++
Programování v jazyce C a C++ Richter 1 Petyovský 2 1. března 2015 1 Ing. Richter Miloslav, Ph.D., UAMT FEKT VUT Brno 2 Ing. Petyovský Petr, UAMT FEKT VUT Brno C++ Stručná charakteristika Nesdíĺı normu
Základy programování 2 KMI/ZP2
Základy programování 2 KMI/ZP2 Petr Osička KATEDRA INFORMATIKY UNIVERZITA PALACKÉHO V OLOMOUCI Adresování paměti Adresování paměti Posloupnost bajtů očíslovaných od nuly podobně jako pole. Adresa = index
2) Napište algoritmus pro vložení položky na konec dvousměrného seznamu. 3) Napište algoritmus pro vyhledání položky v binárním stromu.
Informatika 10. 9. 2013 Jméno a příjmení Rodné číslo 1) Napište algoritmus pro rychlé třídění (quicksort). 2) Napište algoritmus pro vložení položky na konec dvousměrného seznamu. 3) Napište algoritmus
Michal Krátký. Úvod do programovacích jazyků (Java), 2006/2007
Úvod do programovacích jazyků (Java) Michal Krátký Katedra informatiky VŠB Technická univerzita Ostrava Úvod do programovacích jazyků (Java), 2006/2007 c 2006 Michal Krátký Úvod do programovacích jazyků
8. lekce Úvod do jazyka C 3. část Základní příkazy jazyka C Miroslav Jílek
8. lekce Úvod do jazyka C 3. část Základní příkazy jazyka C Miroslav Jílek 1/41 Základní příkazy Všechny příkazy se píšou malými písmeny! Za většinou příkazů musí být středník (;)! 2/41 Základní příkazy
7 Formátovaný výstup, třídy, objekty, pole, chyby v programech
7 Formátovaný výstup, třídy, objekty, pole, chyby v programech Studijní cíl Tento studijní blok má za cíl pokračovat v základních prvcích jazyka Java. Konkrétně bude věnována pozornost formátovanému výstupu,
Distanční opora předmětu: Programování v jazyce C Tématický blok č. 6: Dynamická alokace paměti, typové konstrukce Autor: RNDr. Jan Lánský, Ph.D.
Distanční opora předmětu: Programování v jazyce C Tématický blok č. 6: Dynamická alokace paměti, typové konstrukce Autor: RNDr. Jan Lánský, Ph.D. Obsah kapitoly 1 Dynamická alokace paměti 2 Organizace
IAJCE Přednáška č. 8. double tprumer = (t1 + t2 + t3 + t4 + t5 + t6 + t7) / 7; Console.Write("\nPrumerna teplota je {0}", tprumer);
Pole (array) Motivace Častá úloha práce s větším množstvím dat stejného typu o Př.: průměrná teplota za týden a odchylka od průměru v jednotlivých dnech Console.Write("Zadej T pro.den: "); double t = Double.Parse(Console.ReadLine());
Abstraktní třídy, polymorfní struktury
Karel Müller, Josef Vogel (ČVUT FIT) Abstraktní třídy, polymorfní struktury BI-PA2, 2011, Přednáška 9 1/32 Abstraktní třídy, polymorfní struktury Ing. Josef Vogel, CSc Katedra softwarového inženýrství
Úvod do jazyka C. Ing. Jan Fikejz (KST, FEI) 28. prosince Fakulta elektrotechniky a informatiky Katedra softwarových technologií
9 Fakulta elektrotechniky a informatiky Katedra softwarových technologií 28. prosince 2009 Struktury Struktury heterogenní struktura položky mohou být různých datových typů vystupuje jako jediný objekt
Základy programování (IZP)
Základy programování (IZP) Osmé počítačové cvičení Brno University of Technology, Faculty of Information Technology Božetěchova 1/2, 612 66 Brno - Královo Pole Petr Veigend, iveigend@fit.vutbr.cz 20.11.2017,
Ukazatel (Pointer) jako datový typ - proměnné jsou umístěny v paměti na určitém místě (adrese) a zabírají určitý prostor (počet bytů), který je daný
Ukazatel (Pointer) jako datový typ - proměnné jsou umístěny v paměti na určitém místě (adrese) a zabírají určitý prostor (počet bytů), který je daný typem proměnné - ukazatel je tedy adresa společně s
Práce s binárními soubory. Základy programování 2 Tomáš Kühr
Práce s binárními soubory Základy programování 2 Tomáš Kühr Binární soubory Mohou mít libovolnou strukturu Data jsou uložena ve stejné podobě jako v paměti za běhu programu Výhody: Pro uložení je potřeba
Algoritmizace a programování
Algoritmizace a programování Strukturované proměnné Pole (array), ukazatele (pointer) Jazyk C České vysoké učení technické Fakulta elektrotechnická Ver.1.10 J. Zděnek 2015 Pole (array) (1) Pole je množina
Operační systémy. Cvičení 4: Programování v C pod Unixem
Operační systémy Cvičení 4: Programování v C pod Unixem 1 Obsah cvičení Řídící struktury Funkce Dynamická alokace paměti Ladění programu Kde najít další informace Poznámka: uvedené příklady jsou dostupné
Dědění, polymorfismus
Programování v jazyce C/C++ Ladislav Vagner úprava Pavel Strnad Dědění. Polymorfismus. Dnešní přednáška Statická a dynamická vazba. Vnitřní reprezentace. VMT tabulka virtuálních metod. Časté chyby. Minulá
Přednáška. Správa paměti I. Katedra počítačových systémů FIT, České vysoké učení technické v Praze Jan Trdlička, 2012
Přednáška Správa paměti I. Katedra počítačových systémů FIT, České vysoké učení technické v Praze Jan Trdlička, 2012 Příprava studijního programu Informatika je podporována projektem financovaným z Evropského
Úvod do jazyka C. Ing. Jan Fikejz (KST, FEI) Fakulta elektrotechniky a informatiky Katedra softwarových technologií
1 Fakulta elektrotechniky a informatiky Katedra softwarových technologií 12. října 2009 Organizace výuky Přednášky Teoretické základy dle normy jazyka C Cvičení Praktické úlohy odpřednášené látky Prostřední
Ukazatele, paměťové třídy, volání funkcí
Ukazatele, paměťové třídy, volání funkcí Jan Faigl Katedra počítačů Fakulta elektrotechnická České vysoké učení technické v Praze Přednáška 06 B0B36PRP Procedurální programování Jan Faigl, 2018 B0B36PRP
Základy programování (IZP)
Základy programování (IZP) Páté počítačové cvičení Brno University of Technology, Faculty of Information Technology Božetěchova 1/2, 612 66 Brno - Královo Pole Petr Veigend, iveigend@fit.vutbr.cz 5. týden
8 Třídy, objekty, metody, předávání argumentů metod
8 Třídy, objekty, metody, předávání argumentů metod Studijní cíl Tento studijní blok má za cíl pokračovat v základních prvcích jazyka Java. Konkrétně bude věnována pozornost třídám a objektům, instančním
Sdílení dat mezi podprogramy
Sdílení dat mezi podprogramy Datové objekty mohou být mezi podprogramy sdíleny pomocí ne-lokálních referenčních prostředí, která jsou vytvářena na základě æ explicitních modifikací (formální parametry
Dynamická alokace paměti
Dynamická alokace paměti doc. Mgr. Jiří Dvorský, Ph.D. Katedra informatiky Fakulta elektrotechniky a informatiky VŠB TU Ostrava Prezentace ke dni 13. března 2017 Jiří Dvorský (VŠB TUO) Dynamická alokace
Vícerozměrná pole. Úvod do programování 2 Tomáš Kühr
Vícerozměrná pole Úvod do programování 2 Tomáš Kühr Organizační záležitosti Konzultace Pracovna 5.043 Úterý 9.40 11.20 (oficiální) Pátek 8.30 9.40, dle potřeby Emailem tomas.kuhr@upol.cz Web předmětu:
Úvod do programovacích jazyků (Java)
Úvod do programovacích jazyků (Java) Michal Krátký Katedra informatiky VŠB Technická univerzita Ostrava Úvod do programovacích jazyků (Java), 2007/2008 c 2006 2008 Michal Krátký Úvod do programovacích
PB071 Programování v jazyce C Jaro 2017
Programování v jazyce C Jaro 2017 Typový systém, Dynamická alokace Typový systém Typový systém - motivace Celé znaménkové číslo se reprezentuje nejčastěji v dvojkovém doplňkovém kódu ival1 = 5 (dvojkový
Pokročilé programování v jazyce C pro chemiky (C3220) Pokročilá témata jazyka C++
Pokročilé programování v jazyce C pro chemiky (C3220) Pokročilá témata jazyka C++ Prostory jmen U programů mohou někdy nastat kolize mezi jmény (tříd, funkcí, globálních proměnných atd.) pokud v různých
PB161 Programování v jazyce C++ Přednáška 5
PB161 Programování v jazyce C++ Přednáška 5 Práce s pamětí Princip RAII Nikola Beneš 16. října 2017 PB161 přednáška 5: práce s pamětí, princip RAII 16. října 2017 1 / 25 Práce s pamětí PB161 přednáška
PB161 Programování v jazyce C++ Přednáška 4
PB161 Programování v jazyce C++ Přednáška 4 Dynamická alokace Kopírovací konstruktor Přetypování v C++ Nikola Beneš 12. října 2015 PB161 přednáška 4: dynamická alokace, kopírovací konstruktor, casting
11a Dynamické dvourozměrné pole (obdobně vícerozměrné)
11a Dynamické dvourozměrné pole (obdobně vícerozměrné) počet hvězdiček == počet rozměrů (dimenze pole) int **p_2d; int radku, sloupcu; printf("zadejte pocet radku a sloupcu pole:"); scanf("%d,%d", &radku,
9. lekce Úvod do jazyka C 4. část Funkce, rekurze Editace, kompilace, spuštění Miroslav Jílek
9. lekce Úvod do jazyka C 4. část Funkce, rekurze Editace, kompilace, spuštění Miroslav Jílek 1/24 Editační prostření Kód programu lze editovat v jakémkoli textovém editoru. 2/24 Editační prostření Kód
Čtvrtek 8. prosince. Pascal - opakování základů. Struktura programu:
Čtvrtek 8 prosince Pascal - opakování základů Struktura programu: 1 hlavička obsahuje název programu, použité programové jednotky (knihovny), definice konstant, deklarace proměnných, všechny použité procedury
int ii char [16] double dd název adresa / proměnná N = nevyužito xxx xxx xxx N xxx xxx N xxx N
Struktura (union) - struktura a union jsou složené typy, které "v sobě" mohou obsahovat více proměnných - struktura obsahuje v každém okamžiku všechny své proměnné, union obsahuje (=je "aktivní") pouze
NMIN102 Programování /2 Z, Zk
NMIN102 Programování 2 --- 2/2 Z, Zk Pavel Töpfer Katedra softwaru a výuky informatiky MFF UK MFF Malostranské nám., 4. patro, pracovna 404 pavel.topfer@mff.cuni.cz http://ksvi.mff.cuni.cz/~topfer Pavel
Jazyk C++, některá rozšíření oproti C
Karel Müller, Josef Vogel (ČVUT FIT) Jazyk C++, některá rozšíření oproti C BI-PA2, 2011, Přednáška 1 1/22 Jazyk C++, některá rozšíření oproti C Ing. Josef Vogel, CSc Katedra softwarového inženýrství Katedra
Funkce, intuitivní chápání složitosti
Příprava studijního programu Informatika je podporována projektem financovaným z Evropského sociálního fondu a rozpočtu hlavního města Prahy. Praha & EU: Investujeme do vaší budoucnosti Funkce, intuitivní
Lineární spojový seznam (úvod do dynamických datových struktur)
Lineární spojový seznam (úvod do dynamických datových struktur) Jan Hnilica Počítačové modelování 11 1 Dynamické datové struktury Definice dynamické struktury jsou vytvářeny za běhu programu z dynamicky
Programování v C++, 2. cvičení
Programování v C++, 2. cvičení 1 1 Fakulta jaderná a fyzikálně inženýrská České vysoké učení technické v Praze Zimní semestr 2018/2019 Přehled 1 Operátory new a delete 2 3 Operátory new a delete minule
Pole a Funkce. Úvod do programování 1 Tomáš Kühr
Pole a Funkce Úvod do programování 1 Tomáš Kühr (Jednorozměrné) pole u Datová struktura u Lineární u Homogenní = prvky stejného datového typu u Statická = předem určený počet prvků u Pole umožňuje pohodlně
Základní způsoby: -Statické (přidělění paměti v čase překladu) -Dynamické (přiděleno v run time) v zásobníku na haldě
Metody přidělování paměti Základní způsoby: -Statické (přidělění paměti v čase překladu) -Dynamické (přiděleno v run time) v zásobníku na haldě Důležitá hlediska jazykových konstrukcí: Dynamické typy Dynamické
MATURITNÍ OTÁZKY ELEKTROTECHNIKA - POČÍTAČOVÉ SYSTÉMY 2003/2004 PROGRAMOVÉ VYBAVENÍ POČÍTAČŮ
MATURITNÍ OTÁZKY ELEKTROTECHNIKA - POČÍTAČOVÉ SYSTÉMY 2003/2004 PROGRAMOVÉ VYBAVENÍ POČÍTAČŮ 1) PROGRAM, ZDROJOVÝ KÓD, PŘEKLAD PROGRAMU 3 2) HISTORIE TVORBY PROGRAMŮ 3 3) SYNTAXE A SÉMANTIKA 3 4) SPECIFIKACE
Strukturu lze funkci předat: (pole[i])+j. switch(výraz) velikost ukazatele
Strukturu lze funkci předat: hodnotou i pomocí ukazatele pouze pomocí ukazatele (reference na strukturu) pouze hodnotou (kopie struktury) (pole[i])+j adresa prvku na souřadnicích i, j adresa i-tého řádku
Základní způsoby: -Statické (přidělění paměti v čase překladu) -Dynamické (přiděleno v run time) v zásobníku na haldě
Metody přidělování paměti Základní způsoby: -Statické (přidělění paměti v čase překladu) -Dynamické (přiděleno v run time) v zásobníku na haldě Důležitá hlediska jazykových konstrukcí: Dynamické typy Dynamické
Pokročilé programování v jazyce C pro chemiky (C3220) Třídy v C++
Pokročilé programování v jazyce C pro chemiky (C3220) Třídy v C++ Třídy v C++ Třídy jsou uživatelsky definované typy podobné strukturám v C, kromě datových položek (proměnných) však mohou obsahovat i funkce
4. Typ ukazatel, strukturované datové typy
Učební cíle a kompetence Anotace kapitoly Časová náročnost 4. Typ ukazatel, strukturované datové typy Po prostudování této kapitoly studující pochopí datový typ ukazatel, speciální ukazatelové operátory,
Operační systémy. Přednáška 7: Správa paměti I
Operační systémy Přednáška 7: Správa paměti I 1 Správa paměti (SP) Memory Management Unit (MMU) hardware umístěný na CPU čipu např. překládá logické adresy na fyzické adresy, Memory Manager software, který
Preprocesor. Karel Richta a kol. katedra počítačů FEL ČVUT v Praze. Karel Richta, Martin Hořeňovský, Aleš Hrabalík, 2016
Preprocesor Karel Richta a kol. katedra počítačů FEL ČVUT v Praze Karel Richta, Martin Hořeňovský, Aleš Hrabalík, 2016 Programování v C++, A7B36PJC 4/2016, Lekce 9b https://cw.fel.cvut.cz/wiki/courses/a7b36pjc/start
Obsah. Předmluva 13 Zpětná vazba od čtenářů 14 Zdrojové kódy ke knize 15 Errata 15
Předmluva 13 Zpětná vazba od čtenářů 14 Zdrojové kódy ke knize 15 Errata 15 KAPITOLA 1 Úvod do programo vání v jazyce C++ 17 Základní pojmy 17 Proměnné a konstanty 18 Typy příkazů 18 IDE integrované vývojové
Aplikace Embedded systémů v Mechatronice. Michal Bastl A2/713a
Aplikace Embedded systémů v Mechatronice Michal Bastl A2/713a Aplikace Embedded systémů v Mechatronice Obsah přednášky: Opakování Pointery v C pole a řetězce předání funkci referencí Vlastní datové typy
PB071 Programování v jazyce C Jaro 2015
Programování v jazyce C Jaro 2015 Argumenty main(), Typový systém, Dynamická alokace Organizační Polosemestrální test Úterý 7. dubna v 10:00 a 11:00 v D1 20 bodů rozdíl mezi E a C Zdroj: http://www.bugemos.com/?node=342
Rekurzivní algoritmy
Rekurzivní algoritmy prof. Ing. Pavel Tvrdík CSc. Katedra počítačových systémů Fakulta informačních technologií České vysoké učení technické v Praze c Pavel Tvrdík, 2010 Efektivní algoritmy (BI-EFA) ZS
Konstruktory a destruktory
Konstruktory a destruktory Nedostatek atributy po vytvoření objektu nejsou automaticky inicializovány hodnota atributů je náhodná vytvoření metody pro inicializaci, kterou musí programátor explicitně zavolat,
Abstraktní datové typy, moduly
Abstraktní datové typy, moduly BI-PA1 Programování a Algoritmizace 1 Miroslav Baĺık, Ladislav Vagner a Josef Vogel Katedra teoretické informatiky a Katedra softwarového inženýrství Fakulta informačních
Metody připojování periferií BI-MPP Přednáška 2
Metody připojování periferií BI-MPP Přednáška 2 Ing. Miroslav Skrbek, Ph.D. Katedra počítačových systémů Fakulta informačních technologií České vysoké učení technické v Praze Miroslav Skrbek 2010,2011
2 Datové typy v jazyce C
1 Procedurální programování a strukturované programování Charakteristické pro procedurální programování je organizace programu, který řeší daný problém, do bloků (procedur, funkcí, subrutin). Původně jednolitý,
PB přednáška (12. října 2015)
PB161 3. přednáška (12. října 2015) Poznámky k domácímu úkolu Dynamická alokace Statická vs. dynamická alokace statická alokace na zásobníku (stack) deklarace uvnitř bloku (lokální proměnné) automatické
Koncepce (větších) programů. Základy programování 2 Tomáš Kühr
Koncepce (větších) programů Základy programování 2 Tomáš Kühr Parametry a návratová hodnota main Již víme, že main je funkce A také tušíme, že je trochu jiná než ostatní funkce v programu Funkce main je
PB161 Programování v jazyce C++ Přednáška 4
PB161 Programování v jazyce C++ Přednáška 4 Přetěžování funkcí Konstruktory a destruktory Nikola Beneš 9. října 2017 PB161 přednáška 4: přetěžování funkcí, konstruktory, destruktory 9. října 2017 1 / 20
konstruktory a destruktory (o)
konstruktory a destruktory (o) - slouží k ovlivnění vzniku (inicializace) a zániku (úklid) objektu - základní myšlenkou je, že proměnná by měla být inicializována (nastavena do počátečního stavu) a zároveň
7. Datové typy v Javě
7. Datové typy v Javě Primitivní vs. objektové typy Kategorie primitivních typů: integrální, boolean, čísla s pohyblivou řádovou čárkou Pole: deklarace, vytvoření, naplnění, přístup k prvkům, rozsah indexů
Programování v jazyce C a C++
Programování v jazyce C a C++ Příklad na tvorbu třídy Richter 1 4. prosince 2017 1 Ing. Richter Miloslav, Ph.D., UAMT FEKT VUT Brno Dvourozměrné pole pomocí tříd Zadání Navrhněte a napište třídu pro realizace
ZÁKLADY PROGRAMOVÁNÍ V C
ZÁKLADY PROGRAMOVÁNÍ V C poznámky pro Základy programování 2 Petr Osička i Tento text je doplňkovým učebním textem k semináři Základy programování 2 vyučovanému na Katedře informatiky Přírodovědecké fakulty
Operační systémy. Správa paměti (SP) Požadavky na SP. Spojování a zavedení programu. Spojování programu (linking) Zavádění programu (loading)
Správa paměti (SP) Operační systémy Přednáška 7: Správa paměti I Memory Management Unit (MMU) hardware umístěný na CPU čipu např. překládá logické adresy na fyzické adresy, Memory Manager software, který
Úvod do programování - Java. Cvičení č.4
Úvod do programování - Java Cvičení č.4 1 Sekvence (posloupnost) Sekvence je tvořena posloupností jednoho nebo více příkazů, které se provádějí v pevně daném pořadí. Příkaz se začne provádět až po ukončení
C++ přetěžování funkcí a operátorů. Jan Hnilica Počítačové modelování 19
C++ přetěžování funkcí a operátorů 1 Přetěžování funkcí jazyk C++ umožňuje napsat více funkcí se stejným názvem, těmto funkcím říkáme přetížené přetížené funkce se musí odlišovat typem nebo počtem parametrů,
Pole stručný úvod do začátku, podrobně později - zatím statická pole (ne dynamicky) - číslují se od 0
Pole stručný úvod do začátku, podrobně později - zatím statická pole (ne dynamicky) - číslují se od 0 int policko[100]; // tj. pole je od 0 do 99!!! policko[5] = 7; // pozor je to 6. prvek s indexem 5
Základy C++ I. Jan Hnilica Počítačové modelování 18
Základy C++ I 1 Přechod z C na C++ jazyk C++ je nadmnožinou jazyka C z hlediska syntaxe se jedná o velmi podobné jazyky, spolu s dalšími jazyky "céčkovské" rodiny, jako je např. C# každý platný program
Algoritmizace a programování
Algoritmizace a programování Výrazy Operátory Výrazy Verze pro akademický rok 2012/2013 1 Operace, operátory Unární jeden operand, operátor se zapisuje ve většině případů před operand, v některých případech
14.4.2010. Obsah přednášky 7. Základy programování (IZAPR) Přednáška 7. Parametry metod. Parametry, argumenty. Parametry metod.
Základy programování (IZAPR) Přednáška 7 Ing. Michael Bažant, Ph.D. Katedra softwarových technologií Kancelář č. 229, Náměstí Čs. legií Michael.Bazant@upce.cz Obsah přednášky 7 Parametry metod, předávání
Programování v C++ Úplnej úvod. Peta (maj@arcig.cz, SPR AG 2008-9)
Programování v C++ Úplnej úvod Co se naučíte? tak samozřejmě C++, s důrazem na: dynamické datové struktury Objektově Orientované Programování STL (standardní knihovna šablon) vytváření vlastních šablon