8.11.2018.

Teme

 Stvaranje, korištenje i brisanje objekta na gomili

 Objekti na gomili vs. Objekti na stogu
 Niz pokazivača na objekte na gomili
 Pokazivač na niz objekata na gomili
 this pokazivači
 const objekt
Objektno-orijentirano programiranje  conts pokazivači
u programskom jeziku C++

8.11.2018. 1 8.11.2018. 2

Pokazivači, pointeri Pokazivači, pointeri

 svaka varijabla ima svoju memorijsku adresu koju se može prikazati  sa operatorom indirekcije ili dereferenciranja (*) može se manipulirati s
operatorom & (address of ) vrijednošću koja je pohranjena na adresi mem. lokaciji na koju pokazivač
 kompajler prema tipu varijable određuje veličinu memorije koja joj je potrebna
upućuje
(npr. za tip long to je 4 byta) i dodjeljuje joj odgovarajuću adresu
 Operator indirekcije * smješten ispred imena pokazivača znači “vrijednost spremljena
 pokazivač je varijabla koja sadrži memorijsku adresu varijable na koju na”
pokazuje  Pr.
 Pr. int vrijednost = *pVar ; // vrijednost na koju pokazuje pokazivač
pohranjuje se u varijablu vrijednost
int var = 5; // inicijalizirana varijabla int
*pVar = 10; // mijenja se vrijednost na koju pokazuje pVar
int * pVar = 0; // deklaracija pokazivač na tip int inicijaliziran na 0 – null pointer
pVar = &var; //adresa varijable var dodijeljena je pokazivaču pVar s operatorom &  Svi pokazivači nakon što su kreirani trebali bi biti inicijalizirani na neku
 ili kraće: vrijednost ili na nulu.
int var = 5;  Pokazivač koji nije inicijaliziran se zove divlji pokazivač (wild pointer).
int * pVar = &var Izbjegavati!

3 8.11.2018. 4

Zašto se pokazivači koriste? Zašto koristiti slobodnu memoriju ?

 Pokazivači se koriste kada se želi:
 upravljati adresama varijable (uglavnom nepotrebno)
 upravljati podacima na slobodnom dijelu memoriji (heap, free store)
 pristupati funkcijama i podacima unutar klase
 prenositi funkcijama varijable po referenci
 Područja memorije: prostor za kod, registri, prostor za globalne varijable,
stog, slobodna memorija – “gomila” (eng. free store, heap).
 Za spremanje podataka prilikom kompajliranja, program može koristiti:
 prostor za globalne varijable
– neometani pristup, nečitak i teško održiv kod, svima dostupan
 stog
- za lokalne varijable i parametre funkcija, automatska alokacija (nisu potrebni
pokazivači), oslobađa se automatski kad se funkcija izvrši (kod return)
 slobodni memorijski prostor – “gomila”:
- za pristup je potrebno rezervirati memorijsko mjesto, alocirati memoriju (new)

- pristupaju mu samo funkcije koje imaju pristup pokazivaču koji na taj prostor
pokazuje
- memorija koju rezerviramo ostaje dostupna sve dok ju eksplicitno ne oslobodimo
(rezervirana memoriju na gomili za parametar funkcije, dostupna je i nakon vraćanja funkcije)
- prostor se ne čisti dok program ne završi, tj. dok se eksplicitno ne izbriše (delete)

5 6

OOP – C++, M. Ivašić-Kos 1

 8.11.2018.

Naredba new Varijable primitivnih tipova vs. tipovi objekata

 slobodna memorija alocira se koristeći naredbu new i tip objekta koji želimo alocirati
tako da kompajler zna koliko memorije je potrebno rezervirati.
new short int - alocira 2 byte memorije na hrpi,
new long - alocira 4 byte memorije na hrpi
Primitivni tip int i = 1 i 1

 Povratna vrijednost od new je adresa slobodne memorije koja odgovara tipu objekta.
Ona mora biti dodijeljena pokazivaču. Objektni tip Krug c c referenca

 Primjer stvaranja int:

