Letní akce! Lákají tě IT školení C#, Javy a PHP v Brně? Přihlas se a napiš nám do zpráv kód "BRNO 500" pro slevu 500 Kč na libovolný brněnský kurz. Lze kombinovat se slevami uvedenými u školení i použít pro více kurzů. Akce končí 28.7.

Lekce 2 - Dynamická alokace paměti v jazyce C

C a C++ Céčko Dynamická práce s pamětí Dynamická alokace paměti v jazyce C

ONEbit hosting Unicorn College Tento obsah je dostupný zdarma v rámci projektu IT lidem. Vydávání, hosting a aktualizace umožňují jeho sponzoři.

V minulé lekci, Úvod do ukazatelů (pointerů) v jazyce C, jsme si uvedli pointery v jazyce C. Již víme, že nás jazyk C nechá pracovat s pamětí a naučili jsme se předávat parametry funkcí referencí. To pravé programování v Céčku ovšem rozjedeme až v dnešním tutoriálu. Pochopíme totiž, jak funguje přidělování paměti a vymaníme se ze všech limitů délky statických polí a řetězců.

Statická a dynamická alokace paměti

Jak víme, o paměť si musí náš program říkat operačnímu systému, což není úplně snadné a proto se toho Céčko snaží udělat co nejvíce za nás.

Staticky alokovaná paměť

Když se náš program překládá, může překladač ve velkém množství případů jednoduše zjistit, kolik paměti bude při běhu programu třeba. Když si vytvoříme proměnnou typu int, Céčko ví, že na ni má vyhradit 32 bitů. Když si vytvoříme pole o 100 znacích, Céčko opět ví, že má rezervovat 800 bitů. Pokud není při běhu programu třeba žádná data přidávat, s touto automatickou alokací si bohatě vystačíme. To je v podstatě způsob, jakým jsme programovali doposud.

Dynamicky alokovaná paměť v zásobníku

Možná vás napadlo, jak v jazyce C funguje přidělování paměti pro lokální proměnné (to jsou ty definované uvnitř funkcí). Céčko přeci neví kolikrát funkci zavoláme a tedy kolik proměnných bude ve finále potřeba. Tato paměť je opravdu přidělována dynamicky až za běhu programu. Vše se ovšem děje zas plně automaticky. Jakmile funkci zavoláme, Céčko si řekne o paměť a jakmile funkce skončí, tato paměť se uvolní. Toto je důvod, proč funkce nemůže vracet pole v ní vytvořené. Jak již víme, pole se totiž nekopíruje (nepředává hodnotou jako třeba int), ale pracuje se s ním jako by to byl ukazatel. Jelikož lokální proměnné po skončení funkce zaniknou, získali bychom ukazatel někam, kde žádné pole již nemusí existovat.

Dynamicky alokovaná paměť v haldě

Zatím to vypadá, že Céčko dělá vše za nás. Kde je tedy problém? Představte si, že programujete aplikaci, která eviduje např. položky ve skladu. Víte dopředu, jak velké pole pro položky vytvořit? Bude jich 100, 1000, miliony? Pokud budeme deklarovat statické pole nějakých struktur, vždy budeme buď plýtvat místem nebo se vystavíme nebezpečí, že nám vyhrazené pole přestane stačit. A nemusíme ani zacházet do této situace, stačí zapřemýšlet nad tím, jak uložit textový řetězec přesně tak dlouhý, jak ho uživatel zadal.

Problém tedy tkví v tom, že někdy do spuštění programu nevíme kolik paměti bude třeba a proto ji za nás Céčko nemůže alokovat. Naštěstí nám ovšem nabízí funkce, kterými si můžeme za běhu programu říkat o libovolné množství paměti.

V textu byly zmíněny pojmy zásobník (stack) a halda (heap). Jedná se o 2 typy paměti v RAM, se kterými program pracuje. Zjednodušeně můžeme říci, že práce se zásobníkem je rychlejší, ale je velikostně omezený. Halda je určena primárně pro větší data, např. pro zmíněné položky ve skladu. Když si budeme říkat o paměť my sami, bude přidělena vždy na haldě.

Dynamická alokace paměti

Těžištěm práce s dynamickou pamětí je v jazyce C dvojice funkcí - malloc() a free().

malloc()

malloc() řekne operačnímu systému o libovolné množství paměti (kolik jí potřebujeme uvedeme do parametru funkce v bajtech). Funkce vrátí pointer na první adresu, kde začíná naše nová paměť. Již víme, že každý pointer má určitý typ, resp. ukazuje na data nějakého typu. Aby byla funkce malloc() univerzální, vrací pointer na typ void. Její výsledek bychom měli vždy přetypovat na takový pointer, který potřebujeme.

Pokud se alokace paměti nepodaří (např. nám došla, což se dnes již teoreticky nestane, ale měli bychom s tímto případem počítat), vrátí malloc() hodnotu NULL (tedy pointer nikam). Při alokování paměti budeme vždy používat funkci sizeof(), protože nikdy nevíme jak je datový typ na daném operačním systému velký (např. int může zabírat 16 i 32 bitů). Volání sizeof() jsou nahrazena konstantami při kompilaci, takže nijak negativně neovlivňují rychlost programu.

