Wskaźniki

Ogromną  zaletą  C++  i  bardzo  potężnym  narzędziem  jest  możliwość 
bezpośredniego manipulowania zawartością pamięci za pomocą wskaźników. 
Należy  jednak  pamiętać,  że  wskaźniki  są  bardzo  często  przyczyną  dużego 
zamieszania w programach w C++.

Wskaźnik jest zmienną przechowującą adres w pamięci.

Pamięć  jest  miejscem  przechowywania  wartości.  Pamięć  dzieli  się  na 
sekwencyjnie ułożone komórki. Każda komórka ma swój adres.
Każda zmienna, każdego typu umieszczona jest pod odrębnym adresem. 

każda komórka = 1 bajt
zmienna nWiek typu unsigned long 
= 4 bajty = 32 bity 
nazwa zmiennej nWiek wskazuje 
na pierwszy bajt 
adres zmiennej nWiek to 102

nWiek

100 101 102 103104 105106 107108109110111

        
0101

1111010
1

0011000
1

1011000
0

0101

Pamięć  jest  różnie  adresowana,  w  zależności  od  typu  komputera.  Zazwyczaj 
programista nie musi wiedzieć jaki jest szczegółowy adres danej zmiennej, od 
tego  jest  kompilator.  Jeśli  jednak  chcielibyście  się  bliżej  z  tym  zapoznać, 
trzeba wykorzystać operator adresu ( & ) . 

Przykład

shortVar

longVar

sVar

0101

0000

5

ff90

ff81

ff82

ff83

ff84

ff85

ff86

ff87

ff88

ff8a ff8c

ff8d ff8f

ff8e

ff8b

ff89

1111

1111

0000

1111

1111

0000

0000

1000

- 65535

 65535

shortVar

longVar

sVar

0101

0000

5

ff90

ff81

ff82

ff83

ff84

ff85

ff86

ff87

ff88

ff8a ff8c

ff8d ff8f

ff8e

ff8b

ff89

1111

1111

0000

1111

1111

0000

0000

1000

- 65535

 65535

Przypisywanie adresu do wskaźnika

Każda  zmienna  ma  swój  adres.  Nawet  nie  znając  konkretnego  adresu 
zmiennej można go przypisać do wskaźnika.
Przykład
Załóżmy,  że  mamy  zmienną  całkowitą  typu  int  o  nazwie  nWiek.  Aby 
zadeklarować  wskaźnik  do  przechowywania  adresu  tej  zmiennej  trzeba 
napisać: 

int *pWiek = 0;

Kiedy  deklaruje  się  zmienną  wskaźnikową,  to  można  w  niej  umieścić  adres 
jakiegoś obiektu w pamięci. 
W  tym  przypadku  zmienna  wskaźnikowa  pWiek  przechowuje  adres  zmiennej 
całkowitej typu int.

Zauważmy,  że  zainicjalizowaliśmy  wskaźnik  pWiek  wartością  0.  Wskaźnik, 
którego wartość wynosi zero określany jest jako 

null 

(pusty, nie wskazujący 

na  żaden  obiekt).  Jeśli  nie  wiecie  jaki  adres  przypisać  do  wskaźnika,  to 
przypiszcie mu wartość zero. 
Wskaźniki  niezainicjalizowane  żadną  wartością  określane  są  jako 

dzikie 

wskaźniki

.  Stanowią  one  potencjalne  zagrożenie  dla  programu,  gdyż  mogą 

przechowywać  adres  dowolnej  komórki  pamięci  (nie  wiemy  jakiej). 
Modyfikacja pamięci pod tym adresem może doprowadzić np. do zawieszenia 
się komputera.

Chcielibyśmy teraz przypisać mu adres zmiennej nWiek.  

int nWiek = 50;   //stwórz zmienna
int *pWiek = 0;   //stwórz wskaźnik
pWiek = &nWiek;   //wstaw adres do wskaźnika