int * pPointer; // deklaracija pokazivača na tip int
pPointer = new int; // alokacija odgovarajuće količine memorije na gomili

 Ili možemo kraće (sa inicijalizacijom): c: Krug

int * pPointer = new int;
Kreirana sa
new Krug() radius = 1
 Analogija sa stvaranjem objekta na gomili:
Macka *pTom = new Macka; // deklarira pokazivač na klasu Macka
i kreiranje instance klase Macka na gomili
7

Kopiranje varijabli primitivnih tipova i tipova objekata Kopiranje varijabli primitivnih tipova i tipova objekata

Pridruživanje primitivnih tipova Pridruživanje objektnih tipova Pridruživanje primitivnih tipova Pridruživanje objektnih tipova
i=j c1 = c2 i=j c1 = c2
Prije: Poslije: Prije: Poslije: Prije: Poslije: Prije: Poslije:

i 1 i 2 c1 c1 i 1 i 2 c1 c1

j 2 j 2 c2 c2 j 2 j 2 c2 c2

c1: Krug c2: Krug c1: Krug c2: Krug

radius = 5 radius = 9 radius = 5 radius = 9

Pristupanje podatkovnim članovima na gomili Naredba delete

 Za pristup članskim podacima i funkcijama objekata klase Macka kreiranih  Kada instanca klase više nije potrebna, sa delete treba osloboditi memorija
na stogu koristi se dot (.) operator (npr. Tom. GetGodine();) na gomili na koju pokazuje pokazivač

 Za pristup objektima klase na gomili, dereferencira se pokazivač i poziva
dot operator na objekt na koji pokazivač pokazuje.
 Primjer: (analogija sa * pPointer = 10;)
(*pTom).GetGodine(); // najprije se dereferencira, a onda
se pristupa metodi klase
ili kraći zapis pomoću operatora points-to (->) :
 zašto je važan delete?:
 delete oslobađa adresni prostor memorije na gomili
 Kako se memorija alocirana sa naredbom new ne oslobađa automatski - > ne
može biti obnovljena sve dok program ne završi = curenje memorije (memory
leaks)
 pokazivač je lokalna varijabla -> Kada se vraća funkcija na kojoj je deklariran
pokazivač, pokazivač je van dosega, izgubljen je.
 Pr. oslobađanje memorije na gomili rezervirane za int
 delete pPointer;

pTom->GetGodine();  Pr. oslobađanje mem. na gomili za objekt klase Macka:

 delete pMacka; //prije oslobađanja memorije poziva se destruktor

11 12

OOP – C++, M. Ivašić-Kos 2

 8.11.2018.

Null pokazivač Životni vijek objekata (stog)

 Za svaku naredbu new u programu, trebala bi biti postojati jedna naredba delete
- > Važno je pratiti koji pokazivač posjeduje memorijsko područje i osigurati da se  alokacija memorije za objekt
memorija oslobodi kad nam više nije potrebna.  objekt se automatski smješta na stog
 Nakon brisanja pokazivača, treba ga postaviti na 0 ili null da se izbjegnu  stvaranje objekta Automatski!
Stog
problemi sa visećim ili divljim pokazivačima.  korištenje objekta Macka Tom;
 Kad se pozove delete za pokazivač, memorija na koju on pokazuje je oslobođena -  uništavanje objekta alokacija stvaranje Macka();
kompajler u tom djelu memorije može slobodno upisivati podatke.
 oslobađanje memorije objekt
 Ako se pokazivač pokuša upotrijebiti nakon naredbe delete bez dodjeljivanja nekoj  memorija se automatski oslobađa Tom.SetTezina(2.5);
drugoj varijabli može doći do rušenja programa odmah ili nakon nekog vremena. …
korištenje Tom.Mijau();
 Ako se nakon delete pokazivač postavi na null (0), ponovni poziv istog pokazivača
više ne uzrokuje rušenje programa! objekt ~Macka(); Stog
 Primjer:
