Ukazatelé I


	17. Ukazatele I

Ukazatele dělíme do dvou základních kategorií: ukazatele na data (objekty) a ukazatele na funkce. Oba dva typy ukazatelů jsou speciální objekty, které obsahují adresy v paměti. Oba dva typy ukazatelů mají různé vlastnosti, účely použití a pravidla zacházení. Obecně řečeno, ukazatelé na funkce se používají pro přístup k funkcím a pro předávání funkcí jako parametrů jiným funkcím. S těmito ukazateli není možné provádět žádné aritmetické operace. Ukazatele na objekty můžeme inkrementovat a dekrementovat tak, jak je to při prohlížení polí nebo složitějších struktur potřeba.

ukazatel na funkci s určitým počtem a typy parametrů a vracející jistý typ

void (*fce)(int);

fce

int

Následující konzolová aplikace ukazuje použití ukazatele na funkci. Program se nejprve zeptá, zda se má provádět sčítání nebo násobení. Podle této odpovědi vloží do proměnné operace ukazatel na funkci sečti nebo na funkci nasob. Dále zadáme dvě čísla, která se použijí jako parametry vybrané funkce.

int secti(int a, int b)

{

return a+b;

}

int nasob(int a, int b)

{

return a*b;

}

int main(int argc, char **argv)

{

int (*operace) (int, int);

int x, y, volba;

cout << "Budeme Sčítat (1) nebo Násobit (2) ?";

do {

cin >> volba;

} while (volba != 1 && volba != 2);

if (volba == 1) operace = secti;

if (volba == 2) operace = nasob;

cout << "Zadej dvě celá čísla: ";

cin >> x >> y;

cout << "Výsledek je " << operace(x, y) << endl;;

getch();

return 0;

}

Většinou se budeme ale zabývat ukazateli na data. Ukazatel na data musí být deklarován tak, aby ukazoval na nějaký konkrétní typ, a to i v případě, že tento typ je void (což vlastně znamená ukazatel na cokoliv). Je-li typ libovolný předdefinovaný nebo uživatelem definovaný typ (včetně void), potom deklarace

typ *ptr; // pozor - neinicializovaný ukazatel

ptr

ukazatel na typ

stdlib.h

void

Podívejme se na příklad. Předpokládejme, že máme pole prvků typu int. Jednotlivé prvky pole můžeme zpřístupňovat pomocí operátoru indexace. To již známe z dřívějška.

int pole[] = {5, 10, 15, 20, 25};

int promenna = pole[3]; // hodnota 20

int pole[] = {5, 10, 15, 20, 25};

int* ptr = pole;

int promenna = ptr[3];

ptr

int

Aritmetika ukazatelů je omezena na sčítání, odčítání a porovnávání ukazatelů. Aritmetické operace na ukazatelích typu "ukazatel na typ" berou v úvahu délku typu typ, tzn. počet slabik potřebných na uchování objektu typu typ. Při provádění aritmetických operací se předpokládá, že ukazatel ukazuje do pole objektů. Je-li tedy ukazatel deklarován jako ukazatel na objekt typu typ, potom přičtení celočíselné hodnoty k tomuto ukazateli jej posune o tento počet objektů typu typ. Má-li typ typ velikost 10 slabik, potom přičtením hodnoty 5 k tomuto ukazateli jej posuneme o 50 slabik v paměti dále. Rozdílem dvou ukazatelů je počet prvků pole, které navzájem oddělují tyto dva ukazatele. Rozdíl ukazatelů má smysl pouze v případě, kdy oba ukazují do stejného pole.

char *str;

int *ip;

str = (char *) ip;

(typ *)

typ

Všechny příklady konzolových aplikací, se kterými jsme se zatím seznámili používají lokální alokaci objektů. Tzn. paměť požadovaná pro proměnnou nebo objekt je získána ze zásobníku programu. Všechnu paměť, kterou program potřebuje pro lokální proměnné, volání funkcí apod. bere ze zásobníku. Tato paměť je alokována, když je zapotřebí a uvolňována, když již zapotřebí není. To obvykle nastává, když program vstupuje do funkce nebo jiného lokálního bloku kódu. Paměť pro všechny lokální proměnné funkce je alokována při vstupu do funkce. Při výstupu z funkce, je všechna paměť alokovaná funkcí uvolněna. Toto probíhá automaticky a nemáme možnost určit jak a kdy paměť bude uvolněna.

adresar zaznam;

strcpy(zaznam.jmeno = "Karel");

strcpy(zaznam.prijmeni = "Novak");

// atd.

new

adresar* zaznam;

zaznam = new adresar;

strcpy(zaznam->jmeno = "Karel");

strcpy(zaznam->prijmeni = "Novak");

// atd.

adresar

adresar seznam[3];

seznam[0].pcs = 53002;

adresar* seznam[3];

for (int i = 0; i < 3; i++)

seznam[i] = new adresar;

seznam[0]->pcs = 53002;