free()

Po každém zavolání funkce malloc() musí někdy (třeba až na konci programu) následovat zavolání funkce free(), která paměť označí opět jako volnou. Tato paměť je plně v naší režií a nikdo jiný než my ji za nás neuvolní. Jakmile přestaneme nějakou dynamicky alokovanou paměť potřebovat, měli bychom ji ihned uvolnit.

Alokujme si za běhu programu místo pro 100 intů:

int main(int argc, char** argv) {
    int *p_i;
    printf("Pokouším se alokovat paměť pro 100 intů.\n");
    // Alokace 100 krát velikosti intu
    p_i = (int *) malloc(sizeof(int) * 100);

    // Kontrola úspěšnosti alokace
    if (p_i == NULL)
    {
        printf("Nedostatek paměti.\n");
        exit(1);
    }

    // Uvolnění paměti
    printf("Uvolňuji paměť.\n");
    free(p_i);
    p_i = NULL; // Pro jistotu vynullujeme ukazatel
    return (EXIT_SUCCESS);
}

Výstup:

c_malloc
Pokouším se alokovat paměť pro 100 intů.
Uvolňuji paměť.

Zatím ještě nevíme jak k jednotlivým intům v paměti přistupovat, vše si vysvětlíme hned příště. Funkce exit() ukončí naši aplikaci. V parametru předáme chybový kód, který by měl být v případě že program nedoběhl správně, nenulový.

Časté chyby při práci s pointery

Práce s ukazateli je poměrně nebezpečná, jelikož nás programátory při ní nikdo nehlídá. A udělat chybu v programu je velmi jednoduché a to člověk ani nemusí být začátečníkem. Zmiňme si několik bodů, na které je dobré při práci s ukazateli dávat pozor.

  • Neuvolnění paměti - Pokud jednou zapomeneme uvolnit nějakou paměť, tak se v zásadě nic nestane. Problém je v případě, kdy paměť zapomeneme uvolnit uvnitř nějaké funkce, která se za běhu programu volá několikrát. Nejhorší situace je, když paměť zapomeneme uvolnit v nějakém cyklu. Paměť nám při této chybě samozřejmě za nějakou dobu dojde, aplikace spadne a uživatel přijde o data a zaplatí raději konkurenci, aby mu prodala funkční aplikaci :)
  • Překročení hranic paměti - Stejně jako tomu bylo u polí, ani u pointerů nikdo nehlídá co do této paměti ukládáme. Pokud uložíme něco většího, než kolik místa máme vyhrazeno, nabouráme paměť jiné části aplikace. Tato chyba se může projevit naprosto kdekoli a pravděpodobně ji budeme velmi dlouho hledat. Následná chyba totiž nijak logicky nesouvisí s místem v programu, kde nám paměť přetekla. Může se najednou rozbít jakákoli část aplikace, protože do ní tato paměť vytekla :)
  • Práce s uvolněnou pamětí - Může se nám stát, že nějakou paměť uvolníme a poté se na tuto adresu pokusíme znovu něco zapsat. V tu chvíli však zapisujeme opět na paměť, která nám nepatří, následky viz. minulý bod. Proto je dobré uložit do ukazatele po uvolnění jeho paměti hodnotu NULL, abychom se této chybě vyvarovali.

V příští lekci, Aritmetika ukazatelů v jazyce C, se naučíme tzv. pointerovou aritmetiku a zjistíme, že ukazatele v jazyce C jsou polím ještě podobnější, než jsme si mysleli.


 

Stáhnout

Staženo 91x (31.81 kB)
Aplikace je včetně zdrojových kódů v jazyce c

 

 

Článek pro vás napsal David Čápka
Avatar
Jak se ti líbí článek?
7 hlasů
Autor pracuje jako softwarový architekt a pedagog na projektu ITnetwork.cz (a jeho zahraničních verzích). Velmi si váží svobody podnikání v naší zemi a věří, že když se člověk neštítí práce, tak dokáže úplně cokoli.
Unicorn College Autor sítě se informační technologie naučil na Unicorn College - prestižní soukromé vysoké škole IT a ekonomie.
Aktivity (5)

 

 

Komentáře
Zobrazit starší komentáře (8)

Avatar
coells
Redaktor
Avatar
coells:19.5.2015 13:56

V debug režimu už to dělá samotný malloc/free, nemusíš vynalézat kolo.

 
Odpovědět 19.5.2015 13:56
Avatar
Martin Dráb
Redaktor
Avatar
Odpovídá na coells
Martin Dráb:19.5.2015 17:34

V debug režimu už to dělá samotný malloc/free, nemusíš vynalézat kolo.

To asi záleží na konkrétní implementaci (překladači). U *NIXu jsem to viděl a i MSVS lze k něčemu podobnému donutit za pár řádků kódu.