uništavanje oslobađanje
Animal *pDog = new Animal; bitovi
delete pDog; //oslobađa memoriju
pDog = 0; //postavlja pokazivač na nulu //... delete pDog; //bezopasno
8.11.2018. 13
8.11.2018. 14

Životni vijek objekata (gomila) Primjer:

#include <iostream.h> int main(){
 alokacija memorije za objekt class Macka { cout<<“Dinamička klasa…”;
 objekt se automatski smješta Stog public: Macka * pTom = new Macka;
na stog Macka Tom; Macka(); cout << " pTom ima " << pTom->getGod()
 pomoću operatora new() poziva se konstruktor ~ Macka();
<< " god. \n";
alokacija stvaranje
moguć je smještaj na gomilu Macka(); pTom ->SetGod(3);
private:
(heap) cout << " pTom is " << pTom ->getGod()
Macka *pTom = new Macka; objekt int godine; << " god. \n";
 stvaranje objekta hrpa: }; delete pTom;
Tom.SetTezina(2.5);
 korištenje objekta korištenje … Macka :: Macka(){ pTom=0;
pTom->tezina =2.5;
 uništavanje objekta … Tom.Mijau(); cout<<“Poziv cout<< “ Kraj.”;
konstruktora.\n"; return 0;
 oslobađanje memorije pTom->Mijau(); objekt Stog
}
godine = 1; IZLAZ:
 memorija se automatski Dinamička klasa.
uništavanje oslobađanje }
oslobađa bitovi
Macka ::~ Macka(){ Poziv konstruktora.
 memorija se oslobađa pTom ima 1 god.
pomoću naredbe delete delete pTom; cout << “Poziv
hrpa: pTom ima 3 god.
Pod kontrolom korisnika! destruktora.\n";
poziva se destruktor Poziv destruktora.
~Macka(); } Kraj...

8.11.2018. 15 8.11.2018. 16

Stvaranje i uništavanje objekata na stogu i gomili Konstruktor

int main(){  sintaksa deklaracije konstruktora:
Macka Suzi;  stvara se objekt na stogu class imeKlase (){
cout<<“Dinamički objekt…”;  automatski se poziva
podrazumijevani imeKlase (){}
Macka * pTom = new Macka;
cout << "Suzi ima " << Suzi.getAge() << " god.\n"; konstruktor imeKlase (tip1 par1, tip2 par2){}
cout << "pTom ima " << pTom->getAge()<< " god.\n"; imeKlase (tip_1 par_1, tip_1 par_2, ..., tip_k par_m){}
cout<<“Brisanje dinamičkog objekta”;  stvara se objekt na gomili ~imeKlase (){}
delete pTom; - treba definirati pokazivač i }
operator new (objekt =
cout<< “ Kraj.”; pokazivač (4 byte) na stogu
return 0; + memorija zauzeta na  sintaksa stvaranja objekta na gomili i poziv odgovarajućeg konstruktora:
gomili)
} imeKlase *objekt1 = new imeKlase;
IZLAZ:  automatski se poziva
podrazumijevani imeKlase *objekt2 = new imeKlase (par1, par2);
Poziv konstruktora. konstruktor imeKlase *objekt3 = new imeKlase (par_1, par_2, …, par_m);
Dinamički objekt.
Poziv konstruktora.  druga varijanta:
 uništavanje objekta
Suzi ima 1 god. imeKlase *objekt1, *objekt2, *objekt3;
 poziva se eksplicitno sa
pTom ima 1 god. operatorom delete objekt1 = new imeKlase;
Brisanje dinamičkog objekta.
objekt2 = new imeKlase (par1, par2);
Poziv destruktora.
Kraj...
Poziv destruktora.
8.11.2018. 17 8.11.2018. 18 / 55

OOP – C++, M. Ivašić-Kos 3

 8.11.2018.

Primjer: Preopterećivanje konstruktora Podrazumijevani parametri konstruktora