Przypisaliśmy adres dzięki operatorowi adresu ( & ). Gdybyśmy zapomnieli o 
tym  operatorze,  to  do  wskaźnika  zostałaby  przypisana  wartość  zmiennej 
nWiek  (a  nie  jej  adres).  Oznacza  to,  że  wskazywałby  on  na  zupełnie  inną 
komórkę pamięci, niż oczekiwaliśmy.

Dostęp do zmiennej za pomocą jej adresu określany jest jako dostęp 
pośredni. 

Dostęp 

pośredni 

oznacza 

modyfikowanie 

lub 

odczytywanie  wartości  zmiennej  za  pośrednictwem  jej  adresu 
przechowywanego we wskaźniku. 

Wskaźniki,  tak  jak  wszystkie  inne  zmienne,  mogą  mieć  dowolne, 
poprawne  w  C++  nazwy.  Przyjmijmy  konwencję  nazywania 
wskaźników  rozpoczynając  nazwę  od  litery  p  (z  ang.  wskaźnik  - 
pointer), np.: pWiek, pLiczba itp.

Operator dostępu pośredniego

Operator dostępu pośredniego ( * ) może służyć do odczytywania i zmieniania 
wartości  zmiennej,  przechowywanej  pod  adresem  zawartym  we  wskaźniku. 
Normalna zmienna pozwala na bezpośredni dostęp do swojej wartości. 

Przykład

Jeśli stworzy się zmienną typu int o nazwie nTwojWiek i chce się jej przypisać 
wartość zmiennej nWiek to można to zrealizować w następujący sposób:

int nTwojWiek; 
nTwojWiek = nWiek;

Wskaźnik  pozwala  na  pośredni  dostęp  do  wartości  zmiennej,  której  adres 
przechowuje. Żeby przypisać wartość zmiennej nWiek do zmiennej nTwojWiek 
posługując się wskaźnikiem pWiek, trzeba napisać w ten sposób:

int nTwojWiek; 
nTwojWiek = *pWiek;

Operator  dostępu  pośredniego  (*)  przed  zmienną  pWiek  oznacza  "wartość 
przechowywana pod adresem zawartym w". To przypisanie można przeczytać 
następująco:  "Weź  wartość  przechowywaną  pod  adresem  zawartą  we 
wskaźniku pWiek i przypisz ją do zmiennej nTwojWiek".

Wskaźniki, adresy i zmienne

Bardzo  ważne  jest,  aby  odróżniać  wskaźnik,  adres  który  ten  wskaźnik 
przechowuje  i  wartość  przechowywaną  pod  adresem  zawartym  we 
wskaźniku.  Wiele  nieporozumień  wynika  z  nieprawidłowej  interpretacji  i 
błędnego rozumienia tych trzech różnych terminów.

Przykład 

int nZmienna = 5;
int *pWskaznik = &nZmienna;

pWskaznik  jest  zadeklarowany  jako  wskaźnik  na  zmienną  typu  int  i  jest 
inicjalizowany  adresem  zmiennej  nZmienna.  pWskaznik  (jak  sama  nazwa 
wskazuje)  jest  wskaźnikiem.  Adres  przechowywany  przez  pWskaznik  jest 
adresem  zmiennej  zmienna.  Wartość  pod  adresem  przechowywanym  przez 
pWskaznik jest równa 5. 

nZmienna

100 101 102 103104 105106 107108109110111

0000010
1

5

pWskaznik

0000  
0000

0000  
0101

101

Manipulowanie danymi za pomocą 

wskaźników

Jeśli  przypisze  się  do  wskaźnika  adres  jakiejś  zmiennej,  to  można 
wykorzystywać ten wskaźnik do manipulowania wartością tej zmiennej. 

Przykład

odczytujemy  wartość  spod  adresu 
przechowywanego 

w 

pWiek 

i 

wypisujemy tę wartość. 

