Kurs C++ Od Zera Do Gier Kodera.pdf

Wska(niki

251

sáowy, kompilator musi znaü odpowied( na pytanie: „Jakiego rodzaju jest zmienna, na
któr pokazuje dany wska(nik?”. Dziki temu potrafi zachowywaü kontrol nad typami
danych w podobny sposób, w jaki czyni to w stosunku do zwykáych zmiennych.

Obejmuje to tak*e rzutowanie midzy wska(nikami, o którym te* sobie powiemy.

Wiedzc o tym, spójrzmy teraz na ten elementarny przykáad deklaracji oraz u*ycia
wska(nika:

// deklaracja zmiennej typu int oraz wska(nika na zmienne tego typu

int

nZmienna =

;

int

* pnWskaznik;

// nasz wska(nik na zmienne typu int

// przypisanie adresu zmiennej do naszego wska(nika i u*ycie go do
// wywietlenia jej wartoci w konsoli

pnWskaznik = &nZmienna;

// pnWskaznik odnosi si teraz do nZmienna

std::cout << *pnWskaznik;

// otrzymamy 10, czyli wartoü zmiennej

Dobra wiadomoü jest taka, i* mimo prostoty ilustruje on wikszoü zagadnie
zwizanych ze wska(nikami na zmiennej. Nieco gorsz jest pewnie to, *e owa prostota
mo*e dla niektórych nie byü wcale taka prosta :) Naturalnie, wyjanimy sobie po kolei, co
dzieje si w powy*szym kodzie (chocia* komentarze mówi ju* caákiem sporo).

Oczywicie najpierw mamy deklaracj zmiennej (z inicjalizacj), lecz nas interesuje
bardziej sposób zadeklarowania wska(nika, czyli:

int

* pnWskaznik;

Poprzez dodanie gwiazdki (*) do nazwy typu

int

informujemy kompilator, *e oto nie ma

ju* do czynienia ze zwyká zmienn liczbow, ale ze wska(nikiem przeznaczonym do
przechowywania adresu takiej zmiennej. pWskaznik jest wic wska(nikiem na
zmienne typu

int

, lub, krócej, wska(nikiem na (typ)

int

A zatem mamy ju* zmienn, mamy i wska(nik. Przydaáoby si zmusiü je teraz do
wspóápracy: niech pWskaznik zacznie odnosiü si do naszej zmiennej! Aby tak byáo,
musimy pobraü jej adres i przypisaü go do wska(nika - o tak:

pnWskaznik = &nZmienna;

Zastosowany tutaj operator & sáu*y wáanie w tym celu - do uzyskania adresu miejsca
w pamici, gdzie egzystuje zmienna. Potem rzecz jasna zostaje on zapisany w
pnWskaznik; odtd wskazuje on wic na zmienn nZmienna.

Na koniec widzimy jeszcze, *e za porednictwem wska(nika mo*emy dostaü si do
zmiennej i u*yü jej w ten sam sposób, jaki znalimy dotychczas, choüby do wypisania jej
wartoci w oknie konsoli:

std::cout << *pnWskaznik;

Jak z pewnoci przypuszczasz, operator * nie dokonuje tutaj mno*enia, lecz podejmuje
wartoü zmiennej, z któr poáczony zostaá pnWskaznik; nazywamy to dereferencj
wska(nika. W jej wyniku otrzymujemy na ekranie liczb, któr oryginalnie przypisalimy
do zmiennej nZmienna. Bez zastosowania wspomnianego operatora zobaczylimy
wartoü wska(nika (a wic adres komórki w pamici), nie za wartoü zmiennej, na
któr on pokazuje. To oczywicie wielka ró*nica.

Podstawy programowania

252

Zaprezentowana próbka kodu faktycznie realizuje zatem zadanie wywietlenia wartoci
zmiennej nZmienna w icie okr*ny sposób. Zamiast bezporedniego przesáania jej do
strumienia wyjcia posáugujemy si w tym celu dodatkowym porednikiem w postaci
wska(nika.
Samo w sobie mo*e to budziü wtpliwoci co do sensownoci korzystania ze wska(ników.
Pomylmy jednak, *e majc wska(nik mo*emy umo*liwiü dostp do danej zmiennej z
jakiegokolwiek miejsca programu - na przykáad z funkcji, do której przeka*emy go jako
parametr (w kocu to tylko liczba!). Potrafimy wtedy zaprogramowaü ka*d czynnoü
(algorytm) i zapewniü jej wykonanie w stosunku do dowolnej iloci zmiennych, piszc
odpowiedni kod tylko raz.

Wicej przekonania do wska(ników na zmiennej nabierzesz wówczas, gdy poznasz je
bli*ej - i temu wáanie zadaniu powicimy teraz uwag.

Deklaracje wska(ników

Stwierdzilimy, *e wska(niki mog z powodzeniem odnosiü si do zmiennych - albo
ogólnie mówic, do danych w programie. Czyni to poprzez przechowywanie numeru
odpowiedniej komórki w pamici, a zatem pewnej wartoci. Sprawia to, *e wska(niki s
w rzeczy samej tak*e zmiennymi.

Wska(niki w C++ to zmienne nale*ce do specjalnych typów wska(nikowych.

Taki typ áatwo poznaü po obecnoci przynajmniej jednej gwiazdki w jego nazwie. Jest nim
wic choüby

int

* - typ zmiennej pWskaznik z poprzedniego przykáadu. Zawiera on

jednoczenie informacj, na jaki rodzaj danych bdzie nasz wska(nik pokazywaá - tutaj
jest to

int

. Typ wska(nikowy jest wic typem pochodnym, zdefiniowanym na

podstawie jednego z ju* wczeniej istniejcych.

To definiowanie mo*e si odbywaü ad hoc, podczas deklarowania konkretnej zmiennej
(wska(nika) - tak byáo w naszym przykáadzie i tak te* postpuje si najczciej.
Dozwolone (i przydatne) jest aczkolwiek stworzenie aliasów na typy wska(nikowe
poprzez instrukcj

typedef

; standardowe nagáówki systemu Windows zawieraj na

przykáad wiele takich nazw.

Deklarowanie wska(ników jest zatem niczym innym, jak tylko wprowadzeniem do kodu
nowych zmiennych - tyle tylko, i* maj one swoiste przeznaczenie, inne ni* reszta ich
licznych wspóábraci. Czynnoü ich deklarowania, a tak*e same typy wska(nikowe
zasáuguj przeto na szersze omówienie.

Nieod*aáowany spór o gwiazdk

Dowiedzielimy si ju*, *e piszc gwiazdk po nazwie jakiego typu, uzyskujemy
odpowiedni wska(nik na ten typ. Potem mo*emy u*yü go, deklarujc wáaciwy wska(nik;
co wicej, mo*liwe jest uczynienie tego a* na cztery sposoby:

int

* pnWskaznik;

int

*pnWskaznik;

int

*pnWskaznik;

int

* pnWskaznik;

Widaü wic, *e owa gwiazdka „nie trzyma si” kurczowo nazwy typu (tutaj

int

) i mo*e

nawet oddzielaü go od nazwy deklarowanej zmiennej, bez potrzeby u*ycia w tym celu
spacji.

Wydawaáoby si, *e taka swoboda skáadniowa powinna tylko cieszyü. W rzeczywistoci
jednak powoduje najczciej trudnoci w rozumieniu kodu napisanego przez innych,

Wska(niki

253

je*eli u*ywaj oni innego sposobu deklarowania wska(ników ni* „nasz”. Dlatego te*
wielokrotnie próbowano ustaliü jaki jeden, sáuszny wariant w tej materii… i w zasadzie
nigdy si to nie udaáo!

Podobnie rzecz ma si tak*e z umieszczaniem nawiasów klamrowych po instrukcjach

else

oraz nagáówkach ptli.

Jeli wic chodzi o dwa ostatnie sposoby, to generalnie prawie nikt nich nie u*ywa i
raczej nie jest to niespodziank. Nieu*ywanie spacji czyni instrukcj maáo czyteln, za
ich obecnoü po obu stronach znaku * nieodparcie przywodzi na myl mno*enie, a nie
deklaracj zmiennej.
Co do dwóch pierwszych metod, to w kwestii ich u*ywania panuje niczym niezmcona
dowolnoü… Powa*nie! W kodach, jakie spotkasz, na pewno bdziesz miaá okazj
zobaczyü obie te skáadnie. Argumenty stojce za ich wykorzystaniem s niemal tak samo
silne w przypadku ka*dej z nich - tak przynajmniej twierdz ich zwolennicy.

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

Temu problemowi powicony jest nawet

fragment FAQ

autora jzyka C++.

Zauwa*yáe byü mo*e, i* w tym kursie u*ywam pierwszej konwencji i bd si tego
konsekwentnie trzymaá. Nie chc jednak nikomu jej narzucaü; najlepiej bdzie, jeli sam
wypracujesz sobie odpowiadajcy ci zwyczaj i, co najwa*niejsze, bdziesz go
konsekwentnie przestrzegaá. Nie ma bowiem nic gorszego ni* niespójny kod.

Z opisywanym problemem wi*e si jeszcze jeden dylemat, powstajcy gdy chcemy
zadeklarowaü kilka zmiennych - na przykáad tak:

int

* a, b;

Czy w ten sposób otrzymamy dwa wska(niki (zmienne typu

int

*)?… Pozostawiam to

zainteresowanym do samodzielnego sprawdzenia

. Odpowied( nie jest taka oczywista,

jak by si to wydawaáo na pierwszy rzut oka, zatem stosowanie takiej konstrukcji
pogarsza czytelnoü kodu i mo*e byü przyczyn bádów. Czuje si wic w obowizku
przestrzec przed ni:

Nie próbuj deklarowaü kilku wska(ników w jednej instrukcji, oddzielajc je przecinkami.

Trzeba niestety przyznaü, *e jzyk C++ zawiera w sobie jeszcze kilka podobnych
niejasnoci. Bd zwracaá na nie uwag w odpowiednim czasie i miejscu.

Wska(niki do staáych

Wska(niki maj w C++ pewn, doü oryginaln cech. Mianowicie, nierzadko aplikuje si
do nich modyfikator

const

, a mimo to caáy czas mo*emy je nazywaü zmiennymi.

Dodatkowo, ów modyfikator mo*e byü do zastosowany a* na dwa ró*ne sposoby.

Pierwszy z nich zakáada poprzedzenie nim caáej deklaracji wska(nika, co wyglda mniej
wicej tak:

const

int

* pnWskaznik;

const

, jak wiemy, zmienia nam zmienn w staá. Tutaj mamy jednak do czynienia ze

wska(nikiem na zmienn, zatem dziaáanie modyfikatora powoduje jego zmian we…
wska(nik na staá :)

Mo*na skorzystaü z podanego wczeniej linka do FAQa.

Podstawy programowania

254

Wska(nik na staá (ang. pointer to constant) pokazuje na wartoü, która mo*e byü
poprzez ten wska(nik jedynie odczytywana.

Przypatrzmy si, jak wska(nik na staá mo*e byü wykorzystany w przykáadowym kodzie:

// deklaracja zmiennej i wska(nika do staáej

float

fZmienna =

3.141592

;

const

float

* pfWskaznik;

// zwizanie zmiennej ze wska(nikiem

pfWskaznik = &fZmienna;

// pokazanie wartoci zmiennej poprzez wska(nik

std::cout << *pfWskaznik;

Przykáad ten jest podobny do poprzedniego: za porednictwem wska(nika odczytujemy
tu wartoü zmiennej. Dozwolne jest zatem, aby ów wska(nik byá wska(nikiem na staá -
jako taki wic go deklarujemy:

const

float

* pfWskaznik;

Ro*nica, jak czyni modyfikator

const

, ujawni si przy próbie zapisania wartoci do

zmiennej, na któr pokazuje wska(nik:

*pfWskaznik =

1.0

;

// BàD! pfWskaznik pokazuje na staá wartoü

Kompilator nie pozwoli na to. Decydujc si na zadeklarowanie wska(nika na staá (tutaj
typu

const

float

*) uznalimy bowiem, *e bdziemy tylko odczytywaü wartoü, do której

si on odnosi. Zapisywanie jest oczywicie pogwaáceniem tej zasady.

Powy*sza linijka byáaby rzecz jasna poprawna, gdyby pfWskaznik byá zwykáym
wska(nikiem typu

float

Je*eli wska(nik na staá jest dodatkowo wska(nikiem na obiekt, to na jego rzecz
mo*liwe jest wywoáanie jedynie staáych metod. Nie modyfikuj one bowiem pól obiektu.

Wska(nik na staá umo*liwia wic zabezpieczenie przed niepo*dan modyfikacj
wartoci, na któr wskazuje. Z tego wzgledu jest dosyü czsto wykorzystywany w
praktyce, chocia*by przy przekazywaniu parametrów do funkcji.

Staáe wska(niki

Druga mo*liwoü u*ycia

const

powoduje nieco inny efekt. Odmienne jest wówczas tak*e

umiejscowienie modyfikatora w deklaracji wska(nika:

float

const

pfWskaznik;

Takie ustawienie powoduje mianowicie zadeklarowanie staáego wska(nika zamiast
wska(nika na staá.

Staáy wska(nik (ang. const(ant) pointer) jest nieruchomy, na zawsze przywizany do
jednego adresu pamici.

Ten jeden jedyny i niezmienny adres mo*emy okreliü tylko podczas inicjalizacji
wska(nika:

float

fA;

Wska(niki

255

float

const

pfWskaznik = &fA;

Wszelkie pó(niejsze próby zwizania wska(nika z inn komórk pamici (czyli inn
zmienn) skocz si niepowodzeniem:

float

fB;

pfWskaznik = &fB;

// BàD! pfWskaznik jest staáym wska(nikiem

Zadeklarowanie staáego wska(nika jest bowiem umow z kompilatorem, na mocy której
zobowizujemy si nie zmieniaü adresu, do którego ten*e wska(nik pokazuje.

Pole zastosowa staáych wska(ników jest, przyznam szczerze, raczej wskie. Mimo to
mielimy ju* okazj korzystaü z tego rodzaju wska(ników - i to niejednokrotnie. Gdzie?
Otó* staáym wska(nikiem jest

this

, który, jak pamitamy, pokazuje wewntrz metod

klasy na aktualny jej obiekt. Nie ogranicza on w *aden sposób dostpu do tego obiektu,
jednak nie pozwala na zmian samego wskazania; jest wic trwale zwizany z tym
obiektem.
Typem wska(nika

this

wewntrz metod klasy klasa jest wic klasa*

const

W przypadku staáych metod wska(nik

this

nie pozwala tak*e na modyfikacj pól obiektu,

a zatem wskazuje na staá. Jego typem jest wtedy

const

klasa*

const

, czyli mikst obu

rodzajów „staáoci” wska(nika.

Podsumowanie deklaracji wska(ników

Na sam koniec tematu deklarowania wska(ników tradycyjnie podam troch wskazówek
dotyczacych skáadni oraz stosowalnoci praktycznej.

Skáadnie deklaracji wska(nika mo*emy, opierajc si na przykáadach z poprzednich
paragrafów, przedstawiü nastpujco:

[

const

]

typ* [

const

]

wska(nik;

Mo*liwoü wystpowania lub niewystpowania modyfikatora

const

w a* dwóch miejscach

deklaracji pozwala stwierdziü, *e z ka*dego typu mo*emy wyprowadziü ácznie nawet
cztery odpowiednie typy wska(nikowe. Ich charakterystyk przedstawia poni*sza
tabelka:

typ wska(nikowy nazwa dostp do pamici zmiana

adresu

typ*

wska(nik (zwykáy)

odczyt i zapis

dozwolona

const

typ*

wska(nik do staáej wyácznie odczyt

dozwolona

typ*

const

staáy wska(nik

odczyt i zapis

niedozwolona

const

typ*

const

staáy wska(nik do staáej wyácznie odczyt

niedozwolona

Tabela 12. Zestawienie typów wska(nikowych

Czy jest jaki prosty sposób na zapamitanie, która deklaracja odpowiada jakiemu
rodzajowi wska(ników? No có*, mo*e nie jest to banalne, ale w pewien sposób zawsze
mo*na sobie pomóc. Przede wszystkim patrzmy na fraz bezporednio za
modyfikatorem

const

Dla staáych wska(ników (przypominam, *e to te, które zawsze wskazuj na to samo
miejsce w pamici) deklaracja wyglda tak:

typ*

const

wska(nik;

Bezporednio po sáowie

const

mamy wic nazw wska(nika, co razem daje

const

wska(nik. W wolnym táumaczeniu znaczy to oczywicie ‘staáy wska(nik’ :)

Podstawy programowania

256

W przypadku wska(ników na staáe forma deklaracji przedstawia si nastpujco:

const

typ* wska(nik;

U*ywamy tu

const

w ten sam sposób, w jaki ze zmiennych czynimy staáe. W tym

przypadku mamy rzecz jasna do czynienia ze ‘wska(nikiem na zmienn’, a poniewa*

const

przemienia nam ‘zmienn’ w ‘staá’, wic ostatecznie otrzymujemy ‘wska(nik na

staá’. Potwierdzenia tego mo*emy szukaü w tabelce.

Niezbdne operatory

Na wszelkich zmiennych mo*na w C++ wykonywaü jakie operacje i wska(niki nie s w
tym wzgldnie *adnym wyjtkiem. Posiadaj nawet wáasne instrumentarium specjalnych
operatorów, dokonujcych na nich pewnych szczególnych dziaáa. To na nich wáanie
skupimy si teraz.

Pobieranie adresu i dereferencja

Wska(nik powinien na co wskazywaü - to znaczy przechowywaü adres jakie komórki w
pamici. Taki adres mo*na uzyskaü na wiele sposobów, w zale*noci od tego, jakie
znaczenie ma owa komórka w programie. Dla zmiennych wáaciw metod jest u*ycie
operatora pobierania adresu, oznaczanego znakiem & (ampersandem).
Popatrzmy na niniejszy przykáad:

// zadeklarowanie zmiennej oraz odpowiedniego wska(nika

unsigned

uZmienna;

unsigned

* puWskaznik;

// pobranie adresu zmiennej i zapisanie go we wska(niku

puWskaznik = &uZmienna;

Wyra*enie &uZmienna reprezentuje tutaj wartoü liczbow, bdc adresem miejsca w
pamici, w którym rezyduje zmienna uZmienna. Typem tej zmiennej jest

unsigned

;

wyra*enie &uZmienna jest natomiast przynale*ne typowi wska(nikowemu

unsigned

Przypisujemy go wic zmiennej tego typu, czyli wska(nikowi puWskaznik. Odtd odnosi
si on do naszej zmiennej liczbowej i mo*e byü u*yty w celu odwoáania si do niej.
Prezentowany tu operator & jest wic unarny - *d tylko jednego argumentu: obiektu,
którego adres ma uzyskaü. Zwraca go w wyniku, za typem tego rezultatu jest
odpowiedni typ wska(nikowy - zobaczylimy to zreszt na powy*szym przykáadzie.

Przypominam, *e adres zmiennej mo*emy przypisaü jedynie do niestaáego
(„ruchomego”) wska(nika.

Majc wska(nik, chciaáoby si odwoáaü do komórki w pamici, czyli zmiennej, na któr on
wskazuje. Potrzebujemy zatem operatora, który dokona czynnoci odwrotnej ni* operator
&, a wic wydobdzie zmienn spod adresu przechowywanego przez wska(nik. Dokonuje
tego operator dereferencji, symbolem którego jest * (asterisk albo po prostu
gwiazdka). Czynnoü przez niego wykonywan nazywamy wic dereferencj wska(nika.
Wystarczy spojrzeü na poni*szy kod, a wszystko stanie si jasne:

// zapisanie wartoci w komórce pamici, na któr pokazuje wska(nik

*puWskaznik =

123

;

// odczytanie i wywietlenie tej wartoci

std::cout <<

"Wartosc zmiennej uZmienna: "

<< *puWskaznik;

Widzimy, *e operator ten jest tak*e unarny, co w oczywisty sposób ró*ni go od
operatora mno*enia, który w C++ jest przecie* reprezentowany przez ten sam znak.

Wska(niki

257

Argumentem operatora jest naturalnie wska(nik, przechowujcy adres miejsca w
pamici, do którego chcemy si dostaü. W wyniku dziaáania tego operatora otrzymujemy
mo*liwoü odczytania oraz ewentualnie zapisania tam jakiej wartoci.
Typ tej wartoci musi si jednak zgadzaü z typem wska(nika: je*eli u nas byá to

unsigned

*, to po dereferencji zostanie typ

unsigned

, akceptujcy tylko dodatnie liczby

caákowite. Podobnie z wyra*enia *puWskaznik mo*emy skorzystaü jedynie tam, gdzie
dozwolone s tego rodzaju wartoci.

Wyra*enie *pWskaznik jest tu tak zwan l-wartoci (ang. l-value). Nazwa bierze si

std, i* taka wartoü mo*e wystpowaü po lewej (ang. left) stronie operatora

przypisania. Typowymi l-wartociami s wic zmienne, a w ogólnoci s to wszystkie

wyra*enia, za którymi kryj si konkretne miejsca w pamici operacyjnej i które nie

zostaáy opatrzone modyfikatorem

const

Dla odró*nienia, r-wartoü (ang. r-value) jest dopuszczalna tylko po prawej (ang. right)

stronie operatora przypisania. Ta grupa obejmuje oczywicie wszystkie l-wartoci, a

tak*e liczby, znaki i ich áacuchy (tzw. staáe dosáowne) oraz wyniki oblicze z u*yciem

wszelkiego rodzaju operatorów (wykorzystujcych tymczasowe obiekty).

Pamitajmy, *e zapisanie danych do komórki pokazywanej przez wska(nik jest mo*liwe
tylko wtedy, gdy nie jest on wska(nikiem do staáej.

Natura operatorów & i * sprawia, *e najlepiej rozpatrywaü je ácznie. Powiedzielimy
sobie nawet, *e ich funkcjonowanie jest sobie wzajemnie przeciwstawne. Ilustruje to
dobrze poni*szy diagram:

Schemat 33. Dziaáanie operatorów: pobrania adresu i dereferencji

Warto równie* wiedzieü, *e pobranie adresu zmiennej oraz dereferencja wska(nika s
mo*liwe zawsze, niezale*nie od typu tej*e zmiennej czy te* wska(nika. Dopiero inne
zwizane z tym operacje, takie jak zachowanie adresu w zmiennej wska(nikowej lub
zapisanie wartoci w miejscu, do którego odwoáuje si wska(nik, mo*e napotykaü
ograniczenia zwizane z typami zmiennej i/lub stosowanego wska(nika.

Wyáuskiwanie skáadników

Trzeci operator wska(nikowy jest nam ju* znany od wprowadzenia OOPu. Operator
wyáuskania -> (strzaáka) sáu*y do wybierania skáadników obiektu, na który wskazuje
wska(nik. Pod pojciem ‘obiektu’ kryje si tu zarówno instancja klasy, jak i typu
strukturalnego lub unii.

Poniewa* znamy ju* doskonale t konstrukcj, na prostym przykáadzie przeledzimy
jedynie zwizek tego operatora z omówionymi przed chwil & i *.
Zaáó*my wic, *e mamy tak oto klas:

Podstawy programowania

258

class

CFoo

{

public

int

Metoda()

const

{

return

; }

};

Tworzc dynamicznie jej instancj przy u*yciu wska(nika, mo*emy wywoáaü skáadowe
metody:

// stworzenie obiektu

CFoo* pFoo =

new

CFoo;

// wywoáanie metody

std::cout << pFoo->Metoda();

pFoo jest tu wska(nikiem, takim samym jak te, z których korzystalimy dotd; wskazuje
na typ záo*ony - obiekt. Wykorzystujc operator -> potrafimy dostaü si do tego obiektu i
wywoáaü jego metod, co te* niejednokrotnie czynilimy w przeszáoci.
Zwróümy jednakowo* uwag, *e ten sam efekt osignlibymy dokonujc dereferencji
naszego wska(nika i stosujc drugi z operatorów wyáuskania - kropk:

// inna metoda wywoáania metody Metoda() ;D

(*pFoo).Metoda();

// zniszczenie obiektu

delete

pFoo;

Nawiasy pozwalaj nie przejmowaü si tym, który z operatorów: * czy . ma wy*szy
priorytet. Ich wykorzystywanie jest wic zawsze wskazane, o czym zreszt nie raz
wspominam :)

Analogicznie, mo*na instancjowaü obiekt poprzez zmienn obiektow i mimo to u*ywaü
operatora -> celem dostpu do jego skáadowych:

// zmienna obiektowa

CFoo Foo;

// obie poni*sze linijki robi to samo

std::cout << Foo.Metoda();
std::cout << (&Foo)->Metoda();

Tym razem bowiem pobieramy adres obiektu, czyli wska(nik na niego, i aplikujemy do
wska(nikowy operator wyáuskania ->.

Widzimy zatem wyra(nie, *e oba operatory wyáuskania maj charakter mocno umowny i
teoretycznie mog byü stosowane zamiennie. W praktyce jednak korzysta si zawsze z
kropki dla zmiennych obiektowych oraz strzaáki dla wska(ników, i to z bardzo prostego
powodu: wymuszenie zaakceptowania drugiego z operatorów wi*e si przecie* z
dodatkow czynnoci pobrania adresu albo dereferencji. àcznie zatem u*ywamy
wtedy dwóch operatorów zamiast jednego, a to z pewnoci mo*e odbiü si na
wydajnoci kodu.

Konwersje typów wska(nikowych

Dwa poznane operatory nie wyczerpuj rzecz jasna asortymentu operacji, jakich mo*emy
dokonywaü na wska(nikach. Dosyü czsto zachodzi bowiem potrzeba przypisywania
wska(ników, których typy s w wikszym lub mniejszym stopniu niezgodne - podobnie

Wska(niki

259

zreszt jak to czasem bywa dla zwykáych zmiennych. W takich przypadkach z pomoc
przychodz nam ró*ne metody konwersji typów wska(nikowych, jakie oferuje C++.

Matka wszystkich wska(ników

Przypomnijmy sobie definicj wska(nika, jak podalimy na pocztku rozdziaáu. Otó* jest
to przede wszystkim adres jakiej komórki (miejsca) w pamici. Przy jej páaskim modelu
sprowadza si to do pojedynczej liczby bez znaku.

Na przechowywanie takiej liczby wystarczyáby wic tylko jeden typ zmiennej liczbowej!
C++ oferuje jednak mo*liwoü definiowania wáasnych typów wska(nikowych w oparciu o
ju* istniejce, inne typy. Cel takiego postpowania jest chyba oczywisty: tylko znajc typ
wska(nika mo*emy dokonaü jego dereferencji i uzyskaü zmienn, na któr on wskazuje.
Informacja o docelowym typie wskazywanych danych jest wic niezbdna do ich
u*ytkowania.

Mo*liwe jest aczkolwiek zadeklarowanie ogólnego wska(nika (ang. void pointer lub
pointer to void), któremu nie s przypisane *adne informacje o typie. Taki wska(nik jest
wic jedynie adresem samym w sobie, bez dodatkowych wiadomoci o rodzaju danych,
jakie si pod tym adresem znajduj.
Aby zadeklarowaü taki wska(nik, zamiast nazwy typu wpisujemy mu

void

* pWskaznik;

// wska(nik, który mo*e pokazywaü na wszystko

Ustalamy t drog, i* nasz wska(nik nie bdzie zwizany z *adnym konkretnym typem
zmiennych. Nic nie wiadomo zatem o komórkach pamici, do których si on odnosi -
mog one zawieraü dowolne dane.
Brak informacji o typie upoledza jednak podstawowe wáaciwoci wska(nika. Nie mogc
okreliü rodzaju danych, na które pokazuje wska(nik, kompilator nie mo*e pozwoliü na
dostp do nich. Powoduje to, *e:

Niedozwolone jest dokonanie dereferencji ogólnego wska(nika typu

void

Có* bowiem otrzymalibymy w jej wyniku? Jakiego typu byáoby wyra*enie *pWskaznik?

void

?… Nie jest to przecie* *aden konkretny typ danych. Sáusznie wic dereferencja

wska(nika typu

void

* jest niemo*liwa.

Uáomnoü takich wska(ników nie jest zbytni zacht do ich stosowania. Czym wic
zasáu*yáy sobie na tytuá paragrafu im powiconego?…
Otó* maj one jedn szczególn i przydatn cech, zwizan z brakiem wiadomoci o
typie. Mianowicie:

Wska(nik typu

void

* mo*e przechowywaü dowolny adres z pamici operacyjnej.

Mo*liwe jest zatem przypisanie mu wartoci ka*dego innego wska(nika (z wyjtkiem
wska(ników na staáe). Poprawny jest na przykáad taki oto kod:

int

nZmienna;

void

* pWskaznik = &nZmienna;

// &nZmienna jest zasadniczo typu int*

Fakt, *e wska(nik typu

void

* to tylko sam adres, bez dodatkowych informacji o typie,

przeznaczonych dla kompilatora, sprawia, *e owe informacje s tracone w momencie
przypisania. Wskazywanym w pamici danym nie dzieje si naturalnie *adna krzywda,
jedynie my tracimy mo*liwoü odwoáywania si do nich poprzez dereferencj.

Czy przypadkiem czego nam to nie przypomina?… W miar podobna sytuacja miaáa
przecie* okazj zainstnieü przy okazji programowania obiektowego i polimorfizmu.

Podstawy programowania

260

Wska(nik do obiektu klasu pochodnej moglimy bowiem przypisaü do wska(nika na
obiekt klasy bazowej i u*ywaü go potem tak samo, jak ka*dego innego wska(nika na
obiekt tej klasy.
Tutaj typ

void

* jest czym rodzaju „typu bazowego” dla wszystkich innych typów

wska(nikowych. Mo*liwe jest zatem przypisywanie ich wska(ników zmiennym typu

void

*. Wówczas tracimy wprawdzie wiedz o pierwotnym typie wska(nika, ale

zachowujemy to, co najwa*niejsze: adres przechowywany przez wska(nik

Przywracanie do stanu u*ywalnoci

Caáy problem z ogólnymi wska(nikami polega na tym, *e przy ich pomocy nie mo*emy w
zasadzie zrobiü niczego konkretnego. Dereferencja nie wchodzi w gr z powodu
niedostatecznych informacji o typie danych, na które wska(nik pokazuje. )eby móc z
tych danych skorzystaü, musimy wic przekazaü kompilatorowi niezbdne informacje o
ich typie. Dokonujemy tego poprzez rzutowanie.

Operacja rzutowania wska(nika typu

void

* na inny typ wska(nikowy jest przede

wszystkim zabiegiem formalnym. Zarówno przed ni, jak i po niej, mamy bowiem do
czynienia z adresem tej samej komórki w pamici. Jej zawartoü jest jednak inaczej
interpretowana.
Dokonanie takiego rzutowania nie jest trudne - wystarczy posáu*yü si standardowym
operatorem

static_cast

// zmienna oraz ogólny wska(nik, do której zapiszemy jej adres

int

nZmienna =

17011987

;

void

* pVoid = &nZmienna;

// ponowne wykorzystanie owego adresu we wska(niku na typ unsigned
// stosujemy rzutowanie, aby przypisaü mu wska(nik typu void*

unsigned

* puLiczba =

static_cast

unsigned

*>(pVoid);

// wywietlenie wartoci pokazywanej przez wska(nik

std::cout << *puLiczba;

// wynikiem jest wartoü zmiennej nZmienna

W powy*szym przykáadzie wska(nik typu

int

* zostaje najpierw zredukowany do

void

by potem poprzez rzutowanie zostaü zinterpretowany jako

unsigned

*. Caáy czas

pokazuje on oczywicie na to samo miejsce w pamici, tyle *e w toku programu jest ono
traktowane na ró*ne sposoby.

Midzy palcami kompilatora

Chwileczk! Przecie* t drog mo*emy zwyczajnie oszukaü kompilator i sprawiü, *e
zacznie on traktowaü jaki typ danych jako zupeánie inny, nawet caákowicie niezwizany z
tym oryginalnym!

Istotnie - za porednictwem wska(nika typu

void

* mo*liwe jest dosáownie

zinterpretowanie cigu bitów jako dowolnego typu zmiennych. Dzieje si tak dlatego,
*

e podczas rzutowania nie jest dokonywane *adne sprawdzenie faktycznej poprawnoci

typów.

static_cast

nie dziaáa tak jak

dynamic_cast

i nie kontroluje sensownoci oraz

celowoci rzutowania.

Zakres stosowalnoci

dynamic_cast

jest za, jak pamitamy, ograniczony tylko do typów

polimorficznych. Skalarne typy podstawowe z pewnocia nimi nie s, dlatego nie mo*emy
do nich u*ywaü tego typu rzutowania.

Potencjalnie wic dostajemy do rki brzytw, któr mo*na si nie(le pokaleczyü. W
okrelonych sytuacjach potrzebne jest jednak takie dosáowne potraktowanie pewnego

Wska(niki

261

rodzaju danych jako zupeánego innego. Porednictwo typu

void

* w niskopoziomowych

konwersjach midzy wska(nikami staje si wtedy káopotliwe.
Z tego powodu (a tak*e z potrzeby caákowitego zastpienia rzutowania w stylu C)
wprowadzono do C++ kolejny operator rzutowania -

reinterpret_cast

/ Potrafi on

rzutowaü dowolny typ wska(nikowy na dowolny inny typ wska(nikowy i nie tylko.
Konwersje przy u*yciu tego operatora prawie zawsze nie s wic bezpieczne i powinny
byü stosowane wyácznie wtedy, gdy zale*y nam na mechanicznej zmianie (bit po
bicie) jednego typu danych w inny.
Je*eli chodzi o przykáady, to chyba jedynym bezpiecznym zastosowaniem

reinterpret_cast

jest zapisanie adresu pamici ze wska(nika do zwykáej zmiennej

liczbowej:

int

* pnWskaznik;

unsigned

uAdres =

reinterpret_cast

unsigned

>(pnWskaznik);

W innych przypadkach stosowanie tego operatora powinno byü wyjtkowo ostro*ne i
oszczdne.

Kompletnych informacji o

reinterpret_cast

dostarcza oczywicie

MSDN

. Jest tam tak*e

ciekawy

artykuá

, wyjaniajcy dogábnie ró*nice midzy tym operatorem, a zwykáym

rzutowaniem

static_cast

Istnieje jeszcze jeden, czwarty operator rzutowania

const_cast

. Jego zastosowanie jest

bardzo wskie i ogranicza si do usuwania modyfikatora

const

z opatrzonych nim typów

danych. Mo*na wic u*yü go, aby zmieniü staáy wska(nik lub wska(nik do staáej w

zwykáy.

Bli*sze informacje na temat tego operatora mo*na naturalnie znale(ü we

wiadomym

(

ródle

Wska(niki i tablice

Tradycyjnie wska(ników u*ywa si do operacji na tablicach. Celowo pisz tu ‘tradycyjnie’,
gdy* prawie wszystkie te operacje mo*na wykonaü tak*e bez u*ycia wska(ników, wic
korzystanie z nich w C++ nie jest tak popularne jak w jego generacyjnym poprzedniku.
Poniewa* jednak czasem bdziemy zmuszeni korzystaü z kodu wywodzcego si z czasów
C (na przykáad z Windows API), wiedza o zastosowaniu wska(ników w stosunku do tablic
mo*e byü przydatna. Obejmuje ona tak*e zagadnienia áacuchów znaków w stylu C,
którym powicimy osobny paragraf.

Ju* sáysz gáosy oburzenia: „Przecie* miaáe zajmowaü si nauczaniem C++, a nie
wywlekaniem jego ró*nic w stosunku do swego poprzednika!”. Rzeczywicie, to prawda.
Wska(niki s to dziedzin jzyka, która najczciej zmusza nas do podró*y w przeszáoü.
Wbrew pozorom nie jest to jednak przeszáoü zbyt odlegáa, skoro z powodzeniem wpáywa
na tera(niejszoü. Z wáaciwoci wska(ników i tablic bdziesz bowiem korzystaá znacznie
czciej ni* sporadycznie.

Tablice jednowymiarowe w pamici

Swego czasu powiedzielimy sobie, *e tablice s zespoáem wielu zmiennych opatrzonych
t sam nazw i identyfikowanych poprzez indeksy. Symbolicznie przedstawialimy na
diagramach tablice jednowymiarowe jako równy rzd prostoktów, wyobra*ajcych
kolejne elementy.
To nie byá wcale przypadek. Tablice takie maj bowiem wa*n cech:

Kolejne elementy tablicy jednowymiarowej s uáo*one obok siebie, w cigáym
obszarze pamici.

Podstawy programowania

262

Nie s wic porozrzucane po caáej dostpnej pamici (czyli pofragmentowane), ale
grzecznie zgrupowane w jeden pakiet.

Schemat 34. Uáo*enie tablicy jednowymiarowej w pamici operacyjnej

Dziki temu kompilator nie musi sobie przechowywaü adresów ka*dego z elementów
tablicy, aby programista mógá si do nich odwoáywaü. Wystarczy tylko jeden: adres
pocztku tablicy, jej zerowego elementu.
W kodzie mo*na go áatwo uzyskaü w ten sposób:

// tablica i wska(nik

int

aTablica[

];

int

* pnTablica;

// pobranie wska(nika na zerowy element tablicy

pnTablica = &aTablica[

];

Napisaáem, *e jest to tak*e adres pocztku samej tablicy, czyli w gruncie rzeczy wartoü
kluczowa dla caáego agregatu. Dlatego reprezentuje go równie* nazwa tablicy:

// inny sposób pobrania wska(nika na zerowy element (pocztek) tablicy

pnTablica = aTablica;

Wynika std, i*:

Nazwa tablicy jest tak*e staáym wska(nikiem do jej zerowego elementu
(pocztku).

Staáym - bo jego adres jest nadany raz na zawsze przez kompilator i nie mo*e byü
zmieniany w programie.

Wska(nik w ruchu

Posiadajc wska(nik do jednego z elementów tablicy, mo*emy z áatwoci dostaü si do
pozostaáych - wykorzystujc fakt, i* tablica jest cigáym obszarem pamici. Mo*na
mianowicie odpowiednio przesunü nasz wska(nik, np.:

pnTablica +=

;

Po tej operacji bdzie on pokazywaá na 3 elementy dalej ni* dotychczas. Poniewa* na
pocztku wskazywaá na pocztek tablicy (zerowy element), wic teraz zacznie odnosiü si
do jej trzeciego elementu.
To ciekawe zjawisko. Wska(nik jest przecie* adresem, liczb, zatem dodanie do niego
jakiej liczby powinno skutkowaü odpowiednim zwikszeniem przechowywanej wartoci.
Poniewa* kolejne adresy w pamici s numerami bajtów, wic pnTablica powinien,
zdawaáoby si, przechowywaü adres trzeciego bajta, liczc od pocztku tablicy.
Tak jednak nie jest, gdy* kompilator podczas dokonywania arytmetyki na wska(nikach
korzysta tak*e z informacji o ich typie. „Skoki” spowodowane dodawaniem liczb
caákowitych nastpuj w odstpach bajtowych równych wielokrotnociom rozmiaru

Wska(niki

263

zmiennej, na jak wskazuje wska(nik. W naszym przypadku pnTablica przesuwa si
wic o

sizeof

(

int

) bajtów, a nie o

bajty!

Obecnie wskazuje zatem na trzeci element tablicy aTablica. Dokonujc dereferencji
wska(nika, mo*emy odwoáaü si do tego elementu:

// obie poni*sze linijki s równowa*ne

*pnTablica =

;

aTablica[

] =

;

Wreszcie, dozwolony jest tak*e trzeci sposób:

*(aTablica +

) =

;

U*ywamy w nim wska(nikowych wáaciwoci nazwy tablicy. Wyra*enie aTablica +

odnosi si zatem do jej trzeciego elementu. Jego dereferencja pozwala przypisaü temu
elementowi jak wartoü.

Wydaáo si wic, *e do i-tego elementu tablicy mo*na odwoáaü si na dwa ró*ne
sposoby:

*(tablica + i)
tablica[i]

W praktyce kompilator sam stosuje tylko pierwszy. Wprowadzenie drugiego miaáo
oczywicie gáboki sens: jest on zwyczajnie prostszy, nie tylko w zapisie, ale i w
zrozumieniu. Nie wymaga te* *adnej wiedzy o wska(nikach, a ponadto daje wiksz
elastycznoü przy definiowaniu wáasnych typów danych.

Nie nale*y jednak zapominaü, *e oba sposoby s tak samo podatne na bád przekroczenia
indeksów, który wystpuje, gdy i wykracza poza przedziaá <

; rozmiar_tablicy -

Tablice wielowymiarowe w pamici

Dla tablic wielowymiarowych sprawa ich rozmieszczenia w pamici jest nieco bardziej
skomplikowana. W przeciwiestwe do pamici nie maj one bowiem struktury liniowej,
zatem kompilator j jako symulowaü (czyli linearyzowaü tablic).
Nie jest to specjalnie trudna czynnoü, ale praktyczny sens jej omawiania jest raczej
wtpliwy. Z tego wzgldu maáo kto stosuje wska(niki do pracy z wielowymiarowymi
tablicami, za my nie bdziemy tutaj *adnym wyjtkiem od reguáy :)

Zainteresowanym mog wyjaniü, *e wymiary tablicy s ukáadane w pamici wedáug

kolejnoci ich zadeklarowania w kodzie, od lewej do prawej. Posuwajc si wzdáu* takiej

zlinearyzowanej tablicy najszybciej zmienia si wic ostatni indeks, wolniej przedostatni, i

tak dalej.

Formuáka matematyczna sáu*ca do obliczania wska(nika na element wielowymiarowej

tablicy jest natomiast podana w

MSDN

acuchy znaków w stylu C

Kiedy ju* omawiamy wska(niki w odniesieniu do tablic, nadarza si niepowtarzalna
okazja, aby zapoznaü si tak*e z áacuchami znaków w jzyku C - poprzedniku C++.

Po co? Otó( jak dotd jest to najczeciej wykorzystywana forma wymiany tekstu midzy
aplikacjami oraz bibliotekami. Do koronnych przykáadów nale*y choüby Windows API,
której obsáugi przecie* bdziemy si w przyszáoci uczyü.

Podstawy programowania

264

Od razu spotka nas tutaj pewna niespodzianka. O ile bowiem C++ posiada wygodny typ
std::string, sáu*cy do przechowywania napisów, to C w ogóle takiego typu nie
posiada! Zwyczajnie nie istnieje *aden specjalny typ danych, sáu*cy reprezentacji
tekstu.
Zamiast niego stosowanie jest inne podejcie do problemu. Napis jest to cig znaków, a
wic uporzdkowany zbiór kodów ANSI, opisujcych te znaki. Dla pojedynczego znaku
istnieje za typ

char

, zatem ich cig mo*e byü przedstawiany jako odpowiednia tablica.

acuch znaków w stylu C to jednowymiarowa tablica elementów typu

char

Ró*ni si ona jednak on innych tablic. S one przeznaczone gáównie do pracy nad ich
pojedynczymi elementami, natomiast áacuch znaków jest czciej przetwarzany w
caáoci, ni* znak po znaku.
Sprawia to, *e dozwolone s na przykáad takie (w gruncie rzeczy trywialne!) operacje:

char

szNapis[

256

] =

"To jest jaki tekst"

;

Manipulujemy w nich wicej ni* jednym elementem tablicy naraz.
Zauwa*my jeszcze, *e przypisywany cig jest krótszy ni* rozmiar tablicy (

256

). Aby

zaznaczyü, gdzie si on koczy, kompilator dodaje zawsze jeszcze jeden, specjalny znak
o kodzie 0, na samym kocu napisu. Z powodu tej wáaciwoci áacuchy znaków w stylu
C s czsto nazywane napisami zakoczonymi zerem (ang. null-terminated strings).

Dlaczego jednak ten sposób postpowania z tekstem jest záy (zostaá przecie* zastpiony
przez typ std::string)?…
Pierwsz przyczyn s problemy ze zmienn dáugoci napisów. Tekst jest káopotliwym
rodzajem danych, który mo*e zajmowaü bardzo ró*n iloü pamici, zale*nie od liczby
znaków. Rozsdnym rozwizaniem jest oczywicie przydzielanie mu dokáadnie tylu
bajtów, ilu wymaga; do tego potrzebujemy jednak mechanizmów zarzdzania pamici w
czasie dziaáania programu (poznamy je zreszt w tym rozdziale). Mo*na te* statycznie
rezerwowaü wicej miejsca, ni* to jest potrzebne - tak zrobiáem choüby w poprzednim
skrawku przykáadowego kodu. Wada tego rozwizania jest oczywista: spora czü
pamici zwyczajnie si marnuje.
Drug niedogodnoci s utrudnienia w dokonywaniu najprostszych w zasadzie operacji
na tak potraktowanych napisach. Chodzi tu na przykáad o konkatenacj; wiedzc, jak
proste jest to dla napisów typu std::string, pewnie bez wahania napisalibymy co w
tym rodzaju:

char

szImie[] =

"Max"

;

char

szNazwisko[] =

"Planck"

;

char

szImieINazwisko[] = szImie +

" "

+ szNazwisko;

// BàD!

Visual C++ zareagowaáby za takim oto bádem:

error C2110: '+': cannot add two pointers

Miaáby w nim caákowit sáusznoü. Rzeczywicie, próbujemy tutaj dodaü do siebie dwa
wska(niki, co jest niedozwolne i pozbawione sensu. Gdzie s jednak te wska(niki?…
To przede wszystkim szImie i szNazwisko - jako nazwy tablic s przecie* wska(nikami
do swych zerowych elementów. Równie* spacja

" "

jest przez kompilator traktowana

jako wska(nik, podobnie zreszt jak wszystkie napisy wpisane w kodzie explicité.

Porównywanie takich napisów poprzez operator == jest wic niepoprawne!

Wska(niki

265

czenie napisów w stulu C jest naturalnie mo*liwe, wymaga jednak u*ycia specjalnych

funkcji w rodzaju strcat(). Inne funkcje s przeznaczone choüby do przypisywania
napisów (str[n]cpy()) czy pobierania ich dáugoci (strlen()). Nietrudno si domyleü,
*

e korzystanie z nich nie nale*y do rzeczy przyjemnych :)

Na caáe szczcie ominie nas ta „rozkosz”. Standardowy typ std::string zawiera
bowiem wszystko, co jest niezbdne do programowej obsáugi áacuchów znaków. Co
wicej, zapewnia on tak*e kompatybilnoc z dawnymi rozwizaniami.
Metoda c_str() (skrót od C string), bo o ni tutaj chodzi, zwraca wska(nik typu

const

char

*, którego mo*na u*yü wszdzie tam, gdzie wymagany jest napis w stylu C. Nie

musimy przy tym martwiü si o pó(niejsze zwolnienie zajmowanej przez nasz tekst
pamici - zadba oto sama Biblioteka Standardowa.
Przykáadem wykorzystania tego rozwizania mo*e byü wywietlenie okna komunikatu
przy pomocy funkcji MessageBox() z Windows API:

#include

#include

<windows.h>

std::string strKomunikat =

"Przykáadowy komunikat"

;

strKomunikat +=

"."

;

MessageBox (NULL, strKomunikat.c_str(),

"Komunikat"

, MB_OK);

O samej funkcji MessageBox() powiemy sobie wszystko, gdy ju* przejdziemy do
programowania aplikacji okienkowych. Powy*szy kod zadziaáa jednak tak*e w programie
konsolowym.

Drugi oraz trzeci parametr tej funkcji powinien byü áacuchem znaków w stylu C. Mo*emy
wic skorzystaü z metody c_str() dla zmiennej strKomunikat, by uczyniü zadoü temu
wymaganiu. W sumie wic nie przeszkadza ono zupeánie w normalnym korzystaniu z
dobrodziejstw standardowego typu std::string.

Przekazywanie wska(ników do funkcji

Jedn z wa*niejszych páaszczyzn zastosowa wska(ników jest usprawnienie korzystania z
funkcji. Wska(niki umo*liwiaj osignicie kilku niespotykanych dotd mo*liwoci i
optymalizacji.

Dane otrzymywane poprzez parametry

Wska(nik jest odwoáaniem do zmiennej („kluczem” do niej), które ma jedn zasadnicz
zalet: mo*e mianowicie byü przekazywane gdziekolwiek i nadal zachowywaü swoj
podstawow rol. Niezale*nie od tego, w którym miejscu programu u*yjemy wska(nika,
bdzie on nadal wskazywaá na ten sam adres w pamici, czyli na t sam zmienn.

Je*eli wic przeka*emy wska(nik do funkcji, wtedy bdzie ona mogáa operowaü na jego
docelowej komórce pamici. W ten sposób mo*emy na przykáad sprawiü, aby funkcja
zwracaáa wicej ni* jedn wartoü w wyniku swego dziaáania.
Spójrzmy na prosty przykáad takiego zachowania:

// funkcja oblicza caákowity iloraz dwóch liczb oraz jego reszt

int

Podziel(

int

nDzielna,

int

nDzielnik,

int

const

pnReszta)

{

// zapisujemy reszt w miejscu pamici, na które pokazuje wska(nik

*pnReszta = nDzielna % nDzielnik;

// zwracamy iloraz

return

nDzielna / nDzielnik;

Podstawy programowania

266

}

Ta prosta funkcja dzielenia caákowitego zwraca dwa rezultaty. Pierwszy to zasadniczy
iloraz - jest on oddawany w tradycyjny sposób poprzez

return

. Natomiast reszta z

dzielenia jest przekazywana poprzez staáy wska(nik pReszta, który funkcja otrzymuje
jako parametr. Dokonuje jego dereferencji i zapisuje *dan wartoü w miejscu, na które
on wskazuje.
Je*eli pamitamy o tym, skorzystanie z powy*szej funkcji jest raczej proste i przedstawia
si mniej wicej tak:

// Division - dzielenie przy u*yciu wska(nika przekazywanego do

funkcji

void

main()

{

// (pominiemy pobranie dzielnej i dzielnika od u*ytkownika)

// obliczenie rezultatu

int

nIloraz, nReszta;

nIloraz = Podziel(nDzielna, nDzielnik, &nReszta);

wywietlenie rezultatu

std::cout << std::endl;

std::cout << nDzielna <<

" / "

<<nDzielnik <<

" = "

<< nIloraz <<

" r "

<< nReszta;

getch();
}

Jako trzeci parametr w wywoáaniu funkcji Podziel():

nIloraz = Podziel(nDzielna, nDzielnik, &nReszta);

przekazujemy adres zmiennej (uzyskany oczywicie poprzez operator &). W niej te*
znajdziemy potem *dan reszt i wywietlimy j w oknie konsoli:

Screen 37. Dwie wartoci zwracane przez jedn funkcj

W podobny sposób dziaáa wiele funkcji z Windows API czy DirectX. Zalet tego
rozwizania jest tak*e mo*liwoü oddzielenia zasadniczego wyniku funkcji (zwracanego
przez wska(nik) od ewentualnej informacji o bádzie czy te* sukcesie jego uzyskania
(przekazywanego w tradycyjny sposób).

Oczywicie nic nie stoi na przeszkodzie, aby t drog zwracaü wicej ni* jeden
„dodatkowy” rezultat funkcji. Jeli jednak ich liczba jest znaczna, lepiej záczyü je w
struktur ni* deklarowaü po kilkanacie parametrów w nagáówku funkcji.

Zapobiegamy niepotrzebnemu kopiowaniu

Oprócz otrzymywania kilku wyników z jednej funkcji, zastosowanie wska(ników mo*e
mieü te* podáo*e optymalizacyjne. Pomylmy, *e taki wska(nik to zawsze jest tylko
zwykáa liczba caákowita, zajmujca zaledwie 4 bajty w pamici. Jednoczenie jednak
mo*e ona odnosiü si do bardzo wielkich obiektów.

Wska(niki

267

Kiedy za wywoáujemy funkcj z parametrami, wówczas kompilator dokonuje ich
caáociowego kopiowania - tak, *e w ciele funkcji mamy do czynienia z duplikatami
rzeczywistych parametrów aktualnych funkcji. Mówilimy zreszt we wáaciwym czasie, i*
parametry peáni w funkcji rol dodatkowych zmiennych lokalnych.
Aby to zilustrowaü, we(my tak oto banaln funkcj:

int

Dodaj(

int

nA,

int

nB)

{

nA += nB;

return

nA;

}

Jak widaü, dokonujemy w niej modyfikacji jednego z parametrów. Kiedy jednak
wywoáamy niniejsz funkcj w sposób podobny do tego:

int

nLiczba1 =

, nLiczba2 =

;

std::cout << Dodaj(nLiczba1, nLiczba2);
std::cout << nLiczba1;

// nadal nLiczba1 == 1 !

zobaczymy, *e podana jej zmienna pozostaje nietknita. Funkcja otrzymaáa bowiem
tylko jej wartoü, która zostaáa w tym celu skopiowana.

Trzeba jednak przyznaü, *e wikszoü funkcji z zaáo*enia nie modyfikuje swoich
parametrów, a jedynie odczytuje z nich wartoci. W takim przypadku jest im wic
„wszystko jedno”, czy odwoáuj si do faktycznie istniejcych zmiennych, czy te* do ich
kopii, istniejcych tylko podczas dziaáania funkcji.
Jednak nam, programistom, nie jest wszystko jedno. Stworzenie kopii zmiennych
wymaga bowiem dodatkowego czasu - na przydzielenie odpowiedniej iloci pamici i
zapisanie w niej po*danej wartoci. Naturalnie, w przypadku typów liczbowych jest to
pomijalnie maáy interwaá, ale dla wikszych obiektów (chocia*by áacuchów znaków)
mo*e staü si znaczcy. A przecie* wcale nie musi tak byü!

Mo*liwe jest zlikwidowanie koniecznoci tworzenia duplikatów zmiennych dla
wywoáywanych funkcji: wystarczy tylko zamiast wartoci przekazywaü odwoáania do
nich, czyli… wska(niki! Skopiowanie czterech bajtów bdzie na pewno znacznie szybsze
ni* przemieszczanie iloci danych liczonej na przykáad w dziesitkach kilobajtów.
Zobaczmy wic, jak mo*na przyspieszyü dziaáanie funkcji operujcych na du*ych
obiektach. Posáu* si tu przykáadem na wyszukiwanie pozycji jednego cigu znaków
wewntrz innego:

#include

// funkcja przeszukuje drugi napis w poszukiwaniu pierwszego;
// gdy go znajdzie, zwraca indeks pierwszego pasujcego znaku,
// w przeciwnym wypadku wartoü -1

int

Wyszukaj (

const

std::string* pstrSzukany,

const

std::string* pstrPrzeszukiwany)

{

// przeszukujemy nasz napis

for

(

unsigned

i =

;

i <= pstrPrzeszukiwany->length() - pstrSzukany->length(); ++i)

{

// porównujemy kolejne wycinki napisu (o odpowiedniej dáugoci)

// z poszukiwanym áacuchem. Metoda std::string::substr() sáu*y

// do pobierania wycinka napisu

(pstrPrzeszukiwany->substr(i, pstrSzukany->length())

== *pstrSzukany)

je*eli wycinek zgadza si, to zwracamy jego indeks

return

Podstawy programowania

268

}

// w razie niepowodzenia zwracamy -1

return

-1

;

}

Przeszukiwany tekst mo*e byü bardzo dáugi - edytory pozwalaj na przykáad na
poszukiwanie wybranej frazy wewntrz caáego dokumentu, liczcego nieraz wiele
kilobajtów. Nie jest to jednak problemem: dziki temu, *e funkcja operuje na nim
poprzez wska(nik, pozostaje on caáy czas „na swoim miejscu” w pamici i nie jest
kopiowany. Zysk na wydajnoü aplikacji mo*e byü wtedy znaczny.

W zamian jednak*e dowiadczamy pewnej niedogodnoci, zwizanej ze skáadni dziaáa
na wska(nikach. Aby odwoáaü si do przekazanego napisu, musimy ka*dorazowo
dokonywaü jego dereferencji; tak*e wywoáywanie metod wymaga innego operatora ni*
kropka, do której przyzwyczailimy si, operujc na napisach.
Ale i na to jest rada. Na koniec podrozdziaáu poznamy bowiem referencje, które
zachowuj cechy wska(ników przy jednoczesnym umo*liwieniu stosowania zwykáej
skáadni, wáaciwej zmiennym.

Dynamiczna alokacja pamici

Kto wie, czy nie najwa*niejszym polem do popisu dla wska(ników jest zawáaszczanie
nowej pamici w trakcie dziaáania programu. Mechanizm ten daje nieosigaln inaczej
elastycznoü aplikacji i pozwala manipulowaü danymi o zmiennej wielkoci. Bez niego
wszystkie programy miaáyby z góry narzuczone limity na iloü przetwarzanych informacji,
których nijak nie mo*naby przekroczyü.
Koniecznie wic musimy przyjrzeü si temu zjawisku.

Przydzielanie pamici dla zmiennych

Wszystkie zmienne deklarowane w kodzie maj statycznie przydzielon pamiü o
staáym rozmiarze. Rezyduj one w obszarze pamici zwanym stosem, który równie* ma
niezmienn wielkoü. Stosujc wyácznie takie zmienne, nie mo*emy wic przetwarzaü
danych cechujcych si du* rozpitoci zajmowanego miejsca w pamici.

Oprócz stosu istnieje wszak tak*e sterta. Jest to reszta pamici operacyjnej,
niewykorzystana przez program w momencie jego uruchomienia, ale stanowica rezerw
na przyszáoü. Aplikacja mo*e ze czerpaü potrzebn w danej chwili iloü pamici
(nazywamy to alokacj), wypeániaü wáasnymi danymi i pracowaü na nich, a po
zakoczeniu roboty zwyczajnie oddaü j z powrotem (zwolniü) do wspólnej puli.
Najwa*niejsze, *e o iloci niezbdnego miejsca mo*na zdecydowaü w trakcie dziaáania
programu, np. obliczyü j na podstawie liczb pobranych od u*ytkownika czy te* z
jakiegokolwiek innego (ródáa. Nie jestemy wic skazani na staáy rozmiar stosu, lecz
mo*emy dynamicznie przydzielaü sobie ze sterty tyle pamici, ile akurat
potrzebujemy. Zbiory informacji o niestaáej wielkoci staj si wtedy mo*liwe do
opanowania.

Alokacja przy pomocy

new

Caáe to dobrodziejstwo jest cile zwizane z wska(nikami, gdy* to wáanie za ich pomoc
uzyskujemy now pamiü, odwoáujemy si do niej i wreszcie zwalniamy j po skoczonej
pracy.

Wszystkie te czynnoci przeledzimy na prostym przykáadzie. We(my wic sobie
zwyczajny wska(nik na typ

int

Wska(niki

269

int

* pnLiczba;

Chwilowo nie pokazuje on na *adne sensowne dane. Moglibymy oczywicie záczyü go z
jak zmienn zadeklarowan w kodzie (poprzez operator &), lecz nie o to nam teraz
chodzi. Chcemy sobie sami takow zmienn stworzyü - u*ywamy do tego operatora

new

(‘nowy’) oraz nazwy typu tworzonej zmiennej:

pnLiczba =

new

int

;

Wynikiem dziaáania tego operatora jest adres, pod którym widnieje w pamici nasza

wie*o stworzona, nowiutka zmienna. Umieszczamy go zatem w przygotowanym

wska(niku - odtd bdzie on sáu*yá nam do manipulowania wykreowan zmienn.

Có* takiego ró*ni j innych, deklarowanych w kodzie? Ano caákiem sporo rzeczy:

nie ma ona nazwy, poprzez któr moglibymy si do niej odwáywaü. Wszelka
„komunikacja” z ni musi zatem odbywaü si za porednictwem wska(nika, w
którym zapisalimy adres zmiennej.

czasu istnienia zmiennej nie kontroluje kompilator, ale sam programista. Inaczej
mówic, nasza zmienna istnieje a* do momentu jej zwolnienia (poprzez operator

delete

, który omówimy za chwil). Wynika std równie*, *e dla takiej zmiennej

nie ma sensu pojcie zasigu.

pocztkowa wartoü zmiennej jest przypadkowa. Zale*y bowiem od tego, co
poprzednio znajdowaáo si w tym miejscu pamici, które teraz system operacyjny
oddaá do dyspozycji naszego programu.

Poza tymi aspektami, mo*emy na tak stworzonej zmiennej wykonywaü te same operacje,
co na wszystkich innych zmiennych tego typu. Dereferujc pokazujcy na wska(nik,
otrzymujemy peáen dostp do niej:

*pnLiczba =

100

;

*pnLiczba += rand();
std::cout << *pnLiczba;

// itp.

Oczywicie nasze mo*liwoci nie ograniczaj si tylko do typów liczbowych czy
podstawowych. Przeciwnie, za pomoc

new

mo*emy alokowaü pamiü dla dowolnych

rodzajów zmiennych - tak*e tych definiowanych przez nas samych.
Widzimy wic, *e to bardzo pot*ne narzdzie.

Zwalnianie pamici przy pomocy

delete

Z ka*dej potgi trzeba jednak korzystaü z rozwag. W przypadku dynamicznej alokacji
zasada BHP brzmi:

Zawsze zwalniaj zaalokowan przez siebie pamiü.

Sáu*y do tego odrbny operator

delete

(‘usu’). U*ycie go jest nadzwyczaj áatwe:

wystarczy jedynie podaü mu wska(nik na przydzielony obszar pamici, a on posáusznie
posprzta po nim i zwróci go do dyspozycji systemu operacyjnego, a wic i wszystkich
pozostaáych programów.

Bez zwolnienia pamici operacyjnej nastpuje jej wyciek (ang. memory leak).
Zaalokowana, a niezwolniona pamiü nie jest ju* bowiem dostpna dla innych aplikacji.

Po skoczeniu pracy z nasz dynamicznie stworzon zmienn musimy j zatem usunü.
Wyglda to nastpujco:

Podstawy programowania

270

delete

pnLiczba;

Nale*y mieü wiadomoü, *e

delete

niczego nie modyfikuje w samym wska(niku, zatem

nadal pokazuje on na ten sam obszar pamici. Teraz jednak nasz program nie jest ju*
jego wáacicielem, dlatego te* aby uniknü omyákowego odwoáania si do nieswojego
rejonu pamici, wypadaáoby wyzerowaü nasz wska(nik:

pnLiczba = NULL;

Wartoü NULL to po prostu zero, za zerowy adres nie istnieje. pnLiczba staje si wic
wska(nikiem pustym, niepokazujcym na *adn konkretn komórk pamici.
Gdybymy teraz (omyákowo) spróbowali ponownie zastosowaü wobec niego operator

delete

, wtedy instrukcja ta zostaáaby po prostu zignorowana. Je*eli jednak wska(nik

nadal pokazywaáby na ju* zwolniony obszar pamici, wówczas bez wtpienia wystpiáby
bád ochrony pamici (ang. access violation).

Zatem pamitaj, aby dla bezpieczestwa zerowaü wska(nik po zwolnieniu
dynamicznej zmiennej, na któr on wskazywaá.

Nowe jest lepsze

Je*eli czytaj to jakie osoby znajce jzyk C (w co wtpie, ale wyjtki zawsze si
zdarzaj :D), to pewnie nie darowaáyby mi, gdybym nie wspomniaá o sposobach na
alokacj i zwalnianie pamici w tym jzyku. Chc zapewne wiedzieü, dlaczego powinny o
nich zapomnieü (a powinny!) i stosowaü wyácznie

new

oraz

delete

Otó* w C mielimy dwie funkcje, malloc() i free(), sáu*ce odpowiednio do
przydzielania obszaru pamici o *danej wielkoci oraz do jego pó(niejszego zwalniania.
Radziáy sobie z tym zadaniem caákiem dobrze i mogáyby w zasadzie nadal sobie z nim
radziü. W C++ doszáy jednak nowe zadania zwizane z dynamiczn alokacj pamici
operacyjnej.
Chodzi tu naturalnie o kwesti klas z programowania obiektowego i zwizanymi z nimi
konstruktorami i destruktorami. Kiedy u*ywamy

new

delete

do tworzenia i

niszczenia obiektów, w poprawny sposób wywoáuj one te specjalne metody. Funkcje
znane z C nie robi tego; nie ma w tym jednak niczego dziwnego, bo w ich
macierzystym jzyku w ogóle nie istniaáo pojcie klasy czy obiektu, nie mówic ju* o
metodach uruchamianych podczas ich tworzenia i niszczenia.

„Nowy” sposób alokacji ma jeszcze jedn zalet. Otó* malloc() zwraca w wyniku
wska(nik ogólny, typu

void

*, zamiast wska(nika na okrelony typ danych. Aby przypisaü

go do wybranej zmiennej wska(nikowej, nale*aáo u*yü rzutowania.
Przy korzystaniu z

new

nie jest to konieczne. Za pomoc tego operatora od razu

uzyskujemy wáaciwy typ wska(nika i nie musimy stosowaü *adnych konwersji.

Dynamiczne tablice

Alokacja pamici dla pojedynczej zmiennej jest wprawdzie poprawna i klarowna, ale
raczej maáo efektowna. Trudno wówczas powiedzieü, *e faktycznie operujemy na zbiorze
danych o niejednostajnej wielkoci, skoro owa niestaáoü objawia si jedynie… obecnoci
lub nieobecnoci jednej zmiennej!

O wiele bardziej interesuj s dynamiczne tablice - takie, których rozmiar jest ustalany
w czasie dziaáania aplikacji. Mog one przechowywaü ró*n iloü elementów, wic nadaj
si do mnóstwa wspaniaáych celów :)
Zobaczymy teraz, jak obsáugiwaü takie tablice.

Wska(niki

271

Tablice jednowymiarowe

Najprociej sprawa wyglda z takimi tablicami, których elementy s indeksowane jedn
liczb, czyli po prostu z tablicami jednowymiarowymi. Popatrzmy zatem, jak odbywa si
ich alokacja i zwalnianie.

Tradycyjnie ju* zaczynamy od odpowiedniego wska(nika. Jego typ bdzie determinowaá
rodzaj danych, jakie mo*emy przechowywaü w naszej tablicy:

float

* pfTablica;

Alokacja pamici dla niej tak*e przebiega w dziwnie znajomy sposób. Jedyn ró*nic w
stosunku do poprzedniego paragrafu jest oczywista koniecznoü podania wielkoci
tablicy:

pfTablica =

new

float

[

1024

];

Podajemy j w nawiasach klamrowych, za nazw typu pojedynczego elementu. Z powodu
obecnoci tych nawiasów, wystpujcy tutaj operator jest czsto okrelony jako

new

[].

Ma to szczególny sens, je*eli porównamy go z operatorem zwalniania tablicy, który
zobaczymy za momencik.

Zwa*my jeszcze, *e rozmiar naszej tablicy jest dosyü spory. Byü mo*e wobec dzisiejszych
pojemnoci RAMu brzmi to zabawnie, ale zawsze przecie* istnieje potencjalna mo*liwoü,
*

e zabraknie dla nas tego *yciodajnego zasobu, jakim jest pamiü operacyjna. I na takie

sytuacje powinnimy byü przygotowani - tym bardziej, *e poczynienie odpowiednich
kroków nie jest trudne.
W przypadku braku pamici operator

new

zwróci nam pusty wska(nik; jak

pamitamy, nie odnosi si on do *adnej komórki, wic mo*e byü u*yty jako wartoü
kontrolna (spotkalimy si ju* z tym przy okazji rzutowania

dynamic_cast

). Wypadaáoby

zatem sprawdziü, czy nie natrafilimy na tak nieprzyjemn sytuacj i zareagowaü na ni
odpowiednio:

(pfTablica == NULL)

// mo*e byü te* if (!pfTablica)

std::cout

"Niestety, zabraklo pamieci!"

;

Mo*emy zmieniü to zachowanie i sprawiü, *eby w razie niepowodzenia alokacji pamici

byáa wywoáywana nasza wáasna funkcja. Po szczegóáy mo*esz zajrzeü do

opisu funkcji

set_new_handler()

w MSDN.

Je*eli jednak wszystko poszáo dobrze - a tak chyba bdzie najczciej :) - mo*emy
u*ywaü naszej tablicy w identyczny sposób, jak tych alokowanych statycznie.
Powiedzmy, *e wypeánimy j treci przy pomocy nastpujcej ptli:

for

(

unsigned

i =

; i <

1024

; ++i)

pfTablica[i] = i *

0.01

;

Widaü, *e dostp do poszczególnych elementów odbywa si tutaj tak samo, jak dla tablic
o staáym rozmiarze. A wáaciwie, *eby byü cisáym, to raczej tablice o staáym rozmiarze
zachowuj si podobnie, gdy* w obu przypadkach mamy do czynienia z jednym i tym
samym mechanizmem - wska(nikami.
Nale*y jeszcze pamitaü, aby zachowaü gdzie rozmiar alokowanej tablicy, *eby móc
na przykáad przetwarzaü j przy pomocy ptli

for

, podobnej do powy*szej.

Na koniec trzeba oczywicie zwolniü pamiü, która przeznaczylimy na tablic. Za jej
usunicie odpowiada operator

delete

[]:

Podstawy programowania

272

delete

[] pfTablica;

Musimy koniecznie uwa*aü, aby nie pomyliü go z podobnym operatorem

delete

. Tamten

sáu*y do zwalniania wyácznie pojedyncznych zmiennych, za jedynie niniejszy mo*e
byü u*yty do usunicia tablicy. Nierespektowanie tej reguáy mo*e prowadziü do bardzo
nieprzyjemnych bádów!

Zatem do zwalniania tablic korzystaj tylko z operatora

delete

[]!

atwo zapamitaü t zasad, je*eli przypomnimy sobie, i* do alokowania tablicy

posáu*yáa nam instrukcja

new

[]. Jej usunicie musi wic równie* odbywaü si przy

pomocy operatora z nawiasami kwadratowymi.

Opakowanie w klas

Jeli czsto korzystamy z dynamicznych tablic, warto stworzyü dla odpowiedni klas,
która uáatwi nam to zadanie. Nie jest to specjalnie trudne.
My stworzymy tutaj przykáadow klas jednowymiarowej tablicy elementów typu

int

Zacznijmy mo*e od jej prywatnych pól. Oprócz oczywistego wska(nika na wewntrzn
tablic klasa powinna byü wyposa*ona tak*e w zmienn, w której zapamitamy
rozmiar utworzonej tablicy. Uwolnimy wtedy u*ytkownika od koniecznoci zapisywania
jej we wáasnym zakresie.
Metody musz zapewniü dostp do elementów tablicy, a wic pobieranie wartoci o
okrelonym indeksie oraz zapisywanie nowych liczb w okrelonych elementach tablicy.
Przy okazji mo*emy te* kontrolowaü indeksy i zapobiegaü ich przekroczeniu, co znowu
zapewni nam dozgonn wdzicznoü programisty-klienta naszej klasy ;)

Definicja takiej tablicy mo*e wic przedstawiaü si nastpujco:

class

CIntArray

{

domylny rozmiar tablicy

static

const

unsigned

DOMYSLNY_ROZMIAR =

;

private

wska(nik na wáaciw tablic oraz jej rozmiar

int

* m_pnTablica;

unsigned

m_uRozmiar;

public

konstruktory

CIntArray()

// domylny

{ m_uRozmiar = DOMYSLNY_ROZMIAR;

m_pnTablica =

new

int

[m_uRozmiar]; }

CIntArray(

unsigned

uRozmiar)

// z podaniem rozmiaru tablicy

{ m_uRozmiar = uRozmiar;

m_pnTablica =

new

int

[m_uRozmiar]; }

destruktor

~CIntArray()

{

delete

[] m_pnTablica; }

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

// pobieranie i ustawianie elementów tablicy

int

Pobierz(

unsigned

uIndeks)

const

{

(uIndeks < m_uRozmiar)

return

m_pnTablica[uIndeks];

else

return

; }

bool

Ustaw(

unsigned

uIndeks,

int

nWartosc)

Wska(niki

273

{

(uIndeks >= m_uRozmiar)

return

false

;

m_pnTablica[uIndeks] = uWartosc;

return

true

;

}

inne

unsigned

Rozmiar()

const

{

return

m_uRozmiar; }

};

S w niej wszystkie detale, o jakich wspomniaáem wczeniej.
Dwa konstruktory maj na celu zaalokowanie pamici na nasz tablic; jeden z nich jest
domylny i ustawia okrelon z góry wielkoü (wpisan jako staáa DOMYSLNY_ROZMIAR),
drugi za pozwala podaü j jako parametr. Destruktor natomiast dba o zwolnienie tak
przydzielonej pamici. W tego typu klasach metoda ta jest wic szczególnie przydatna.
Pozostaáe funkcje skáadowe zapewniaj intuicyjny dostp do elementów tablicy,
zabezpieczajc przy okazji przed bádem przekroczenia indeksów. W takiej sytuacji
Pobierz() zwraca wartoü zero, za Ustaw() -

false

, informujc o zainstniaáym

niepowodzeniu.

Skorzystanie z tej gotowej klasy nie jest chyba trudne, gdy* jej definicja niemal
dokumentuje si sama. Popatrzmy aczkolwiek na nastpujcy przykáad:

#include

#include

<ctime>

srand (

static_cast

unsigned

>(time(NULL)));

CIntArray aTablica(rand());

for

(

unsigned

i =

; i < aTablica.Rozmiar(); ++i)

aTablica.Ustaw (i, rand());

Jak widaü, generujemy w nim losow iloü losowych liczb :) Nieodmiennie te* u*ywamy
do tego ptli

for

, nieodzownej przy pracy z tablicami.

Zdefiniowana przed momentem klasa jest wic caákiem przydatna, posiada jednak trzy
zasadnicze wady:

raz ustalony rozmiar tablicy nie mo*e ju* ulegaü zmianie. Jego modyfikacja
wymaga stworzenia nowej tablicy

dostp do poszczególnych elementów odbywa si za pomoc maáo wygodnych
metod zamiast zwyczajowych nawiasów kwadratowych

typem przechowywanych elementów mo*e byü jedynie

int

Na dwa ostatnie mankamenty znajdziemy rad, gdy ju* nauczymy si przeci*aü
operatory oraz korzystaü z szablonów klas w jzyku C++.
Niemo*noü zmiany rozmiaru tablicy mo*emy jednak usunü ju* teraz. Dodajmy wic
jeszcze jedn metod za to odpowiedzialn:

class

CIntArray

{

(reszt wycito)

public

bool

ZmienRozmiar(

unsigned

);

};

Wykona ona alokacj nowego obszaru pamici i przekopiuje do niego ju* istniejc czü
tablicy. Nastpne zwolni j, za caáa klasa bdzie odtd operowaáa na nowym fragmencie
pamici.
Brzmi to dosyü tajemniczo, ale w gruncie rzeczy jest bardzo proste:

Podstawy programowania

274

#include

<memory.h>

bool

CIntArray::ZmienRozmiar(

unsigned

uNowyRozmiar)

{

// sprawdzamy, czy nowy rozmiar jest wikszy od starego

(!(uNowyRozmiar > m_uRozmiar))

return

false

;

// alokujemy now tablic

int

* pnNowaTablica =

new

int

[uNowyRozmiar];

// kopiujemy do star tablic i zwalniamy j

memcpy (pnNowaTablica, m_pnTablica, m_uRozmiar *

sizeof

(

int

));

delete

[] m_pnTablica;

// "podczepiamy" now tablic do klasy i zapamitujemy jej rozmiar

m_pnTablica = pnNowaTablica;

m_uRozmiar = uNowyRozmiar;

// zwracamy pozytywny rezultat

return

true

;

}

Wyjanienia wymaga chyba tylko funkcja memcpy(). Oto jej prototyp (zawarty w
nagáówku memory.h, który doáczamy):

void

* memcpy(

void

* dest,

const

void

* src, size_t count);

Zgodnie z nazw (ang. memory copy - kopiuj pamiü), funkcja ta sáu*y do kopiowania
danych z jednego obszaru pamici do drugiego. Podajemy jej miejsce docelowe i
(

ródáowe kopiowania oraz iloü bajtów, jaka ma byü powielona.

Wáanie ze wzgldu na bajtowe wymagania funkcji memcpy() u*ywamy operatora

sizeof

by pobraü wielkoü typu

int

i pomno*yü go przez rozmiar (liczb elementów) naszej

tablicy. W ten sposób otrzymamy wielkoü zajmowanego przez ni rejonu pamici w
bajtach i mo*emy go przekazaü jako trzeci parametr dla funkcji kopiujcej.

Peána dokumentacja funkcji memcpy() jest oczywicie dostpna w

MSDN

Po rozszerzeniu nowa tablica bdzie zawieraáa wszystkie elementy pochodzce ze starej
oraz nowy obszar, mo*liwy do natychmiastowego wykorzystania.

Tablice wielowymiarowe

Uelastycznienie wielkoci jest w C++ mo*liwe tak*e dla tablic o wikszej liczbie
wymiarów. Jak to zwykle w tym jzyku bywa, wszystko odbywa si analogicznie i
intuicyjnie :D

Przypomnijmy, *e tablice wielowymiarowe to takie tablice, których elementami s… inne
tablice. Wiedzc za, i* mechanizm tablic jest w C++ zarzdzany poprzez wska(niki,
dochodzimy do wniosku, *e:

Dynamiczna tablica n-wymiarowa skáada si ze wska(ników do tablic (n-1)-wymiarowych.

Dla przykáadu, tablica o dwóch wymiarach jest tak naprawd jednowymiarowym
wektorem wska(ników, z których ka*dy pokazuje dopiero na jednowymiarow tablic
wáaciwych elementów.

Wska(niki

275

Aby wic obsáugiwaü tak tablic, musimy u*yü doü osobliwej konstrukcji
programistycznej - wska(nika na wska(nik. Nie jest to jednak takie dziwne. Wska(nik
to przecie* te* zmienna, a wic rezyduje pod jakim adresem w pamici. Ten adres mo*e
byü przechowywany przez kolejny wska(nik.
Deklaracja czego takiego nie jest trudna:

int

** ppnTablica;

Wystarczy dodaü po prostu kolejn gwiazdk do nazwy typu, na który ostatecznie
pokazuje nasz wska(nik.

Jak taki wska(nik ma si do dynamicznych, dwuwymiarowych tablic?… Ilustrujc nim opis
podany wczeniej, otrzymamy schemat podobny do tego:

Schemat 35. Dynamiczna tablica dwuwymiarowa jest tablic wska(ników do tablic

jednowymiarowych

Skoro wic wiemy ju*, do czego zmierzamy, pora osignü cel.
Alokacja dwywumiarowej tablicy musi odbywaü si dwuetapowo: najpierw
przygotowujemy pamiü pod tablic wska(ników do jej wierszy. Potem natomiast
przydzielamy pamiü ka*demu z tych wierszy - tak, *e w sumie otrzymujemy tyle
elementów, ile chcielimy.
Po przeáo*eniu na kod C++ algorytm wyglda w ten sposób:

// Alokacja tablicy 3 na 4

// najpierw tworzymy tablic wska(ników do kolejnych wierszy

ppnTablica =

new

int

* [

];

// nastpnie alokujemy te wiersze

for

(

unsigned

i =

; i <

; ++i)

ppnTablica[i]

new

int

[

];

Podstawy programowania

276

Przeanalizuj go dokáadnie. Zwróü uwag szczególnie na linijk:

ppnTablica[i] =

new

int

[

];

Za pomoc wyra*enia ppnTablica[i] odwoáujemy si tu do i-tego wiersza naszej
tablicy - a cilej mówic, do wska(nika na niego. Przydzielamy mu nastpnie adres
zaalokowanego fragmentu pamici, który bdzie peániá rol owego wiersza. Robimy tak
po kolei ze wszystkimi wierszami tablicy.

U*ytkowanie tak stworzonej tablicy dwuwymiarowej nie powinno nastrczaü trudnoci.
Odbywa si ono bowiem identycznie, jak w przypadku statycznych macierzy. Najczstsz
konstrukcj jest tu znowu zagnie*d*ona ptla

for

(

unsigned

i =

; i <

; ++i)

for

(

unsigned

j =

; j <

; ++j)

ppnTablica[i][j] = i - j;

Co za ze zwalnianiem tablicy? Otó* przeprowadzamy je w sposób dokáadnie przeciwny
do jej alokacji. Zaczynamy od uwolnienia poszczególnych wierszy, a nastpnie
pozbywamy si tak*e samej tablicy wska(ników do nich.
Wyglda to mniej wicej tak:

// zwalniamy wiersze

for

(

unsigned

i =

; i <

; ++i)

delete

[] ppnTablica[i];

// zwalniamy tablic wska(ników do nich

delete

[] ppnTablica;

Przedstawion tu kolejnoü nale*y zawsze bezwgldnie zachowywaü. Gdybymy
bowiem najpierw pozbyli si wska(ników do wierszy tablicy, wtedy nijak nie moglibymy
zwolniü samych wierszy! Usuwanie tablicy „od tyáu” chroni za przed tak
ewentualnoci.

Znajc technik alokacji tablicy dwuwymiarowej, mo*emy áatwo rozszerzyü j na wiksz
liczb wymiarów. Popatrzmy tylko na kod odpowiedni dla trójwymiarowej tablicy:

/* Dynamiczna tablica trójwymiarowa, 5 na 6 na 7 elementów */

// wska(nik do niej ("trzeciego stopnia"!)

int

*** p3nTablica;

/* alokacja */

// tworzymy tablic wska(ników do 5 kolejnych "páaszczyzn" tablicy

p3nTablica =

new

int

** [

];

// przydzielamy dla nich pamiü

for

(

unsigned

i =

; i <

; ++i)

{

// alokujemy tablic na wska(niki do wierszy

p3nTablica[i]

new

int

* [

];

// wreszcie, dla przydzielamy pamiü dla wáaciwych elementów

for

(

unsigned

j =

; j <

; ++j)

p3nTablica[i][j]

new

int

[

];

}

Wska(niki

277

/* u*ycie */

// wypeániamy tabelk jak treci

for

(

unsigned

i =

; i <

; ++i)

for

(

unsigned

j =

; j < 6; ++j)

for

(

unsigned

k =

; k <

; ++k)

p3nTablica[i][j][k] = i + j + k;

/* zwolnienie */

// zwalniamy kolejne "páaszczyzny"

for

(

unsigned

i =

; i <

; ++i)

{

// zaczynamy jednak od zwolnienia wierszy

for

(

unsigned

j =

; j <

; ++j)

delete

[] p3nTablica[i][j];

// usuwamy "páaszczyzn"

delete

[] p3nTablica[i];

}

// na koniec pozbywamy si wska(ników do "páaszczyzn"

delete

[] p3nTablica;

Widaü niestety, *e z ka*dym kolejnym wymiarem kod odpowiedzialny za alokacj oraz
zwalnianie tablicy staje si coraz bardziej skomplikowany. Na szczcie jednak
dynamiczne tablice o wikszej liczbie wymiarów s bardzo rzadko wykorzystywane w
praktyce.

Referencje

Naocznie przekonaáe si, *e domena zastosowa wska(ników jest niezwykle szeroka.
Je*eli nawet nie daáyby w danym programie jakich niespotykanych mo*liwoci, to na
pewno za ich pomoc mo*na poczyniü spore optymalizacje w kodzie i przyspieszyü jego
dziaáanie.

Za popraw wydajnoci trzeba jednak zapáaciü wygod: odwoáywanie si do obiektów
poprzez wska(niki wymaga bowiem ich dereferencji. Wprowadza ona nieco zamieszania
do kodu i wymaga powicenia mu wikszej uwagi. Có*, zawsze co za co, prawda?…
Otó* nieprawda :) Twórcy C++ wyposa*yli bowiem swój jzyk w mechanizm referencji,
który áczy zalety wska(ników z normaln skáadni zmiennych. Zatem i wilk jest syty, i
owca caáa.

Referencje (ang. references) to zmienne wskazujce na adresy miejsc w pamici, ale
pozwalajce u*ywaü zwyczajnej skáadni przy odwoáywaniu si do tych*e miejsc.

Mo*na je traktowaü jako pewien szczególny rodzaj wska(ników, ale stworzony dla czystej
wygody programisty i poprawy wygldu pisanego przeze kodu. Referencje s aczkolwiek
niezbdne przy przeci*aniu operatorów (o tym powiemy sobie niedáugo), jednak swoje
zastosowania mog znale(ü niemal wszdzie.
Przy takiej rekomendacji trudno nie oprzeü si chci ich poznania, nieprawda*? ;) Tym
wáanie zagadnieniem zajmiemy si wic teraz.

Podstawy programowania

278

Typy referencyjne

Podobnie jak wska(niki wprowadziáy nam pojcie typów wska(nikowych, tak i referencje
dodaj do naszego sáownika analogiczny termin typów referencyjnych.
W przeciwiestwie jednak do wska(ników, dla ka*dego normalnego typu istniej jedynie
dwa odpowiadajce mu typy referencyjne. Dlaczego tak jest, dowiesz si za chwil. Na
razie przypatrzmy si deklaracjom przykáadowych referencji.

Deklarowanie referencji

Referencje odnosz si do zmiennych, zatem najpierw przydaáoby si jak zmienn
posiadaü. Niech bdzie to co w tym rodzaju:

short

nZmienna;

Odpowiednia referencja, wskazujca na t zmienn, bdzia natomiast zadeklarowana w
ten oto sposób:

short

& nReferencja = nZmienna;

Koczcy nazw typu znak & jest wyró*nikiem, który mówi nam i kompilatorowi, *e
mamy do czynienia wáanie z referencj. Inicjalizujemy j od razu tak, a*eby wskazywaáa
na nasz zmienn nZmienna. Zauwa*my, *e nie u*ywamy do tego *adnego
dodatkowego operatora!

Posáugujc si referencj mo*liwe jest teraz zwyczajne odwoáywanie si do zmiennej, do
której si ona odnosi. Wyglda to wic bardzo zachcajco - na przykáad:

nReferencja =

;

// przypisanie wartoci zmiennej nZmienna

std::cout << nReferencja;

// wywietlenie wartoci zmiennej nZmienna

Wszystkie operacje, jakie tu wykonujemy, odbywaj si na zmiennej nZmienna, chocia*
wyglda, jakby to nReferencja byáa jej celem. Ona jednak tylko w nich poredniczy,
tak samo jak czyni to wska(niki. Referencja nie wymaga jednak skorzystania z
operatora * (zwanego notabene operatorem dereferencji) celem dostania si do miejsca
pamici, na które sama wskazuje. Ten wáanie fakt (midzy innymi) ró*ni j od
wska(nika.

Prawo staáoci referencji

Najdziwniej wyglda pewnie linijka z przypisaniem wartoci. Mimo *e po lewej stronie
znaku = stoi zmienna nReferencja, to jednak now wartoü otrzyma nie ona, lecz
nZmienna, na któr tamta pokazuje. Takie s po prostu uroki referencji i trzeba do nich
przywyknü.
No dobrze, ale jak w takim razie zmieniü adres pamici, na który pokazuje nasza
referencja?… Powiedzmy, *e zadeklarujemy sobie drug zmienn:

short

nInnaZmienna;

Chcemy mianowicie, *eby odtd nReferencja pokazywaáa wáanie na ni (a nie na
nZmienna). Jak (czy?) mo*na to uczyniü?…

Niestety, odpowied( brzmi: nijak. Raz ustalona referencja nie mo*e byü bowiem
„doczepiona” do innej zmiennej, lecz do koca pozostaje zwizana wyácznie z t
pierwsz. A zatem:

Wska(niki

279

W C++ wystpuj wyácznie staáe referencje. Po koniecznej inicjalizacji nie mog ju*
byü zmieniane.

To jest wáanie powód, dla którego istniej tylko dwa warianty typów referencyjnych. O
ile wic w przypadku wska(ników atrybut

const

mógá wystpowaü (lub nie) w dwóch

ró*nych miejscach deklaracji, o tyle dla referencji jego drugi wystp jest niejako
domylny. Nie istnieje zatem *adna „niestaáa referencja”.
Przypisanie zmiennej do referencji mo*e wic si odbywaü tylko podczas jej
inicjalizacji. Jak widzielimy, dzieje si to prawie tak samo, jak przy staáych
wska(nikach - naturalnie z wyáczeniem braku operatora &, np.:

float

fLiczba;

float

& fRef = fLiczba;

Czy fakt ten jest jak niezmiernie istotn wad referencji? miem twierdziü, *e ani
troch! Tak naprawd prawie nigdy nie u*ywa si mechanizmu referencji w odniesieniu
do zwykáych zmiennych. Ich prawdziwa u*ytecznoü ujawnia si bowiem dopiero w
poáczeniu z funkcjami.
Zobaczmy wic, dlaczego s wówczas takie wspaniaáe ;D

Referencje i funkcje

Chyba jedynym miejscem, gdzie rzeczywicie u*ywa si referencji, s nagáówki funkcji
(prototypy). Dotyczy to zarówno parametrów, jak i wartoci przez te funkcje zwracanych.
Referencje daj bowiem caákiem znaczce optymalizacje w szybkoci dziaáania kodu, i to
w zasadzie za darmo. Nie wymagaj *adnego dodatkowego wysiáku poza ich u*yciem w
miejsce zwykáych typów.
Brzmi to bardzo kuszco, zatem zobaczmy te wymienite rozwizania w akcji.

Parametry przekazywane przez referencje

Ju* przy okazji wska(ników zauwa*ylimy, *e wykorzystanie ich jako parametrów funkcji
mo*e przyspieszyü dziaáanie programu. Zamiast caáych obiektów funkcja otrzymuje
wtedy odwoáania do nich, za poprzez nie mo*e odnosiü si do faktycznych obiektów. Na
potrzeby funkcji kopiowane s wic tylko 4 bajty odwoáania, a nie czasem wiele
kilobajtów wáaciwego obiektu!
Przy tej samej okazji narzekalimy jednak, *e zastosowanie wska(ników wymaga
przeformatowania skáadni caáego kodu, w którym nale*y dodaü konieczne dereferencje i
zmieniü operatory wyáuskania. To niewielki, ale jednak dolegliwy káopot.

I oto nagle pojawia si cudowne rozwizanie :) Referencje, bo o nich rzecz jasna
mówimy, s tak*e odwoáaniami do obiektów, ale mo*liwe jest stosowanie wobec nich
zwyczajnej skáadni, bez uci*liwoci zwizanych ze wska(nikami. Czynic je parametrami
funkcji, powinnimy wic upiec dwie pieczenie na jednym ogniu, poprawiajc zarówno
osigi programu, jak i wáasne samopoczucie :D
Spójrzmy zatem jeszcze raz na funkcj Wyszukaj(), z któr spotkalimy si ju* przy
wska(nikach. Tym razem jej parametry bd jednak referencjami. Oto jak wpáynie to na
wygld kodu:

#include

int

Wyszukaj (

const

std::string& strSzukany,

const

std::string& strPrzeszukiwany)

{

// przeszukujemy nasz napis

for

(

unsigned

i =

;

i <= strPrzeszukiwany.length() - strSzukany.length(); ++i)

{

Podstawy programowania

280

// porównujemy kolejne wycinki napisu

(strPrzeszukiwany.substr(i, strSzukany.length())

== strSzukany)

je*eli wycinek zgadza si, to zwracamy jego indeks

return

}

// w razie niepowodzenia zwracamy -1

return

-1

;

}

Obecnie nie widaü tu najmniejszych oznak silenia si na jakkolwiek optymalizacj, a
mimo jest ona taka sama jak w wersji wska(nikowej. Powodem jest forma nagáówka
funkcji:

int

Wyszukaj (

const

std::string& strSzukany,

const

std::string& strPrzeszukiwany)

Oba jej parametry s tutaj referencjami do staáych napisów, a wic nie s kopiowane
w inne miejsca pamici wyácznie na potrzeby funkcji. A jednak, chocia* faktycznie
funkcja otrzymuje tylko ich adresy, mo*emy operowaü na tych parametrach zupeánie tak
samo, jakbymy dostali caáe obiekty poprzez ich wartoci. Mamy wic zarówno wygodn
skáadni, jak i dobr wydajnoü tak napisanej funkcji.

Zatrzymajmy si jeszcze przez chwil przy modyfikatorach

const

w obu parametrach

funkcji. Obydwa napisy nie w jej ciele w *aden sposób zmieniane (bo i nie powinny),
zatem logiczne jest zadeklarowanie ich jako referencji do staáych. W praktyce tylko takie
referencje stosuje si jako parametry funkcji; je*eli bowiem nale*y zwróciü jak wartoü
poprzez parametr, wtedy lepiej dla zaznaczenia tego faktu u*yü odpowiedniego
wska(nika.

Zwracanie referencji

Na podobnej zasadzie, na jakiej funkcje mog pobieraü referencje poprzez swoje
parametry, mog te* je zwracaü na zewntrz. Uzasadnienie dla tego zjawiska jest
równie* takie samo, czyli zaoszczdzenie niepotrzebnego kopiowania wartoci.

Najprotszym przykáadem mo*e byü ciekawe rozwizanie problemu metod dostpowych -
tak jak poni*ej:

class

CFoo

{

private

unsigned

m_uPole;

public

unsigned

& Pole() {

return

m_uPole; }

};

Poniewa* metoda Pole() zwraca referencj, mo*emy u*ywaü jej niemal tak samo, jak
zwyczajnej zmiennej:

CFoo Foo;
Foo.Pole() =

;

std::cout << Foo.Pole();

Oczywicie kwestia, czy takie rozwizanie jest w danym przypadku po*dane, jest mocno
indywidualna. Zawsze nale*y rozwa*yü, czy nie lepiej zastosowaü tradycyjnego wariantu
metod dostpowych - szczególnie, je*eli chcemy zachowywaü kontrol nad wartociami
przypisywanymi polom.

Wska(niki

281

Z praktycznego punktu widzenia zwracanie referencji nie jest wic zbytnio przydatn
mo*liwoci. Wspominam jednak o niej, gdy* stanie si ona niezbdna przy okazji
przeáadowywania operatorów - zagadnienia, którym zajmiemy si w jednym z przyszáych
rozdziaáów.

***

Tym drobnym wybiegniciem w przyszáoü zakoczymy nasze spotkania ze wska(nikami
na zmienne. Je*eli miaáe jakiekolwiek wtpliwoci co do u*ytecznoci tego elementu
jzyka C++, to chyba do tego momentu zostaáy one caákiem rozwiane. Najlepiej jednak
przekonasz si o przydatnoci mechanizmów wska(ników i referencji, kiedy sam bdziesz
miaá okazj korzystaü z nich w swoich wáasnych aplikacjach. Przypuszczam tak*e, *e owe
okazje nie bd wcale odosobnionymi przypadkami, ale staá praktyk programistyczn.

Oprócz wska(ników na zmienne jzyk C++ oferuje równie* inn ciekaw konstrukcj,
jak s wska(niki na funkcje. Nie od rzeczy bdzie wic zapoznanie si z nimi, co te*
pilnie uczynimy.

Wska(niki do funkcji

Mylc o tym, co jest przechowywane w pamici operacyjnej, zwykle wyobra*amy sobie
ró*ne dane programu: zmienne, tablice, struktury itp. One stanowi informacje
reprezentowane w komórkach pamici, na których aplikacja wykonuje swoje dziaáania.
Caáa pamiü operacyjna jest wic usiana danymi ka*dego z aktualnie pracujcych
programów.

Hmm… Czy aby na pewno o czym nie zapomnielimy? A co z samymi programami?! Kod
aplikacji jest przecie* pewn porcj binarnych danych, zatem i ona musi si gdzie
podziaü. Przez wikszoü czasu egzystuje wprawdzie na dysku twardym w postaci pliku
(zwykle o rozszerzeniu EXE), ale dla potrzeb wykonywania kodu jest to z pewnoci zbyt
wolne medium. Gdyby system operacyjny co rusz sigaá do pliku w czasie dziaáania
programu, wtedy na pewno wszelkie czynnoci cignáyby si niczym toffi i przyprawiaáy
zniecierpliwionego u*ytkownika o biaá gorczk. Co wic zrobiü z tym fantem?…
Rozsdnym wyjciem jest umieszczenie w pamici operacyjnej tak*e kodu dziaáajcej
aplikacji. Dostp do nich jest wówczas wystarczajco szybki, aby programy mogáy dziaáaü
w normalnym tempie i bez przeszkód wykonywaü swoje zadania. Pamiü RAM jest
przecie* stosunkowo wydajna, wielokrotnie bardziej ni* nawet najszybsze dyski twarde.

Tak wic podczas uruchamiania programu jego kod jest umieszczany wewntrz pamici
operacyjnej. Ka*dy podprogram, ka*da funkcja, a nawet ka*da instrukcja otrzymuj
wtedy swój unikalny adres, zupeánie jak zmienne. Maszynowy kod binarny jest bowiem
tak*e swoistego rodzaju danymi. Z tych danych korzysta system operacyjny (glównie
poprzez procesor), wykonujc kolejne instrukcje aplikacji. Wiedza o tym, jaka komenda
ma byü za chwil uruchomiona, jest przechowywana wáanie w postaci jej adresu - czyli
po prostu wska(nika.
Nam zwykle nie jest potrzebna a* tak dokáadna lokalizacja jakiego wycinka kodu w
naszej aplikacji, szczególnie je*eli programujemy w jzyku wysokiego poziomu, którym
jest z pewnoci C++. Trudno jednak pogardziü mo*liwoci uzyskania adresu funkcji w
programie, jeli przy pomocy tego* adresu (oraz kilku dodatkowych informacji, o czym za
chwil) mo*na ow funkcj swobodnie wywoáywaü. C++ oferuje wic mechanizm
wska(ników do funkcji, który udostpnia taki wáanie potencjaá.

Wska(nik do funkcji (ang. pointer to function) to w C++ zmienna, która przechowuje
adres, pod jakim istnieje w pamici operacyjnej dana funkcja.

Podstawy programowania

282

Wiem, *e pocztkowo mo*e byü ci trudno uwiadomiü sobie, w jaki sposób kod programu
jest reprezentowany w pamici i jak wobec tego dziaáaj wska(niki na funkcje. Dokáadnie
wyjanienie tego faktu wykracza daleko poza ramy tego rozdziaáu, kursu czy nawet
programowania w C++ jako takiego (oraz, przyznam szczerze, czciowo tak*e mojej
wiedzy :D). Dotyka to ju* bowiem niskopoziomowych aspektów dziaáania aplikacji.
Niemniej postaram si przystpnie wyjaniü przynajmniej te zagadnienia, które bd
nam potrzebne do sprawnego posáugiwania si wska(nikami do funkcji. Zanim to si
stanie, mo*esz myleü o nich jako o swoistych áczach do funkcji, podobnych w swych
zaáo*eniach do skrótów, jakie w systemie Windows mo*na tworzyü w odniesieniu do
aplikacji. Tutaj natomiast mamy do czynienia z pewnego rodzaju „skrótami” do
pojedynczych funkcji; przy ich pomocy mo*emy je bowiem wywoáywaü niemal w ten sam
sposób, jak to czynimy bezporednio.

Omawianie wska(ników do funkcji zaczniemy nieco od tyáu, czyli od bytów na które one
wskazuj - a wic od funkcji wáanie. Przypomnimy sobie, có* takiego charakteryzuje
funkcj oraz powiemy sobie, jakie jej cechy bd szczególne istotne w kontekcie
wska(ników.
Potem rzecz jasna zajmiemy si u*ywaniem wska(ników do funkcji w naszych wáasnych
programach, poczynajc od deklaracji a* po wywoáywanie funkcji za ich porednictwem.
Na koniec uwiadomimy sobie tak*e kilka zastosowa tej ciekawej konstrukcji
programistycznej.

Cechy charakterystyczne funkcji

Ró*nego rodzaju funkcji - czy to wáasnych, czy te* wbudowanych w jzyk - u*ywalimy
dotd tak czsto i w takich ilociach, *e chyba nikt nie ma najmniejszych wtpliwoci,
czym one s, do czego sáu* i jaka jest ich rola w programowaniu.
Teraz wic przypomnimy sobie jedynie te wáasnoci funkcji, które bd dla nas istotne
przy omawianiu wska(ników. Nie omieszkamy tak*e poznaü jeszcze jednego aspektu
funkcji, o którym nie mielimy okazji dotychczas mówiü. Wszystko to pomo*e nam
zrozumieü koncepcj i stosowanie wska(ników na funkcje.

Trzeba tu zaznaczyü, *e w tym momencie absolutnie nie chodzi nam o to, jakie instrukcje
mog zawieraü funkcje. Przeciwnie, nasza uwaga bdzie skoncentrowana wyácznie na
prototypie funkcji, jej „wizytówce”. Dla wska(ników na funkcje peáni on bowiem
podobne posáugi, jak typ danych dla wska(ników na zmienne. Sama zawartoü bloku
funkcji, podobnie jak wartoü zmiennej, jest ju* zupeánie jednak inn („wewntrzn”)
spraw.
Na pocztek przyjrzyjmy si skáadni prototypu (deklaracji) funkcji. Wydaje si, *e jest
ona doskonale nam znana, jednak tutaj przedstawimy jej peán wersj:

zwracany_typ [konwencja_wywoáania] nazwa_funkcji([parametry]);

Ka*demu z jej elementów przypatrzymy si natomiast w osobnym paragrafie.

Typ wartoci zwracanej przez funkcj

Wiele jzyków programowania rozró*nia dwa rodzaje podprogramów. I tak procedury
maj za zadanie wykonanie jakich czynnoci, za funkcje s przeznaczone do obliczania
pewnych wartoci. Dla obu tych rodzajów istniej zwykle odmienne rozwizania
skáadniowe, na przykáad inne sáowa kluczowe.

W C++ jest nieco inaczej: tutaj zawsze mamy do czynienia z funkcjami, gdy*
bezwgldnie konieczne jest okrelenie typu wartoci, zwracanej przez nie. Naturalnie
mo*e byü nim ka*dy typ, który mógáby równie* wystepowaü w deklaracji zmiennej: od
typów wbudowanych, poprzez wska(niki, referencje, a* do definiowanych przez
u*ytkownika typów wyliczeniowych, klas czy struktur (lecz nie tablic).

Wska(niki

283

Specjaln rol peáni tutaj typ

void

(‘pustka’), który jest synonimem ‘niczego’. Nie mo*na

wprawdzie stworzyü zmiennych nale*cych do tego typu, jednak mo*liwe jest uczynienie
go typem zwracanym przez funkcj. Taka funkcj bdzie zatem „zwracaü nic”, czyli po
prostu nic nie zwracaü; mo*na j wic nazwaü procedur.

Instrukcja czy wyra*enie

Od kwestii, czy funkcja zwraca jak wartoü czy nie, zale*y to, jak mo*emy nazwaü jej
wywoáanie: instrukcj lub te* wyra*eniem. Ró*nica pomidzy tymi dwoma elementami
jzyka programowania jest doü oczywista: instrukcja to polecenie wykonania jakich
dziaáa, za wyra*enie - obliczenia pewnej wartoci; wartoü ta jest potem
reprezentowana przez owo wyra*enie.
C++ po raz kolejny raczy nas tu niespodziank. Otó* w tym jzyku niemal wszystko
jest wyra*eniem - nawet taka wybitnie „instrukcyjna” dziaáalnoü jak choüby
przypisanie. Rzadko jednak u*ywamy jej w takim charakterze, za o wiele czciej jako
zwyká instrukcj i jest to wówczas caákowicie poprawne.

Wyra*enie mo*e byü w programowaniu u*yte jako instrukcja, natomiast instrukcja nie
mo*e byü u*yta jako wyra*enie.

Dla wyra*enia wystpujcego w roli instrukcji jest wprawdzie obliczana jego wartoü, ale
nie zostaje potem do niczego wykorzystana. To raczej typowa sytuacja i chocia* mo*e
brzmi niepokojco, wikszoü kompilatorów nigdy o niej nie ostrzega i trudno poczytywaü
to za ich beztrosk.

Pedantyczni programici stosuj jednak niecodzienny zabieg rzutowania na typ

void

dla

wartoci zwróconej przez funkcj u*yt w charakterze instrukcji. Nie jest to rzecz jasna

konieczne, ale niektórzy twierdz, i* mo*na w ten sposób unikaü nieporozumie.

Przeciwny przypadek: kiedy staramy si umieciü wywoáanie procedury (niezwracajcej
*

adnej wartoci) wewntrz normalnego wyra*enia, jest ju* w oczywisty sposób nie do

przyjcia. Takie wywoáanie nie reprezentuje bowiem *adnej wartoci, która mogáaby byü
u*yta w obliczeniach. Mo*na to równie* interpretowaü jako niezgodnoü typów, poniewa*

void

jako typ pusty jest niekompatybilny z *adnym innym typem danych.

Widzimy zatem, *e kwestia zwracania lub niezwracania przez funkcj wartoci oraz jej
rodzaju jest nierzadko bardzo wa*na.

Konwencja wywoáania

Troch trudno w to uwierzyü, ale podanie (zdawaáoby si) wszystkiego, co mo*na
powiedzieü o danej funkcji: jej parametrów, wartoci przeze zwracanej, nawet nazwy -
nie wystarczy kompilatorowi do jej poprawnego wywoáania. Bdzie on aczkolwiek
wiedziaá, co musi zrobiü, ale nikt mu nie powie, jak ma to zrobiü.

Có* to znaczy?… Celem wyjanienia porównajmy caá sytuacj do telefonowania. Gdy
mianowicie chcemy zadzwoniü pod konkretny numer telefonu, mamy wiele mo*liwych
dróg uczynienia tego. Mo*emy zwyczajnie pójü do drugiego pokoju, podnieü sáuchawk
stacjonarnego aparatu i wystukaü odpowiedni numer. Mo*emy te* siegnc po telefon
komórkowy i u*yü go, wybierajc na przykáad wáaciw pozycj z jego ksi*ki adresowej.
Teoretycznie mo*emy te* wybraü si do najbli*szej budki telefonicznej i skorzystaü z
zainstalowanego tam aparatu. Wreszcie, mo*liwe jest wykorzystanie modemu
umieszczonego w komputerze i odpowiedniego oprogramowania albo te* dowolnej formy
dostpu do globalnej sieci oraz protokoáu VoIP (Voice over Internet Protocol).
Technicznych mo*liwoci mamy wic mnóstwo i zazwyczaj wybieramy t, która jest nam
w aktualnej chwili najwygodniejsza. Zwykle te* osoba po drugiej stronie linii nie odczuwa
przy tym *adnej ró*nicy.

Podstawy programowania

284

Podobnie rzecz ma si z wywoáywaniem funkcji. Znajc jej miejsce docelowe (adres
funkcji w pamici) oraz ewentualne dane do przekazania jej w parametrach, mo*liwe jest
zastosowanie kilku dróg osignicia celu. Nazywamy je konwencjami wywoáania
funkcji.

Konwencja wywoáania (ang. calling convention) to okrelony sposób wywoáywania
funkcji, precyzujcy przede wszystkim kolejnoü przekazywania jej parametrów.

Dziwisz si zapewne, dlaczego dopiero teraz mówimy o tym aspekcie funkcji, skoro jasno
widaü, i* jest on nieodzowny dla ich dziaáania. Przyczyna jest prosta. Wszystkie funkcje,
jakie samodzielnie wpiszemy do kodu i dla których nie okrelimy konwencji wywoáania,
posiadaj domylny jej wariant, wáaciwy dla jzyka C++. Je*eli za chodzi o funkcje
biblioteczne, to ich prototypy zawarte w plikach naglówkowych zawieraj informacje o
u*ywanej konwencji. Pamitajmy, *e korzysta z nich gáównie sam kompilator, gdy* w
C++ wywoáanie funkcji wyglda skáadniowo zawsze tak samo, niezale*nie od jej
konwencji. Je*eli jednak u*ywamy funkcji do innych celów ni* tylko prostego
przywoáywania (a wic stosujemy choüby wska(niki na funkcje), wtedy wiedza o
konwencjach wywoáania staje si potrzebna tak*e i dla nas.

O czym mówi konwencja wywoáania?

Jak ju* wspomniaáem, konwencja wywoáania determinuje gáównie przekazywanie
parametrów aktualnych dla funkcji, by mogáa ona u*ywaü ich w swoim kodzie.
Obejmuje to miejsce w pamici, w którym s one tymczasowo przechowywane oraz
porzdek, w jakim s w tym miejscu kolejno umieszczane.

Podstawowym rejonem pamici operacyjnej, u*ywanym jako porednik w wywoáaniach
funkcji, jest stos. Dostp do tego obszaru odbywa si w doü osobliwy sposób, który
znajduj zreszt odzwierciedlenie w jego nazwie. Stos charakteryzuje si bowiem tym, *e
gdy poáo*ymy na nim po kolei kilka elementów, wtedy mamy bezporedni dostp jedynie
do tego ostatniego, poáo*onego najpó(niej (i najwy*ej). Je*eli za chcemy dostaü si do
obiektu znajdujcego si na samym dole, wówczas musimy zdjü po kolei wszystkie
pozostaáe elementy, umieszczone na stosie pó(niej. Czynimy to wic w odwrotnej
kolejnoci ni* nastpowaáo ich odkáadanie na stos.

Dobr przykáadem stosu mo*e byü haáda ksi*ek, pitrzca si na twoim biurku ;D

Jeli zatem wywoáujcy funkcj (ang. caller) umieci na stosie jej parametry w pewnym
porzdku (co zreszt czyni), to sama funkcja (ang. callee - wywoáywana albo routine -
podprogram) musi je pozyskaü w kolejnoci odwrotnej, aby je wáaciwie zinterpretowaü.
Obie strony korzystaj przy tym z informacji o konwencji wywoáania, lecz w opisach
„katalogowych” poszczególnych konwencji podaje si wyácznie porzdek stosowany
przez wywoáujcego, a wic tylko kolejnoü odkáadania parametrów na stos.
Kolejnoü ich podejmowania z niego jest przecie* dokáadnie odwrotna.
Nie myl jednak, *e kompilatory dokonuj jakich záo*onych permutacji parametrów
funkcji podczas ich wywoáywania. Tak naprawd istniej jedynie dwa porzdki, które
mog byü kanw dla konwencji i stosowaü si dla ka*dej funkcji bez wyjtku.
Mo*na mianowicie podawaü parametry wedle ich deklaracji w prototypie funkcji, czyli od
lewej do prawej strony. Wówczas to wywoáujcy jest w uprzywilejowanej pozycji, gdy*
u*ywa bardziej naturalnej kolejnoci; sama funkcja musi u*yü odwrotnej. Drugi wariant
to odkáadanie parametrów na stos w odwrotnej kolejnoci ni* w deklaracji funkcji; wtedy
to funkcja jest w wygodniejszej sytuacji.

Oprócz stosu do przekazywania parametrów mo*na te* u*ywaü rejestrów procesora, a
dokáadniej jego czterech rejestrów uniwersalnych. Im wicej parametrów zostanie tam
umieszczonych, tym szybsze powinno byü (przynajmniej w teorii) wywoáanie funkcji.

Wska(niki

285

Typowe konwencje wywoáania

Gdyby ka*dy programista ustalaá wáasne konwencje wywoáania funkcji (co jest
teoretycznie mo*liwe), to oczywicie natychmiast powstaáby totalny rozgardiasz w tej
materii. Koniecznoü uwzgldniania upodoba innych koderów byáaby z pewnoci
niezwykle frustrujca.

Za spraw jzyków wysokiego poziomu nie ma na szczcie a* tak wielkich problemów z
konwencjami wywoáania. Jedynie korzystajc z kodu napisanego w innym jzyku trzeba
je uwzgldniaü. W zasadzie wic zdarza si to doü czsto, ale w praktyce caáy wysiáek
wáo*ony w zgodnoü z konwencjami ogranicza si co najwy*ej do dodania
odpowiedniego sáowa kluczowego do prototypu funkcji - w miejsce, które oznaczyáem w
jego skáadni jako konwencja_wywoáania. Czsto nawet i to nie jest konieczne, jako *e
prototypy funkcji oferowanych przez przeró*ne biblioteki s umieszczane w ich plikach
nagáówkowych, za zadanie programisty-u*ytkownika ogranicza si jedynie do wáczenia
tych*e nagáówków do wáasnego kodu.

Kompilator wykonuje zatem spor czü pracy za nas. Warto jednak przynajmniej znaü te
najczciej wykorzystywane konwencje wywoáania, a nie jest ich wcale a* tak du*o.
Poni*sza lista przedstawia je wszystkie:

cdecl - skrót od C declaration (‘deklaracja C’).. Zgodnie z nazw jest to domylna
konwencja wywoáania w jzykach C i C++. W Visual C++ mo*na j jednak jawnie
okreliü poprzez sáowo kluczowe

__cdecl

. Parametry s w tej konwencji

przekazywane na stos w kolejnoci od prawej do lewej, czyli odwrotnie ni* s
zapisane w deklaracji funkcji

stdcall - skrót od Standard Call (‘standardowe wywoáanie’). Jest to konwencja
zbli*ona do cdecl, posáuguje si na przykáad tym samym porzdkiem odkáadania
parametrów na stos. To jednoczenie niepisany standard przy pisaniu kodu, który
w skompilowanej formie bdzie u*ywany przez innych. Korzysta z niego wic
chocia*by system Windows w swych funkcjach API.
W Visual C++ konwencji tej odpowiada sáowo

__stdcall

fastcall (‘szybkie wywoáanie’) jest, jak nazwa wskazuje, zorientowany na szybkoü
dziaáania. Dlatego te* w miar mo*liwoci u*ywa rejestrów procesora do
przekazywania parametrów funkcji.
Visual C++ obsáuguj t konwencj poprzez sáówko

__fastcall

pascal budzi sáuszne skojarzenia z popularnym ongi jzykiem programowania.
Konwencja ta byáa w nim wtedy intensywnie wykorzystywana, lecz dzisiaj jest ju*
przestarzaáa i coraz mniej kompilatorów (wszelkich jzyków) wspiera j

thiscall to specjalna konwencja wywoáywania metod obiektów w jzyku C++.
Funkcje wywoáywane z jej u*yciem otrzymuj dodatkowy parametr, bdcy
wska(nikiem na obiekt danej klasy

. Nie wystpuje on na licie parametrów w

deklaracji metody, ale jest dostpny poprzez sáowo kluczowe

this

. Oprócz tej

szczególnej wáaciwoci thiscall jest identyczna z stdcall.
Ze wzgldu na specyficzny cel istnienia tej konwencji, nie ma mo*liwoci
zadeklarowania zwykáej funkcji, która by jej u*ywaáa. W Visual C++ nie
odpowiada jej wic *adne sáowo kluczowe

A zatem dotychczas (niewiadomie!) u*ywalimy tylko dwóch konwencji: cdecl dla
zwykáych funkcji oraz thiscall dla metod obiektów. Kiedy zaczniemy nauk
programowania aplikacji dla Windows, wtedy ten wachlarz zostanie poszerzony. W
ka*dym przypadku skáadnia wywoáania funkcji w C++ bdzie jednak identyczna.

Jest on umieszczany w jednym z rejestrów procesora.

Podstawy programowania

286

Nazwa funkcji

To zadziwiajce, *e chyba najwa*niejsza dla programisty cecha funkcji, czyli jej nazwa,
jest niemal zupeánie nieistotna dla dziaáajcej aplikacji!… Jak ju* bowiem mówiáem,
„widzi” ona swoje funkcje wyácznie poprzez ich adresy w pamici i przy pomocy tych
adresów ewentualnie wywoáuje owe funkcje.
Mo*na dywagowaü, czy to dowód na caákowity brak skrzy*owania midzy drogami
czáowieka i maszyny, ale fakt pozostaje faktem, za jego przyczyna jest prozaicznie
pragmatyczna. Chodzi tu po prostu o wydajnoü: skoro funkcje programu s podczas
jego uruchamiania umieszczane w pamici operacyjnej (mo*na áadnie powiedzieü:
mapowane), to dlaczego system operacyjny nie miaáby u*ywaü wygenerowanych przy
okazji adresów, by w razie potrzeby rzeczone funkcje wywoáywaü? To przecie* proste i
szybkie rozwizanie, naturalne dla komputera i niewymagajce *adnego wysiáku ze
strony programisty. A zatem jest ono po prostu dobre :)

Rozterki kompilatora i linkera

Jedynie w czasie kompilacji kodu nazwy funkcji maj jakie znaczenie. Kompilator musi
bowiem zapewniü ich unikalnoü w skali caáego projektu, tj. wszystkich jego moduáów.
Nie jest to wcale proste, je*eli przypomnimy sobie o funkcjach przeci*anych, które z
zaáo*enia maj te same nazwy. Poza tym funkcje o tej samej nazwie mog te*
wystpowaü w ró*nych zakresach: jedna mo*e byü na przykáad metod jakiej klasy, za
druga zwyczajn funkcj globaln.

Kompilator rozwizuje te problemy, stosujc tak zwane dekorowanie nazw.
Wykorzystuje po prostu dodatkowe informacje o funkcji (jej prototyp oraz zakres, w
którym zostaáa zadeklarowana), by wygenerowaü jej niepowtarzaln, wewntrzn nazw.
Zawiera ona wiele ró*nych dziwnych znaków w rodzaju @, ^, ! czy _, dlatego wáanie jest
okrelana jako nazwa dekorowana.
Wywoáania z u*yciem takich nazw s umieszczane w skompilowanych moduáach. Dziki
temu linker mo*e bez przeszkód poáczyü je wszystkie w jeden plik wykonywalny caáego
programu.

Parametry funkcji

Ogromna wikszoü funkcji nie mo*e obyü si bez dodatkowych danych, przekazywanych
im przy wywoáywaniu. Pierwsze strukturalne jzyki programowania nie oferowaáy
*

adnego wspomagania w tym zakresie i skazywaáy na korzystanie wyácznie ze

zmiennych globalnych. Bardziej nowoczesne produkty pozwalaj jednak na deklaracj
parametrów funkcji, co te* niejednokrotnie czynimy w praktyce.

Aby wywoáaü funkcj z parametrami, kompilator musi znaü ich liczb oraz typ ka*dego z
nich. Informacje te podajemy w prototypie funkcji, za w jej kodzie zwykle nadajemy
tak*e nazwy poszczególnym parametrom, by móc z nich pó(niej korzystaü.
Parametry peáni rol zmiennych lokalnych w bloku funkcji - z t jednak ró*nic, *e ich
pocztkowe wartoci pochodz z zewntrz, od kodu wywoáujcego funkcj. Na tym
wszak*e kocz si wszelkie odstpstwa, poniewa* parametrów mo*emy u*ywaü
identycznie, jak gdyby byáo one zwykáymi zmiennymi odpowiednich typów. Po
zakoczeniu wykonywania funkcji s one niszczone, nie pozostawiajc *adnego ladu po
ewentualnych operacjach, które mogáy byü na nich dokonywane kodzie funkcji.
Wnioskujemy std, *e:

Parametry funkcji s w C++ przekazywane przez wartoci.

Reguáa ta dotyczy wszystkich typów parametrów, mimo *e w przypadku wska(ników
oraz referencji jest ona pozornie áamania. To jednak tylko záudzenie. W rzeczywistoci
tak*e i tutaj do funkcji s przekazywane wyácznie wartoci - tyle tylko, *e owymi

Wska(niki

287

wartociami s tu adresy odpowiednich komórek w pamici. Za ich porednictwem
mo*emy wic uzyskaü dostp do rzeczonych komórek, zawierajcych na przykáad jakie
zmienne. Gdy dodatkowo korzystamy z referencji, wtedy nie wymaga to nawet specjalnej
skáadni. Trzeba byü jednak wiadomym, *e zjawiska te dotycz samej natury wska(ników
czy te* referencji, nie za parametrów funkcji! Dla nich bowiem zawsze obowizuje
przytoczona wy*ej zasada przekazywania poprzez wartoü.

U*ywanie wska(ników do funkcji

Przypomnielimy sobie i uzupeánilimy wszystkie niezbdne wiadomoci funkcjach,
konieczne do poznania i stosowania wska(ników na nie. Teraz wic mo*emy ju* przejü
do wáaciwej czci tematu.

Typy wska(ników do funkcji

Jakkolwiek wska(niki s przede wszystkim adresami miejsc w pamici operacyjnej,
niemal wszystkie jzyki programowania oraz ich kompilatory wprowadzaj pewne
dodatkowe informacje, zwizane ze wska(nikami. Chodzi tu gáównie o typ wska(nika.
W przypadku wska(ników na zmienne byá on pochodn typu zmiennej, na któr dany
wska(nik pokazywaá. Podobne pojcie istnieje tak*e dla wska(ników do funkcji - w tym
wypadku mo*emy wic mówiü o typie funkcji, na które wskazuje okrelony wska(nik.

Wáasnoci wyró*niajce funkcj

Co jednak mamy rozumieü pod pojciem „typ funkcji”? W jaki sposób funkcja mo*e w
ogóle byü zakwalifikowana do jakiego rodzaju?…

W odpowiedzi mo*e nam znowu pomóc analogia do zmiennych. Otó* typ zmiennej
okrelamy w momencie jej deklaracji - jest nim w zasadzie caáa ta deklaracja z
wyáczeniem nazwy. Okrela ona wszystkie cechy deklarowanej zmiennej, ze
szczególnym uwzgldnieniem rodzaju informacji, jakie bdzie ona przechowywaü.
Typu funkcji mo*emy zatem równie* szukaü w jej deklaracji, czyli prototypie. Kiedy
bowiem wyáczymy z niego nazw funkcji, wtedy pozostaáe skáadniki wyznacz nam jej
typ. Bd to wic kolejno:

typ wartoci zwracanej przez funkcj

konwencja wywoáania funkcji

parametry, które funkcja przyjmuje

Wraz z adresem danej funkcji stanowi to wystarczajcy zbiór informacji dla kompilatora,
na podstawie których mo*e on dan funkcj wywoáaü.

Typ wska(nika do funkcji

Posiadajc wyliczone wy*ej wiadomoci na temat funkcji, mo*emy ju* bez problemu
zadeklarowaü wáaciwy wska(nik na ni. Typ tego wska(nika bdzie wic oparty na typie
funkcji - to samo zjawisko miaáo miejsce tak*e dla zmiennych.

Typ wska(nika na funkcj okrela typ zwracanej wartoci, konwencj wywoáania oraz
list parametrów funkcji, na które wska(nik mo*e pokazywaü i które mog byü za jego
porednictwem wywoáywane.

Wiedzc to, mo*emy przystpiü do poznania sposóbu oraz skáadni, poprzez które jzyk
C++ realizuje mechanizm wska(ników do funkcji.

Podstawy programowania

288

Wska(niki do funkcji w C++

Deklarujc wska(nik do funkcji, musimy podaü jego typ, czyli te trzy cechy funkcji, o
których ju* kilka razy mówiáem. Jednoczenie kompilator powinien wiedzieü, *e ma do
czynienia ze wska(nikiem, a nie z funkcj jako tak. Oba te wymagania skutkuj
specjaln skáadni deklaracji wska(ników na funkcje w C++.

Zacznijmy zatem od najprostszego przykáadu. Oto deklaracja wska(nika do funkcji, która
nie przyjmuje *adnych parametrów i nie zwraca te* *adnego rezultatu

void

(*pfnWskaznik)();

Jestemy teraz wáadni u*yü tego wska(nika i wywoáaü za jego porednictwem funkcj o
odpowiednim nagáówku (czyli nic niebiorc oraz nic niezwracajc). Mo*e to wygldaü
chocia*by tak:

#include

// funkcja, któr bdziemy wywoáywaü

void

Funkcja()

{
std::cout

"Zostalam wywolana!"

;

}

void

main()

{

// deklaracja wska(nika na powy*sz funkcj

void

(*pfnWskaznik)();

// przypisanie funkcji do wska(nika

pfnWskaznik = &Funkcja;

wywoáanie funkcji poprzez ten wska(nik

(*pfnWskaznik)();
}

Ponownie, tak samo jak w przypadku wska(ników na zmienne, moglibymy wywoáaü
nasz funkcj bezporednio. Pamitasz jednak*e o korzyciach, jakie daje wykorzystanie
wska(ników - wikszoü z nich dotyczy tak*e wska(ników do funkcji. Ich u*ycie jest wic
czsto bardzo przydatne.

Omówmy zatem po kolei wszystkie aspekty wykorzystania wska(ników do funkcji w C++.

Od funkcji do wska(nika na ni

Deklaracja wska(nika do funkcji jest w C++ doü nietypow czynnoci. Nie przypomina
bowiem znanej nam doskonale deklaracji w postaci:

typ_zmiennej nazwa_zmiennej;

Zamiast tego nazwa wska(nika jest niejako wtrcona w typ funkcji, co w pierwszej
chwili mo*e byü nieco mylce. àatwo jednak mo*na zrozumieü tak form deklaracji,
je*eli porównamy j z prototypem funkcji, np.:

float

Funkcja(

int

);

Posiada te* domyln w C++ konwencj wywoáania, czyli cdecl. Pó(niej zobaczymy przykáady wska(ników do

funkcji, wykorzystujcych inne konwencje.

Wska(niki

289

Otó* odpowiadajcy mu wska(nik, który mógáby pokazywaü na zadeklarowan wy*ej
funkcj Funkcja(), zostanie wprowadzony do kodu w ten sposób:

float

(*pfnWskaznik)(

int

);

Nietrudno zauwa*yü ró*nic: zamiast nazwy funkcji, czyli Funkcja, mamy tutaj fraz
(*pfnWskaznik), gdzie pfnWskaznik jest oczywicie nazw zadeklarowanego wáanie
wska(nika. Mo*e on pokazywaü na funkcje przyjmujce jeden parametr typu

int

oraz

zwracajce wynik w postaci liczby typu

float

Ogólnie zatem, dla ka*dej funkcji o tak wygldajcym prototypie:

zwracany_typ nazwa_funkcji([parametry]);

deklaracja odpowiadajcego jej wska(nika jest bardzo podobna:

zwracany_typ (*nazwa_wska(nika)([parametry]);

Ogranicza si wic do niemal mechanicznej zmiany cile okrelonego fragmentu kodu.

Deklaracja wska(nika na funkcj o domylnej konwencji wywoáania wyglda tak, jak jej
prototyp, w którym nazwa_funkcji zostaáa zastpiona przez (*nazwa_wska(nika).

Ta prosta zasada sprawdza si w 99 procentach przypadków i bdziesz z niej stale
korzystaá we wszystkich programach wykorzystujcych mechanizm wska(ników do
funkcji.

Trzeba jeszcze podkreliü znaczenie nawiasów w deklaracji wska(ników do funkcji. Maj
one tutaj niebagateln rol skáadniow, gdy* ich brak caákowicie zmienia sens caáej
deklaracji. Gdybymy wic opucili je:

void

*pfnWskaznik();

// a co to jest?

caáa instrukcja zostaáaby zinterpretowana jako:

void

* pfnWskaznik();

// to prototyp funkcji, a nie wska(nik na ni!

i zamiast wska(nika do funkcji otrzymalibymy funkcj zwracajc wska(nik. Jest to
oczywicie caákowicie niezgodne z nasz intencj.

Pamitaj zatem o poprawnym umieszczaniu nawiasów w deklaracjach wska(ników do
funkcji.

Specjalna konwencja

Opisanego powy*ej sposobu tworzenia deklaracji nie mo*na niestety u*yü do wska(ników
do funkcji, które stosuj inn konwencj wywoáania ni* domylna (czyli cdecl) i zawieraj
odpowiednie sáowo kluczowe w swoim naglówku czy te* prototypie. W Visual C++ tymi
sáowami s

__cdecl

__stdcall

oraz

__fastcall

Przykáad funkcji podpadajcej pod te warunki mo*e byü nastpujcy:

float

__fastcall

Dodaj(

float

fA,

float

fB) {

return

fA + fB; }

Dodatkowe sáowo midzy zwracanym_typem oraz nazw_funkcji caákowicie psuje nam
schemat deklaracji wska(ników. Wynik jego zastosowania zostaáby bowiem odrzucony
przez kompilator:

Podstawy programowania

290

float

__fastcall

(*pfnWskaznik)(

float

);

// BàD!

Dzieje si tak, poniewa* gdy widzi on najpierw nazw typu (

float

), a potem specyfikator

konwencji wywoáania (

__fastcall

), bezdyskusyjne interpretuje caá linijk jako

deklaracj funkcji. Nastpujc potem niespodziewan sekwencj (*pfnWskaznik)
traktuje wic jako bád skáadniowy.

By go uniknü, musimy rozcignü nawiasy, w których umieszczamy nazw wska(nika
do funkcji i „wziü pod ich skrzydáa” tak*e okrelenie konwencji wywoáania. Dziki temu
kompilator napotka otwierajcy nawias zaraz po nazwie zwracanego typu (

float

) i

zinterpretuje caáoü jako deklaracj wska(nika do funkcji. Wyglda ona tak:

float

(

__fastcall

*pfnWskaznik)(

float

);

// OK

Ten, zdawaáoby si, szczegóá mo*e niekiedy stanü oci w gardle w czasie kompilacji
programu. Wypadaáoby wic o nim pamitaü.

Skáadnia deklaracji wska(nika do funkcji

Obecnie mo*emy ju* zobaczyü ogóln postaü deklaracji wska(nika do funkcji. Je*eli
uwa*nie przestudiowaáe poprzednie akapity, to nie bdzie on dla ciebie *adn
niespodziank. Przedstawia si za nastpujco:

zwracany_typ ([konwencja_wywoáania] *nazwa_wska(nika)([parametry]);

Pasujcy do niego prototyp funkcji wyglda natomiast w ten sposób:

zwracany_typ [konwencja_wywoáania] nazwa_funkcji([parametry]);

Z obu tych wzorców widaü, *e deklaracja wska(nika do funkcji na podstawie jej prototypu
oznacza wykonanie jedynie trzech prostych kroków:

zamiany nazwy_funkcji na nazw_wska(nika

dodania * (gwiazdki) przed nazw_wska(nika

ujcia w par nawiasów ewentualn konwencj_wywoáania oraz nazw_wska(nika

Nie jest to wic tak trudna operacja, jak si niekiedy powszechnie sdzi.

Wska(niki do funkcji w akcji

Zadeklarowanie wska(nika to naturalnie tylko pocztek jego wykorzystania w programie.
Aby byá on u*yteczny, powinnimy przypisaü mu adres jakiej funkcji i skorzystaü z niego
celem wywoáania tej*e funkcji. Przypatrzmy si bli*ej obu tym czynnociom.

W tym celu zdefiniujmy sobie nastpujc funkcj:

int

PobierzLiczbe()

{

int

nLiczba;

std::cout

"Podaj liczbe: "

;

std::cin >> nLiczba;

return

nLiczba;

}

Wáaciwy wska(nik, mogcy pokazywaü na t funkcj, deklarujemy w ten oto (teraz ju*,
mam nadziej, oczywisty) sposób:

Wska(niki

291

int

(*pfnWskaznik)();

Jak ka*dy wska(nik, zaraz po zadeklarowaniu nie pokazuje on na nic konkretnego - w
tym przypadku na *adn konkretn funkcj. Musimy dopiero przypisaü mu adres naszej
przygotowanej funkcji PobierzLiczbe(). Czynimy to wic w nastpujcej zaraz linijce
kodu:

pfnWskaznik = &PobierzLiczbe;

Zwróümy uwag, *e nazwa funkcji PobierzLiczbe() wystpuje tutaj bez, wydawaáoby
si - nieodácznych, nawiasów okrgáych. Ich pojawienie si oznaczaáoby bowiem
wywoáanie tej funkcji, a my przecie* tego nie chcemy (przynajmniej na razie).
Pragniemy tylko pobraü jej adres w pamici, by móc jednoczenie przypisaü go do
swojego wska(nika. Wykorzystujemy do tego znany ju* operator &.

Ale… niespodzianka! Ów operator tak naprawd nie jest konieczny. Ten sam efekt
osigniemy równie* i bez niego:

pfnWskaznik = PobierzLiczbe;

Po prostu ju* sam brak nawiasów okrgáych (), wyró*niajcych wywoáanie funkcji, jest
wystarczajca wskazówk mówic kompilatorowi, i* chcemy pobraü adres funkcji o
danej nazwie, nie za - wywoáywaü j. Dodatkowy operator, chocia* dozwolony, nie jest
wic niezbdny - wystarczy sama nazwa funkcji.
Czy nie mamy w zwizku z tym uczucia deja vu? Identyczn sytuacj mielimy przecie*
przy tablicach i wska(nikach na nie. A zatem zasada, któr tam poznalimy, w
poprawionej formie stosuje si równie* do funkcji:

Nazwa funkcji jest tak*e wska(nikiem do niej.

Nie musimy wic korzystaü z operatora &, by pobraü adres funkcji.

W tym miejscu mamy ju* wska(nik pfnWskaznik pokazujcy na nasz funkcj
PobierzLiczbe(). Ostatnim aktem bdzie wywoáanie jej za porednictwem tego*
wska(nika, co czynimy poni*szym wierszem kodu:

std::cout << (*pfnWskaznik)();

Liczb otrzyman z funkcji wypisujemy na ekranie, ale najpierw wywoáujemy sam
funkcj, korzystajc midzy innymi z nastpnego znajomego operatora - dereferencji,
czyli *.
Po raz kolejny jednak nie jest to niezbdne! Wywoáanie funkcji przy pomocy wska(nika
mo*na z równym powodzeniem zapisaü te* w takiej formie:

std::cout << pfnWskaznik();

Jest to druga konsekwencja faktu, i* funkcja jest reprezentowana w kodzie poprzez swój
wska(nik. Taki sam fenomen obserwowalimy i dla tablic.

Przykáad wykorzystania wska(ników do funkcji

Wska(niki do funkcji umo*liwiaj wykonywanie ogólnych operacji przy u*yciu funkcji,
których implementacja nie musi byü im znana. Wa*ne jest, aby miaáy one nagáówek
zgodny z typem wska(nika.

Prawie podrcznikowym przykáadem mo*e byü tu poszukiwanie miejsc zerowych funkcji
matematycznej. Procedura takiego poszukiwania jest zawsze identyczna, równie* same

Podstawy programowania

292

funkcje maj nieodmiennie t sam charakterystyk (pobieraj liczb rzeczywist i tak
te* liczb zwracaj w wyniku). Mo*emy wic zaimplementowaü odpowiedni algorytm
(tutaj jest to algorytm bisekcji

) w sposób ogólny - posáugujc si wska(nikami do

funkcji.

Przykáadowy program wykorzystujcy t technik mo*e przedstawiaü si nastpujco:

// Zeros - szukanie miejsc zerowych funkcji

// granica toleracji

const

double

EPSILON =

0.0001

;

// rozpietoü badanego przedziaáu

const

double

PRZEDZIAL =

100

;

// wspóáczynniki funkcji f(x) = k * log_a(x - p) + q

double

g_fK, g_fA, g_fP, g_fQ;

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

// badana funkcja

double

x) {

return

g_fK * (log(x - g_fP) / log(g_fA)) + g_fQ; }

// algorytm szukajcy miejsca zerowego danej funkcji w danym przedziale

bool

SzukajMiejscaZerowego(

double

fX1,

double

fX2,

// przedziaá

double

(*pfnF)(

double

// funkcja

double

* pfZero)

// wynik

{

// najpierw badamy koce podanego przedziaáu

(fabs(pfnF(fX1)) < EPSILON)

{

*pfZero = fX1;

return

true

;

}

else

(fabs(pfnF(fX2)) < EPSILON)

{

*pfZero = fX2;

return

true

;

}

// dalej sprawdzamy, czy funkcja na kocach obu przedziaáów

// przyjmuje wartoci ró*nych znaków

je*eli nie, to nie ma miejsc zerowych

((pfnF(fX1)) * (pfnF(fX2)) >

)

return

false

;

nastpnie dzielimy przedziaá na póá i sprawdzamy, czy w ten sposób

// nie otrzymalimy pierwiastka

double

fXp = (fX1 + fX2) /

;

(fabs(pfnF(fXp)) < EPSILON)

{

*pfZero = fXp;

return

true

;

}

jeli otrzymany przedziaá jest wystarczajco maáy, to rozwizaniem

// jest jego punkt rodkowy

(fabs(fX2 - fX1) < EPSILON)

Oprócz niego popularna jest równie* metoda Newtona, ale wymaga ona znajomoci równie* pierwszej

pochodnej funkcji.

Wska(niki

293

{

*pfZero = fXp;

return

true

;

}

// jezeli nadal nic z tego, to wybieramy t poáówk przedziaáu,

// w której zmienia si znak funkcji

((pfnF(fX1)) * (pfnF(fXp)) <

)

fX2 = fXp;

else

fX1 = fXp;

// przeszukujemy ten przedziaá tym samym algorytmem

return

SzukajMiejscaZerowego(fX1, fX2, pfnF, pfZero);

}

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

// funkcja main()

void

main()

{

// (pomijam pobranie wspóáczynników k, a, p i q dla funkcji)

/* znalezienie i wywietlenie miejsca zerowego */

// zmienna na owo miejsce

double

fZero;

// szukamy miejsca i je wywietlamy

std::cout << std::endl;

(SzukajMiejscaZerowego(g_fP > -PRZEDZIAL ? g_fP : -PRZEDZIAL,

PRZEDZIAL, f, &fZero))

std::cout

"f(x) = 0 <=> x = "

<< fZero << std::endl;

else

std::cout

"Nie znaleziono miejsca zerowego."

<< std::endl;

// czekamy na dowolny klawisz

getch();
}

Aplikacja ta wyszukuje miejsca zerowe funkcji okrelonej wzorem:

( )

log (

)

f x

Najpierw zadaje wic u*ytkownikowi pytania co do wartoci wspóáczynników k, a, p i q w
tym równaniu, a nastpnie pogr* si w obliczeniach, by ostatecznie wywietliü wynik.

Niniejszy program jest przykáadem zastosowania wska(ników na funkcje, a nie
rozwizywania równa. Jeli chcemy wyliczyü miejsce zerowe powy*szej funkcji, to
znacznie lepiej bdzie po prostu przeksztaáciü j, wyznaczajc x:

exp

Podstawy programowania

294

Screen 38. Program poszukujcy miejsc zerowych funkcji

Oczywicie w niniejszym programie najbardziej interesujca bdzie dla nas funkcja
SzukajMiejscaZerowego() - gáównie dlatego, *e wykorzystany w niej zostaá mechanizm
wska(ników na funkcje. Ewentualnie mo*esz te* zainteresowaü si samym algorytmem;
jego dziaáanie caákiem dobrze opisuj obfite komentarze :)

Gdzie jest wic ów sáawetny wska(nik do funkcji?… Znale(ü go mo*emy w nagáówku
SzukajMiejscaZerowego():

bool

SzukajMiejscaZerowego(

double

fX1,

double

fX2,

double

(*pfnF)(

double

* pfZero)

To nie pomyáka - wska(nik do funkcji (biorcej jeden parametr

double

i zwracajcej

tak*e typ

double

) jest tutaj argumentem innej funkcji. Nie ma ku temu *adnych

przeciwwskaza, mo*e poza doü dziwnym wygldem nagáówka takiej funkcji. W naszym
przypadku, gdzie funkcja jest swego rodzaju „danymi”, na ktorych wykonujemy operacje
(szukanie miejsca zerowego), takie zastosowanie wska(nika do funkcji jest jak
najbardziej uzasadnione.
Pierwsze dwa parametry funkcji poszukujcej s natomiast liczbami okrelajcymi
przedziaá poszukiwa pierwiastka. Ostatni parametr to z kolei wska(nik na zmienn typu

double

, poprzez któr zwrócony zostanie ewentualny wynik. Ewentualny, gdy* o

powodzeniu lub niepowodzeniu zadania informuje „regularny” rezultat funkcji, bdcy
typu

bool

Nasz funkcj szukajc wywoáujemy w programie w nastpujcy sposób:

double

fZero;

(SzukajMiejscaZerowego(g_fP > -PRZEDZIAL ? g_fP : -PRZEDZIAL,

PRZEDZIAL, f, &fZero))

std::cout

"f(x) = 0 <=> x = "

<< fZero << std::endl;

else

std::cout

"Nie znaleziono miejsca zerowego."

<< std::endl;

Przekazujemy jej tutaj a* dwa wska(niki jako ostatnie parametry. Trzeci to, jak wiemy,
wska(nik na funkcj - w tej roli wystpuje tutaj adres funkcji f(), któr badamy w
poszukiwaniu miejsc zerowych. Aby przekazaü jej adres, piszemy po prostu jej nazw bez
nawiasów okrgáych - tak jak si tego nauczylimy niedawno.
Czwarty parametr to z kolei zwykáy wska(nik na zmienn typu

double

i do tej roli

wystawiamy adres specjalnie przygotowanej zmiennej. Po zakoczonej powodzeniem
operacji poszukiwania wywietlamy jej wartoü poprzez strumie wyjcia.
Je*eli za chodzi o dwa pierwsze parametry, to okrelaj one obszar poszukiwa,
wyznaczony gáównie poprzez staá PRZEDZIAL. Dolna granica musi byü dodatkowo

Wska(niki

295

„przycita” z dziedzin funkcji - std te* operator warunkowy ?: i porównanie granicy
przedziaáu ze wspóáczynnikiem p.

Powiedzmy sobie jeszcze wyra(nie, jaka jest praktyczna korzyü z zastosowania
wska(ników do funkcji w tym programie, bo mo*e nie jest ona zbytnio widoczna. Otó*
majc wpisany algorytm poszukiwa miejsca zerowego w ogólnej wersji, dziaáajcy na
wska(nikach do funkcji zamiast bezporednio na funkcjach, mo*emy stosowaü go do tylu
ró*nych funkcji, ile tylko sobie za*yczymy. Nie wymaga to wicej wysiáku ni* jedynie
zdefiniowania nowej funkcji do zbadania i przekazania wska(nika do niej jako parametru
do SzukajMiejscaZerowego(). Uzyskujemy w ten sposób wiksz elastycznoü
programu.

Zastosowania

Poprawa elastycznoci nie jest jednak jedynym, ani nawet najwa*niejszym
zastosowaniem wska(ników do funkcji. Tak naprawd stosuje si je glównie w technice
programistycznej znanej jako funkcje zwrotne (ang. callback functions).

Doü powiedzieü, *e opieraj si na niej wszystkie nowoczesne systemy operacyjne, z
Windows na czele. Umo*liwia ona bowiem informowanie programów o zdarzeniach
zachodzcych w systemie (wywoáanych na przykáad przez u*ytkownika, jak kliknicie
myszk) i odpowiedniego reagowania na nie. Obecnie jest to najczstsza forma pisania
aplikacji, zwana programowaniem sterowanym zdarzeniami. Kiedy rozpoczniemy
tworzenie aplikacji dla Windows, tak*e bdziemy z niej nieustannie korzystaü.

***

I tak zakoczylimy nasze spotkanie ze wska(nikami do funkcji. Nie s one mo*e tak
czsto wykorzystywane i przydatne jak wska(niki na zmienne, ale, jak mogáe
przeczytaü, jeszcze wiele razy usáyszysz o nich i wykorzystasz je w przyszáoci. Warto
wic byáo dobrze poznaü ich skáadni (fakt, jest nieco zagmatwana) oraz sposoby u*ycia.

Podsumowanie

Wska(niki s czsto uwa*ane za jedn z natrudniejszych koncepcji programistycznych w
ogóle. Wielu caákiem dobrych koderów ma niekiedy wiksze lub mniejsze káopoty w ich
stosowaniu.
Celowo nie wspomniaáem o tych opiniach, aby mógá najpierw samodzielnie przekonaü si
o tym, czy zagadnienie to jest faktycznie takie skomplikowane. Doáo*yáem przy tym
wszelkich stara, by uczyniü je chocia* troch prostszym do zrozumienia. Jednoczenie
chciaáem jednak, aby zawarty tu opis wska(ników byá jak najbardziej dokáadny i
szczegóáowy. Wiem, *e pogodzenie tych dwóch d*e jest prawie niemo*liwe, ale mam
nadziej, *e wypracowaáem w tym rozdziale w miar rozsdny kompromis.

Zaczáem wic od przedstawienia garci przydatnych informacji na temat samej pamici
operacyjnej komputera. Podejrzewam, *e wikszoü czytelników nawet i bez tego byáa
wystarczajco obeznana z tematem, ale przypomnie i uzupeánie nigdy doü :) Przy
okazji wprowadzilimy sobie samo pojcie wska(nika.
Dalej zajlimy si wska(nikami na zmienne, ich deklarowaniem i wykorzystaniem: do
wspomagania pracy z tablicami, przekazywania parametrów do funkcji czy wreszcie
dynamicznej alokacji pamici. Poznalimy te* referencje.
Podrozdziaá o wska(nikach na funkcje skáadaá si natomiast z poszerzenia wiadomoci o
samych funkcjach oraz wyczerpujcego opisu stosowania wska(ników na nie.

Podstawy programowania

296

Nieniejszy rozdziaá jest jednoczenie ostatnim z czci 1, stanowicej podstawowy kurs
C++. Po nim przejdziemy (wreszcie ;D) do bardziej zaawansowanych zagadnie jzyka,
Biblioteki Standardowej, a pó(niej Windows API i DirectX, a wreszcie do programowania
gier.
A zatem pierwszy du*y krok ju* za nami, lecz nadal szykujemy si do wielkiego skoku :)

Pytania i zadania

Tradycji musi staü si zadoü: oto wie*a porcja pyta dotyczcych treci tego rozdziaáu
oraz üwicze do samodzielnego rozwizania.

Pytania

Jakie s trzy rodzaje pamici wykorzystywanej przez komputer?

Na czym polega páaski model adresowania pamici operacyjnej?

Czym jest wska(nik?

Co to jest stos i sterta?

W jaki sposób deklarujemy w C++ wska(niki na zmienne?

Jak dziaáaj operatory pobrania adresu i dereferencji?

Czym rózni si wska(nik typu

void

* od innych?

Dlaczego áacuchy znaków w stylu C nazywamy napisami zakoczonymi zerem?

Dlaczego u*ywanie wska(ników lub referencji jako parametrów funkcji mo*e
poprawiü wydajnoü programu?

10.

W jaki sposób dynamicznie alokujemy zmienne, a w jaki tablice?

11.

Co to jest wyciek pamici?

12.

Czym ró*ni si referencje od wska(ników na zmienne?

13.

Jakie podstawowe konwencje wywoáywania funkcji s obecnie w u*yciu?

14.

(Trudne) Czy funkcja mo*e nie u*ywaü *adnej konwencji wywoáania?

15.

Jakie s trzy cechy wyznaczajce typ funkcji i jednoczenie typ wska(nika na ni?

16.

Jak zadeklarowaü wska(nik do funkcji o znanym prototypie?

wiczenia

Przejrzyj przykáadowe kody z poprzednich rozdziaáów i znajd( instrukcje,
wykorzystujce wska(niki lub operatory wska(nikowe.

Zmodyfikuj nieco metod ZmienRozmiar() klasy CIntArray. Niech pozwala ona
tak*e na zmniejszenie rozmiaru tablicy.

Spróbuj napisaü podobn klas dla tablicy dwuwymiarowej.
(Trudne) Niech przechowuje ona elementy w cigáym obszarze pamici - tak, jak
robi to kompilator ze statycznymi tablicami dwuwymiarowymi.

Zadeklaruj wska(nik do funkcji:

pobierajcej jeden parametr typu

int

i zwracajcej wynik typu

float

biorcej dwa parametry typu

double

i zwracajcej áacuch std::string

pobierajcej trzy parametry: jeden typu

int

, drugi typu

__int64

, a trzeci

typu std::string i zwracajcej wska(nik na typ

int

(Trudniejsze) przyjmujcej jako parametr picioelementow tablic liczb
typu

unsigned

i nic niezwracajc

(Trudne) zwracajcej wartoü typu

float

i przyjmujcej jako parametr

wska(nik do funkcji biorcej dwa parametry typu

int

i nic niezwracajcej

(Trudne) pobierajcej tablic picioelementow typu

short

i zwracajcej

jedn liczb typu

int

(Bardzo trudne) biorcej dwa parametry: jeden typu

char

, a drugi typu

int

, i zwracajcej tablic 10 elementów typu

double

Wskazówka: to nie tylko trudne, ale i podchwytliwe :)

Wska(niki

297

(Ekstremalne) przyjmujcej jeden parametr typu std::string oraz
zwracajcej w wyniku wska(nik do funkcji przyjmujcej dwa parametry
typu

float

i zwracajcej wynik typu

bool

Okrel typy parametrów oraz typ wartoci zwracanej przez funkcje, na które mo*e
pokazywaü wska(nik o takiej deklaracji:

int

(*pfnWskaznik)(

int

);

float

* (*pfnWskaznik)(

const

std::string&);

bool

(*pfnWskaznik)(

void

const

int

**,

char

);

const

unsigned

const

(*pfnWskaznik)(

void

);

(Trudne)

void

(*pfnWskaznik)(

int

(*)(

bool

const

char

*);

(Trudne)

int

(*pfnWskaznik)(

char

[

], tm&);

(Bardzo trudne)

float

(*pfnWskaznik(

short

long

bool

))(

int

);