class Pravokutnik{ void main(){  Nekada se umjesto preopterećivanja konstruktora (različiti broj parametara), mogu
public: Pravokutnik* pRect, *pRect2; koristiti podrazumijevane vrijednosti parametara
Pravokutnik(){ pRect = new Pravokutnik;
Pravokutnik(){
visina=5; cout << "pRect visina: " << pRect->getVisina() << " m\n“; Pravokutnik(int v=0, int d=0){
visina=0; visina=v;
duljina= 10; pRect->setVisina(10);
duljina= 0; duljina = d;
} cout << "pRect visna: " << pRect->getVisina()<<" m\n";
} }
Pravokutnik(int v, int d){ pRect2 = new Pravokutnik (15,30);
Pravokutnik(int v){
visina=v; cout << "pRect2 visina: " << pRect2->getVisina()<<" m\n“; void main(){
visina=v;
duljina = d; } // visina i duljina od pRec je jednaka visini i diljini od pRec2 Pravokutnik* pRect, *pRect2, *pRect3;
duljina = 0;
~ Pravokutnik() {} pRect->setVisina (pRect2->getVisina() ); pRect = new Pravokutnik;
}
void setDuljina (int d) { duljina = d; } pRect->setDuljijna (pRect->getVisina()); cout << "pRect visina: " << pRect->getVisina() << " m\n“;
Pravokutnik(int v, int d){
int getDuljina () { return duljina; } cout << "pRect visina: " << pRect->getVisina()<<" m\n“; pRect2 = new Pravokutnik (5);
visina=v;
cout << "pRect duljina: " << pRect->getDuljina()<<" m\n“; cout << "pRect2 visina: " << pRect2->getVisina()<<" m\n“;
void setVisina (int v) { visina= v; } duljina = d;
delete pRect, pRect2; } pRect2 = new Pravokutnik (5,10);
int getVisina () { return visina; } }
cout << "pRect3 visina: " << pRect3->getVisina()<<" m\n“;
private:
delete pRect, pRect2, pRect3;
int duljina, visina;};
}
19 20

Podatkovni članovi klase kao pokazivači Parametri konstruktora kao pokazivači

 Jedan ili više podatkovnih članova klase mogu biti pokazivači na objekt na gomili Zaposlenik(){
#include <iostream>
strcpy_s(ime," ");
 memorija se može alocirati u konstruktoru klase ili u nekoj od metoda, a obrisati u using namespace std;
strcpy_s(prezime, " ");
destruktoru placa = 0; }
Macka :: Macka(){ class Zaposlenik {
pGodine = new int(2); //inicijalizacija pokazivača Zaposlenik(char *i, char *p){
#include <iostream.h> private:
pTezina = new float(5); strcpy_s(ime,i);
class Macka{ char ime[20];
} strcpy_s(prezime, p);
private: char prezime[20];
Macka ::~ Macka(){ placa = 0; }
int * pGodine; //pokazivači na int delete pGodine; //čisti se memorija na gomili float placa;
Zaposlenik(char *i, char *p, float pl){
float * pTezina; //pokazivač na float delete pTezina; public:
strcpy_s(ime,i);
} Zaposlenik(){}
strcpy_s(prezime, p);
public: int main(){ Zaposlenik (char *i, char *p){}
placa = pl; }
Macka(); Macka *Mica = new Macka; Zaposlenik (char *i, char *p, float pl){}
~ Macka(); cout << “Mica ima " <<Mica -> getGod() << " god.\n"; float getPlaca() { return placa; } void main() {
int getGod() const { return * pGodine; } Mica -> setGod(5); void setPlaca(float pp){ placa = pp; } Zaposlenik *z1 = new Zaposlenik ("Moje Ime",
void setGod (int god) { * pGodine = god; } cout << “ Mica ima " << Mica -> getGod() << " god\n"; void unos() ; „Moje Prezime", 1000);
float getTez() const { return * pTezina; } void ispis(); z1->Ispis();
void setTez (float tez) { * pTezina = tez; } delete Mica; void povecaj(float x) { placa=placa+x; } Zaposlenik *z2 = new Zaposlenik(„mIme„,„mPrez”);
}; Mica = 0; }; z2->Ispis();
return 0; delete z1, z2;}
}
21 22