do 

zmiennej 

o 

adresie 

przechowywanym 

we 

wskaźniku 

pWiek 

(nMojWiek), 

przypisujemy 

wartość 7. Na 7 zmienia się zawartość 
zmiennej nMojWiek. 

do  zmiennej  nMojWiek  przypisujemy 
wartość  9.  Wartość  tę,  bezpośrednio 
i  pośrednio  odczytujemy  w  tych 
fragmentach kodu

Kontrolowanie adresu

Wskaźniki pozwalają na manipulowanie adresami bez wiedzy o ich faktycznej 
wartości.  Powiedzieliśmy,  że  kiedy  przypisujemy  adres  zmiennej  do 
wskaźnika,  to  on  na  prawdę  ma  wartość  równą  adresowi  tej  zmiennej. 
Dlaczego by jednak tego nie sprawdzić? 

Przykład

Kwintesencja 
wskaźników:

Co przechowuje 
wskaźnik?

Jak odczytać tę 
wartość?

►

    Zawsze  do  odczytania  lub  modyfikacji  wartości  zmiennej 

przechowywanej  pod  danym  adresem,  wykorzystuj  operator 
adresowania pośredniego ( *).

►

    Zawsze  inicjalizuj  wskaźniki  albo  konkretnym  adresem  zmiennej 

wartością null (lub 0).  

►

    Zawsze  pamiętaj  o  różnicy  pomiędzy  adresem  przechowywanym 

we wskaźniku, a wartością przechowywaną pod adresem. 

Zazwyczaj wskaźniki są wykorzystywane w trzech sytuacjach:

♦

 Zarządzanie danymi w pamięci operacyjnej.

♦

 Dostęp do wnętrza klas - danych i funkcji.

♦

 Przekazywanie wartości do zmiennych poprzez referencje.

Programiści na ogół wyróżniają pięć obszarów pamięci:



 Obszar zmiennych globalnych



 Wolna pamięć



 Rejestry



 Kod programu



 Stos

Zmienne  lokalne  wraz  z  parametrami  funkcji  są  przechowywane  na  stosie. 
Kod  znajduje  się  w  obszarze  kodu  programu  (co  jest  chyba  oczywiste). 
Zmienne  globalne  również  znajdują    się  w  przeznaczonym  dla  siebie 
obszarze.  Rejestry  są  wykorzystywane  do  wewnętrznego  zarządzania 
funkcjami  (np.  do  przechowywania  adresu  szczytu  stosu  lub  wskaźnika 
instrukcji).  Cała  pozostała  pamięć  jest  dla  programu  wolna  (określa  się  ją 
czasem jako stertę - ang. heap).
Problem  ze  zmiennymi  lokalnymi  polega  na  tym,  że  wraz  z  zakończeniem 
funkcji są one przez program "zapominane". Zmienne globalne rozwiązują ten 
problem,  jednak  kosztem  nieograniczonego  dostępu  do  nich  z  dowolnego 
miejsca  w  programie,  co  niesie  ze  sobą  znaczną  komplikację  kodu. 
Umieszczenie danych w wolnej pamięci operacyjnej rozwiązuje oba problemy.

Można  z  powodzeniem  traktować  wolną  pamięć  jako  ogromy  zbiór 
sekwencyjne  ułożonych  komórek  pamięci  "czekających"  na  dane.  Jednak 
dostęp do tych komórek nie jest tak swobodny jak np. dostęp do stosu. Przed 
wykorzystaniem komórki trzeba „poprosić" system operacyjny o przydzielenie 
adresu i zarezerwowanie odpowiedniej liczby komórek. Dopiero wtedy można 
taki adres przypisać do wskaźnika i wykorzystywać.