Odpovědět 19.5.2015 17:34
2 + 2 = 5 for extremely large values of 2
Avatar
Pavel Habžanský:6.12.2015 23:12

Nepřetypováváš přímo tu adresu, jenom tím říkáš, co se na tý adrese bude ukládat (v tomto případě int). Takhle bych to dovedl asi nejsnáze vysvětlit

Odpovědět 6.12.2015 23:12
Čím větší výzva, tím větší zkušenost
Avatar
David Novák
Redaktor
Avatar
David Novák:7.12.2015 10:30

valgrind

Odpovědět  +1 7.12.2015 10:30
Chyba je mezi klávesnicí a židlí.
Avatar
Taskkill
Redaktor
Avatar
Taskkill:7.12.2015 11:17

gcc -d main.c / g++ -d main.cpp
valgrind ./a.out
jak pise David N. Valgrind je nejlepsi varianta..navic kdyz do kompilace pridas prepinac -d bude se ti to kompilovat s debugovacima symbolama ... takze se potom v tom valgrindu podivas cos pokazil...

pripadne jestli chces mi fakt cistej kod kompiluj takhle
gcc -d -Wall -pedantic main.c / g++ -d -Wall -pedantic main.cpp

to ti z kazdyho warningu udela error a rve to na tebe kdyz porusujes standardy .. ;) bav se

 
Odpovědět  +1 7.12.2015 11:17
Avatar
David Novák
Redaktor
Avatar
Odpovídá na Taskkill
David Novák:7.12.2015 11:50

Trochu poopravím..

gcc -Wall -Wextra -pedantic // vypíše všechny možné varování
gcc -Wall -Wextra -pedantic -Werror // bere je jako chyby - nutí tě psát validně
gcc -g // přidává debugovací informace

Můžeš prosím tě v krátkosti říct, co dělá -d ? Nechce se mi to studovat a kompilace s tímto přepínačem mi vypíše "no input files". Nakoukl jsem do manuálu a myslím, že to má produkovat výstupy jednotlivých fází překladu. -da vyprodukuje vše.. Docela zajímavý výstup.. Ale myslím, že jsi asi myslel -g :)

Odpovědět  +1 7.12.2015 11:50
Chyba je mezi klávesnicí a židlí.
Avatar
David Novák
Redaktor
Avatar
Odpovídá na David Novák
David Novák:7.12.2015 11:52

Jo a u toho -pedantic je ještě velmi vhodné uvést konkrétní standard, jinak tě ti to bude nutit výchozí, což bude asi iso 89..

gcc -std=c11 -pedantic // varuje, když použiješ něco, co není v C11 standardu
Odpovědět 7.12.2015 11:52
Chyba je mezi klávesnicí a židlí.
Avatar
Taskkill
Redaktor
Avatar
Odpovídá na David Novák
Taskkill:7.12.2015 12:47

urcite jsem myslel -g :D jen jsem nepremyslel diky za doplneni ...

 
Odpovědět  +1 7.12.2015 12:47
Avatar
Lukáš Hypša:6. ledna 18:35

Když zadám jako počet intů 9, vypíše se pouze RUN_SUCCESFUL, při 10 se vypíšou i čísla v cyklu, při 11 se vypíše pouze RUN FAILED. Neví někdo?

int pocet = 10; // pro 9, 10 a 11 se program chová odlišně
int *p_cisla = (int *) malloc(sizeof(int) * pocet);
for(int i = 0; i < pocet; i++)
{
*p_cisla = i;
printf("%d ", *p_cisla);
p_cisla++;
}
free(p_cisla);
p_cisla = NULL;
return (EXIT_SUCCESS);

Odpovědět 6. ledna 18:35
Jsem lama co se roky snaží naučit napsat aspoň pár řádků a furt mu to nejde...
Avatar
DarkCoder
Člen
Avatar
Odpovídá na Lukáš Hypša
DarkCoder:6. ledna 21:51

Vytvořený ukazatel na začátek pole je třeba považovat za konstantu a není dovoleno jej měnit. Pro přístup a výpis prvků dynamického pole ukazuje následující kód:

int pocet = 10;
int *p_cisla = (int *)malloc(sizeof(int) * pocet);
for (int i = 0; i < pocet; i++) {
        *(p_cisla + i) = i;
        printf("%d ", *(p_cisla + i));
}
free(p_cisla);
p_cisla = NULL;
Odpovědět  +2 6. ledna 21:51
"„Učíš-li se proto, aby sis zapamatoval, zapomeneš. Učíš-li se proto, abys porozuměl, zapamatuješ si."
Děláme co je v našich silách, aby byly zdejší diskuze co nejkvalitnější. Proto do nich také mohou přispívat pouze registrovaní členové. Pro zapojení do diskuze se přihlas. Pokud ještě nemáš účet, zaregistruj se, je to zdarma.

Zobrazeno 10 zpráv z 18. Zobrazit vše