Podrazumijevani parametri konstruktora Niz pokazivača na objekte na gomili

 varijanta s podrazumijevanim vrijednostima parametara konstruktora koja zamjenjuje  deklaracija niza pokazivača na objekte klase imeKlase :
preopterećivanje konstruktora
imeKlase * pok [max_broj];
Zaposlenik(){ Zaposlenik(char *i=“ “, char *p=“ “, float pl =0){
strcpy_s(ime," "); strcpy_s(ime,i);
strcpy_s(prezime, " "); strcpy_s(prezime, p);  alokacija memorije na gomili za svaki element niza (pokazivač)
placa = 0; }
Zaposlenik(char *i, char *p){
placa = pl; } pok [i] = new imeKlase();
strcpy_s(ime,i); void main() {
strcpy_s(prezime, p); Zaposlenik *z1 = new Zaposlenik(„ime", „prezime");
placa = 0; } z1->ispis();
 pristup članskim funkcijama elemenata niza:
Zaposlenik(char *i, char *p, float pl){ Zaposlenik *z2 = new Zaposlenik("Moje Ime", pok [i]->metoda1();
strcpy_s(ime,i); "Prezime", 1000);
strcpy_s(prezime, p); z2->ispis();
placa = pl; } Zaposlenik *z3 = new Zaposlenik();
z3->ispis();
Zaposlenik *z4 = new Zaposlenik(„prezime”);
z4>ispis();
delete z1, z2, z3, z4;
}
23 8.11.2018. 24 / 55

OOP – C++, M. Ivašić-Kos 4

 8.11.2018.

Primjer: Dana je klasa Primjer: Niz pokazivača na instance klasa na gomili

#include <iostream> void Zaposlenik::unos(){
using namespace std; cout<<"Unesite ime zaposlenika: "; // niz od 3 pokazivača na objekte
// 1 pokazivač na objekt klase Zaposlenik
cin>>ime; Klase Zaposlenik
void main() {
class Zaposlenik { cout<<"Unesite prezime zaposlenika: "; Zaposlenik *z1 = new Zaposlenik();
cin>>prezime; void main() {
private: z1->unos();
cout<<"Unesite iznos place zaposlenika: ";
char ime[20]; cin>>placa; Zaposlenik *zap[3]; z1->ispis();
char prezime[20]; } for (int i=0; i<3; i++){ delete z1;
public: void Zaposlenik::ispis(){ z1=0;
zap[i] = new Zaposlenik();
float placa; cout<<"Ime zaposlenika: " <<ime<<endl; }
cout<<"Prezime zaposlenika: "; zap[i]->unos();
void unos() ;
cout<<prezime<<endl; }
void uspis(); cout<<"Iznos place zaposlenika: "; for (int i=0; i<3; i++){
void povecaj(float x) { cout<<placa<<endl;
placa=placa+x;
zap[i]->ispis();
} } }
}; }

8.11.2018. 25 8.11.2018. 26

Niz pokazivača vs. Pokazivač na niz instanci Primjer: Niz pokazivača vs Pokazivač na niz instanci
 Primjer: Niz pokazivača na objekte  Dana je klasa:
 Zadatak:
#include <iostream>
1. Napraviti niz sa 5 pokazivača na objekte klase Pravokutnik
Pravokutnik *pRect1[5]; // niz sa 5 pokazivaca na objekte klase Pravokutnik using namespace std; na gomili
pRect1[0] = new Pravokutnik(); // pokazivac na objekt na gomili se pridružuje 1. el. niza class Pravokutnik{ 2. Napraviti 1 pokazivač na niz od 5 objekata klase
public: Pravokutnik na gomili
pRect1[1] = new Pravokutnik(); // pokazivac na objekt na gomili se pridružuje 2. el. niza Pravokutnik(int s=5, int d=5){
sirina =s;
duljina = d; }
~ Pravokutnik() {}
 Primjer: 1. pokazivač na niz objekata