Stos,  w  momencie  wyjścia  z  funkcji,  jest  automatycznie  czyszczony. 
Wszystkie  zmienne  lokalne  są  wyrzucane  z  pamięci.  Dane  na  stercie  trwają 
aż  do  zakończenia  programu.  Jest  możliwość  zwolnienia  zarezerwowanej 
pamięci, jeśli nie jest ona już  potrzebna.

Zaletą sterty:

•    pamięć  w  niej  zarezerwowana  jest  dostępna  tak  długo,  aż  jej  się 
bezpośrednio  nie  zwolni.  Jeżeli  zarezerwuje  się  pamięć  na  stercie  wewnątrz 
funkcji to po zakończeniu funkcji, będzie ona nadal zarezerwowana.

•  możliwość dostępu tylko przez te funkcje, które mają dostęp do wskaźnika 
danego  obszaru.  Gwarantuje  to  spójność  dostępu  do  danych  i  eliminuje 
problem  niepożądanej  modyfikacji  danych  przez  niepowołane  do  tego 
funkcje.

Aby móc wykorzystywać pamięć na stercie trzeba mieć możliwość stworzenia 
wskaźnika do obszaru na stercie i przekazania tego wskaźnika do wybranych 
funkcji.

new

Do  alokacji  (rezerwacji)  pamięci  służy  w  C++  słowo  kluczowe  new. 
Następuje  po  nim    nazwa  typu  obiektu  dla  którego  rezerwujemy  pamięć. 
Dzięki temu kompilator wie,  ile pamięci ma zarezerwować. 

Wartością  zwracaną  przez  new  jest  adres  w  pamięci.  Musi  on  być 
przypisany do wskaźnika. 

Przykład

unsigned short int * pWskaznik; 
pWskaznik = new unsigned short int;

unsigned short int * pWskaznik = new unsigned short int;

W obu przypadkach, pWskaznik wskazuje na stercie na wartość typu 
unsigned short int. 

Można ten wskaźnik wykorzystywać dokładnie tak, jak wskaźnik na zmienną i 
dowolnie przypisywać wartości do pamięci:

*pWskaznik = 72;

Oznacza  to:  "Wstaw  72  pod  adres  wskazywany  przez  pWskaznik"  albo 
"Przypisz 72 do obszaru wskazywanego przez pWskaznik".

delete

Kiedy  zakończy  się  operacje  na  zarezerwowanym  obszarze  pamięci  i  nie 
będzie  się  jej  już  więcej  wykorzystywać  to  należy  użyć  instrukcji  delete  na 
wskaźniku do danego obszaru. 
Wskaźnik  zadeklarowany  w  funkcji  jest  zmienną  lokalną  tej  funkcji,  w 
przeciwieństwie  do  pamięci  na  stercie,  na  którą  wskazuje.  Kiedy  funkcja  się 
skończy  to  wskaźnik  ten,  tak  jak  wszystkie  zmienne  lokalne  zostanie 
wyrzucony z pamięci (ze stosu). Oznacza to, że wskaźnika już nie będzie, ale 
obszar  na  stercie  będzie  nadal  zarezerwowany.  Taki  obszar  jest  już  dla 
programu  niedostępny.  Takie  zjawisko  określane  jest  jako  ulatnianie  się 
pamięci. Tak zarezerwowana pamięci pozostanie zajęta (i niedostępna) aż do 
zakończenia się programu.
Żeby zwolnić pamięć na stercie, musisz użyć słowa kluczowego delete. 
Przykład

delete pWskaznik;

Przykład

Mimo że w tym konkretnym 
przypadku  jest  nadmiarowa 
ta  instrukcja  delete  (koniec 
programu 

automatycznie 

zwolni  całą  zarezerwowaną 
pamięć) 

to 

dobrym 

zwyczajem  jest  zadbanie  o 
to,  aby  samemu  zwolnić, 
przed 

zakończeniem 

programu, 

całą 

wykorzystywaną  pamięć  na 
stercie. 

Utrata obszarów na stercie

