1. díl - Úvod do ukazatelů (pointerů) v jazyce C

C++ Dynamická práce s pamětí Úvod do ukazatelů (pointerů) v jazyce C

Vítejte u prvního dílu pokročilé sekce seriálů o programování v jazyce C. V této sekci se naučíme pracovat s dynamicky alokovanou pamětí v jazyce C a dostaneme se také k práci se soubory. Asi vás nepřekvapí, že předpokladem ke zdolání seriálu je znalost základních konstrukcí jazyka C.

Adresy v paměti

Když jsme se poprvé zmiňovali o proměnných, říkali jsme si, že proměnná je "místo v paměti", kam si můžeme uložit nějakou hodnotu. Také víme, že proměnné mají různé datové typy (např. int) a ty zabírají v paměti různě místa (např. int zabírá 32 bitů, tedy 32 nul a jedniček).

Paměť počítače si můžeme představit jako dlouhou (téměř nekonečnou :) ) řadu nul a jedniček. Některé části paměti jsou obsazené jinými aplikacemi a některé jsou operačním systémem chápány jako volné místo. Aby se dalo s pamětí rozumně pracovat, je adresována, jako jsou např. domy v ulici. Adresy se většinou zapisují v šestnáctkové soustavě, ale stále se jedná o obyčejná čísla. Adresy jdou chronologicky za sebou a na každé adrese se nachází 1 bajt (tedy 8 bitů, protože adresování po drobných bitech by bylo nepraktické).

Jakmile v céčku deklarujeme nějakou proměnnou ve zdrojovém kódu a aplikaci spustíme, Céčko si řekne operačnímu systému o tolik paměti, kolik je pro tuto proměnnou třeba. Od systému získá adresu do paměti, na kterou může hodnotu proměnné uložit (zjednodušeně řečeno).

Získání adresy proměnné

Jazyk C nás od adres zatím plně odsťiňoval, paměť rezervoval za nás a s proměnnými jsme pracovali jednoduše pomocí jejich jmen. Vytvořme si nyní jednoduchý program, který založí proměnnou typu int a do ni uloží hodnotu 56. Adresu této proměnné si získáme pomocí tzv. referenčního operátoru & (ampersand) a vypíšeme ji do konzole. Ve formátovacím řetězci uvedeme %p, což ji vypíše v šestnáctkové soustavě tak, jak se na paměťovou adresu sluší a patří.

int main(int argc, char** argv) {
    int a;
    a = 56;
    printf("Proměnná a s hodnotou %d je v paměti uložená na adrese %p", a, &a);
    return (EXIT_SUCCESS);
}

Výsledek:

Získání adresy proměnné v jazyce C

Vidíte, že na mém počítači si systém vybral adresu 0x23aadc. Vy tam budete mít jiné číslo. Situace v paměti počítače bude vypadat takto:

Paměť počítače

(Datový typ int má 32 bitů, proto tedy zabírá 4 osmice bitů a 4 adresy. Udáváme vždy adresu začátku hodnoty.)

Ukazatelé (pointery)

Získat číslo adresy je sice hezké, ale pokud bychom s pamětí takto pracovali, bylo by to poněkud nepraktické. Z toho důvodu jazyk C podporuje tzv. ukazatele (anglicky pointery). Ukazatel je proměnná, jejíž hodnotou je adresa někam do paměti. Céčko ukazatel však nebere jako pouhé číslo, ale ví, že ho má používat jako adresu. Když do ukazatele tedy něco uložíme nebo z něj naopak něco vypisujeme, nevypisuje se adresa (hodnota ukazatele), ale použije se hodnota, na kterou ukazatel ukazuje.

Vraťme se opět k našemu programu. Tentokrát si kromě proměnné a definujeme i ukazatel na proměnnou a. Ten bude také typu int, avšak před jeho názvem bude tzv. dereferenční operátor * (hvězdička). Zvykněte si pointery pojmenovávat vždy tak, aby začínaly na p_. Vyhnete se tak v budoucnu velkým problémům, protože pointery jsou poměrně nebezpečné, jak dále zjistíme, a měli bychom si srozumitelně označit, zda je proměnná pointerem či nikoli.