void setDuljina(int d) { duljina = d; }
Pravokutnik *pRect3 = new Pravokutnik[5]; // 1 pokazivač na niz od 5 objekata na gomili int getDuljina() { return duljina; }
pRect3->setDuljina(100); // pristupa se 1. elementu niza (objekt) void setSirina(int s) { sirina = s; }
(pRect3+1)->setDuljina(100); // pristupa se 2. elementu niza (objekt) int getSirina() { return sirina; }
private:
int duljina;
int sirina;
};
8.11.2018. 27 8.11.2018. 28

Primjer: Niz pokazivača vs Pokazivač na niz instanci 1 Niz pokazivača vs. Pokazivač na niz instanci
void main(){  Primjer: Niz pokazivača na objekte
Pravokutnik *pRect[5]; // niz sa 5 pokazivaca
pRect[0]= new Pravokutnik(); // 2. varijanta referenciranja Pravokutnik *pRect1[5]; // niz sa 5 pokazivaca na objekte klase Pravokutnik
pRect[0]->setDuljina(10); Pravokutnik *pRe; // pokazivac na objekt klase Pravokutnik
for (int i =0; i<5; i++) { for (int i =0; i<5; i++) {
pRect[i]= new Pravokutnik(); // pokazivac na objekt pRe= new Pravokutnik(); // def. se pokazivac na objekt na gomili
pRect[i]->setDuljina(i*10); } pRe->setDuljina(i*20);
for (int i =0; i<5; i++) pRect1[i] = pRe; // el. niz pokazivača pridružujemo pokazivač
cout << "pRect duljina: " << pRect[i]->getDuljina()<< "\n"; }
 Primjer: 1. pokazivač na niz objekata
Pravokutnik *pRect2 = new Pravokutnik[5]; // 1 pokazivac na niz objekata
pRect2->setDuljina(100); // pristupa 1 elementu niza objekata – 2. varijanta Pravokutnik *pRect3 = new Pravokutnik[5]; // 1 pokazivac na niz od 5 objekata na gomili
for (int i =0; i<5; i++) Pravokutnik *pRr; // pokazivac na objekt klase Pravokutnik
for (int i =0; i<5; i++) {
(pRect2+i)->setDuljina(i*100);
pRr = new Pravokutnik; // def. se pokazivac na objekt na gomili
for (int i =0; i<5; i++) pRr->setDuljina(i*20);
cout << "pRect duljina: " << (pRect2+i)->getDuljina()<< "\n"; pRect3[i] = *pRr; // ali pridružuje se objekt jer je niz objekata a ne pokazivaca !!!
delete []pRect2;} delete pRr;
}
8.11.2018. 29 8.11.2018. 30

OOP – C++, M. Ivašić-Kos 5

 8.11.2018.

Primjer: Niz pokazivača vs Pokazivač na niz instanci 2 Pokazivač this

void main(){  Svaka funkcija klase ima skriveni parametar koji prilikom poziva pokazuje na određeni
Pravokutnik *pRect1[5]; // niz sa 5 pokazivaca na objekte klase Pravokutnik objekt - this pokazivač.
Pravokutnik *pRe; // pokazivac na objekt klase Pravokutnik  this pokazivač se može koristiti i eksplicitno, kada želimo koristiti podatke unutar trenutnog
for (int i =0; i<5; i++) { objekta kojem funkcija i sama pripada npr:
pRe= new Pravokutnik(); // def. se pokazivac na objekt na gomili
pRe->SetDuljina(i*20);
pRect1[i] = pRe; // niz pokazivaca void SetGod(int god) { this->god= god; } // parametar funkcije i varijabla klase imaju isto
} ime (god), pa pokazivač this omogućuje
for (int i =0; i<5; i++) cout << "pRect duljina: " << pRect1[i]->getDuljina()<< "\n"; neposredni pristup varijablam koje
Pravokutnik *pRect3 = new Pravokutnik[5]; // 1 pokazivac na niz od 5 objekata na gomili pripadaju trenutnoj instanci klase;
Pravokutnik *pRr;
for (int i =0; i<5; i++) {  U istom programskom bloku dvije varijable ne mogu imati jednaka imena, ali dopušteno je
pRr = new Pravokutnik; preklapanje imena varijabli instance s imenima lokalnih varijabli metoda ili sa parametrima
pRr->SetDuljina(i*200); funkcije.
pRect3[i] = *pRr; // niz objekata a ne pokazivaca !!!
delete pRr;  korištenje pokazivača this je ispravno ali nije nužno i kada se imena varijabli instance i
} lokalnih vrijabli razikuju:
for (int i =0; i<5; i++) cout << "pRect duljina: " << pRect3[i].getDuljina()<< "\n";
void SetAge(int a) { this->age = a; }
}
8.11.2018. 31 32

