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