int main(int argc, char** argv) {
    int a, *p_a;
    a = 56;
    p_a = &a; // Uloží do p_a adresu proměnné a
    *p_a = 15; // Uloží hodnotu 15 na adresu v p_a
    printf("Ukazatel p_a má hodnotu %d ukazuje na hodnotu %d", p_a, *p_a);
    return (EXIT_SUCCESS);
}

Aplikace si vytvoří proměnnou typu int a dále ukazatel na int. Ukazatelé také mají vždy svůj datový typ podle toho, na hodnotu jakého typu ukazují. Do proměnné a se uloží hodnota 56.

Do ukazatele p_a (zatím bez hvězdičky) se uloží adresa proměnné a, kterou získáme pomocí referenčního operátoru &. Nyní budeme chtít tam, kam ukazuje pointer p_a, uložit číslo 15. Použijeme dereferenční operátor (*) a tím neuložíme hodnotu do ukazatele, ale tam, kam ukazatel ukazuje.

Následně vypíšeme hodnotu ukazatele (což je nějaká adresa v paměti, obvykle vysoké číslo, zde ho vypisujeme v desítkové soustavě) a dále vypíšeme hodnotu, na kterou ukazatel ukazuje. Kdykoli pracujeme s hodnotou ukazatele (ne adresou), používáme operátor *.

Výsledek:

Ukazatel/pointery v jazyce C

Opět si ukažme i situaci v paměti:

Paměť počítače

Předávání referencí

Umíme tedy na proměnnou vytvořit ukazatel. K čemu je to ale dobré? Do proměnné jsme přeci uměli ukládat i předtím. Jednou z výhod pointerů je tzv. předávání referencí. Vytvořme si funkci, které přijdou v parametru 2 čísla a my budeme chtít, aby jejich hodnoty prohodila (této funkci se anglicky říká swap). Naivně bychom mohli napsat následující kód:

// Tento kód nefunguje
void prohod(int a, int b)
{
    int pomocna = a;
    a = b;
    b = pomocna;
}

int main(int argc, char** argv) {
    int cislo1 = 15;
    int cislo2 = 8;
    prohod(cislo1, cislo2);
    printf("V cislo1 je číslo %d a v cislo2 je číslo %d.", cislo1, cislo2);
    return (EXIT_SUCCESS);
}

Výsledek:

Předávání referencí v jazyce C

Proč že aplikace nefunguje? Při volání funkce prohod ve funkci main() se vezmou hodnoty proměnných cislo1 a cislo2 a ty se zkopírují do proměnných a a b v definici funkce. Funkce dále změní tyto proměnné a a b, avšak původní proměnné cislo1 a cislo2 zůstanou beze změny. Tomuto způsobu, kdy se hodnota proměnné do parametru funkce zkopíruje, říkáme předávání hodnodnou.

Pozn.: K prohození 2 čísel potřebujeme pomocnou proměnnou. Kdybychom ve funkci prohod() napsali jen a = b; b = a;, byla by v obou proměnných hodnota b, protože hodnota a se mezitím změnila.

Libovolnou proměnnou můžeme předat referencí a to tak, že funkci upravíme aby přijímala v parametrech pointery a při volání funkce použijeme referenční operátor &:

void prohod(int *p_a, int *p_b)
{
    int pomocna = *p_a;
    *p_a = *p_b;
    *p_b = pomocna;
}

int main(int argc, char** argv) {
    int cislo1 = 15;
    int cislo2 = 8;
    prohod(&cislo1, &cislo2);
    printf("V a je číslo %d a v b je číslo %d.", cislo1, cislo2);
    return (EXIT_SUCCESS);
}

Výsledek:

Předávání referencí v jazyce C

Jelikož funkci nyní předáváme adresu, je schopna změnit původní proměnnou.

Někteří programátoři v jazyce C používají často parametry funkcí k vracení hodnoty. To ovšem není příliš přehledné a pokud nás netlačí výpočetní čas a je to jen trochu možné, měla by funkce vracet jen jednu hodnotu pomocí příkazu return, případně může vracet strukturu nebo ukazatel na strukturu/pole.