Operátory & a * jsou operátory odkazu (reference) a dereference. Např.

&typový_výraz

typový_výraz

* typový_výraz

typový_výraz

typ

Pokuste se určit co dělají následující příkazy:

int i, *ukazatel = &i;

cin >> i;

cout << ukazatel << endl << *ukazatel << endl;

Předpokládejte deklarace:

int promenna;

int *ukazatel = &promenna;

int **ukazatel_na_ukazatel = &ukazatel;

**ukazatel_na_ukazatel = 10;	*ukazatel = 10;
promenna = 10;	*ukazatel_na_ukazatel = &promenna;

Neinicializovaný ukazatel obsahuje, stejně jako jiná neinicializovaná proměnná, náhodnou hodnotu. Pokus o použití neinicializovaného ukazatele může způsobit havárii programu. V mnoha případech provádíme současnou deklaraci a inicializaci ukazatele. Např.

adresar* pom = 0;

int* i;

int *i;

int * i;

Zadání 4 z kapitoly 15 nyní změníme na použití dynamické alokace. Náš program se změní takto (hlavičkový soubor zůstane beze změny):

#include <iostream.h>

#include <conio.h>

#include <stdlib.h>

#pragma hdrstop

#include "structur.h"

//---------------------------------------------------------------------

#pragma argsused

void zobrazZaznam(int, adresar adrZaz);

int main(int argc, char **argv)

{

adresar* seznam[3];

for (int i = 0; i < 3; i++)

seznam[i] = new adresar;

cout << endl;

int index = 0;

do {

cout << "Jméno: ";

cin.getline(seznam[index]->jmeno, sizeof(seznam[index]->jmeno)-1);

cout << "Příjmení: ";

cin.getline(seznam[index]->prijmeni,

sizeof(seznam[index]->prijmeni)-1);

cout << "Ulice: ";

cin.getline(seznam[index]->ulice, sizeof(seznam[index]->ulice)-1);

cout << "Město: ";

cin.getline(seznam[index]->mesto, sizeof(seznam[index]->mesto)-1);

cout << "Psč: ";

char buff[10];

cin.getline(buff, sizeof(buff)-1);

seznam[index]->psc = atoi(buff);

index++;

cout << endl;

} while (index < 3);

clrscr();

for(int i = 0; i < 3; i++) {

zobrazZaznam(i, *seznam[i]);

}

cout << "Zadej číslo záznamu: ";

int zaz;

do {

zaz = getch();

zaz -= 49;

} while (zaz < 0 || zaz > 2);

adresar pom = *seznam[zaz];

clrscr();

zobrazZaznam(zaz, pom);

getch();

return 0;

}

void zobrazZaznam(int cis, adresar adrZaz)

{

cout << "Záznam " << (cis + 1) << ":" << endl;

cout << "Jméno: " << adrZaz.jmeno << " " << adrZaz.prijmeni << endl;

cout << "Adresa: " << adrZaz.ulice << endl;

cout << " " << adrZaz.mesto << endl;

cout << " " << adrZaz.psc << endl << endl;

}

zobrazZaznam

Parametry funkcí v jazyku C jsou volány hodnotou. To znemožňuje funkci měnit hodnotu parametru tak, aby změněná hodnota byla použitelná mimo funkci, tzn. jazyk C nepoužívá parametry volané odkazem. Tento problém lze vyřešit pomocí ukazatelů. Funkci předáme jako parametr adresu proměnné, s jejiž hodnotou pak budeme pracovat. Např. následující funkce zaměňuje hodnoty svých parametrů:

void zamen(int *a, int *b)

{

int c = *a;

*a = *b;

*b = *c;

}

int x = 10, y = 20;

zamen(&x, &y);

a > b

Hlavičkový soubor stdlib.h obsahuje řadu různých funkcí. Jsou zde např. funkce provádějící celočíselné dělení a určující maximální a minimální hodnotu ze dvou hodnot (div, ldiv, max a min). Dále tu jsou funkce provádějící převody typů (atoi, atol, ecvt, strtod a řada dalších). Jsou zde také funkce pro generování náhodných čísel, s kterými jsme se již seznámili. Seznamte se s těmito funkcemi pomocí ukázkových programů v nápovědě.

Nové pojmy:

Ukazatel je proměnná, která obsahuje adresu jiné proměnné (ukazuje na jinou proměnnou). Protože ukazatel nemá přímý vztah k aktuálním datům, používáme pojem nepřímý přístup, když se tímto způsobem odkazujeme na data.
Lokální alokace znamená, že paměť potřebná pro proměnnou nebo objekt je získána ze zásobníku.
Zásobník je oblast pracovní paměti nastavená programem při spuštění programu.
Dynamická alokace znamená, že paměť potřebná pro objekt je alokována v hromadě.
Hromada je všechna virtuální paměť našeho počítače.
Paměť alokujeme dynamicky pomocí operátoru new.
Dereference ukazatele znamená získání obsahu objektu, na který ukazatel ukazuje.

17. Ukazatele I