Innym przypadkiem, w którym tracimy dostęp do zarezerwowanego na 
stercie obszaru, jest przypisanie nowego adresu do wskaźnika przed 
zwolnieniem pamięci wskazywanej przez ten wskaźnik. 

unsigned short int * pWskaznik = new unsigned short int; 
*pWskaznik = 72;
pWskaznik = new unsigned short int;
*pWskaznik = 84;

Do  wskaźnika  pWskaznik  ponownie  przypisujemy,  nowy  adres  obszaru  na 
stercie  i  w  wstawiamy  do  tego  obszaru  wartość  84.  Pierwszy  obszar,  ten  z 
wartością  72  jest  nadal  zarezerwowany  ale  już  niedostępny,  ponieważ 
wskaźnik,  który  na  niego  wskazywał  otrzymał  nową  wartość.  Nie  ma 
możliwości  odczytania  ani  zmiany  zawartości  tego  obszaru.  Będzie  on 
niepotrzebnie zajmował pamięć aż do zakończenia się programu. 

unsigned short int * pWskaznik = new unsigned short int; 
*pWskaznik = 72;
delete pWskaznik;
pWskaznik = new unsigned short int;
*pWskaznik = 84;

Tworzenie obiektów na stercie

Tak  jak  tworzyliśmy  wskaźniki  do  zmiennych  typu  int,  tak  samo  możemy 
stworzyć wskaźnik do dowolnego innego obiektu. Jeżeli zadeklaruje się obiekt 
typu  Kot,  to  można  zadeklarować  wskaźnik  do  obiektów  tej  klasy  i  stworzyć 
obiekt  na  stercie,  podobnie  jak  na  stosie.  Składnia  jest  tu  taka  sama  jak  w 
przypadku liczb całkowitych:

Kot *pKot = new Kot;

Zostanie  wywołany  konstruktor  domyślny,  ten  bez  parametrów.  Konstruktor 
jest  wywoływany  zawsze  w  momencie  tworzenia  obiektu  danej  klasy, 
niezależnie od tego, czy operacja ma miejsce na stosie, czy na stercie.

Usuwanie obiektów

Kiedy wywoła się delete na wskaźniku do obiektu klasy znajdującego się na 
stercie,  to  przed  zwolnieniem  pamięci  zajmowanej  przez  obiekt  zostanie 
wywołany destruktor klasy, której jest dany obiekt. Dzięki temu klasa ma np. 
możliwość  zwolnienia  dodatkowo  zarezerwowanej  pamięci  tak,  jak  jest  to 
robione podczas usuwania obiektów ze stosu w momencie wyjścia z funkcji. 

Przykład

na  stosie  tworzony  jest  obiekt 
klasy  ZwyklyKot,  wskazywany 
przez pRags. 

Dostęp do danych wewnętrznych klasy

Dotychczas,  dostęp  do  wewnętrznych  danych  i  funkcji  obiektów  klasy 
zadeklarowanych lokalnie realizowany był poprzez użycie operatora kropka ( . 
).  Żeby  dostać  się  do  elementów  obiektu  stworzonego  na  stercie  trzeba 
pośrednio odwołać się do tego obiektu za pomocą wskaźnika. 

Przykład

(*pRags).PobierzWiek();

wywołuje funkcję wewnętrzną  
PobierzWiek() 

Nawiasy gwarantują, że odwołanie do obiektu nastąpi przed próbą dostępu 
do funkcji PobierzWiek ().

Ponieważ takie stosowanie wskaźników jest raczej nieporęczne, C++ 
oferuje  specjalny  operator  dla  pośredniego  dostępu  do  obiektów 
wskazywanych  przez  wskaźniki.  Operator  "wskazujący  na"  (  ->  ) 
składający się z myślnika ( - ) i znaku większości ( > ). C++ traktuje 
to jako pojedynczy symbol. 

Przykład

na stercie, tworzony jest 
obiekt  klasy  ZwyklyKot. 
Konstruktor 