Možná vás napadlo, že konečně rozumíte funkci scanf(), která ukládá hodnoty do proměnných předaných parametry. Operátor & zde používáme proto, abychom funkci předali adresu, na kterou má data uložit:

int a;
scanf("%d", &a);

Předávání pole

Pole a pointery mají v céčku mnoho společného. Proto když předáme pole do parametru nějaké funkce a pole v ní změníme, změny se v původním poli projeví. Pole je na rozdíl od ostatních typů vždy předáváno referencí aniž bychom se o to museli snažit.

void napln_pole(int pole[], int delka)
{
    int i;
    for (i = 0; i < delka; i++)
    {
        pole[i] = i + 1;
    }
}

int main(int argc, char** argv) {
    int cisla[10];
    napln_pole(cisla, 10);
    printf("%d", cisla[5]); // Vypíše číslo 6
    return (EXIT_SUCCESS);
}

Jak jsme si řekli dříve, pole je vlastně spojité místo v paměti. Ale takové místo musíme umět nějak adresovat. Adresujeme ho právě pomocí ukazatele. Samotné jméno proměnné u pole není nic jiného než ukazatel. To znamená, že nám bez problémů projde následující operace přiřazení.

int pole[10];
int* p_pole = cisla;

V kapitole Aritmetika ukazatelů si ukážeme, že je úplně jedno, zda máme pole nebo ukazatel.

NULL

Všem pointerům libovolného typu můžeme přiřadit konstantu NULL. Ta udává, že je pointer prázdný a že zrovna na nic neukazuje. Na většině platforem se NULL rovná hodnotě 0 a tak se v některých kódech můžete setkat s přiřazením 0 místo NULL. To se obecně nedoporučuje kvůli kompatibilitě mezi různými platformami. Tuto hodnotu budeme v budoucnu hojně používat.

Co si zapamatovat: Pointer je proměnná, ve které je uložena adresa do paměti. Můžeme pracovat buď s touto adresou nebo s hodnotou na této adrese a to pomocí operátoru *. Adresu libovolné proměnné získáme pomocí operátoru &.

Ačkoli jsme si pointery poměrně slušně uvedli, jejich pravým účelem je zejména dynamické alokování paměti, na které se podíváme hned v příštím dílu.


 

  Aktivity (4)

Článek pro vás napsal David Čápka
Avatar
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 se informační technologie naučil na Unicorn College - prestižní soukromé vysoké škole IT a ekonomie.

Jak se ti líbí článek?
Celkem (4 hlasů) :
55555


 



 

 

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

Avatar
Matej
Člen
Avatar
Matej:

ak dosadime do funkcie &a a &b

void prohod(int *p_a, int *p_b) // dosadime &a , &b
{
    int pomocna = *p_a; // pomocna je refencia na pamat a (&a)
    *p_a = *p_b; // pamat _a sa nadstavi na pamat _b tj aj na odkazujucu hodnotu
    *p_b = pomocna; // naopak
}

ak sa to bere takto , tnak sa nezmeni iba hodnota ale swapne sa cela pamat aj s hotou nie? podla predchadzajuceho prikladu na pointeri by sa hodota swapla iba ak by dany pointer (teda ak som pochopil spravne pointer v argument liste sa spava ako pointer) musel odkazovat na danu hodnotu tj

*p_a=b

a nie

*p_a=&b //referencia na pamat

V c som novy takze si to asi zle vykladam ale stale mi to nesedi :D

 
Odpovědět 11.10.2015 14:42
Avatar
tomisoka
Redaktor
Avatar
Odpovídá na Matej
tomisoka:

Však taky platí:

p_a=&a

a z toho plyne:

*p_a=a

A okomentovaná funkce:

