Diskusia – 1. diel - Úvod do ukazovateľov (pointer) v jazyku C
SpäťUpozorňujeme, že diskusie pod našimi online kurzami sú nemoderované a primárne slúžia na získavanie spätnej väzby pre budúce vylepšenie kurzov. Pre študentov našich rekvalifikačných kurzov ponúkame možnosť priameho kontaktu s lektormi a študijným referentom pre osobné konzultácie a podporu v rámci ich štúdia. Toto je exkluzívna služba, ktorá zaisťuje kvalitnú a cielenú pomoc v prípade akýchkoľvek otázok alebo projektov.
Ešte som si neprešiel všetky lekcie z tohto kurzu, ak si ich prejdem
poctivo tak sa ti ozvem a tvoju myšlienku môžeme zrealizovať 
DarkCoder:19.2.2021 5:43
Zde je vyhodnocení toho, jak si se vypořádal s otázkami a příklady k
ukazatelům v C.
Ke každé otázce doplním i svůj komentář a řešení, aby si měl zpětnou
vazbu.
1. Pro práci s ukazateli se používají dva speciální operátory (* a &). Operátor * má dva významy. První význam je ten, že se používá pro deklarování ukazatelové proměnné. Druhý význam je, že vrací hodnotu uloženou na adrese před kterou stojí. Tento operátor se nazývá operátor dereference nebo operátor indirekce. Druhý operátor & slouží pro získání adresy proměnné před kterou stojí. Tento operátor se nazývá operátor reference nebo adresový operátor.
Ukázkový příklad:
int i = 10, *pi = &i; // ukazatel pi je inicializovan adresou i
printf("%d", *pi); // vypis hodnotu i pomoci ukazateleOperátor & lze vyjádřit slovy "adresa něčeho".
Operátor * lze vyjádřit slovy "na adrese"
Proto můžeš zápisy v příkladu číst následovně:
Přiřaď ukazateli pi adresu proměnné i
Vypiš hodnotu na adrese pi
Je-li hodnota proměnné získána pomocí ukazatele, říkáme, že je získána odkazem (dereferencováním, nepřímo).
Tedy správně si určil první význam operátoru *. Druhý chyběl. Význam operátoru & jsi uvedl správně. Avšak:
cize hodnotu ktoru ma premenna p_i je hodnota, ktoru ma aj premena i a to je 5
Ne. Hodnota pi není shodná s hodnotou i. p_i obsahuje adresu i, kdežto i
obsahuje hodnotu 5.
Pomatuj: Ukazatel je proměnná, která obsahuje adresu
objektu.
2. Inicializace ukazatelové proměnné na typ float, která na nic neukazuje, vypadá následovně:
float *p = NULL;NULL je makro definované v mnoha hlavičkových souborech (stdio.h, string.h, ..) A je definováno jako:
#define NULL ((void*)0)K následujícímu příkazu:
pf = NULL;Toto není inicializace ale přiřazovací příkaz. Inicializace znamená
přiřazení v definici.
Na dynamickou alokaci nebyly otázky ani cvičení mířeny, nikde není
třeba.
Zápis který si uvedl je syntakticky správně, ovšem sémanticky chybně. Za
prvé by bylo třeba kontrolovat, zda-li se podařilo alokovat paměť. Za
druhé tuto paměť neuvolňuješ pomocí funkce free(), čímž vytváříš
memory leak a za třetí dokonce přepisuješ ukazatel na neplatný a nikdy už
se tak k alokované paměti nedostaneš. Tato paměť se uvolní až po
skončení programu. Takže na to pozor..
3. V pořádku. Základní principy práce s referenčním a dereferenčním operátorem. Zde jen znovu připomínám. Výraz *p_q lze číst - hodnotu na adrese p_q. Všimni si, jak sufix proměnné napomáhá čtení. Pak lze číst výraz i takto - hodnotu q pomocí ukazatele.
4. Úryvek kódu pochopitelně není správný. Neboť ukazatel p neukazuje na žádný známý objekt. Proto je pokus o nepřímé přiřazení hodnoty pomocí p nesmyslný a nebezpečný.
5. Další úryvek kódu který není správný. Příklad ukazuje, proč je důležitý základní typ ukazatele a proč je třeba zajistit, aby byl typ ukazatele shodný s typem objektu na který ukazuje. Při přiřazení:
q = *p;nedojde ke zkopírování čísla, neboť se přenesou pouze sizeof(int) bytů. Jelikož je p ukazatel na int, nelze jej použít pro přenos hodnoty odpovídající velikosti typu double. Toto je důvod, proč program nebude pracovat správně.
Obvykle míchání odlišných typů levé a pravé strany není vhodné. Někdy však to může být vhodné, jelikož jedním z pravidel je pravidlo při přiřazení, které říká, že typ pravé strany se převádí na typ levé strany.
6. Ano, všechny tyto operátory lze použít pro práci s ukazateli. Pouze doplním, že k nim samozřejmě patří i operátory * a & a také -> přístup k členům a [] přístup k prvkům.
7. Hodnota ukazatelové proměnné je adresa objektu na který ukazatel ukazuje. Tedy správná odpověď je že ano. Pokud ukazatel p bude obsahovat adresu 100, pak příkaz
p = p + 4;Bude podle ukazatelové aritmetiky ukazovat na 4tý prvek za prvkem na, který ukazoval. Je-li tedy ukazatel p ukazatelem na int, pak adresa, na kterou bude ukazovat bude:
p = p + 4 * sizeof(int); // 100 + 4 * sizeof(int)Tedy v p bude uložena hodnota 116 (ve 32bit prostředí, kde sizeof(int) ==
4).
Velikost typu se určuje zásadně pomocí operátoru sizeof.
8. Je to správně. Snad jen že jazyk C má pro zvyšování o 1 speciální operátor inkrementace ++. Tedy příkaz pro zvyšování proměnné o 1 pomocí ukazatele by vypadal následovně:
(*p_q)++;Smyslem tohoto příkladu bylo si uvědomit, jaký je rozdíl mezi
(*p_q)++;
// a
*p_q++;V prvním případě se inkrementuje hodnota prvku, ve druhém případě se inkrementuje nejprve ukazatel a poté se bere hodnota na nové adrese. Příklad ukazuje důležitost použití závorek z důvodu priorit operátorů.
9. V pořádku. Správně si použil bázovou adresu pole a posun. Výsledkem součtu ukazatele a celého čísla je opět ukazatel. Výrazy *(p + i) a p[i] vyjadřují totéž. Výraz, kde je použita pointerová aritmetika je o něco efektivnější. Nicméně moderní kompilátory nahrazují indexaci pole právě adekvátním výrazem pointerové aritmetiky.
Ještě jedna drobnost. Příkaz:
p_q = &pole[0];
// je ekvivalentni prikazu
p_q = pole;Často se vyskytuje a zapisuje ukazatel na pole druhou formou.
Pokud je vytvářen ukazatel na pole, nepíše se &. Jméno pole adresa na
začátek pole.
10. Jde. Následující zápisy výpisu třetího prvku pole jsou totožné
int pole[] = {1, 2, 3, 4, 5};
int p = pole;
printf("%d", *(pi + 2)); // ukazatelova aritmetika ukazatele
printf("%d", *(pole + 2)); // ukazatelova aritmetika pole
printf("%d", pole[2]); // indexace pole
printf("%d", pi[2]); // indexace ukazateleIndexovat ukazatel nejspíš dělat nebudeš, neboť ukazatelová aritmetika je vhodnější.
11. Ano. Je třeba mít stále v paměti souvislost mezi *(p + i) a p[i].
12. Jméno pole bez indexu představuje ukazatel na začátek pole. Oproti klasickému ukazateli se liší v tom, že ukazatel na začátek pole je konstantní. Nelze jej tedy měnit. Pokud tedy chceme traversovat pole pomocí ukazatele, přiřadí se ukazatel na toto pole jinému ukazateli, který již lze modifikovat.
Pokud tedy máme pole
int pole[] = {1, 2, 3, 4, 5};
int p = pole;pak v programu je:
pole++; // neplatný příkaz
p++; platný příkaz13. Funkci lze předat argument hodnotou nebo odkazem. Při volání hodnotou se předává kopie proměnné což má za následek, že změna proměnné se neprojeví vně funkce. Pokud se ovšem provádí volání odkazem, předává se adresa na tuto proměnnou a změny se pak projeví vně funkce. Otázkou může být, kdy použít volání hodnotou a kdy volání odkazem. Pomůcka je jednoduchá - volání odkazem, tedy kdy funkce přebírá ukazatel, se vytváří tehdy, chceme-li měnit hodnotu argumentu předaného jako parametr funkce.
Následující příklad ukazuje tuto problematiku:
#include <stdio.h>
void func1(int i);
void func2(int* i);
int main(void) {
int val = 0;
func1(val);
printf("vne func1 %d\n", val);
func2(&val);
printf("vne func2 %d\n", val);
return 0;
}
void func1(int i) {
i = 10;
printf("uvnitr func1 %d\n", i);
}
void func2(int *i) {
*i = 10;
printf("uvnitr func2 %d\n", *i);
}Tedy ukazatel jako argument funkce použijeme tehdy, chceme-li, aby se změna proměnné promítla i mimo funkci nikoli jen uvnitř funkce.
14. Deklarace pětiprvkového pole ukazatelů na int vypadá následovně:
int *p[5];Kdežto deklarace ukazatele na pětiprvkové pole typu int vypadá následovně:
int (*p)[5];Smyslem příkladu bylo opět ukázat, jak důležité jsou závorky při práci s ukazateli. Jak priorita operátorů mění smysl. Toto bývá častá chyba.
Opět zde není důvod používat dynamickou alokaci. Navíc druhý zápis je chybný (neberu v potaz přepsání se v přetypování na int*. Funkce malloc() vrací ukazatel na void a návratovou hodnotu je třeba přiřadit ukazatelové proměnné nikoli klasické proměnné.
15. Ano, úryvek kódu je správný. Správně jsi zodpověděl, že ukazatel je inicializován adresou řetězcové konstanty. Funkce printf() přebírá jako první argument řetězec a je zcela v pořádku, pokud je tímto argumentem ukazatel na řetězec. Důležité je neměnit tento ukazatel, jinak se ztratí přístup k tomuto řetězci. Ano, nulový znak je přidáván na konec automaticky.
16. Tuto otázku si zodpověděl správně a dodal si i informaci o nutnosti předávání informace o velikosti pole a to, že není nutné předávat pole od začátku ale od ukazatele který je vytvořen s posunem. Pouze upřesním informaci o předávání velikosti pole. Toto není třeba u polí které jsou řetězci. Důvodem je to, že řetězec je ukončen vždy nulovým znakem. tedy lze určit, kdy řetězec končí.
17. Zde jsem nespecifikoval zadání úplně přesně a došlo tak nedorozumění v tom, co jsem požadoval a co jsi vypracoval. Pokud bych totiž chtěl pouze délku řetězce, bylo by neefektivní tuto funkci vytvářet a zaobalovat tak již existující funkci strlen(), která již toto dělá. Úkolem bylo vytvořit funkci, která převezme řetězec zadaný jako argument funkce spolu se znakem zadaným jako druhý argument. Funkce tedy bude mít dva parametry a bude vracet počet nalezených znaků v řetězci. Druhý parametr určuje právě hledaný znak. Abych Tě o tuto úlohu neochudil, dostaneš ji za úkol zpracovat v tomto upřesněném zadání. Opět, uvědom si, kdy je třeba předávat funkci argument odkazem a kdy hodnotou a jak je to s určení velikosti řetězcových polí. A opravdu není třeba použití dynamické alokace.
18. Je to správně. Pouze menší efektivita a zbytečné použití pomocné proměnné. Ale to není někdy na škodu. Následující úryvek kódu ukazuje, jak to lze napsat lépe. Ukazatele p_zacatek a p_konec jsou inicializovány přímo.
char str[] = "Ucim se ukazatele";
char *p_zacatek = str;
char *p_konec = str + strlen(str) - 1;Je třeba mít stále na paměti, že ukazatel + celočíselná konstanta dává ukazatel.
19. Smyslem úlohy bylo uvědomit si, že vracet hodnoty z funkce lze i přes parametry ne jen přes návratovou hodnotu funkce. Opět, pokud je předáván ukazatel, lze měnit hodnoty argumentů a změny se projeví vně funkce. Stačila mi funkce a nebylo třeba v tom hledat složitosti. Využije se zde přístup do proměnné nepřímo pomocí ukazatele. Funkce vypadá následovně:
void vypocet(double r, double* o, double* s) {
*o = 2 * PI * r;
*s = PI * r * r;
}celý program pak například takto:
#define PI 3.141592653
#include <stdio.h>
void vypocet(double r, double *o, double *s);
int main(void) {
double obvod, obsah;
vypocet(10.0, &obvod, &obsah);
printf("obvod=%f\nobsah=%f\n", obvod, obsah);
return 0;
}
void vypocet(double r, double* o, double* s) {
*o = 2 * PI * r;
*s = PI * r * r;
}Způsobů, jak vracet vícero hodnot z funkce je více. Lze využít pole popř. struktury. Zde šlo pouze o princip a to, že je třeba předat ukazatel na proměnnou.
Ještě malá odbočka k dynamické alokaci. Funkce free() pro uvolnění alokované paměti se nikdy nezavolá, jelikož funkce je ukončena dříve pomocí příkazu return. Často se způsob alokace ve funkci využívá spolu s tím, že paměť je uvolněna později někde v programu. Takové funkce pak vrací ukazatel aby se mohla tato paměť později, když je třeba, uvolnit.
20. Nejtěžší na konec. Nic však, co by se nedalo vyřešit. Pořád je to o tom, kdy je třeba argument předat voláním odkazem nebo hodnotou. Tedy zda se bude měnit či nikoli. Aby funkce byla soběstačná, je třeba, aby byl řetězec předáván jako argument, spolu s oběma znaky. První je třeba mít představu o tom jak bude vypadat takový prototyp funkce. Mohl by vypadat např. následovně:
char *zamena_znaku(char *str, char c_puvodni, char c_novy);A celý program pak např. takto:
#include <stdio.h>
char *zamena_znaku(char *str, char c_puvodni, char c_novy);
int main(void) {
char text[] = "Ucim se ukazatele";
printf(zamena_znaku(text, 'e', 'x'));
return 0;
}
char* zamena_znaku(char* str, char c_puvodni, char c_novy) {
char* s = str;
while (*str) {
if (*str == c_puvodni) *str = c_novy;
str++;
}
return s;
}Pole se vždy předává pomocí ukazatele. Zbylé dva znaky není třeba předávat voláním odkazem. Ukazatel s uvnitř funkce slouží pro uchování adresy začátku pole. Postupně procházím všechny znaky a testuji, zda znak je původním. Pokud ano, přepíšu ho novým. Pro ukončení cyklu se využívá faktu, že řetězec končí nulovou hodnotou (nepravdivou). Podmínka ve while cyklu zjišťuje, zda-li znak který testuji není znakem, který ukončuje řetězec. Aby se prošly všechny znaky, je třeba inkrementace ukazatele. Cyklus while má na starosti změny. A abych předal zpět tento upravený řetězec, využívám lokalní ukazatel s, který mi uchovává adresu začátku tohoto pole. Tento ukazatel s je nutný, neboť pro traversování pole používám ukazatel. Pokud bych používal konstantu posunu, měl bych uchovaný začátek tohoto pole stále v ukazateli str. Nakonec, co stojí za povšimnutí je to jak užitečné je vracet ukazatel. Návratovou hodnotu funkce, tedy ukazatel na tento řetězec mohu použít jako argument funkce printf(). Díky tomu mám definici řetězce, provedení změn a výpisu pole na pouhých dvou řádcích.
Tolik k tvému zpracování otázek a cvičení na téma - Základy
ukazatelů v C. Doufám, že Ti vše doplněné o předchozí výklad více
přiblížilo pochopení práce s ukazateli a porozuměl si všemu, co si dělal
chybně. Pokud Ti cokoli z toho co jsem napsal není jasné, ptej se. A
nezapomeň, úloha 17. na tebe stále čeká k vyřešení 
Zobrazené 10 správy z 58.