domyślny 

ustala jego wiek na 5. 

wywoływana jest metoda 
PobierzWiek  ().  Ponieważ 
odwołanie 

następuje 

poprzez  wskaźnik,  to 
wykorzystujemy operator 
"wskazujący na" ( -> ). 

Dane wewnętrzne na stercie

Jedna (lub  więcej) zmienna wewnętrzna  może  być wskaźnikiem na obiekt 
na stercie. Pamięć może być zarezerwowana w konstruktorze klasy (albo w 
jednej z jej metod) i może być zwolniona w destruktorze. 

Przykład

Funkcja wywołująca, w tym 

przypadku main (), "nie wie", że 

nJegoWiek i nJegoWaga są 

wskaźnikami. main () wywołuje 

metody PobierzWiek () i UstawWiek 

() , a szczegóły operacji na pamięci 

zaszyte są wewnątrz implementacji 

klasy. 

Podczas 

kasowania 

obiektu 

oFilemon, 

wywoływany 

jest 

automatycznie 

destruktor 

klasy. 

Destruktor  kasuje  wskaźniki.  Jeśli 
wskaźniki  wskazywałyby  na  obiekty 
innej  klasy,  to  zostałyby  wywołane 
destruktory tych klas.

Wskaźnik this

Każda wewnętrzna funkcja klasy ma ukryty parametr: wskaźnik this. 
this zawsze wskazuje na aktualny obiekt. 
Przy  każdym  wywołaniu  metod  PobierzWiek  ()  albo  UstawWiek  (),  wskaźnik 
this jest dołączany jako ukryty parametr.

Zadaniem  wskaźnika  this  jest  wskazywanie  na  obiekt,  którego  metoda 
została wywołana. Zazwyczaj nie będziemy go potrzebowali, będzie się tylko 
wywoływać  metody  i  zmieniać  zmienne  wewnętrzne.  Jednak  czasami  trzeba 
zagwarantować dostęp do obiektu (np. zwrócić adres aktualnego obiektu). W 
takiej sytuacji this będzie bardzo pomocny.
W normalnej sytuacji, aby dostać się do elementów klasy, nie potrzebuje się 
wskaźnika this. Można jednak bezpośrednio odwołać się do this. 

Przykład 

Funkcje  dostępu  PobierzDlugosc  ()  i  UstawDlugosc  () 
bezpośrednio wykorzystują wskaźnik this do odczytania 
i  modyfikacji  zmiennych  wewnętrznych  obiektu 
Prostokąt.  PobierzSzerokosc()  i  UstawSzerokosc  () 
dokonują  odczytania  i  modyfikacji  klasyczną  metodą. 
Efekt  jest  taki  sam  w  obu  sytuacjach,  jednak  metoda 
klasyczna jest bardziej przejrzysta.

Wskaźniki const

Umieszczenie go przed nazwą typu, na samym początku deklaracji wskaźnika 
powoduje  że  wskaźnik  jest  stały  i  nie  może  ulec  zmianie.  Słowo  const  po 
gwiazdce  i  przed  nazwą  typu  obiektu  powoduje,  że  obiekt  nie  może  być 
zmieniony z wykorzystaniem deklarowanego wskaźnika. 

Przykład

const int *pJeden;
int *const pDwa;
const int *const pTrzy;

pJeden jest wskaźnikiem na stałą typu int. Wartość ta nie może zostać 
zmieniona z wykorzystaniem tego wskaźnika. Oznacza to, że nie możesz 
napisać np. tak:

*pJeden = 5;

pDwa jest stałym wskaźnikiem na int. Wartość, na którą wskazuje może 
się zmienić, ale wskaźnik nie. Oznacza to, że nie wolno napisać tak:

pDwa = &x

pTrzy jest stałym wskaźnikiem na 
stałą int. Zarówno wartość jak i 
wskaźnik nie mogą się zmienić.