void prohod(int *p_a, int *p_b){ // dosadime &a, &b
  int pomocna = *p_a;//pomocna je přepsána hodnotou na kterou ukazuje pointer p_a(a)
  *p_a = *p_b; // hodnota na kterou ukazuje pointer p_a (a) je přepsána hodnotou na
  //kterou ukazuje pointer p_b (b)
  *p_b = pomocna; // hodnota na kterou ukazuje p_b (b) je přepsána hodnotou pomocna
}

Jinak dál se ve tvém komentáři nějak ztrácím, co znamená:

tnak sa nezmeni iba hodnota ale swapne sa cela pamat aj s hotou nie?

 
Odpovědět 11.10.2015 16:00
Avatar
Matej
Člen
Avatar
Odpovídá na tomisoka
Matej:

ak som to spravne pochopil tak ak das

*p_a=&a

tak vlastne nastane

p_a=&a;
*p_a= hodnota a

a ked dosadis do pointeru ktory je ako argument adresu k pameti ako parameter, tak sa priradi hodnota k tomu pointeru? :D

 
Odpovědět 11.10.2015 16:37
Avatar
tomisoka
Redaktor
Avatar
Odpovídá na Matej
tomisoka:

Ale v tom kódu není nic jako:

*p_a=&a

Ta část v parametru "int *" je datový typ a "p_a" je název proměnné.
Pokud do pointeru "p_a" dosadíš adresu k paměti, tak pak pomocí "*p_a" pracuješ s hodnotou, která se nachází na té dosazené adrese. Samotná hodnota není k ničemu přiřazená, ta se prostě nachází na té adrese.

Editováno 11.10.2015 17:04
 
Odpovědět 11.10.2015 17:03
Avatar
pangas
Člen
Avatar
pangas:

Zdravím, měl bych malý dotaz. Nějak se mi nedaří inicializovat ukazatel na dvourozměrné pole. Chybové hlášení zní: cannot convert 'char()[26]' to 'char' in initialization.

char abcd[26][26];
char * u = abcd;

Díky za každý tip.

 
Odpovědět 10. března 14:10
Avatar
ostrozan
Redaktor
Avatar
Odpovídá na pangas
ostrozan:
char abcd[26][26];

je sám o sobě ukazatel - a ty chceš ukazatel na ukazatel?

 
Odpovědět 10. března 15:45
Avatar
B42P6
Člen
Avatar
Odpovídá na pangas
B42P6:

Ahoj, chyba musí byť niekde inde. Čo máš na riadku kde sa vyskytla chyba?

Odpovědět 10. března 15:47
'long long long' is too long for GCC
Avatar
B42P6
Člen
Avatar
Odpovídá na ostrozan
B42P6:

Nemyslel si

char *pole[5];
(pole pointer-ov)

?
Teraz by získaním adresy tohto poľa dostal pointer na pointer.

Získaním adresy viacrozmerného poľa by získal len samotnú adresu poľa, pretože viacrozmerné pole je v pamäti uložené rovnako ako jednorozmerné.

Editováno 10. března 16:45
Odpovědět 10. března 16:45
'long long long' is too long for GCC
Avatar
pangas
Člen
Avatar
pangas:

Děkuji, už jsem problém vyřešil. :) Potřeboval jsem vlastně do funkce předat dvourozměrné pole a protože jsem si neuvědomil, že už to vlastně ukazatel je, tak jsem si myslel, že potřebuji jako parametr předat ukazatel na to pole, aby jsem po skončení funkce neměl zase prázdné pole.. Moje chyba, děkuji za odpovědi :-)

 
Odpovědět 10. března 17:02
Avatar
Tomáš Svoboda:

Zdarec, nedochází mi to.
Chápu co pointery dělají, chápu jakým způsobem asi fungují, nechápu ale jak je využít. Pro dynamické alokování to bude asi esenciální ale mě to nedochází.

Plácnu, když bych je nepoužíval bude alokovaná paměť pro můj daný program při běhu neustále růst.. ? Zavolat proměnou odkudkoliv mohu přeci i tak přimo jejím názvem.

Díky :) [ Tom, the "rozmazlen pythonem"]

Odpovědět 20. dubna 18:05
Alea iacta est.
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 15. Zobrazit vše