const pokazivači i conts objekt const pokazivači i const funkcijski članovi

 Moguće je koristiti definiciju const prije deklaracije tipa, nakon deklaracije  Kada je funkcija deklarirana kao konstantna, kompajler javlja grešku na
tipa ili na oba mjesta pri definiciji pokazivača svaki pokušaj promjene podataka unutar te funkcije
 ključna riječ const odnosi se na ono što joj se nalazi s desne strane:  Ako pokazivač pokazuje na const objekt, dopušteno je pozivanje jedino
const metoda
const int * pOne; // pokazivač pOne na cons. vrijednost
const Pravokutnik * pConstRect = new Pravokutnik; // const objekt
//vrijednost na koju se pokazuje je nepromjenjiva
Pravokutnik * const pConstPtr = new Pravokutnik; // const pokazivač

int * const pTwo; //const pokazivač pTwo class Pravokutnik{

//pokazivač ne može pokazivati ni na koju drugu varijablu public:
….
const int * const pThree; // const pokazivač na const vrijednost int getDuljina () const { return duljina; }
//konstantna vrijednost i nepromjenjiv pokazivač void setSirina (int s) { sirina = s; }
int getSirina () const { return sirina; }
};

33 34

Primjer: const pokazivači i const funkcijski članovi const pokazivači i const funkcijski članovi
void main(){
 Neka je dana klasa:
Pravokutnik* pRect = new Pravokutnik; // pokazivač na Pravokutnik
class Pravokutnik{ const Pravokutnik * pConstRect = new Pravokutnik; // const objekt
public: Pravokutnik * const pConstPtr = new Pravokutnik; // const pokazivač
Pravokutnik():sirina(5),duljina(10 ){} // isto što i { sirina =5; duljina=10; } Output:
~ Pravokutnik() {} cout << "pRect sirina: " << pRect->getSirina() << " m\n";
cout << "pConstRect sirina: " << pConstRect->getSirina() << " m\n“; pRect sirina: 5 m
void setDuljina (int d) { duljina = d; }
pConstRect sirina: 5 m
int getDuljina () const { return duljina; } cout << "pConstPtr sirina: " << pConstPtr->getSirina() << " m\n"; pConstPtr sirina: 5 m
void setSirina (int s) { sirina = s; }
int getSirina () const { return sirina; } pRect->setSirina(10);
private: // pConstRect->setSirina(10); //konstant objekt - nije dozvoljeno mijenjanje vrijednosti
int duljina; pConstPtr->setSirina(10); //pokazivač je const, ali objekt nije
int sirina;
}; cout << "pRect sirina: " << pRect->getSirina() << " m\n";
pRect sirina: 10 m
cout << "pConstRect sirina: " << pConstRect->getSirina() << " m\n“;
pConstRect sirina: 5 m
cout << "pConstPtr sirina: " << pConstPtr->getSirina() << " m\n"; pConstPtr sirina: 10 m
35
} 8.11.2018. 36

OOP – C++, M. Ivašić-Kos 6

 8.11.2018.

Sažetak

 Stvaranje objekta na gomili vs. stvaranje objekata na stogu

 Korištenje objekta na gomili vs. korištenje objekata na stogu
 Brisanje objekta na gomili vs. brisanje objekata na stogu
 Niz pokazivača vs. Pokazivač na niz
 const objekt vs. const pokazivač

8.11.2018. 37

OOP – C++, M. Ivašić-Kos 7