Programiranje Za 3. Razred

ET Tuzla
Selma Krajinovi, mag.ing.el.
ET Tuzla
Istorija dokumenta
Verzija
1.0
1.1
1.2
1.3
2.1
2.2
3.1
Datum
01.10.2010.
16.10.2010.
04.12.2011.
28.01.2012
15.9.2013
4.11.2013
3.11.2014
Autor
skr
Skr
Skr
Skr
Skr
SKR
Skr
Napomena
Draft
Modifikacije Povezane liste
Modifikacije pointer + niz
Povezane liste, pocetni primjer
Izmjenjen redoslijed modula
Dodana vjezba Pokazivaci
Izmjena redoslijeda modula
SADRAJ
Modul 5: Dvodimenzionalni niz .................................................................................................................... 1
Uvod, Matrice ........................................................................................................................................... 1
C++ : Dvodimenzionalni niz ....................................................................................................................... 3
Mnoenje matrice skalarom ..................................................................................................................... 7
Sabiranje matrica ...................................................................................................................................... 9
Mnoenje matrica ................................................................................................................................... 10
Transponovana matrica .......................................................................................................................... 12
ZADACI ZA VJEBU .................................................................................................................................. 24
MODUL 6: Primjena struktura podataka i pointera .................................................................................... 26
Sloeni tipovi i strukture podataka ......................................................................................................... 26
Strukture ................................................................................................................................................. 26
Definicija strukture.............................................................................................................................. 26
Deklaracija promjenljive tipa struktura .............................................................................................. 27
Pristup lanovima strukture ................................................................................................................ 27
Zadaci za vjebu: ................................................................................................................................. 30
Struktura i niz .......................................................................................................................................... 31
Struktura kao lan strukture ............................................................................................................... 32
Zadaci za vjebu: ................................................................................................................................. 36
Pokazivai (pointers) ................................................................................................................................... 38
ET Tuzla
Statike i dinamike promjenljive ....................................................................................................... 38
Pokazivai ............................................................................................................................................ 38
Deklaracija pokazivaa ........................................................................................................................ 38
Operatori ............................................................................................................................................. 38
Zadaci za vjebu .................................................................................................................................. 42
Pitanja za ponavljanje ......................................................................................................................... 43
POINTERI, vjeba 1 .............................................................................................................................. 45
Reference ................................................................................................................................................ 48
Podruje primjene pokazivaa i referenci............................................................................................... 49
Vjebe.................................................................................................................................................. 52
Pokazivai i nizovi.................................................................................................................................... 54
Zadaci za vjebu .................................................................................................................................. 59
Povezane liste ......................................................................................................................................... 61
ta je povezana lista? .......................................................................................................................... 61
Definisanje strukture podataka za povezanu listu .............................................................................. 64
Funkcija za kreiranje vora liste .......................................................................................................... 65
Dodavanje vora u listu ....................................................................................................................... 65
Dodavanje vora na kraj liste .............................................................................................................. 65
Dodavanje vora na poetak liste ....................................................................................................... 68
Zadataci za vjebu: .............................................................................................................................. 68
Pristup podacima u listi ....................................................................................................................... 72
Brisanje vora ...................................................................................................................................... 72
Navigacija kroz listu............................................................................................................................. 77
Primjer programa za rad sa jednostruko povezanom listom .............................................................. 80
Zadaci za vjebu .................................................................................................................................. 93
Zadaci za ponavljanje .......................................................................................................................... 95
POVEZANE LISTE, vjeba 1 (osnovni pojmovi, deklaracija, kreiranje liste) ......................................... 95
Vjeba 2 ............................................................................................................................................... 97
MODUL 7: KLASE i OBJEKTI ....................................................................................................................... 101
Uvod: Proceduralno i Objektno Programiranje .................................................................................... 101
Chair Wars (ili kako objekti mogu promijeniti tvoj ivot) ................................................................. 101
Klase i objekti Qt project ................................................................................................................... 108
3
ET Tuzla
Kreiranje klase....................................................................................................................................... 112
VJEBA 1:........................................................................................................................................... 114
Pitanja za ponavljanje ....................................................................................................................... 115
Privatno i javno ................................................................................................................................. 116
PRIMJER 2 objekti klase XYpoint kao elementi niza....................................................................... 121
PRIMJER 3 Klasa trougao ................................................................................................................ 122
Primjer 4 klasa semafor.................................................................................................................. 124
VJEBA 5: Klasa FMRadio .................................................................................................................. 129
Terminologija ........................................................................................................................................ 130
Kontruktori i destruktori klase .......................................................................................................... 131
ET Tuzla
MODUL 5: DVODIMENZIONALNI NIZ

Uvod, Matrice
U matematici, matrica je pravougaona tabela brojeva, ili openito, tabela koja se sastoji od
apstraktnih objekata koji se mogu sabirati i mnoiti.
Matrice se koriste za opisivanje linearnih jednaina, za praenje koeficijenata linearnih
transformacija, kao i za uvanje podataka koji ovise od dva parametra. Matrice se mogu
sabirati, mnoiti i razlagati na razne naine, to ih ini kljunim konceptom u linearnoj algebri i
teoriji matrica.
Matrice omoguuju jednostavan zapis i rjeavanje sistema linearnih jednaina.
Definicija
Pravougaona tablica brojeva
zove se matrica tipa mxn. Tablica se stavlja u uglaste ili oble zagrade.
Brojevi
su elementi matrice ili komponente matrice. Svaki element matrice odjeen je indeksom reda u
kojem se nalazi (i) i indeksom kolone (j). Tako je element a2,8 onaj koji se nalazi u drugom redu i
8. koloni.
Brojevi
formiraju -ti red, brojevi

tvore j-tu kolonu, a brojevi
formiraju dijagonalu matrice
Ako je
kaemo da je
A1,1, A2,2, A3,3,. An,n,
kvadratna matrica reda
. Kod kvadratne matrice brojevi
ET Tuzla
formiraju glavnu dijagonalu matrice

Brojevi
A1,n, A2,n-1, A3,n-2,. An,1,
formiraju sporednu dijagonalu.
Ako je
kaemo da je
kaemo da je
retana matrica (ima samo jedan redak), a ako je
stupana matrica. Retane i stupane matrice se jo zovu vektori.
Matrice obino oznaavamo velikim pisanim slovima, A,B,X,YKoriste se i oznake
Vektore moemo oznaavati i s malim tampanim slovima a,b,x, ili s masnim slovima, a,b,x.
Na primjer,
je matrica tipa 3x4, s oznaenim drugim retkom,
su primjeri retane odnosno stupane matrice,
dok su
Matrice
i
i
kvadratne matrice reda
su jednake ako su istog tipa i ako je

za sve parove indeksa
, a ujedno i stupane i retane matrice
ET Tuzla
C++ : Dvodimenzionalni niz

Matrica se u C++ predstavlja kao dvodimenizionalni niz. Kao i kod matrice, svaki element odreen je indeksom
reda i kolone u kojoj se nalazi, s tim to je indeks prvog reda i indeks prve kolone 0.
Na primjer, dvodimenzionalni niz A formata 3x5, sadri slijedee elemente:
Red 1 (indeks 0)
Red 2 (indeks 1)
Red 3 (indeks 2)
Kolona 1 (indeks 0)
Kolona 2 (indeks 1)
Kolona 3 (indeks 2)
Kolona 4 (indeks 3)
Kolona 5 (indeks 4)
a00
a10
a20
a01
a11
a21
a02
a12
a22
a03
a13
a23
a04
a14
a24
Dakle, indeks prvog reda je 0, a poslednjeg 2. Indeks prve kolone je 0, a poslednje 4.

Deklaracija dvodimenzionalnog niza
Dvodimenzionalni niz deklarie se tako to ste najprije navede tip elemenata niza, zatim naziv niza, a onda, u
uglastim zagradama, broj redova i broj kolona.
Tip_elemenata naziv_niza [broj redova] [broj kolona]
Primjer:
float X [4] [3]
Ovom naredbom deklarisali smo niz koji e sadrati maksimalno 4x3 realna broja.
Uitavanje dvodimenizionalnog niza
Elemente niza uitavamo tako to najprije uitamo broj redova (N) i broj kolona (M), a zatim pomou dva
brojaa, unutar dvije for petlje, uitavamo red po red niza. Broja i kontrolie red a broja j vrstu (ili kolonu) u
koju e uitani element biti upisan. Kod sadri i kontrolu dimenzija koje korisnik upie.
ET Tuzla
Ispisivanje dvodimenzionalnog niza

Kao i kod uitavanja, dvodimenzionalni niz ispisujemo pomou dva brojaa.
Ako testiramo kodi zadamo dimenizije niza 3x3, dobijemo
ET Tuzla
Ako elimo urediti ispis niza moemo koristiti funkciju setw iz biblioteke iomanip. Modifikovani kod za ispis je
Ovaj kod daje
Manipulator setw(n) je manipulator koji slui za formatiranje izlaza . Odreuje minimalni broj kolona (n) za ispis
broja koji slijedi. Tako u naredbi
cout <<setw(6)<<X[i][j];
odreujemo da je najmanji broj kolona u kojima e se ispisati element niza.
Podrazumijevano poravnanje broja koji slijedi je udesno. To se moe promijeniti pomou manipulatora left i right,
koji se mogu navesti poslije manipilatora setw.
Npr. ako u kodu za ispis niza modifikujemo naredba cout za ispis elementa niza na slijedei nain
cout <<setw(6)<<left<<X[i][j];
onda ispis izgleda ovako
Inicijalizacija niza
Elemente niza moemo inicijalizovati prilikom deklaracije. Npr.
Ako izostavimo zadnji red u inicijalizaciji, elementima niza u zadnjem redu bie dodijeljene nule
ET Tuzla
Primjer 1.
Napii program koji e uitati matricu dimenzija nxm (n,m 10), ispisati ju u obliku tabele te nai i
ispisati sumu elemenata drugog reda i proizvod elemenata tree kolone. Elementi niza su cijeli
brojevi, najmanji broj kolona je 3, najmanji broj redova je 2.
S
Promjenljiva suma2 se inicijalizuje na 0. Koristit e
za formiranje sume elemenata reda.
Promjenljiva proizvod2 se inicijalizuje na 1. Koristit
e se za formiranje proizvoda elemenata kolone.
Uitavanje M i N se ponavlja sve dok nije u
dozvojenim granicama, i to:
2<=N<=10 i 3<=M<=10
Nakon uitavanja i ispisivanja elemenata niza, formiraju se traena suma i proizvod, kako slijedi:
Indeks i elemenata drugog reda je 1, pa je u prvoj petlji fiksiran. Pomou petlje po j dodaju se
elementi reda.
Indeks j elemenata tree kolone je 2, pa je u drugoj petlji fiksiran. Pomou petlje po i mnoe se
elementi tree kolone.
i/j
Primjer izvravanja programa
ET Tuzla
Mnoenje matrice skalarom

Matrica se mnoi s nekim skalarom (brojem) tako da se svaki element matrice pomnoi s tim
brojem.
c*A = c*A[i, j]
Na primjer:
Primjer 2
Napii program koji e uitati matricu dimenzija nxm (n,m 10), i realni broj x, te nai proizvod matrice i
broja x. Novodobivenu matricu treba ispisati u obliku tabele.
Rjeenje 1
Mnoenje elemenata matrice moemo izvriti prilikom ispisa, kako slijedi:
ET Tuzla
Rjeenje 2
Formira se novi dvodimenzionalni niz Y prema formuli:
Y = broj * X, tj. Y[i,j]= broj * X[i,j]
ET Tuzla
Sabiranje matrica
Ako su zadane matrice A i B, dimenzija mxn, njihov zbir A + B je nova matrica C, dimenzija mxn,
iji su elementi izraunati sabiranjem odgovarajuih elemenata matrica A i B, t.j.
C=A+B, C[i, j] = A[i, j] + B[i, j]
Na primjer:
Primjer 3
Uitati dva dvodimenzionalna niza sa maksimalno 10x10 elemenata i formirajte i ispiite matricu koja predstavlja
zbir uitanih matrica.
ET Tuzla
Mnoenje matrica
Matrice A i B moemo pomnoiti samo ako su ulanane, odnosno ako A ima onoliko kolona koliko B ima redova.
Matrica C=A*B ima redova koliko ima matrica A i onoliko kolona koliko ima matrica B.
Neka je, dakle, A dimenzija nxk i B dimenzija kxm. Tada je matrica C dimenzija nxm i vrijedi
Anxk * Bkxm = Cnxm
Npr. neka je zadana matrica A formata 3x4 i B formata 4x5 sa elementima kao na slici
A3x4 * B4x5 = C3x5
Rezultujua matrica C bie formata 3x5, sa elementima:
c11
c21
c31
c12
c22
c32
c13
c23
c33
c14
c24
c34
c15
c25
c35
Npr. element c23 rauna se kao
Elementi prvog reda nove matrice raunaju se prema formulama:

c11=a11*b11 + a12*b21 + a13*b31 + a14*b41
c12=a11*b12 + a12*b22 + a13*b32 + a14*b42
c13=a11*b13 + a12*b23 + a13*b33 + a14*b43
c14=a11*b14 + a12*b24 + a13*b34 + a14*b44
c15=a11*b15 + a12*b25 + a13*b35 + a14*b45
Dakle, elementi prvog reda matrice A mnoe se odgovarajuim elementima pojedinih kolona u matrici B.
c1,j =a11*b1j + a12*b2j + a13*b3j + a14*b4j, gdje j uzima vrijednosti od 1 do 5 i predstavlja indeks kolone sa kojom se mnoi.
Elementi drugog reda nove matrice raunaju se prema formulama:

C21=a21*b11 + a22*b22 + a23*b31 + a24*b41
C22=a21*b12 + a22*b22 + a23*b32 + a24*b42
C23=a21*b13 + a22*b23 + a23*b33 + a24*b43
C24=a21*b14 + a22*b24 + a23*b34 + a24*b44
C25=a21*b15 + a22*b25 + a23*b35 + a24*b45
Dakle, drugog reda matrice A mnoe se odgovarajuim elementima pojedinih kolona u matrici B.
C2,j =a21*b1j + a22*b2j + a23*b3j + a24*b4j
Elementi treeg reda nove matrice raunaju se prema formulama:

C31=a31*b11 + a32*b22 + a33*b31 + a34*b41
C32=a31*b12 + a32*b22 + a33*b32 + a34*b42
C33=a31*b13 + a32*b23 + a33*b33 + a34*b43
C34=a31*b14 + a32*b24 + a33*b34 + a34*b44
C35=a31*b15 + a32*b25 + a33*b35 + a34*b45
10
ET Tuzla
Dakle, drugog reda matrice A mnoe se odgovarajuim elementima pojedinih kolona u matrici B.
C2,j =a21*b1j + a22*b2j + a23*b3j + a24*b4j
Na primjer,
Primjer 4
Napisati program koji ucitava matricu X formata nxk i matricu Y formata kxm, te izracunava i ispisuje matricu C koja je proizvod
matrica A i B.
Formiranje elemenata rezultujueg niza realizuje se u okviru tri petlje:
Petlja i kontrolie red u kome je element niza Z; petlja j kontrolie kolonu. Poto se rezultujui element rauna kao suma,
postavlja se poetna vrijednost netralni element za sabiranje. Zatim se mnoe elementi i-tog reda prve matrice sa elementima
i-te kolone druge matrice. Ima ih K, pa broja l uzima vrijednosti od 1 do K.
11
ET Tuzla
Transponovana matrica
Transponovana matrica matrice A je matrica AT kod koje su kolone i redovi zamijenili mjesta.
Dakle, ako je A dimenzija nxm, tada je AT tipa mxn. Na primjer,
Primjer 5
Uitati matricu, a zatim ispisati transponovanu matricu.
Element transponovane matrice sa indeksom i,j dobiva vrijednost

elementa sa indeksom j,i polazne matrice.
12
ET Tuzla
Primjer 6
Uitati kvadratnu matricu i ispisati elemente na glavnoj i elemente na sporednoj dijagonali.
Kvadratna matrica ima jednak broj redova i kolona, te oba
brojaa imaju isti opseg.
Za elemente na glavnoj dijagonali vrijedi i=j, tj. na glavnoj

dijagonali su oni elementi koji imaju isti indeks reda i kolone.
Sporedna dijagonala sadri elemente kod kojih je indeks
kolone odreen kao N-i-1
Primjer 7
Napisati program koji formira kvadratnu matricu formata nmax =20 iji elementi su *. Npr. za n=5, matrica
izgleda ovako:
* * * * *
* * * * *
* * * * *
* * * * *
* * * * *
Ispisati kreiranu matricu. Zatim formirati i ispisatimatrice kako slijedi
GD1
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
GD2
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
13
ET Tuzla
SD1
*
*
*
*
*
SD2
* * * *
* * *
* *
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
Kreiranje matrice realizuje se u okviru slijedeeg koda:
Posmatrajmo indekse elemenata matrice formata 5x5

a00
a10
a20
a30
a40
a01
a11
a21
a31
a41
a02
a12
a22
a32
a42
a03
a13
a23
a33
a43
a04
a14
a24
a34
a44
Moemo uoiti ovisnost izmeu indeksa elemenata kako slijedi:

GD1: ai,j ={
,
, >
a00
a10
a20
a30
a40
a01
a11
a21
a31
a41
a02
a12
a22
a32
a42
14
a03
a13
a23
a33
a43
a04
a14
a24
a34
a44
ET Tuzla
GD2: ai,j ={
,
, <
a00
a10
a20
a30
a40
a01
a11
a21
a31
a41
a02
a12
a22
a32
a42
a03
a13
a23
a33
a43
a04
a14
a24
a34
a44
a00
a10
a20
a30
a40
a01
a11
a21
a31
a41
a02
a12
a22
a32
a42
a03
a13
a23
a33
a43
a04
a14
a24
a34
a44
a00
a10
a20
a30
a40
a01
a11
a21
a31
a41
a02
a12
a22
a32
a42
a03
a13
a23
a33
a43
a04
a14
a24
a34
a44
SD1: ai,j ={
, + 1
, + < 1
SD2: ai,j ={
, + 1
, + > 1
Primjer 8
Napii program koji e uitati matricu dimenzija nxm (n,m 10), ispisati ju u obliku tabele te nai i
ispisati koordinate (red i kolona) prve i zadnje pojave najmanjeg, odnosno najveeg elementa
matice.
Pretpostavimo da je uitana matrica kao na slici. Tada bi oekivani rezultati bili:
1
0
1
1
7
5
2
2
2
8
2
4
5
0
7
1
6
6
7
0
5
4
2
8
8
U ovoj matrici najmanji element je 0. Prva pojava ovog elementa je u

redu 2 i koloni 1. Zadnja pojava je u redu 5 i koloni 4.
Najvei element je 8. Prva pojava ovog elementa je u redu 4 i koloni 5.
Zadnja pojava je u redu 5 i koloni 5.
Rjeenje
Obiljeimo promjenljive kako slijedi:
15
ET Tuzla
mini najmanji element
minip_i indeks reda prve pojave najmanjeg elementa
minip_j indeks kolone prve pojave najmanjeg elementa
miniz_i indeks reda zadnje pojave najmanjeg elementa
miniz_j indeks kolone zadnje pojave najmanjeg elementa
maxi najvei element
maxip_i indeks reda prve pojave najveeg elementa
maxip_j indeks kolone prve pojave najveeg elementa
maxiz_i indeks reda zadnje pojave najveeg elementa
maxiz_j indeks kolone zadnje pojave najveeg elementa
Najprije pronaemo najvei i najmanji element matrice:
Zatim, pronaimo traene indekse:
16
ET Tuzla
Primjer 9
Uitati kvadratnu matricu (elementi matrice su cijeli brojevi, maximalan broj redova i kolona je 10).
Formirati novu matricu kod koje su u svakom redu elementi polazne matrice poredani u rastuem
redoslijedu. Ispisati obje matrice.
Npr. ako je uitana matrica x, onda matrica y treba da bude kao na slici.
1
0
1
1
7
5
2
2
2
8
2
4
5
0
7
1
6
6
7
0
1
0
1
0
0
5
4
2
8
8
1
2
2
1
7
2
4
2
2
7
5
4
5
7
8
5
6
6
8
8
Rjeenje
Za svaki red ulazne matrice (kontrolisan indeksom i) uradimo slijedee:
-
Prepiemo i.ti red ulazne umatrice x u i.ti red matrice y

Sortiramo i.ti red. Za svaki element kolone (j) postavljamo najmanji element na poziciju j.
Koristimo algoritam za sortiranje niza Bubble sort. Trea petlja omoguava pristup elementima
j+1..n-1, s ciljem nalaenja najmanjeg elementa reda i i kolone j.
Primjer 10
Korisnik uitava n cijelih brojeva tipa long (n max =10). Prebrojati koliko puta se meu uitanim
brojevima pojavljuju cifre Dekadnog brojnog sistema.
Npr. korisnik uitava 4 broja, kako slijedi:
17
ET Tuzla
123123
3455
2232
98744
Program treba da ispie:
Cifra 0 pojavljuje se 0 puta.
...
Rjeenje:
U programu emo korisiti bibilioteku climits, pomou koje emo proitati maksimalnu vrijednost koja
se moe upisati za long tip podataka.
Konstanta LONG_MAX prikazuje maksimalnu vrijednost za tip long na datom sistemu i koritenom
kompajleru.
Cilj je od ucitanih brojeva formirati dvodimenzionalnu matricu iji elementi e biti cifre uitanih brojeva.
Nakon uitavanja broja, pomou operatora div i mode izdvajamo cifre broja i formiramo matricu cifara u
slijedeem kodu:
U prvu kolonu svakog reda upiemo koliko broj ima cifara (x[i][0]=j-1). Promjenljivu m koristimo da
bismo zapamtili maksimalan broj cifara.
Ako su ucitani brojevi
18
ET Tuzla
123123
3455
2232
98744
Ovaj kod bi u memoriju upisao:
6 3 2 1 3 2 1
4 5 5 4 3
4 2 3 2 2
5 4 4 7 8 9
U prvoj koloni je broj cifara, a u ostalim su cifre ispisane u obrnutom poretku. Neki od elemenata niza
ostaju nedefinisani, tj. Imaju vrijednosti koje su prethodno bile dodjeljene lokacijama rezervisanim pri
deklaraciji niza. Stoga emo ih definisati, tako to emo im dodijeliti vrijednost -1. To radi slijedei kod:
Sada u memoriji imamo

6 3 2 1 3 2
4 5 5 4 3 -1
4 2 3 2 2 -1
5 4 4 7 8 9
Ispiimo uitane brojeve sa
pozicioni brojni sistem:
1
-1
-1
-1
vodeim prazninama, vodei rauna o tome da je dekadni brojni sistem
Brojeve ispisujemo u poretku kako su uitani, pa je broja i u rastuem redoslijedu (for (i=0;i<n;i++)), ali
broja j postavljamo da se mijenja u opdajuem redoslijedu (j=m-1;j>0;j--), s tim to ne ispisujemo prvu
kolonu koja sadri broj cifara. Ako je u matrici -1, ispisujemo razmak.
Konano, koristimo jednodimenzionalni niz bc, kojeg naprije inicijalizujemo na 0. Zatim za svaku cifru iz
dvodimenzionalne matrice cifara uveavamo odgovarajui element jednodimenzionalnog niza.
19
ET Tuzla
Primjer 11
Napisati program koji uitava kvadratnu matricu sa maksimalno 10x10 cijelih brojeva, a zatim ispisuje
sve sub matrice reda n-1xn-1. Npr. neka imamo matricu formata 3x3
A00 A01 A02
A10 A11 A12
A20 A21 A22
Treba ispisati matrice
A11
A21
A12
A22
A10
A20
A12
A22
A10
A20
A11
A21
20
ET Tuzla
A01
A21
A02
A22
A00
A20
A02
A22
A00
A20
A01
A21
A01
A11
A02
A12
A00
A10
A02
A12
A00
A10
A01
A11
Za formiranje submatrica koristimo kod:

//formiranje sub matrica
for (r=0;r<n;r++)
for (k=0; k<n; k++)
{
cout << endl<<"Sub matrica ("<<r <<","<<k<<") "<<endl;
for (i=0;i<n ; i++)
{
for (j=0;j<n; j++)
if ((i!=r) && (j!=k))
cout <<setw(6)<<x[i][j];
cout <<endl;
}
}
21
ET Tuzla
Primjer 12
Napisati program koji omoguava unos 2D niza sa maksimalno 30 redova i 15 kolona. Potrebno je
formirati 2 nova niza koji sadre zbir elemenata po kolonama odnosno po redovima uitanog niza.
#include <iostream>
using namespace std;
int main()
{
int i,j,s, N,M,A[30][15];
int SR[30], SK[15];
//unos niza a
cout << "Unesite broj redova N -> " << endl;
cin >> N;
cout << "Unesite broj kolona M -> " << endl;
cin >> M;
cout <<"Unesite elemente matrice"<<endl;
for (i=0; i<N; i++)
for (j=0; j<M; j++)
{
cout <<"A["<<i<<","<<j<<"]=";
cin >> A[i][j];
}
// formiranje niza koji sadrzi sumu elemenata jednog reda
for (i=0; i<N; i++)
{
SR[i]=0;
for (j=0; j<M; j++)
SR[i]=SR[i]+A[i][j];
}
// formiranje niza koji sadrzi sumu elemenata jedne kolone
for (j=0; j<M; j++)
{
SK[j]=0;
for (i=0; i<N; i++)
SK[j]=SK[j]+A[i][j];
}
//ispisivanje rezultata
cout <<"Ucitana matrica, sume elemenata u redu i koloni"<<endl;
for (i=0; i<N; i++)
{
for (j=0; j<M; j++)
cout <<" " <<A[i][j];
cout <<" " << SR[i];
cout<<endl;
}
for (j=0; j<M; j++)
cout <<" "<< SK[j];
cout <<endl;
return 0;
}
22
ET Tuzla
Primjer 13
Potrebno je isprojektovati ranarsku mreu topologije zvijezda. Poloaj svakog od raunara koje je
potrebno povezati odreen je sa dvije koordinate take u ravni. Poloaj routera je u taci u
koordinatnom poetku. Potrebno je izraunati ukupnu duinu kabla potrebnog za implementiranje
mree, pod pretpostavkom da se oni polau najkraom putanjom.
Rjeenje:
#include <iostream>
#include <stdlib.h>
#include <math.h>
struct tacka
{
int x,y;
};
tacka unosTacke();
void ispisTacke(tacka t);
float udaljenost(tacka t);
int main()
{
tacka R[100];
int N,i;
float DK=0;
cout <<"Koliko racunara treba povezati? ";
cin >> N;
cout <<"Unesite koordinate racunara "<<endl;
for (i=0;i<N; i++)
{
cout <<"Unesite koordinate "<<i+1<<". racunara"<<endl;
R[i]=unosTacke();
}
cout <<"Upisali ste koordinate racunara "<<endl;
for (i=0;i<N; i++)
{
ispisTacke(R[i]);
}
//racunanje udaljenosti racunara od switcha
for (i=0;i<N; i++)
{
DK=DK+udaljenost(R[i]);
}
cout <<"Za povezivanje racunara potrebno je "<< DK <<" metara mreznog kabla"<< endl;
system("pause");
return 0;
}
tacka unosTacke()
{
23
ET Tuzla
tacka T;
cout <<"X=";
cin >> T.x;
cout <<"Y=";
cin >> T.y;
return T;
}
void ispisTacke(tacka t)
{
cout <<"("<< t.x<<","<<t.y<<")"<<endl;
return;
}
float udaljenost(tacka t)
{
return sqrt(pow(t.x,2)+pow(t.y,2));
}
ZADACI ZA VJEBU
1. Napii program koji e uitati matricu dimenzija nxm (n,m 10), ispisati ju u obliku tabele te nai
sumu (proizvod) svakog reda (stupca) matrice.
2. Napii program koji e uitati matricu dimenzija nxm (n,m 10), ispisati ju u obliku tabele te nai
sumu (proizvod) svakog reda matrice i ispisati red koji ima najveu (najmanju) sumu (proizvod).
3. Napii program koji e uitati matricu dimenzija nxm (n,m 10), ispisati ju u obliku tabele te nai i
ispisati najmanji (najvei) element matice.
ispisati u kojem koloni/redu se nalazi najmanji (najvei) element drugog reda/stupca matice.
ispisati koliko elemenata matrice je vee (manje) od prosjeka.
6. Napii program koji e uitati matricu dimenzija nxm (n,m 10), ispisati ju u obliku tabele te uitati
koordinate (r,s) nekog njenog elementa i ispisati koliko puta se taj element javlja u matrici. Takoer
treba ispisati koliko elemenata matrice je vee (manje) od tog elementa.
ispisati najmanji (najvei) maksimum (minimum) redova matice. (Nai max svakog reda i onda min
od tih brojeva. Analogno za najvei minimum)
8. Napii program koji e uitati matricu reda n (n 10), ispisati ju u obliku tabele te nai i ispisati trag
matrice. (Suma elemenata glavne dijagonale je trag matrice).
9. Napii program koji e uitati matricu reda n (n 10), ispisati ju u obliku tabele te nai i ispisati
sumu (proizvod) elemenata sporedne dijagonale.
najvei (najmanji) element glavne (sporedne) dijagonale.
najvei (najmanji) element ispod (iznad) glavne dijagonale.
24
ET Tuzla
sumu (proizvod) element ispod (iznad) glavne dijagonale.
13. Napii program koji e uitati matricu reda n (n 10), ispisati ju u obliku tabele te provjeriti i ispisati
je li ona simetrina (ai,j=aj,i) / antisimetrina (ai,j=-aj,i)
je li ona gornja (svi elementi ispod glavne dijagonale su 0) / donja (svi elementi iznad glavne
dijagonale su 0) trokutasta matrica.
15. Napii program koji e uitati 2 matrice reda n (n 10), te nai njihovu sumu i proizvod.
Novodobivenu matricu treba ispisati u obliku tabele.
16. Napii program koji e uitati matricu A reda n (n 10), a zatim formirati drugu matricu B tako da je
bi,j = proizvodu suma i-tog reda i j-tog stupca
17. Napisati program koji rauna:
A) Sumu elemenata ispod glavne dijagonale, ne raunajui elemente na glavnoj dijagonali
B) Sumu elemenata iznad glavne dijagonale, ne raunajui elemente na glavnoj dijagonali
C) Sumu elemenata ispod sporedne dijagonale, ne raunajui elemente na glavnoj dijagonali
D) Sumu elemenata iznad sporedne dijagonale, ne raunajui elemente na glavnoj dijagonali
je li ona simetrina / antisimetrina.
Matrica je simetrina ako vai, za svako i i j da je ai,j=aj,i.
Matrica je antsimetrina ako vai, za svako i i j da je ai,j=-aj,i.
19. U 2D nizu evidentira se potronja vode u nekoj zgradi. Svaki element niza sadri broj lanova
domainstva, mjesenu potronju vode (u kubnim mentrima) kao i broj stana. Potrebno je izraunati
ukupnu potronju vode po spratovima, prosjenu potronju po lanu domainstva na nivou cijele
zgrade, kao i najveeg odnosno najmanjeg potroaa vode po vertikali.
Za pohranjivanje podataka koristiti strukturu sa elementima broj stana, broj lanova domainstva i
mjesena potronja vode.
U jednom redu niza uvaju se podaci o stanovima na jednom spratu.
Jednu vertikalu ine stanovi koji se nalaze jedan ispod/iznad drugog.
25
ET Tuzla
MODUL 6: PRIMJENA
PODATAKA I POINTERA
STRUKTURA
Sloeni tipovi i strukture podataka

Do sada smo koristili samo ugraene, proste tipove podataka (int, float, char...). Svaka promjenljiva koju
smo koristili mogla je imati samo jednu vrijednost odreenog tipa. U sluaju niza, svaki element niza
mogao je imati samo jednu vrijednost odreenog prostog tipa podataka.
U praksi, esto je potrebno obraivati podatke ije svoenje na proste tipove podataka rjeavanje
problema znatno komplikuje. U takvim situacijama, moemo sami kreirati sloene, korisnike tipove
podataka.
Promjenljive koje prilikom deklaracije povezujemo sa ugraenim ili korisnikim tipovima podataka imaju
odreena ogranienja, naroito kada je u pitanju rad sa funkcijama i nizovima promjenljivih dimenzija.
U ovom modulu upoznaemo napredne strukture podataka, a to su strukture, pokazivai, reference i
povezane liste.
Strukture
esto se javlja potreba za objedinjavanjem razliitih tipova podataka u jednu cjelinu, kao to su npr.
podaci o jednom ueniku (ime, prezime, pol, razred...). U ovakvim situacijama prikladno je koritenje
sloenog tipa podataka kojeg nazivamo struktura (slog ili zapis record).
Struktura je skup jedne ili vie promjenljivih koje su povezane, odnosno grupisane, zajednikim imenom.
Razlikujemo jednostavne i sloene strukture. Struktura moe sadravati bilo koji prosti tip podatka u
C++, niz, ugnijedenu strukturu ili pokaziva.
Definicija strukture
U optem sluaju, struktura se definie na slijedei nain:
struct ime_strukture
{
tip_lana_1 naziv_lana_1;
tip_lana_2 naziv_lana_2;
...
tip_lana_n naziv_lana_n;
};
gdje je
struct kljuna rije koja oznaava poetak definisanja strukture,

ime_strukture naziv strukture,
unutar vitiastih zagrada navodimo sve lanove (elemente) strukture, tako to navodimo tip a
zatim naziv lana
26
ET Tuzla
Definicija strukture moe se navesti bilo gdje u programu, ali je obino izvan funkcije main, to je ini
dostupnom svugdje unutar programa.
Npr. slijedeim kodom definiemo strukturu uenik, koja ima tri elementa: prezime i ime tipa string i broj
tipa int.
struct Ucenik
{
string prezime;
string ime;
int broj;
};
Deklaracija promjenljive tipa struktura

Ako elimo koristiti promjenljivu tipa struktura, deklariemo je na potpuno isti nain kao i kada se
koristimo standardnim tipovima podataka. To znai, navedemo naziv strukture a zatim ime promjenljive.
Slijedi primjer deklaracije:
Ucenik osoba;
Na ovaj nain deklarisali smo promjenljivu osoba koja je tipa strukture Ucenik.
Pristup lanovima strukture
lanovima strukture pristupamo navoenjem imena promjenljive tipa struktura, take i imena lana
strukture.
Npr. Ako elimo ucitati prezime osobe, navodimo:
cin >> osoba.prezime;
Primjer 1
Napisati program koji definie strukturu Ucenik, a zatim deklarie promjenljivu osoba. Uitati i ispisati
podatke o jednoj osobi.
27
ET Tuzla
Zadatak za vjebu 1
Definisati strukturu pravougaonik, koja kao lanice ima slijedee realne podatke: a i b (stranice
pravougaonika), P (povrina pravougaonika) i O (obim pravougaonika). Napraviti funkcije za raunanje
povrine (Povrs) i obima (Obim) pravougaonika ako im se kao argumenti proslijede stranice
pravougaonika. U glavnom programu uitati elemente strukture a i b, zatim pozvati odgovarajue
funkcije za raunanje lanica strukture P i O. Ispisati sve vrijednosti lanica strukture.
Primjer 2
Definiite strukturu Vrijeme koja sadri tri lana: sati, minute i sekunde i koja predstavlja vrijeme
izraeno u satima, minutama i sekundama. Definiite funkciju UcitajVrijeme, koja uitava sate, minute i
sekunde u strukturu Vrijeme. Zatim definiite funkciju IspisiVrijeme koja ispisuje vrijeme, proslijeeno
kao parametar u funkciju, u obliku hh:mm:ss (tj. sati, minute i sekunde se ispisuju kao dvocifreni brojevi
sa, eventualno, vodeim nulama. Zatim definisati funkciju SaberiVrijeme koja prima dva vremena koja
su proslijeena kao parametri i vraa tree vrijeme koje nastaje sabiranjem dva ulazna vremena (npr.
sabiranjem 3h 34min 52sec i 4h 42min i 20sec treba da se dobije vrijeme 8h 17 min 12 sec).
Napraviti testni program koji testira sve funkcije.
Rjeenje
Najprije definiemo strukturu i sve funkcije.
28
ET Tuzla
Funkcija UcitajVrijeme provjerava unos vrijednosti i vraa strukturu Vrijeme. Funkcija IspisiVrijeme ne
vraa nikakvu vrijednost:
U funkciji main testiramo ove dvije funkcije:
29
ET Tuzla
Startovanjem programa dobijemo:
Funkcija SaberiVrijeme koristi cjelobrojno dijeljenje i operator modul za raunanje sabranih sekundi,
minuta i sekundi, kako slijedi:
Za testiranje koristimo kod:
Zadaci za vjebu:
1. Ispraviti funkciju SaberiVrijeme iz prethodnog zadatka tako da vri provjeru zbira sati kako bi
umjesto ispisa 25 sati ispisala vrijeme 01 sati.
2. Napisati programi koji izraunava udaljenost izmeu dvije take odreene koordinatama x i y. U
programu koristiti strukturu taka, koja sadri lanice x i y, a koje predstavljaju koordinate take
30
ET Tuzla
u ravni. Za unos koordinata take napraviti funkciju uitajTaku a za ispis funkciju ispisiTacku.
Napraviti i funkciju udaljenost za raunanje udaljenosti izmeu dvije take u ravni.
3. Napisati program koji izvava osnovne operacije (+,- * i /) nad kompleksnim brojevima. Koristiti
strukturu kompleksan_broj koja ima dva lana: realni_dio i imaginarni_dio. Napraviti funkcije za
unos i ispis kompleksnog broja. Za svaku operaciju napisati funkciju, te je pozvati u glavnom
programu.
Uputstvo:
Neka su z1=x1+iy1 i z2=x2+iy2 dva kompleksna broja. Raunske operacije su definisane na sljedei
nain:
Struktura i niz
Promjenljive tipa niz takoer mogu kao elemente imati strukturu podataka. Npr, ako u programu treba
obraivati podatke o vie uenika, deklariemo niz kao
Ucenik ucenici[30];
Elementima niza/ strukture pristupamo ovako:

Ucenici [i].prezime
Primjer 3
Definisati strukturu uenik, sa lanovima prezime, ime i prosjek. Napraviti program koji uitava podatke
o N ucenika a zatim ispisuje ime, prezime i prosjek svakog uenika, a zatim uenika sa najveim
prosjekom.
Rjeenje
Definisanje strukture ucenik i promjenljive razred, koja je niz promjenljivih tipa uenik
31
ET Tuzla
Struktura kao lan strukture

Definicja strukture moe sadrati lan koji je tipa struktura. Npr. definiimo strukturu datum
struct datum
{
int dan;
int mjesec;
32
ET Tuzla
int godina;
};
Zatim definiimo strukturu ija lanica je tipa datum:

struct ucenik
{
char ime[15];
char prezime[15];
int maticni;
float prosjek;
struct datum rodjendan;
}
Ako je lan strukture takoer struktura, za pristup lanicama strukture koristimo taku da odvojimo
naziv promjenljive i ime lana, sve do posljenjeg lana sloene strukture. Npr.
cout<<"Datum rodjenja, dan: ";
cin>>razred[i].rodjendan.dan;
cout<<" Datum rodjenja, mjesec: ";
cin>>razred[i].rodjendan.mjesec;
cout<<" Datum rodjenja, godina: ";
cin>>razred[i].rodjendan.godina;
Primjer:
Za potrebe ski centra, potrebno je napisati program za evidenciju rezultata i formiranje rang liste.
Podaci o takmienju uvaju se u jednodimenzionalnom nizu iji elementi su tipa strukture koja ima dvije
lanice: startni broj i vrijeme. Vrijeme je promjenljiva tipa strukture Vrijeme, koja ima lanice minute,
sekunde, stotinke.
Potrebno je formirati i ispisati rang listu takmienja koja sadri startni broj i vrijeme takmiara sortirano
u opadajuem redoslijedu.
Rjeenje:
Za prvi niz u kojem pohranjujemo vrijeme spusta koristimo strukturu Vrijeme, kako slijedi:
Komponenta vInt je integer reprenzentacija vremena koja se rauna kao

vInt = stotinke + 100*sekunde + 6000*minute
Ova vrijednost rauna se prilikom uitavanja podataka o vremenu, u okviru funkcije za uitavanje
vremena, kako slijedi:
33
ET Tuzla
Elementi niza kojeg program koristi su tipa strukture Takmicar, ija lanica je promjenljiva strukture
Vrijeme:
U ovoj definiciji strukture koristi se struktura u strukturi, jer je lanica v tipa strukture Vrijeme.
Deklaracija niza iji elementi su tipa Takmicar slijedi:
Uitavanje elemenata niza vri kod:
Nakon uitavanja podataka, niz sortiramo u opadajuem redoslijedu:
34
ET Tuzla
Sortirani niz zatim ispisujemo:
U prethodnom kodu koristi se funkcija IspisTakmicara, koja poziva funkciju IspisVremena. Slijedi kod za
obje funkcije:
Primjer izvravanja programa:
35
ET Tuzla
Zadaci za vjebu:
1. Modifikovati primjer 3, tako to se, uz ostalo, za uenika uitava i datum roenja. Takoer, kod
ispisa najboljeg uenika ispisati i datum roenja.
2. Modifikovati primjer 3, tako da uzima u obzir mogunost da vie uenika ima isti prosjek. Ispisati
sve uenike iji prosjek je jednak maksimalnom.
3. Modifikovati primjer 3, tako to dodajemo funkcije za sortiranje uenika po rednom broju,
prosjeku i prezimenu.
4. Napraviti strukturu tacka ije lanice su koordinate x i y. Zatim definisati strukturu tougao, ije
lanice su tri take koje predstavljaju tjemena trougla, kao i lanice povrina i obim trougla.
Napraviti funkcije za:
- Unos tjemena trogula
- Raunanje udaljenosti izmeu dvije take
- Raunanje obima trougla
- Raunanje povrine trougla
U glavnom programu korisnik uitava podatke o n trouglova, a zatim ispisati podatke o trouglu
ija povrina je najvea.
5. Napisati program za uitavanje 2d niza (max 10*10) iji elementi su tipa strukture koja sadri
informacije o trouglu. Za svaki trougao uvaju se slijedei podaci: duine stranica (a,b,c),
povrina i obim pravouglog trougla. Napraviti funkcije za uitavanje promjenljive tipa strukture
trougao i ispisivanje podataka iz strukture.
a. Pronai trougao ija povrina je najvea, a njegovi podaci su na glavnoj dijagonali.
b. Izraunati ukupnu povrinu svih trougla u 2d nizu.
c. Ispisati podatke o trouglu sa najmanjim obimom.
6. Za potrebe ski centra, potrebno je napisati program za evidenciju rezultata i formiranje rang
liste.
Za evidenciju rezultata (vrijeme spusta) formirati 2D niz. Elementi niza su tipa strukture koja
omoguava uvanje vremena a iji elementi su minute, sekunde i stotinke (max dim niza 20x3).
2D niz u jednom redu uva podatke o jednom takmiaru, tako to se u prvu kolonu upisuje
rezultat prve, a u drugu kolonu rezultat drugog spusta. Indeks reda uvean za jedan je startni
broj takmiara.
Za formiranje rang liste uzima se bolje vrijeme.
Rang listu takmienja implementirati kao novi, jednodimenzionalni niz iji elementi sadre
srednje vrijeme takmiara sortirano u opadajuem redoslijedu.
Primjer izvravanja programa:
36
ET Tuzla
Unos podataka
Ispis uitanih podataka i rang liste
37
ET Tuzla
POKAZIVAI (POINTERS)
Statike i dinamike promjenljive
Do sada smo koristili statike promjenljive. Npr. u naredbama koje slijede, odreujemo da se u toku
izvravanja programa rezervie memorijska lokacija za smjetaj cjelobrojnog podatka sa simbolikim
imenom a, a zatim toj promjenljivoj dodjeljujemo vrijednost 10. a je statika promjenljiva:
int a;
a=10;
Statika promjenljiva predstavlja imenovani prostor koji sadri vrijednost. Memorijska lokacija na kojoj je
ta promjenljiva ostaje zauzeta svo vrijeme trajanja programa.
Za razliku od statike, pokaziva je promjenljiva koja pokazuje na drugu promjenljivu. Pokaziva sadri
memorijsku adresu na kojoj se nalazi vrijednost. Taj memorijski sadraj na koji pokazuje pokaziva
predstavlja dinamiku promjenljivu.
Pokazivai
Pokaziva je promjenljiva koja uva memorijsku adresu.
Memorija raunara je podijeljena na sekvencijalno oznaene memorijske lokacije. Svaka lokacija ima
adresu. Adresa lokacije moe se uvati u pokazivau.
Kocka simboliki oznaava memorijsku lokaciju u kojoj se uva objekat. objekat je

promjenljiva. Njena trenutna vrijednost je 6.
obj
eka
Ox999AC
t
Promjenljiva koja sadri adresu memorijske lokacije u kojoj se uva objekat

prikazana je strelicom kao na slici (objekat_ptr). Promjenljiva objekat_ptr je
pokaziva. Pokaziva sadri adresu promjenljive. Pokaziva pokazuje na
promjenljivu. Nazivamo ga i adresnom promjenljivom, jer sadri adresu druge
promjenljive.
Deklaracija pokazivaa
Pokaziva deklariemo navoenjem tipa promjenljive na koju e pokazivati i znaka asterisk (*) ispred
imena koje dodijelimo pokazivakoj promjenljivoj. Npr.
int objekat;
in *objekat_ptr;
// objekat je promjenljiva tipa int

// *objekat_ptr je pokaziva na promjenljvu tipa integer
Operatori
Operatori koji se koriste sa pokazivaima dati su u tabeli:
38
ET Tuzla
Operator
Znaenje
Dereferenciranje - Vraa vrijednost promjenljive koja je na lokaciji na koju pokazuje

pokaziva
&
Referenciranje - Vraa adresu lokacije na kojoj je promjenljiva ije ime se navodi nakon
operatora
Slijede primjeri koritenja operatora.

int objekat =5;
int *objekat_ptr;
objekat_ptr = &objekat;
objekat je promjenljiva koja ima vrijednost 5.

objekat_ptr je pokaziva na lokaciju na kojoj je
cjelobrojna promjenljiva.
Pokazivau objekat_ptr dodjeljuje se adresa na
kojoj je promjenljiva objekat.
drugi_objekat = *objekat_ptr;
Promjenljiva drugi_objekat dobiva vrijednost koja

se uva na adresi koja je u pokazivau objekat_ptr.
*objekat_ptr = 6;
U promjenljivu ija je adresa u pokazivau

objekat_ptr smjeta se vrijednost 6. Objekat_ptr
sadri adresu promjenljive objekat, te promjenljiva
objekat poprima vrijednost 6.
Primjetimo da se operator * moe imati razliite funkcije:
u deklaraciji pokazivaa int

kao operator dereferenciranja
kao operator mnoenja
int *x_ptr;
y = *x_ptr;
z =x*z;
39
ET Tuzla
Primjer 1
U slijedeem primjeru ilustrujemo koritenje pokazivaa i operatora * i &. Deklariemo statiku
promjenljivu Godina i pokaziva pGodina, a zatim dodjeljujemo adrese, vrijednosti sa adresa i
vrijednosti.
Vano je istaknuti da postoji bitna razlika izmeu deklaracije statike promjenljive i deklaracije pointera.
Kada deklariemo pointer, ne dovodimo ga u vezu ni sa jednom memorijskom lokacijom. Ako to elimo
uraditi, koristi se slubena rije new.
Ako deklariemo pokaziva zadajemo naredbu:
int *a;
Ovom naredbom samo deklariemo pokaziva, ali ne i lokaciju na koju on pokazuje. Pokaziva ne sadri
nikakvu vrijednost.
Slijedeom naredbom rezerviemo memorijsku lokaciju u koju se moe smjestiti cio broj a njenu adresu
dodjeljujemo pointeru. Kaemo, alociramo memoriju za pointer.
a=new int;
Ove dvije naredbe moemo objediniti naredbom:

int *a = new int;
I do sada smo statike promjenljive istom naredbom deklarisali (najavljivali njihovo koritenje) i
inicijalizovali (dodjelivali poetnu vrijednost promjenljivoj). Analogno tome, moemo rei da pointere u
40
ET Tuzla
jednoj naredbi deklariemo i inicijalizujemo, pomou new(). Dodatno, rezerviemo i memorijsku lokaciju
za promjenljivu ija adresa se smjesti u pokaziva.
U dosadanjim primjerima, pointeru smo dodjeljivali vrijednost pomou operatora referenciranja (&), uz
prethodnu deklaraciju statike promjenljive. Koritenjem new izbjegavamo koritenje statikih
promjenljivih.
Slijedi primjer koji ilustruje alokaciju memorije za pointer.
Ovaj kod moemo predstaviti grafiki kako slijedi:
41
ET Tuzla
Pokuajmo napraviti analogiju izmeu pokazivaa i daljinskog upravljaa za neki ureaj. Daljinski ureaj
sam za sebe nema upotrebnu vrijednost ako nema i ureaja kojim emo upravljati. Ako ureaj nema
svoje vlastite komande, onda je on neupotrebljiv ako nemamo daljinski ureaj.
Ako je pokaziva daljinski za tv ureaj, onda naredbom

int *p;
samo obezbjeujemo daljinski. Slijedeom naredbom obezbjeujemo tv i dovodimo ga u vezu sa
daljinskim:
p = new int;
Obje radnje obezbjeujemo slijdeom naredbom:
Int *p = new int;
Ovom naredbom daljinski i tv postaju upotrebljivi!
Zadaci za vjebu
Testirajte slijedei kod i ispravite greku
42
ET Tuzla
Ma kako komplikovano izgledalo, pravila za rad sa pokazivaima se svode na slijedea prosta pravila:
1. Pointeri uvaju adrese promjenljivih. Promjenljive uvaju podatke.
2. Do vrijednosti promjenljive na koju pokazuje pointer dolazimo pomou operatora
dereferenciranje (*). Dereferenciranje se moe izvriti samo ako je prethodno u pointer
smjetena adresa memorijske lokacije. Veina bug-ova sa pointerima posljedica je nepotivanja
ovog pravila.
3. Samom deklaracijom pointera ne dovodimo ga u vezu sa promjenljivom. To moemo uraditi
pomou new. Na ovaj nain, inicijalizujemo pointer.
4. Operatorom dodjele vrijednosti izmeu dva pointera postiemo da oni pokazuju na istu
memorijsku lokaciju (istu promenljivu).
Pitanja za ponavljanje
1. Koji operator se koristi za odreivanje adrese promjenljive?
2. Koji operator se koristi za nalaenje vrijednosti na adresi koja se uva u pokazivau?
43
ET Tuzla
3. ta je pokaziva?
4. Koja je razlika izmeu adrese koju uva pokaziva i vrijednosti na toj adresi?
5. Koja je razlika izmedu operatora referencijranja i dereferenciranja?
6. ta rade ove deklaracije?
a. int *pOne;
b. int vTwo;
c. int *pThree = &vTwo;
7. Ako imate unsigned short promjeljivu yourAge, kako biste deklarisali pokaziva za manipulisanje
promjenljivom yourAge?
8. Dodjelite vrijednost 50 promjenljivoj yourAge, koritenjem pokazivaa, koji je deklarisan u
pitanju 7.
9. Napiite mali program koji deklarie cjelobrojnu vrijednost i pokaziva na cjelobrojnu vrijednost.
Dodjelite pokazivau adresu cjelobrojne vrijednosti. Upotrijebite pokaziva za postavljanje
vrijednosti u cjelobrojnoj promjenljivoj.
10. ta nije u redu sa ovim kodom:
int main()
{
int *pInt;
*pInt = 9;
cout << Vrijednost na pInt je << *pInt;
return 0; }
11. ta nije u redu sa ovim kodom:

int main()
{
int someVariable = 5;
cout <<Some variable: <<someVariable<<endl;
int *pVar =&someVariable;
pVar = 9;
cout << someVariable: <<*pVar << endl;
return 0;
}
44
ET Tuzla
POINTERI, vjeba 1
Uputstvo: Svaki zadatak najprije prepisati u svesku, a zatim ga u svesci i uraditi. Zadatak 1 testirati na
raunaru.
1.
a)
Napisati C++ program koji sadri slijedee naredbe deklaracije. Neka program koristi operator
referenciranja i operator cout kako bi ispisao adresu svake od deklarisanih varijabli.
int num, count;
long date;
float slope;
double yield;
b) Testirati program i napisati objanjenje za funkciju sizeof()

#include <iostream>
int main()
{
int num;
num = 22;
cout <<The value stored in num is << num <<endl;
cout << sizeof(num) << bytes are used to store this value << endl;
return 0;
}
c)
Nakon testiranja programa 1. a, modifikovati program tako da se, koritenjem funkcije sizeof(), prikazuje
koliko bajta zauzima svaka od promjenljivih deklarisanih u programu.
d) Nacrtati logiku predstavu memorije i ucrtati lokacije koje zauzimaju promjenljive iz ovog programa.
Naznaiti adrese (proizvoljne oznake).
2.
Napisati naredbe deklaracije za:
a.
b.
c.
d.
e.
f.
g.
h.
i.
j.
yAddr koji pokazuje na int lokaciju

Pointer chAddr koji pokazuje character.
Pointer ptYr koji pokazuje long integer.
Pointer amt koji pokazuje double-precision variable.
Pointer z koji pokazuje integer.
Pointer qp koji pokazuje single-precision variable.
datePt pointer koji pokazuje integer.
yldAddr pointer koji pokazuje double-precision variable.
amtPt pointer koji pokazuje single-precision variable.
ptChr pointer koji pokazuje character variable.
3. Napisati punu reenicu na naem jeziku koja objanjava slijedee deklaracije varijabli:
a.
b.
c.
d.
e.
f.
4.
char *keyAddr;
int *m;
double *yldAddr;
long *yPtr;
double *pCou;
int *ptDate;
Koja od slijedeih naredbi je naredba deklaracije pointera?
45
ET Tuzla
a.
b.
c.
d.
e.
f.
g.
h.
i.
long a;
char b;
char *c;
int x;
int *p;
double w;
float *k;
float l;
double *z;
5.
Uzimajui u obzir slijedee naredbe deklaracije:

a. int *xPt,*yAddr;
b. long *dtAddr, *ptAddr;
c. double *ptZ;
d. int a;
e. long b;
f. double c;
odrediti koje od slijedeih naredbi su ispravne:
a. yAddr = &a;
b. yAddr = &b;
c. yAddr = &c;
d. yAddr = a;
e. yAddr = b;
f. yAddr = c;
g. dtAddr = &a;
h. dtAddr = &b;
i. dtAddr = &c;
j. dtAddr = a;
k. dtAddr = b;
l. dtAddr = c;
m. ptZ = &a;
n. ptAddr = &b;
o. ptAddr = &c;
p. ptAddr = a;
q. ptAddr = b;
r. ptAddr = c;
s. yAddr = xPt;
t. yAddr = dtAddr;
u. yAddr = ptAddr;
6.
Popuniti memorijske lokacije prikazane na slici, nakon izvravanja slijedeih naredbi:

a. ptNum = &m;
b. amtAddr = &amt;
c. *zAddr = 25;
d. k = *numAddr;
e. ptDay = zAddr;
f. *ptYr = 2011;
g. *amtAddr = *numAddr;
46
ET Tuzla
47
ET Tuzla
Reference
Referenca je alijas alternativno ime drugog objekta. Kada kreirate referncu, inicjalizujete je imenom
drugog objekta mete. Od tog momenta, referenca se ponaa kao drugo ime tog objekta, te sve to
radimo referenci uistinu radimo meti.
Referencu kreiramo navoenjem tipa ciljanog objekta, praeno operatorom &, poslije ega slijedi ime
reference. Npr. ako imamo cjelobrojnu promjenljivu someInt, referencu na tu promjenljivu pravimo
naredbom:
int &rSomeRef = someInt;
Ovo se ita kao: rSomeRef je referenca na cjelobrojnu vrijednost koja je inicijalizovana da pokazuje na
cjelobrojnu promjenljivu someInt.
Pogledajmo slijedee naredbe deklaracije:
int Godina;
int &rGodina = Godina;
ta bi bio efekat ovih naredbi?

Godina = 2000;
cout << Godina;
cout << rGodina;
Na ekranu bi bila ispisana ista vrijednost!
48
ET Tuzla
Podruje primjene pokazivaa i referenci

Prilikom koritenja funkcija, uoili smo da funkcije imaju dva ogranienja:
1. Argumenti se funkciji predaju po vrijednosti
2. Funkcija moe vratiti samo jednu vrijednost
Zato su to ogranienja?
Argumenti koji se predaju funkciji su lokalni za tu funkciju. Promjene koje se deavaju nad tim
argumentima u funkciji ustvari ne mijenjaju originalne argumente u funkcije iz koje je pozvana. Ovo je
poznato kao predavanje po vrijednosti, to znaci da se u funkciji pravi lokalna kopija svakog argument.
Koritenjem pokazivaa i referenci oba ova ogranienja mogu se prevazii. Koritenjem pokazivaa i
referenci, funkcija nee kreirati kopiju objekta ve e promjene vriti nad orginalnim objektom.
U narednom primjeru funkciji Zamjena argumente predajemo po vrijednosti. To znai da de se pozivom
funkcije napraviti lokalne kopije. Funkcija mijenja lokalne kopije, a ne promjenljive iz pozivajue funkcije.
Poto funkcija radi sa kopijama proslijeenih vrijednost, nakon povratka u funkciju main, vrijednosti x i y
su nepromijenjene.
49
ET Tuzla
Ukoliko funkciji proslijedimo adrese promjenljivih tj. pokazivae na promjenljive, onda e funkcija
manipulisati vrijednostima na toj adresi. Ovo rjeenje zahtijeva odreene izmjene u samoj funkciji,
obratite panju. Poto se funkciji prosljeuju adrese promjenljivih, dereferenciranjem dolazimo do
njihovih vrijednosti.
Nakon povratka u funkciju main vrijednosti x i y su zamijenjene.

Ipak, ovo rjeenje ima odredene nedostatke. Potreba za dereferenciranjem pokazivaa ini ga tekim za
itanje i podlonim grekama. Ovo bismo mogli uraditi i pomou referenci, kao u listingu koji slijedi:
50
ET Tuzla
Parametri funkcije deklarisani su kao reference, te se stoga mijenjaju i u funkciji main. Pozivajua
funkcija razlikuje da li se parametar predaje po referenci ili po vrijednosti na osnovu prototipa
funkcije.
Prosljeivanjem parametara kao pokazivaa ili referenci rjeavamo oba problema:
-
funkcija mijenja promjenljive u onoj iz koje je pozvana, umjesto da radi sa lokanim kopijama
tih promjenljivih.
Istovremeno, rjeen je i drugi problem, jer sada funkcija moe indirektno, preko
promjenjivih, vratiti vie vrijednosti. Npr. U prethodnom primjeru izmjenjene su dvije
vrijednosti, x i y, to se moe tumaiti kao vraanje dvije vrijednosti.
Potvrdimo prethodno i slijedeim primjerom. Program sadri funkciju koja izraunava kvadrat i kub
zadatog broja.
Prototip funkcije je
int Faktor (int n, int *kvadrat, int *kub);
Dakle, argumetni funkcije su:

n cjelobrojna promjenljiva,
*kvadrat pokazivac na cjelobrojnu promjenljivu i
51
ET Tuzla
*kub pokazivac na cjelobrojnu promjenljivu.
U pozivu funkcije imamo:
greska = Faktor(x, &x2, &x3);
Dakle, proslijeujemo promjenljivu x i adrese promjenljivih x2 i x3.

Implementacija funkcije je data slijedeim kodom:
Posmatrajmo naredbe:
*kvadrat = n*n;
//na adresu koju cuva pokazivac *kvadrat upisujemo kvadrat vrijednosti u promjenljivoj x
*kub = n*n*n;
//na adresu koju cuva pokazivac *kub upisujemo kub vrijednosti u promjenljivoj x
Na ovaj nain funkcija mijenja dvije vrijednosti koje su dostupne u funkciji iz koje je pozvana. Stoga,
koritenjem pokazivaa moemo prevazii problem vraanja jedne vrijenosti u okviru naredbe return.
Vjebe
1. Deklarisati funkciju Hex, koja uzima promjenljivu p kao parameter a vraa 8 znakova (heksadecimalni
broj) koji predstavlja sadraj pokazivaa, tj adresu koju on uva.
void Hex(void* p)
{
cout << hex << setfill('0') << setw(8) << (long) p << ends;
return;
}
Deklariite cjelobrojne promjenljive x i y, kao i int* pokazivae p i q. Promjenljivoj x dodijelite 2,

promjenljivoj y dodijelite 8, p adresu od x i q adresu od y. Zatim ispiite slijedee informacije:
Adresu od x i vrijednost x.
Vrijednost p i vrijednost *p.
Adresu od y i vrijednost y.
Vrijednost q i vrijednost *q.
Adresu od p (ne sadraj!)
52
ET Tuzla
Adresu od q (ne sadraj!)
Koristite Hex funkciju da biste ispisali vrijednost u pokazivau.

2. Deklariite cjelobrojne promjenljive x, y, z kao i int* pokazivae p, q, r. Postavite u x, y, z tri razliite
vrijednosti. Postavite u p, q, r adrese promjenljivih x, y, z, respektivno.
Ispiite vrijednosti x, y, z, p, q, r, *p, *q, *r (svakoj vrijednosti prethodi komentar).

Ispiite: Zamjena vrijednosti.
Izvrite kod zamjene: z = x; x = y; y = z;
Ispiite vrijednosti x, y, z, p, q, r, *p, *q, *r (svakoj vrijednosti prethodi komentar).
Nacrtajte na papiru ta se deava sa promjenljivim
53
ET Tuzla
Pokazivai i nizovi
Pokazivae moemo koristiti i za rad sa nizovima. Posmatrajmo primjer slijedeih deklaracija:
char array[10];
char *array_ptr = array;
Prvom naredbom deklarisali smo niz znakova sa maksimalno 10 elemenata. Drugom naredbom
deklariemo pokaziva array_ptr i inicijalizujemo ga adresom prvog elementa niza. Zadnja naredba
mogla bi se napisati i na slijedei nain:
char *array_ptr = &array[0];
Sada elementima niza moemo pristupati pomou pokazivaa array_ptr: Npr. ovom naredbom
ispisujemo prvi element niza
cout << *array_ptr;
Drugi element niza ispisujemo naredbom

cout << *(array_ptr+1);
Slijedee naredbe imaju isti efekat:

cout << *array_ptr;
cout << *(array_ptr + 1);
cout << *(array_ptr + 2);
isto to i
isto to i
isto to i
cout << array[0] ;

cout << array[1] ;
cout << array[2] ;
Kada deklariemo niz, za elemente niza rezerviemo susjedne lokacije. Ako pokazivau dodjelimo adresu
prvog elementa niza, onda ostalim elementima moemo pristupati tako to emo manipulisati adresom
prvog elementa dodavanjem (ili oduzimanjem) cjelobrojne vrijednosti. Izraz *(array_ptr + 2) znai
uveaj adresu prvog elemnta za 2, a efekat je da pokaziva zapravo sadri adresu treeg elementa
niza.
Ovo moemo predstaviti grafiki, kako slijedi:
array_ptr
0x5000
array_ptr+2
0x5002
Adresa na kojoj je prvi element niza je u pokazivau array_ptr (0x5000). Treem elementu niza moe se
pristupiti pomou pokazivaa ako mu dodamo vrijednost 2 (array_ptr+2).
54
ET Tuzla
Primjer 1: Napisati program koji uitava niz od N znakova. Zatim ispisati elemente niza koritenjem
pokazivaa.
Za vjebu: Modifikovati prethodni zadatak tako da omoguava da se uita reenica (dozvoliti unos
razmaka) tako da se izvravanjem programa moe dobiti rezultat kao u drugom primjeru.
Na prvi pogled, ovo izgleda kao komplikovaniji nain koritenja jednostavnih nizova. Poet emo sa
jednostavnom aritmetikom sa pokazivaima. Poslije emo koristiti sloenije pokazivae za efikasan rad
sa znatno komplikovanijim strukturama.
Slijedei program vraa broj elemenata prije prve nule u nizu, inicijalizovanom pri deklaraciji. U nizu
mora biti barem jedna nula. Program se zaustavlja kada naie na prvu nulu.
Slijedi rjeenje bez pointera.
55
ET Tuzla
Zatim, rjeenje pomou pointera na elemente niza:
Primjer 2
Uitati liniju teksta koja sadri prezime i ime u slijededoj formi:
Prezime/Ime
(Dakle, ime i prezime su odvojeni znakom /). Napisati program koji razdvaja ime i prezime.
Primjer (Izgled ekrana po startovanju programa):
Unesite prezime/ime: Krajinovic/Selma
Prezime: Krajinovic
Ime: Selma
U ovom programu koristit emo funkciju strchr. Funkcija vraa pokaziva na poziciju na kojoj se prvi
puta pojavljuje navedeni karakter. Karakter koji oznaava kraj stringa \n takoer moe da se locira
pomou ove funkcije.
Format funkcije: char * strchr ( char * str, int character );
Parametri
str je pokazivac na C string.

character je znak cija pozicija se trai. (proslijeuje se integer vrijednost karaktera, koja se
interno konvertuje u znak)
Povratna vrijednost
Pokaziva na poziciju na kojoj se prvi puta pojavljuje karakter. Ako karakter nije pronaen,
funkcija vraa null pokaziva
56
ET Tuzla
Za rjeavanje problema iz zadatka, pomou funkcije strchr nai emo poziciju karaktera /. Koristimo
dva pokazivaa:
ime_ptr pokazuje na karakter kojim poinje ime

prezime_ptr pokazuje na karakter kojim poinje prezime
Karakter / u ulaznom stringu zamijenit emo karakterom \0. Ova Esc sekvenca oznaava prelazak u
novi red, to emo iskoristiti da ulazni niz ispiemo u dva reda. Pogledajmo grafiki prikaz:
Slijedi kod:
57
ET Tuzla
Slijedi objanjenje za pojedine linije koda
Primjer 3
Uitati prezime i ime u format: Prezime/ime. Ispisati inicijale . Izgled ekrana:
Primjer 4
Napisati program koji uitava rije i karakter, a zatim funkciju koja ispituje koliko puta se u nekom
stringu pojavljuje neki karakter. U glavnom programu pozvati funkciju i ispisati rezultat.
58
ET Tuzla
Zadaci za vjebu
1. U ulaznoj datoteci podaci.xls nalaze se podaci o uenicima:
Prezime
Ime
Adresa
Grad
Potanski broj
Podaci su razdvojeni znakom ;. Ispisati tekst za naljepnicu na koverti u obliku:

Prezime i ime
Adresa
Grad i postanski broj
2. Napraviti funkciju za spajanje dva stringa u jedan string, drugi se dodaje na poetak prvog. Testirati
fju.
59
ET Tuzla
3. Napraviti funkciju za uporeivanje jednog znakovnog niza (stringa) s drugim, vratiti nulu ako su
jednaki, odnosno 1 ako nisu jednaki. Testirati fju.
4. Unesite tekst sa standardnog ulaza, a zatim odredite koliko ima suglasnika u zadanom tekstu.
5. Unesi tekst sa standardnog ulaza, a zatim unesi slovo iju prvu pojavu u uneenom tekstu traite. Ako
je slovo pronadeno ispiite njegov poloaj u rijeci. Koristite pokazivae.
6. Unesite reenicu sa standardnog ulaza, a zatim unesite rije koju traite u uneenom tekstu. Ako je
rije pronaena ispiite njen poloaj u reenici. Koristite pokazivae.
60
ET Tuzla
Povezane liste
Za pohranjivanje skupa podataka istoga tipa do sada smo koristili nizove. Neka imamo slijedee
deklaracije:
struct ucenik
{ char ime[20];
int godine;
float visina;
}
ucenik razred[30];
// ime do 20 karaktera
// godine starosti
// u metrima
Prethodnim naredbama smo deklarisali strukturu ucenik i niz iji su elementi tipa strukture ucenik.
Prilikom deklaracije niza moramo navesti maksimalan broj elemenata niza, to predstavlja veliko
ogranienje ove vrste podataka. Naime, ukoliko navedemo veliki broj elemenata, rizikujemo da e
program nepotrebno zauzeti veliki memorijski prostor. Ako navedemo mali broj elemenata, rizikujemo
da program nee zadovoljavati potrebe korisnika. Stoga, potreba dimenzionisanja niza gotovo uvijek
predstavlja problem, jer je nemogue predvidjeti koliko elemenata niz uistinu ima kada se program
pokrene.
Kao rjeenje ovog problema moe se koristiti povezana lista. Meutim, svako rjeenje ima i
odgovarajue mane. Jedna od mana povezane liste jeste i to to imaju loe performance kada je u
pitanju sluajan pristup. Naime, povezana lista zahtijeva sekvencijalnu obradu, koja zahtijeva mnogo
vremena za itanje eljene, sluajno odabrane vrijednosti.
ta je povezana lista?
Povezana lista je sloena struktura podataka koju ine vorovi. vor, kao osnovni element povezane
liste baziran je na tipu podataka struktura, koja sadri informacioni dio (za uvanje podataka) i bar jedan
pointer. Povezanu listu ini lanac vorova koje meusobno povezuju pointeri.
Postoje jednostruko i dvostruko povezane liste. Jednostruko povezana lista sadri pokaziva na slijedei
vor, a dvostruko povezane sadri dva pokazivaa: jedan pokazuje na slijedei a jedan na prethodni vor.
Jednostruko povezanu listu moemo predstaviti ovako:
Info
info
info
info
info
NULL
info
info
NULL
slijedei
Dvostruko povezana lista sadri dva pokazivaa u svakom voru:

Info
info
info
Slijedei
NULL
prethodni
Upoznat emo jednostruko povezanu listu. Na slici je primjer jednostruko povezane liste:
61
ET Tuzla
START
Ime:
Edo
Godine:
34
Visina: 1.7
Ime:
Damir
Godine:
27
Visina: 1.2
Ime:
Davor
Godine:
48
Visina: 1.4
Ime:
Marina
Godine:
30
Visina: 1.3
NULL
Povezana lista na slici sadri 4 vora, pri emu svaki, osim poslednjeg, sadri pokaziva na slijedei vor.
Poslednji vor umjesto pokazivaa na slijedei vor, sadri vezu sa specijalnom vrijednou NULL, to
oznaava kraj liste. Postoji jo jedan specijalni pokaziva, Start, koji pokazuje na prvi vor u lancu.
Kako bismo razumjeli ta je uistinu povezana lista, posmatrajmo jednostavan primjer. Uitat emo rije,
a zatim znakove smjestiti u jednostruko povezanu listu, dodavajui slovo po slovo na kraj liste.
N
UL
L
F
Za kreiranje ovakve liste definisat emo najprije strukturu podataka:
Prvi element, slovo, sadrat e korisnu informaciju. U ovom primjeru, tu emo upisivati slova iz
uitane rijei. Drugi element, slijedeci, je pokaziva na slijedei element liste. Zadnji vor imat e
vrijednost NULL u elementu slijedeci.
Koristit emo slijedee pokazivaa na ovu strukturu:
-
start_ptr, pokaziva na prvi vor liste. U svakom trenutku, ovaj pokaziva sadrat e
adresu prvog elementa u listi. Na poetku, kada je lista prazna, ovaj pokaziva sadri
vrijednost NULL. Kasnije, kada dodamo prvi vor u listu, ovdje sauvamo adresu prvog
vora. Ne smijemo izgubiti ovu vrijednost, ako se to ipak desi, izgubili smo cijelu listu!
zadnji, pokaziva na zadnji vor u listi. Kada dodajemo vor u listu, koristimo pokaziva
zadnji kako bismo novi vor uistinu povezali sa listom.
novi, pokaziva na vor kojeg dodajemo u listu. Kada dodajemo novi vor, pomou ovog
pokazivaa alociramo prostor, upisujemo vrijednosti i konano, povezujemo novi vor sa
listom.
62
ET Tuzla
Uitat emo rije u promjenljivu tipa string. Zatim emo, slovo po slovo, dodavati vorove na kraj liste.
Sada emo od uitane rijei formirati jednostruko povezanu listu. Najprije emo postaviti start_ptr na
NULL vrijednost. Koristit emo promjenljivu i za pristup karakterima uitanog stringa, te petlju while u
okviru koje testiramo da li je kraj stringa.
Alociramo memorijske lokacije za novi vor. U lanicu

structure slovo upiemo znak. Poto se vor dodaje na
kraj liste, slijedeci postaje NULL (nema vie vorova u
listi).
Provjeravamo da li je ovo prvi vor. Ako jeste, njegovu
adresu sauvamo u pokazivau start_ptr. Ako nije prvi
vor, upisujemo u zadnji vor adresu novog. Za tu radnju
koristimo pointer zadnji. Ovim zapravo dodajemo novi
vor u postojeu listu.
Za vor kojeg emo upisati u nastavku, ovo (novi) e biti
zadnji vor.
Da bismo provjerili prethodni kod, napisaemo kod za ispisivanje podataka iz liste.

Pokaziva zadnji pokazivat e na element liste
kojeg ispisujemo. Polazimo od prvog vora,
ija adresa je u pokazivau start_ptr. Sve dok
zadnji ne sadri vrijednost NULL, ispisujemo
slovo i pomjeramo pokaziva zadnji na
slijedei element liste.
Kada pokrenemo program, dobijemo:
Zadaci za vjebu:
63
ET Tuzla
1. Napisati program koji u povezanu listu upisuje znakove iz uitane rijei u redoslijedu obrnutom u
odnosu na redoslijed uitavanja. Ispisati podatke iz liste. Za ispisivanje liste napraviti funkciju.
2. Napisati program koji uitava cio broj proizvoljnog broja cifara, a zatim cifre broja upisuje u
jednostruko povezanu listu. Ispisati broj iz liste.
Definisanje strukture podataka za povezanu listu

Osnova povezane liste je struktura koja uva podatke za svaki vor liste (npr. ime, adresa, godine) kao i
pokaziva na slijedei vor u listi. Slijedi primjer tipine structure koja se koristi u povezanoj listi
struct cvor
{ char ime[20];
// ime do 20 karaktera
int godine;
// godine starosti
float visina;
// u metrima
cvor *slijedeci;
// Pointer na slijedei vor
};
Vaan dio ove structure je zadnja linija definicije structure. Ovdje definiemo lanicu strukture
slijedeci koja je pointer tipa cvor, tj. strukture koju ovim definiemo. Ovo je jedini sluaj kada je
dozvoljeno da upuujemo na tip podataka kojeg jo nisamo definisali (u ovom sluaju cvor).
cvor *start_ptr;
64
ET Tuzla
Prethodnom naredbom deklariemo pointer start_ptr koji e sadrati pokaziva na prvi vor liste. Na
poetku, kada je lista prazna, tj. nema vorova, u ovaj pointer postavljamo NULL vrijednost.
Funkcija za kreiranje vora liste
Za kreiranje novog vora liste moemo koristiti funkciju koja alocira memorijski prostor, upisuje podatke
i vraa pokaziva na kreirani vor. S obzirom da funkcija vraa pokaziva, deklariemo je ovako
cvor *kreiraj_novi_cvor.
Ova funkcija mora vratiti pokaziva, to znai da mora imati naredbu return pokaziva.
Funkcija moe imati argumente, npr. vrijednosti koje se upisuju u informacioni dio vora. Slijedi jedan
primjer takve funkcije:
Poziv funkcije realizuje se u naredbi dodjele vrijednosti u kojoj je lijevo od znaka jednakosti pokaziva.
Npr.
Funkcija moe biti bez argumenata. U tom sluaju podatke koje upisujemo u informacioni dio vora
uitavamo unutar funkcije, kao u zadatku na kraju poglavlja.
Dodavanje vora u listu
Prvi zadatak u vezi sa povezanom listom je kako dodati vor u listu. Novi vor moemo dodati na
poetak, kraj ili unutar liste. Upoznaemo najprije dodavanje vora na kraj i poetak liste.
U uvodnom primjeru pokazali smo kako formiramo listu unutar while petlje. Sada emo napraviti
funkciju za dodavanje vora na kraj ili poetak postojee liste, koja se moe pozivati prema potrebi.
Dodavanje vora na kraj liste
Dodavanje vora na kraj liste realizujemo u slijedeim koracima:
1. Deklariemo promjenljivu tipa structure na kojoj se baziraju vorovi liste i rezerviemo
memorijski prostor za novi vor
2. Unosimo podatke u elemente structure vora
3. Ako lista nije prazna, onda postojei zadnji vor u listi mijenjamo tako to u pokaziva tog vora
upiemo adresu novog vora. Time novi vor uistinu postaje dio liste.
65
ET Tuzla
Ako je lista prazna, adresu novog vora dodjelimo pointeru koji pokazuje na poetak liste, start_ptr.
Najprije deklariemo promjenljivu tipa struktura cvor i rezerviemo memorijski prostor za vor,
slijedeom naredbom:
novi
cvor *novi = new cvor;
nedefinisano
Zatim, korisnik unosi podatke koje upisujemo u lanice promjenljive novi:
cout << "Upisite ime: ";
cin >> novi->ime;
cout << "Upisite godine: ";
cin >> novi->godine;
cout << "Upisite visinu osobe: ";
cin >> novi->visina;
novi->slijedeci = NULL;
U zadnjoj liniji postavljamo NULL vrijednost u lanicu strukuture slijedeci, ime iniciramo da e ovaj
vor, kada ga ubacimo u listu, biti zadnji vor.
Sada postavljamo vrijednost za pointer start_ptr. Ako je lista prazna, onda samo adresu tmp vora
podeavamo da pokazuje na novi vor:
if (start_ptr == NULL)
start_ptr = novi;
Ako u listi ve postoje vorovi, koristimo drugi pointer, pom, i pomjeramo ga na kraj liste:
{
pom = start_ptr;
// postavljamo pom na kraj liste
while (pom->slijedeci != NULL)
{
pom = pom->slijedeci;
}
pom->slijedeci = novi;
// pomjeranje na slijedei vor
//
pokaziva
zadnjeg
vora
u
listi
//postavljamo da pokazuje na novi vor
66
ET Tuzla
Petlja e se zavriti kada pom sadri adresu zadnjeg vora u lancu. U zadnjem voru liste slijedeci sadri
null vrijednost. Kada smo pronali zadnji vor, postavljamo slijedeci zadnjeg vora da pokazuje na vor
kojeg dodajemo u listu:
start_ptr
pom
novi
novi
vor
dodan
NULL
Kompletan kod za dodavanje vora u listu slijedi:
void dodaj_cvor_na_kraj ()
{ cvor *novi, *pom;
// pomoni pokazivai
// Rezervisanje prostora za novi vor i unos podataka
novi = new cvor;
cin >> novi->ime;
// Ubacivanje vora u listu
start_ptr = novi;
else
{
pom = start_ptr;
// postavljamo pom na pocetak liste
while (pom->slijedeci != NULL)
{
// pomjeranje na slijedei vor
}
}
return;
}
// pokaziva zadnjeg vora u listi postavljamo da pokazuje na novi vor
Zadatak
Modifikovati prethodnu funkciju tako da se unutar nje poziva funkcija za kreiranje novog vora.
67
ET Tuzla
Dodavanje vora na poetak liste
Ovaj postupak je znatno jednostavniji. Nakon kreiranja novog vora i unosa podataka, potrebno je u novi
vor upisati adresu trenutno prvog vora u listi (novi->slijedeci = start_ptr), a zatim postaviti u
start_ptr adrsu novog vora (start_ptr = novi). Ako je lista prazna, samo postavimo da start_ptr
pokazuje na novi vor.
void dodaj_cvor_na_pocetak ()
{ cvor *novi, *pom;
// pomocni pokazivaci
// Rezervisanje prostora za novi cvor i unos podataka
novi = new cvor;
cin >> novi->ime;
// Ubacivanje cvora u listu
start_ptr = novi;
else
{
novi->slijedeci = start_ptr;
start_ptr = novi;
}
return;
}
Zadataci za vjebu:
1. Modifikovati uvodni zadatak, tako da se slova iz uitane rijei upisuju na poetak liste.
Na ovaj nain, uitana rije treba da bude upisana u obrnutom redoslijedu. Ispisati
elemente liste.
2. Napisati program koji uitava cio broj proizvoljnog broja cifara, a zatim cifre broja upisuje u
jednostruko povezanu listu. vorove dodavati na poetak liste.
68
ET Tuzla
3.
Prethodni zadatak moe se rijeiti na tri naina:

a. Bez funkcija
b. Koritenjem funkcija i dodavanjem vora na kraj liste
c. Koritenjem funkcija i dodavanjem vora na poetak liste
RJEENJE
a) Rjeenje 1 (bez funkcija)
Pokretanjem programa dobiju se cifre poevi od jedinica.
69
ET Tuzla
b) Rjeenje sa funkcijama dodavanje na kraj liste
c) Rjeenje sa funkcijama dodavanje na poetak liste
70
ET Tuzla
71
ET Tuzla
Pristup podacima u listi
Slijedei problem kojeg treba rijeiti je kako pristupati elementima liste. Pokazaemo kako moemo
itati podatke iz liste i ispisivati ih na ekranu.
Uradit emo slijedee:
Pomoni pointer postavljamo da pokazuje na prvi vor, tj. dodjeljujemo mu vrijednosrt startnog
pointera (start_ptr).
Ako pomoni pointer sadri null vrijednost, lista je prazna pa prikazujemo poruku: "Kraj liste" i
zaustavljamo prikaz.
Ako pomoni pointer ne sadri null vrijednost, prikazujemo detalje iz vora na koji pokazuje
pomoni pointer.
Mijenjamo vrijednost pomocnog pointera, dodjeljujui mu vrijednost iz pointera slijedeci
vora iji smo sadraj upravo ispisali.
Vraamo se na drugi korak.
Slijedi kod za ispisvanje podataka iz liste:

void ispisi_listu()
{
cvor *pom = start_ptr;
do
{
if (pom == NULL)
cout << endl<<"Kraj liste" << endl;
else
{ // Ispis detalja iz vora na koji pokazuje pom pointer
cout << "Ime: " << pom->ime << endl;
cout << "Godina: " << pom->godine << endl;
cout << "Visina: " << pom->visina << endl;
cout << endl;
// Pomjeranje na slijedei vor
}
}
while (pom != NULL);
return;
}
Brisanje vora
vor moe da se nalazi na poetku, kraju i u sredini liste. Ovisno o njegovoj poziciji, postupak brisanja je
drugaiji.
Kada obriemo vor, potrebno je osloboditi memorijski prostor. Ako to ne uradimo, rizikujemo out of
memory! Oslobaanje memorijskog prostora realizujemo naredbom delete:
delete pom;
72
ET Tuzla
Meutim, ne moemo samo obrisati vor iz liste, jer bismo u tom sluaju prekinuli lanac. Stoga, najprije
moramo izmjeniti vrijednost odgovarajueg pokazivaa pa onda obrisati vor.
Evo kako bismo obrisali prvi vor iz liste.
pom = start_ptr; // Sacuvamo startni pointer u pomocnom
start_ptr
etc.
pom
Nakon to smo sauvali vrijednost startnog pointera u pom pointer, mijenjamo vrijednost start_ptr tako
da pokazuje na slijedei vor:
start_ptr = start_ptr->slijedeci; // drugi cvor u lancu
start_ptr
etc.
pom
delete pom; // obrisi pocetni start cvor
start_ptr
73
ET Tuzla
etc.
pom
Slijedi funkcija za brisanje startnog vora:
void brisi_prvi_cvor()
{ cvor *pom;
pom = start_ptr;
start_ptr = start_ptr->slijedeci;
delete pom;
return;
}
Brisanje vora na kraju liste je tee, jer se pomoni pointer mora najprije pomjeriti na kraj liste (kao kod
unosa novog vora). Potrebna su dva pomona pointera, pom1 i pom2. Prvi e pokazivati na zadnji vor
u listi, a drugi na njegovo prethodnika. Potrebne su nam obje vrijednosti kako bismo zadnji obrisali, a
predzadnji modifikovali tako da on u polju slijedei sadri null vrijednost, pokazujui na taj nain da je
zadnji vor liste.
Prikaimo proces brisanja zadnjeg vora crteima. Posmatrajmo listu. Najprije emo postaviti oba
pomona pokazivaa, pom1 i pom2, da pokazuju na poetak liste.
start_ptr
NULL
pom1 pom2
Zatim , pom1 pomjeramo na slijedei vor u listi:
start_ptr
74
ET Tuzla
NULL
pom2
pom1
Poto pom1 jo uvijek ne pokazuje na zadnji vor u listi, pomjeramo i pom2, tako da pokazuje isti vor
kao i pom1
start_ptr
NULL
pom2 pom1
Opet pomjeramo pom1 na slijedei:
start_ptr
NULL
pom2
pom1
Ovo ponavljamo sve dok pom1 ne pokazuje zadnji vor u listi, a pom2 na njegovog prethodnika:
75
ET Tuzla
start_ptr
NULL
pom2
pom1
Zatim briemo vor na kojeg pokazuje pom1
start_ptr
pom2
pom1
Zatim u pokaziva slijedeci vora na kojeg pokazuje pom2 upisujemo NULL vrijednost:
start_ptr
NULL
pom2
Ako lista sadri samo jedan vor, onda samo treba postaviti start_ptr na null vrijednost i obrisati vor.
Slijedi kod za brisanje vora na kraju liste:
void brisi_zadnji_cvor()
{
76
ET Tuzla
cvor *pom1, *pom2;
cout << "Lista je prazna!" << endl;
else
{
pom1 = start_ptr;
if (pom1->slijedeci == NULL)
{
delete pom1;
start_ptr = NULL;
}
else
{
while (pom1->slijedeci != NULL)
{
pom2 = pom1;
pom1 = pom1->slijedeci;
}
delete pom1;
pom2->slijedeci = NULL;
}
}
return;
}
Navigacija kroz listu
Za rad sa povezanom listom, potrebno je uspostaviti mehanizam kretanja po listi, unaprijed ili unazad.
Ovo je naroito potrebno aki elimo brisati ili upisivati vor unutar liste.
Deklariimo pointer tekuci. Najprije mu dodjeljujemo adresu prvog vora u listi, koju uvamo u pointeru
start_ptr :
cvor *tekuci;
tekuci = start_ptr;
Nakon ovih naredbi oba pointera pokazuju na isti vor:
start tekuci
itd
Pomjeranje pointera tekuci unaprijed realizujemo naredbom u kojoj pointeru tekuci dodjeljujemo
adresu cvora koji slijedi, a koja je upisana u lanicu slijedeci vora na kojeg tekuci pokazuje:
tekuci = tekuci->slijedeci;
77
ET Tuzla
Prije prethodne naredbe dodjele, potrebno je provjeriti da tekui u polju slijedei ne sadri null
vrijednost. Ako je to tako, onda tekuci pokazuje na zadnji vor u list ii nema potrebe za njegovim
pomjeranjem.
if (tekuci->slijedeci == NULL)
cout << "Pozicionirani ste na kraj liste." << endl;
else
tekuci = tekuci->slijedeci;
Pomjeranje pointera unazad je neto tea rutina. Jedini nain da naemo prethodni vor jeste da
krenemo od poetnog i pomjeramo pokaziva do vora kojeg traimo. To e se desiti kada pointer
slijedeci pokazuje na tekui vor.
Pomo!!!
Pokuajmo sa slikama:
prethodni
slijedeci
Najprije emo provjeriti da li pointer tekuci (na slici current) pokazuje na prvi vor. Ako je tako, onda on
nema prethodnika. Ako nije, onda provjeravamo sve vorove dok ne naiemo na prethodnika tekueg.
if (tekuci == start_ptr)
cout << "Pocetak liste!" << endl;
else
{ cvor *prethodni;
// pointer koji pokazuje na prethodnika
prethodni = start_ptr;
while (prethodni->slijedeci != tekuci)
{
prethodni = prethodni->slijedeci;
}
tekuci = prethodni;
}
Kod koji je naveden iza else odreuje slijedee:
Najprije deklariemo pointer koji e pokazivati na prethodni vor pointer prethodni.

U prethodni postavljamo adresu prvog vora.
Sve dok ne pokazuje na vor koji prethodi tekuem, mijenjamo adresu u pointeru prethodni tako
da pokazuje na slijedei vor.
Kada pronaemo prethodnika u odnosu na tekui, pointer tekuci postavljamo da pokazuje na isti
vor kao i pointer prethodni, kojeg smo doveli do njegovog prethodnika
78
ET Tuzla
Sada kada moemo da se kreemo unaprijed i unazad kroz listu, moemo uraditi jo poneto sa listom.
Naprimjer, moemo mijenjati podatke u voru liste na koji pokazuje tekuci:
cout << "Unesite novo ime: ";
cin >> tekuci->ime;
cout << "Unesite novi podatak o godinama : ";
cin >> tekuci->ime;
cout << "Upisite novi podatak o visini : ";
cin >> tekuci->visina;
Slijedea procedura je brisanje vora koji se nalazi odmah iza vora na kojeg pokazuje pokaziva tekuci.
Koristit emo pomoni pokaziva koji e pokazivati na vor kojeg elimo obrisati pom (na slici temp).
Nabrojat emo ta treba uraditi da bismo obrisali vor.
Najprije, podesimo da pomoni pokaziva pokazuje na vor iza tekueg, tj. na vor kojeg emo obrisati:
tekuci
pom
Zatim podeavamo da pointer u tekuem voru sadri adresu vora koji slijedi iza onog na kojeg
pokazuje pomoni:
tekuci
pom
Zadnji korak je brisanje vora na kojeg pokazuje pomoni.

Slijedi kod za brisanje vora iza tekueg. Ovaj kod ukljuuje i provjeru da li je tekui zadnji u listi.
cout << "Nema vise cvorova u listi" << endl;
else
{ cvor *pom;
pom =tekuci->slijedeci;
tekuci->slijedeci = pom->slijedeci;
delete pom;
}
79
ET Tuzla
Slijedi kod za dodavanje vora iza tekueg.
dodaj_cvor_na_kraj();
else
{ cvor *novi;
new novi;
upisi_podatke_u_cvor(novi);
// Postavi da novi cvor pokazuje na isti cvor kao i tekuci
novi->slijedeci = tekuci->slijedeci;
// Tekuci pokazuje na novi
tekuci->slijedeci = novi;
}
Funkcija dodaj_cvor_na_kraj() je ranije deifinisana. Funkcija upisi_podatke_u_cvor(novi) omoguava unos

podataka u strukturu vor.
U slijedeem primjeru primjeniemo ove procedure i pokazati kako se implementiraju i neke dodatne
funkcionalnosti povezane liste.
Primjer programa za rad sa jednostruko povezanom listom
Napisati program koji omoguava formiranje liste koja sadri koeficijente kvadratne jednaine. Nakon
startovanja programa, prikazati glavni meni sa slijedeim opcijama:
Za pohranjivanje podataka program koristi strukturu cvor, kako slijedi:
80
ET Tuzla
Opcija 5, Sekvencijalna obrada liste, nudi dodatni meni za pojedinanu obradu vorova liste.
Omoguava sekvencijalni prolazak kroz listu, gdje se za svaki vor nude slijedee opcije:
Svaka od opcija glavnog menija i menija za sekvencijalnu obradu podataka realizuje se kao zasebna
funkcija. I sam meni komandi je relizovan kao funkcija koja se poziva u funkciji main, kao na screenshotu koji slijedi.
Program je realizovan kroz slijedee funkcije:
81
ET Tuzla
Glavni meni poziva se u funkciji main, gdje se, nakon povratka iz menija, u okviru switch naredbe poziva
odgovarajua funkcija:
Glavni meni implementiran je na slijedei nain:
82
ET Tuzla
Dodavanje vora na poetak liste ve je objanjeno:
Kako bi program bio funkcionalan, samo kreiranje novog vora realizovano je u zasebnoj, pomonoj
funkciji kreiraj_novi_cvor koja se poziva u prethodnoj, ali i u okviru drugih funkcija programa.
83
ET Tuzla
Ova funkcija vraa pokaziva na vor. Kao tip povratne vrijednosti navodimo strukturu cvor, a ispred
imena funkcije znak *, kako bismo odredili da funkcija vraa pokaziva na vor.
Prednost ovakvog pristupa je to istu funkciju moemo koristiti na vie mjesta u programu. S druge
strane, prednost je i u tome to istu metodologiju moemo koristiti i u drugim zadacima jedino to
treba da prilagodima je struktura vora u funkciji kreiraj_novi_cvor (isto i u ispisi_cvor).
Vec u slijedeoj funkciji opet koristimo funkciju kreiraj_novi_cvor
Za potrebe ispisivanja liste takoer koristimo pomonu funkciju za ispisivanje sadraja jednog vora.
84
ET Tuzla
Argument ove funkcije je pokaziva sa fiktivnim imenom tekuci. On pokazuje na vor iji sadraj elimo
ispisati .
Funkciju ispisi_cvor koristimo u funkciji za ispisivanje liste od prvog do zadnjeg vora, iji algoritam
smo ve objasnili.
Funkciju ispisi_cvor koristimo i u funkciji za ispisivanje liste od zadnjeg ka prvom voru. Ova funkcija
radi na slijedei nain. Ako lista nije prazna i ako ne sadri samo jedan vor, koristimo dva pomona
pokazivaa. Pom1 na poetku funkcije pomjerimo na zadnji vor u petlji i ispiemo njegov sadraj:
Sve dok pom1 ne bude imao istu adresu kao i start_ptr, radimo slijedee:
-
pokaziva pom2 pozicioniramo na vor koji prethodi voru pom1
pokaziva pom1 pomjerimo na prethodni vor i ispiemo njegov sadraj

85
ET Tuzla
Slijedi kompletan kod ove funkcije:
Brisanje vora na poetku i kraju liste takoer je objanjeno ranije. Slijedi kod ovih funkcija:
86
ET Tuzla
Sekvencijalna obrada liste realizuje se pomou funkcije sekvencijalna_obrada. 1 U okviru ove funkcije
prolazimo kroz listu, od prvog do zadnjeg vora, tako to mijenjamo vrijednost pokazovaa tekuci.
Nakon svakog pomjeranja, prikazujemo sadraj vora i prikazujemo pomoni meni iz kojeg korisnik bira
odgovarajuu akciju.
Koristi se i pomoni pokaziva pom u kojeg spremimo kopiju vrijednosti polja slijedeci iz tekueg
vora. Ova vrijednost (adresa slijedeeg vora) nam je potrebna u sluaju da korisnik izabere brisanje
tekueg vora. Ako ne bismo imali kopiju adrese slijedeeg vora, nakon brisanja tekueg vora lista bi
bila prekinuta i ne bismo se mogli referencirati na slijedei vor (koji nakon izvrene operacije postaje
tekui).
Sekvencijalni pristup (engl. sequential access) je nain pristupa podacima pri emu su podaci na raspolaganju u
odreenom poretku, a vrijeme pristupa podacima je zavisno o koliini pohranjenih podataka i fizikom smjetaju
podataka. Npr. magnetna traka ima sekvencijalni pristup podacima. Da bi se dolo do podatka koji je smjeten na
nekom dijelu trake, potrebno je proitati cjelokupan sadraj trake od mjesta na kome se nalazi magnetska glava pa
sve do mjesta gdje se nalazi traeni podatak (ili premotati trake uz poznato mjesto na kome se nalazi traeni
podatak). U svakom sluaju ispred glave za itanje moraju proi svi podaci izmeu trenutnog poloaja glave i
mjesta na kome se nalazi podatak. Kod direktnog pristupa, podacima se pristupa direktno bez potrebe itanja
prethodnih vrijednosti. Ovo je mogue zahvaljujui uspostavljanju kljua. Kad su u pitanju magnetski mediji, hard
drive je primjer medija sa direktnim pristupom.
87
ET Tuzla
Za svaki vor iz liste prikazuje se pomoni meni sa opcijama rasploivim nad odabranim vorom:
Ista funkcija sadri switch naredbu u okviru koje pozivamo odgovarajuu funkciju za sekvencijalnu
obradu:
88
ET Tuzla
Funkcija za izmjenu tekueg vora jednostavno mijenja upisane podatke:
Dodavanje vora prije tekueg realizuje se tako to se najprije provjeri dali je tekui prvi vor liste. Ako
jeste, pozivamo funkciju za dodavanje vora na poetak liste. Ako tekui nije prvi vor, onda:
-
kreiramo novi vor pozivom funkcije kreiraj_novi_cvor

pomoni pokaziva prethodni postavimo da pokazuje na vor prije tekueg, a zatim
o podesimo da u prethodnom voru polje slijedei pokazuje na novi vor
o podesimo da u novom voru polje slijedei pokazuje na tekui
89
ET Tuzla
Dodavanje vora prije tekueg realizujemo na slijedei nain.

A) Ako je lista prazna, pozivamo funkciju za dodavanje vora na pocetak liste
B) Ako lista nije prazna:
a. Kreiramo novi vor pozivamo funkciju kreiraj_novi_cvor(),
b. podeavamo da pokaziva u voru koji prethodi tekuem pokazuje na novi vor, a
pokaziva u novom voru pokazuje na tekui
tekuci
novi
prethodni
novi
90
ET Tuzla
Brisanje vora poslije tekueg realizuje se u slijedeoj funkciji:
vor prije tekueg briemo pomou funkcije:
91
ET Tuzla
Konano, snimanje podataka iz vorova povezane liste realizuje se u funkciji kako slijedi:
Npr. pozivom ove funkcije kreirana je datoteka
Podaci iz jednog vora upisuju se u jedan red sa razmacima izmeu pojedinih vrijednosti. Osim za prvi
vor, prije upisa podataka iz vora, u datoteku se upisuje znak za novi red:
if (pom != start_ptr) Izlaz << endl;
itanje podataka iz datoteka u listu realizuje funkcija:
92
ET Tuzla
Sve dok nije kraj datoteke (!Ulaz.eof()), kreiramo novi vor i u njega upisujemo podatke proitane iz
datoteke:
Zadaci za vjebu
1. Napisati program koji omoguava unos podataka o proizvoljnom broju uenika. Za svakog
uenika treba upisati slijedee podatke:
a. Redni broj, cio broj
b. Prezime i ime, string
c. Broj bodova, cio broj
d. Ocjena, cio broj (1-5)
Nakon unosa podataka o jednom ueniku, provjeriti da li je potreban nastavak unosa, tj.
Postaviti pitanje: Nastavak? (D/N).
Ispisati uitane podatke, tako to podatke o jednom ueniku ispisujemo u jednoj liniji. Koristiti
povezanu listu.
2. Modifikovati zadatak 1 dodavanjem menija iz kojeg korisnik moe izarbrati slijedee opcije:
a. Unos novog vora, sa podacima redni broj i prezime i ime
i. Na poetak liste
ii. Unutar liste, sa auriranjem postojeih rednih brojeva
93
ET Tuzla
3.
4.
5.
6.
7.
1. Prije zadanog rednog broja

2. Poslije zadanog rednog broja
iii. Na kraj liste
b. Unos broja bodova:
i. za sve ucenike u listi
ii. Za odabranog uenika, na osnovu rednog broja
c. Brisanje uenika sa zadanim rednim brojem
d. Unos kriterija za ocjenjivanje u formi
i. Ocjena 1: do ___ bodova
ii. Ocjena 2: od ____ do ____ bodova
iii. Ocjena 3: od ____ do ____ bodova
iv. Ocjena 4: od ____ do ____ bodova
v. Ocjena 5: od ____ do ____ bodova
e. Ispisivanje ocjena uenika
i. Svi uenici
ii. Odabrani uenik, zadavanjem rednog broja
f. Ispisivanje rang liste po broju bodova
g. Upisivanje liste u datoteku
h. Uitavanje liste iz datoteke
Napisati program koji omoguava unos podataka u povezanu listu. Svaki vor sadri prezime i
me uenika i broj osvojenih bodova. Prilikom unosa uenika, automatski se vri sortiranje
podataka u opadaju listu pr broju osvojenih bodova. Nakon unosa ispisati listu sa kolonama:
prezime ii me, broj bodova.
Napisati program koji nudi iste opcije kao i primjer 1, samo to se u vorovima liste uvaju
podaci o vrijednostim tri otpora R1, R2 i R3. Prilikom ispisa podataka iz liste izraunava se i
ispisuje ukupan otpor ako su otpornici spojeni serijski i paralelno.
Napisati program koji omoguava formiranje liste (dodavanje vora na poetak i kraj) kao i
ispisivanje liste od prvog do zadnjeg vora. Napraviti funkciju koja nalazi najvei element u
voru. Ova funkcija vraa vrijednost koja se trai a kao argument uzima pokaziva na prvi vora
liste. vor sadri samo dva elementa: cio broj i pokaziva.
Napisati program koji omoguava formiranje liste (dodavanje vora na poetak i kraj) kao i
ispisivanje liste od prvog do zadnjeg vora. Napraviti funkciju koja od podataka u listi formira niz,
a zatim ispisuje taj niz sortiran u rastuem redoslijedu. Funkcija nema argumenata i ne vraa
nikakvu vrijednost. vor sadri samo dva elementa: cio broj i pokaziva.
Napraviti funkciju za sortiranje liste.
94
ET Tuzla
Zadaci za ponavljanje
POVEZANE LISTE, vjeba 1 (osnovni pojmovi, deklaracija, kreiranje liste)
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
ta je povezana lista?
vor povezane liste sadri dva dijela. Navedi ih i opii.
Nacrtaj kako izgleda jednostruko povezana lista
Nacrtaj kako izgleda dvostruko povezana lista
Potrebno je formirati jednostruko povezanu listu koja u informacionom dijelu ima podatke o
pravouglom trouglu. uvaju se duine dvije stranice trougla a i b kao cijeli brojevi. Deklarii
strukturu cvor koja e omoguiti rad sa ovakvom listom.
ta oznaava konstanta NULL i kako se koristi u povezanoj listi?
Koji je znaaj pointera koji pokazuje na poetak liste? Opii ovaj pointer i njegov znaaj.
Ako je deklarisana struktura cvor (kao u zadatku 5) koja e se koristiti za kreiranje jednostruko
povezane liste, napii naredbu kojom se deklarie pointer koji e pokazivati na poetak liste
(start_ptr), kao i pointer novi, pomou kojeg emo dodavati vorove u listu.
Napii naredbu kojom e se alocirati memorijski prostor za novi vor liste. Koristiti pokaziva
novi.
Prikai grafiki efekat naredbe iz zadatka 9, pod pretpostavkom da je lista prazna. Ucrtaj
pokazivae start_ptr i novi, kao i vor(ove) liste.
Prikai grafiki efekat naredbe iz zadatka 9, pod pretpostavkom da lista nije prazna. Ucrtaj
pokazivae start_ptr i novi, kao i vor(ove) liste.
Napisati naredbu kojom se u informacioni dio vora za koji je u naredbi iz zadatka 9 alociran
memorijski prostor upisuju podaci. Pretpostavka je da se podaci nalaze u cjelobrojnim
promjenljivim v_a i v_b.
Deklarisati pokaziva zadnji, koji e pokazivati na kraj liste.
Napisati if naredbu kojom se provjerava da li je lista prazna. Ako jeste, onda zadati naredbu
kojom se odreuje da start_ptr pokazuje na novi cvor (pointer novi), a ako nije onda podesiti da
postojei zadnji vor pokazuje na novi. Prikazati grafiki oba sluaja.
Napisati naredbu kojom se odreuje da pokaziva zadnji pokazuje na isti vor na koji pokazuje i
novi.
Pretpostavimo da imamo formiranu slijedeu listu
4
2
1
2
4
2
NULL
2
2
3
2
Za ispisaivanje podataka u listi koristi se slijedei kod:

cout <<"Podaci upisani u listu su "<<endl;
zadnji = start_ptr;
while (zadnji != NULL)
95
ET Tuzla
{
cout << zadnji->a << zadnji->b;
zadnji = zadnji->slijedeci;
}
Predstaviti grafiki kako e se izvravati ovaj kod na prethodnom primjeru. Prikazati na koji vor
pokazuju pokazivai start_ptr i zadnji, te koje vrijednosti se ispisuju.
Grafiki prikaz povezane liste je grupisan u jedan grafiki objekat, pa se moe kopirati slijedei
element.
1
2
4
2
4
2
2
2
3
2
Koristiti slijedei obrazac:

1. Nakon naredbe zadnji = start_ptr, pokaziva start_ptr pokazuje na prvi vor liste, kao na slici:
Start_ptr
1
2
2.
4
3.
2
4.
4
2
2
2
3
2
2
2
3
2
2. Prvi prolazak kroz petlju while

Start_ptr
4
2
Zadnji ????
1
2
4
2
ISPIS:......
96
ET Tuzla
Vjeba 2
Potrebno je napraviti program koji omoguava

praenje prevoza putnika i tereta koritenjem
povezane liste.
Voz ine vagoni razliite namjene:
-
Lokomotiva
Kupe
Teretni
Restoran
Za svaki vagon treba upisati slijedee podatke, ovisno o namjeni vagona:

-
Namjena (lokomotiva,kupe,teretni,restoran)
Broj ukrcanih putnika (popunjava se ako je namjena vagona kupe)
Teina utovarene robe (popunjava se ako je namjena vagona teretni)
Broj stolova (popunjava se ako je namjena vagona restoran)
Broj stolica (popunjava se ako je namjena vagona restoran)
Ako je namjena vagona lokomotiva, upisuje se samo polje namjena.

Maximalan broj putnika vagona tipa kupe je 20. Maksimalna teina tereta koji se moe utovariti u
teretni vagon je 5 tona. Voz moe imati samo jedan vagon-restoran.
Potrebno je napraviti program koji omoguava evidentiranje broja putnika i utovarenog tereta,
dodavanje i iskljuivanje vagona.
Prema potrebi, omoguiti dodavanje ili iskljuivanje vagona u/iz voza, na kraj voza prije ili poslije
odreenog vagona.
Iskljuivanje vagona iz voza uraditi automatski kada se desila jedna od slijedeih promjena:
-
Broj ukracanih putnika postaje nula

Teina utovarene robe postaje nula
Dodavanje putnikog vagona uraditi automatski ako je u svim kupe vagonima maksimalan broj putnika.
Omoguiti ispisivanje podataka o putnicima i teretu koji su trentuno u vozu.
97
ET Tuzla
Vjeba Railway Station
1. Kreirati strukturu podataka koja e se koristiti za pohranjivanje podataka o vagonu.
2. Napisati naredbu kojom se deklarie pokaziva lokomotiva koji e se koristiti kao pokaziva na
prvi vagon voza lokomotivu.
lokomotiva
3. Napisati naredbe kojima se kreiraju i povezuju vorovi voza. vorove dodavati postpno, u tri
koraka: najprije dodati lokomotivu, zatim teretni vagon i na kraju putniki. Upisati kod i na slici
obiljeiti na to pokazuju koriteni pokazivai
lokomotiva
4. Napisati kompletan program koji e kreirati podatke o vozu kao na slici na prethodnoj strani. Voz
ine lokomotiva, jedan putniki vagon iji broj putnika upisuje korisnik i jedan teretni vagon bez
tereta. Ispisati podatke o ovom vozu.
5. Napisati funkciju koja ispisuje podatke o vagonu u odgovarajuoj formi. Argument funkcije je
pokaziva na vor iji podaci se ispisuju. Modifikovati program iz prethodnog zadatka tako to se
ispisivanje podataka o vozu vri koritenjem ove funkcije.
6. Napisati kod koji na kraj voza dodaje novi vagon. Obiljeiti na slici pokazivae koji se koriste da
bi se dodao vor na kraj voza.
7. Napisati
98
kod za dodavanje
ET Tuzla
novog vagona odmah iza lokomotive. Obiljeiti na slici pokazivae koji se koriste da bi se dodao
vor na eljenu poziciju.
8. Napisati kod za brisanje zadnjeg vagona . Obiljeiti na slici pokazivae koji se koriste za ovu
operaciju. Nakon brisanja voz treba izgledati ovako.
9. Napisati kod za brisanje drugog vagona. Obiljeiti pokazivae. Nakon brisanja voz treba izgledati
ovako.
10. Napisati funkciju koja omoguava kreiranje novog vora u kojeg se upisuju podaci o vagonu.
Funkcija treba da vrati pokaziva na novi vagon.
11. Za svaku od operacija iz zadataka 6-9 napisati odgovarajuu funkciju i program koji je testira.
12. Napraviti kompletan program na osnovu zadanog projektnog zadatka definisanog na prvoj
strani.
Koristiti meni komandi koji treba da sadri slijedee opcije:
99
ET Tuzla
1. Dodavanje vagona
1.1 Lokomotiva
1.2 Putniki vagon
1.3 Teretni vagon
1.4 Restoran
A.
Na kraj voza
B.
Poslije lokomotive
C.
Poslije restorana
D.
Prije restorana
2. Ispisivanje podataka o vozu
2.1 Ispisivanje podataka o svim vagonima
2.2 Ispisivanje ukupnog broja putnika i tereta u vozu
2.3 Ispisivanje broja putnika po vagonima
2.4 Ispisivanje tereta po vagonima
3. Pretraivanje voza i izmjena podataka
3.1 Pronalaenje prvog vagona u kome ima x slobodnih mjesta; dodavanje x putnika
3.2 Pronalaenje prvog vagona u koji se moe utovariti x kg robe, dodavanje x kg robe
4. Brisanje vagona
4.1 Brisanje zadnjeg vagona
4.2 Brisanje svih vagona koji imaju 0 putnika
4.3 Brisanje svih vagona koji su natovareni sa 0 kg tereta
4. 4 Brisanje restorana
5. Upisivanje podataka o vozu u datoteku
6. Uitavanje podataka o vozu iz datoteke
100
ET Tuzla
MODUL 7: KLASE I OBJEKTI

Uvod: Proceduralno i Objektno Programiranje
Upozorenje: kada jednom uete u
Objectville, nikada se neete
vratiti nazad. Poalji razglednicu.
Trip to Objectville2
U dosadanjim programima, sav programski kod upisivali smo unutar funkcije main(). U prethodnom
modulu nauili smo kako sami moemo praviti tip podataka (strukturu), kako dinamiki koristimo
memorijski prostor (pokazivai, povezane liste), ali nismo razvili ni jedan korisniki tip objekta. Sve
dosadanje metode razvoja programa oznaavamo kao procedurealno programiranje.
Sada emo napustiti svijet proceduralnog programiranja i zapoeti koritenje objekata koje emo sami
kreirati. Upoznat emo pojmove klasa i objekat i nauiti ih razlikovati.
Chair Wars (ili kako objekti mogu promijeniti tvoj ivot)

Jednom davno, u prodavnici software-a radila su dva programera kojima
je data specifikacija i reeno Napravite to!. Zaista neugodan voa
projekta obeao je developeru koji prvi rijei problem dati Aeron stolicu
koju imaju svi developeri u silikonskoj dolini. Larry, proceduralni
programer, i Brad, OO guy, oba su znala da je ovaj zadatak - maiji
kaalj.
Larry je, sjedei u svojoj kutiji (cube), razmiljao o slijedeem: ta
program treba da radi? Koje procedure (funkcije) treba?. I odgovorio je
sebi: rotacija i emitujZvuk (rotate and playSpund). Onda je otiao i
poeo pisati funkcije. Na kraju, ta je program ako nije gomila procedura?
U meuvremenu, Brad s vratio u kafi i razmiljao: Koje su stvari u ovom
programu... ko su kljuni igrai?. Najprije je razmiljao o oblicima (Shapes).
Naravno, razmiljao je i o drugim objektima, kao to su korisnici (Users),
zvukovima (Sounds) i dogaaju click. Ali ve je imao bibilioteku sa kodom
za ove elemente programa, pa se fokusiorao na pravljenje objekta.
Ideja za uvod i dijelovi teksta preuzeti iz knjige Head First Java, O Relly, Katty Sierra, Bert Bates
101
ET Tuzla
itajte dalje kako su Brad i Larry pravili program i ko je dobio stolicu....
In Larry's cube
At Brad's laptop at the cafe
Kao to je to uradio milion puta do sada, Larry je Brad je napisao klasu za svaki od tri oblika....
pravio vane procedure. Za tren je napisao kod za
procedure rotate i playSound....
rotate (shapeNum)
{
// okretanje oblika ya 360 stepeni
}
playSo (shapeNum)
{
// koristiti shapeNum za izbor zvuka
kojeg treba emitovati
}
Larry je mislio da je stvar gotova ve je mogao osjetiti kako se kotrlja na svojoj novoj stolici....
Ali....Specifikacija se promijenila.
OK, tehniki, Larry je prvi, ree ef, samo trebamo dodati jednu malu izmjenu u program. To
nee biti nikakav problem za programere poput vas...
Larry je znao da je mala izmjena bez problema ista fantazija.
Brad nije bio tako uzbuen. Leerno je upitao: ta je s tim?
Na ekranu treba prikazati oblik amebe, pored ostalih, ranije definisanih

oblika. Kada korisnik klikne na ovaj oblik, rotirat e se kao i drugi oblici i
pokrenue specifinu muziku (format muzike je .hif).
In Larry's cube
Procedura za rotiranje e i dalje raditi, koristim

shapeNum za odabir oblika...
Ali playSound moram promijeniti. ta je sada .hif
file?
playSound (shapeNum)
{
// ako oblik NIJE ameba, sviraj
102
Brad se smjekao, popio malo od svog pia i

NAPISAO NOVU KLASU.
Ono to najvie voli kod OOP je to uopte ne
mora da mijenja postojei, ve testiran i
isporuen kod.
Fleksibilnost, proirljivost... pjevuio je,
komentariui prednosti OO.
ET Tuzla
//AIF sound
// else
// hif sound
}
Zakljuio je da ovo nee biti VELIKI problem, ipak,
nije bio sretan to mora mijenjati kod koji je ve
testiran. Morao je znati da, ta god da ef kae,
specifikacija se UVIJEK izmjeni...
Jo jedna mala izmjena specifikacije....
Stvarno nezgodan ef ree (tonom razoarenja): Au, ne, to nije nain kako se ameba treba
okretati...
Naime, oba programera napravili su kod za rotaciju amebe na slijedei nain:
Odredi pravougaonik koji ograniava amebu
Izraunaj centar pravougaonika i rotaraj amebu oko te take
Ali ambe treba da se okree oko take koja je na njenom kraju, kao kazaljka
sata....
Larry je pomislio: Ve mogu nazdraviti! Ipak. Hmmmm. Dodau jo jednu if/else naredbu u rotate
proceduru, i hard code taku rotacije.... To vjerovatno nee promjeniti mnogo koda... Ali neki glas
u pozadini mu je govorio: Velika Greka! Kako zna da se specifikacija nee OPET promijeniti?
In Larry's cube
Shvatio je da bi bilo dobro dodati dva argumenta u

proceduru za rotaciju. Oni bi predstavljali
koordinate take oko koje treba rotirati amebu.
MNOGO KODA treba izmjeniti... Zatim testirati,
kompajlirati i opet isti put od devet milja....Ono to
je do sada bilo ok nee vie raditi
rotate (shapeNum, xPt, yPt)
{
// ako oblik NIJE ameba, sviraj
/*izracunaj centar na bazi pravougaonika
onda rotiraj*/
// else
// koristi xPt i yPt za centar rotacije
// onda rotiraj
}
Znai, Brad (OO) je osvojio stolicu?

103
Brad se nije nimalo zbunio, samo je IZMJENIO

METODU. ALI SAMO U AMENA KLASI.
Nita nije promijenio u kodu koji je ranije
napisao, testirao i isporuio
Da bi omoguio rotaciju oko zadane take, u
klasu ameba dodao je nove atribute.
Modifikovao je, testirao i isporuio (koristei
wireless) kod, sve to dok je svirana jedna
stvar....
ET Tuzla
Ne tako brzo. Larry je naao manu Brad-ovom pristupu. (Usput, nadao se da e uz stolicu dobiti i
Lucy, pa je odluio ponovo stvar uzeti u svoje ruke...)
Larry: Ima dupli kod! Procedura za rotiranje nalazi se u sve etiri oblika 4 te tvoje stvari.
Brad: To se zove METOD( method), ne procedura. I to su KLASE (class), a ne stvari.
Larry: tagod. Kakogod. To je glup dizajn. Mora odravati etiri razliita koda (metode) za
rotaciju. Kako to uopte moe biti dobro?
Brad: Aha. Ti oito nisi vidio konaan dizajn. Dozvoli da ti pokaem kako funkcionie NASLJEIVANJE
(inheritance), Larry.
1. Prvo razmislim ta je zajedniko za sve etiri klase
2. Postoje oblici, i svi oni se rotiraju i klikom na njih ujemo muziki klip. Poto je ovo zajedniko za
sve oblike, onda to apstrahujem kao zajednike osobine i stavljam ih u novu klasu koju nazivam
Shape.
3. Zatim povezujem ostale etiri klase sa ovom novom Shape klasom u relaciju koju nazivamo
nasljeivanje.
Ovo moemo ovako objasniti:
104
ET Tuzla
Kvadrat nasljeuje osobine oblika. Krunica nasljeuje osobine oblika. itd. Metode rotate() i
playSound() su u klasi oblik (Shape) a uklonjene su iz ostalih klasa, tako da se sada odrava kod za
samo jednu.
Klasa Shape naziva se super klasa (superclass) nad ostale etiri klase. Ostale klase su podklase
(subclasses) klase Shape. Podklase NASLJEUJU metode svoje superklase. Drugim rijeima, ako
Shape ima neku funkcionalnost, onda sve podklase automatski imaju istu funkcionalnost.
Larry: Zar cijela pria nije upravo ovdje procedure za rotaciju i sviranje amebe je potpuno
drugaiji od ostalih oblika?
Brad: METOD!
Larry: tagod. Kakogod. Kako ameba moe neto uraditi drugaije ako nasljeuje funkcionalnost
oblika?
Brad: To je zadnji korak. Klasa Ameba prepisuje preko(override) metoda klase Shape. Dalje, u
vrijeme izvravanja tano se zna koja metoda e se pozvati i izvriti ona iz superklase ili
podklase.
4.
Overriding - U klasi Ameba prepisano je preko metoda rotate() i playSound(). Zapravo,
napisane su nove metode sa istim imenom. Overriding znai da podklase redefinie jednu ili vie
naslijeenih metoda, ako postoji potreba da se izmjeni ili proiri ponaanje neke metode.
Metode sa istim
imenom su ponovo
napisane u podklasi
(overriding)
ta je sa rotacijom amebe?
Larry: Kako kae amebi da neto uradi? Dali mora da pozove proceduru, izvini, metod, a
onda da kae koja stvar treba neto da uradi?
Brad: To je stvarno cool u OO. Kada npr. treba da se rotira trougao, program poziva rotate()
metod objekta trougao. Ostatak programa stvarno ne zna i ne interesuje ga kako se trougao
okree. A kada treba dodati neto novo u program, samo napravi novu klasu za novi tip
objekta, tako da novi objekat ima svoje vlastito, specifino ponaanje.
105
ET Tuzla
Upravo smo ispriali priu o nainu rada proceduralnog programera i OO

programera. Ukratko smo se upoznali sa nekim kljunim osobinama OO kao
to su klasa, metod, atribut, objekat. U nastavku emo o tome govoriti sa
neto vie detalja.
Na osnovu ovoga to smo do sada upoznali (i to moda ve znate o OO),
razmislimo o slijedeim pitanjima:
ta su osnovne (fundamentalne) stvari koje moramo znati o OO da bismo

mogli programirati?
Ako biste mogli napraviti listu radnji koje treba da uradite kada pravite
klasu, kako bi ona izgledala?
Kada pravite klasu, razmiljajte o objektima koji e biti kreirani na osnovu te

klase. Razmislite...
ta o objektima znamo
ta objekti treba da rade
Evo jo nekoliko primjera klasa:
Ono to znamo o objektima nazivamo varijablama instance objekta (instance variable), poljima ili
atributima. Mi emo korisititi termin atributi.
Ono to objekti mogu da urade nazivamo metodama (methods).
Naziv klase
Atributi
Metode
Klase predstavljamo koritenjem grafikog jezika
UML
(Unified Modeling
Language). Ovo je opte prihvaeni standardni jezik koji se koristi u IT industriji za

predstavljanje razliitih elemenata software-a.
Kada pravite klasu, razmiljajte o....
106
ET Tuzla
Ono to znamo o objektu nazivamo atributima. One opisuju stanje objekta (podatke) i sadre
konkretne vrijednosti za sbaki pojedini objekat kreiran na osnovu klase.
Instanca je isto to i objekat!
Ono to objekat moe uraditi nazivamo metodama.
Kada dizajniramo klasu razmiljamo o tome ta treba da znamo o objektu (podacima o

objektu) i o metodama koje obrauju te podatke.
Uobiajeno je da svaki objekat ima metode koje itaju ili postavljaju vrijednosti atributa. Npr.
objekat alarm ima varijablu instance koja uva vrijeme alarma, i dvije metode: za postavljanje i
itanje tog vremena.
Znai, objekti imaju atribute i metode, ali njihovo definisanje (dizajn) radi se u dizajnu
klase, a ne objekta....
Razmislite koje varijable instance i koje metode moemo definisati za objekat TV
Klasa i objekat u emu je razlika?

Klasa NIJE objekat, ali se KORISTI za kreiranje objekta.
Klasa je nacrt (blueprint) za objekat. U vrijeme izvravanja
programa, ona odreuje kako napraviti objekat odreenog tipa.
Svaki objekat tog tipa ima vlastite vrijednosti varijabli instance.
Npr. moemo napraviti desetine objekata klase Button, tako da
svaki objekat moe imati vlastitu boju, oblik, natpis i druge
podatke koji ga opisuju.
Posmatrajmo razliku na primjeru imenika sa kontakt podacima o prijateljima,
poslovnim partnerima....
Za pohranjivanje podataka o kontaktima koriste se kartice u koje
upisujemo podatke o osobama, a sve te kartice se uvaju u posebnoj
kuitiji i sortirane po abecednom redu (Rolodex cards).
Klasa je skup podataka i radnji koje vrimo nad kontaktima o kojima uvamo podatke, odravamo ih
i koristimo. Objekat je kao jedna kartica u imeniku.
107
ET Tuzla
Svaka kartica ima prazna polja za upisivanje podataka (varijable instance). Kada upiete podatke,
kreirate instancu klase, koju zovemo i objekat. Ono to upiete na karticu predstavlja njeno stanje.
Metode klase su ono to sa karticom moete uraditi, kao npr. getName(), setName() itd.
Tako svaka kartica moe uraditi iste radnje (getName(), setName() ), ali svaka ima jedinstvene
vrijednosti svojih atributa.
Klase i objekti Qt project

Napravimo prvu klasu i objekat...
Pretpostavimo da treba napraviti jednostavnu klasu Vozilo, iji su
osnovni elementi predstavljeni UML dijagramom:
Vozilo
marka
tip
tezina
godina
start()
Dakle, klasa se naziva Vozilo i ima 4 atributa i jedan metod.

Pokazaemo kako se kreiranje klase i objekata realizuje u C++ a zatim u Javi.
C++
1. Kreiramo C++ projekat na uobiajen nain
2. Kreiramo klasu izborom iz menija File, New... Biramo File and Classes, C++ Class
Upisujemo naziv klase. U ovom sluaju upisujemo Class Name Vozilo, a ostali podaci se
popunjavaju automatski.
108
ET Tuzla
Nastavljamo.... U zadnjem koraku dobiemo informaciju da e dva file-a (vozilo.h i vozilo.cpp)

biti dodana u projekat Vozilo.pro
Nakon zavretka, arobnjak za kreiranje klasa izmjenio je sadraj projekta, te on sada sadri
Vozilo.h je deklaracija klase Vozilo. Ovu datoteku nazivamo i header file. U deklaraciji klase
navodimo atribute i metode koje definiu klasu (primjer slijedi). Automatski je kreiran slijedei sadraj:
109
ET Tuzla
class je slubena rije kojom zapoinje definicija klase. Vozilo je ime klase to je c++ identifikator.
Uobiajeno je da ime klase poinje velikim slovom, dok su ostala mala.
Vozlo.cpp je definicija klase. Ovdje definiemo metode klase.
Modifikujmo sada main.cpp. Obiljeenom naredbom kreiramo objekat v1 klase Vozilo.
Uistinu, ako pokrenemo program neemo vidjeti...nita korisno
Dodajmo atribute i metod u klasu Vozilo, prema specifikaciji i UML

dijagramu. Mijenjamo deklaraciju i definiciju klase:
110
ET Tuzla
C++ klasa prepoznaje tip podataka string samo

ako navedemo std::string
Atributi klase
Metode klase
U klasi Vozilo automatski je kreirana metoda Vozilo(). Ovu metodu nazivamo konstruktor, a njene
osobine su:
Svaka klasa ima konstruktor. To je metoda koja kreira objekat.

Konstruktor ima isto ime kao i klasa.
Moe ali i ne mora imati argumente. (U ovom primjeru ih nema.)
Nikada ne vraa vrijednost, nikada ne navodimo tip povratne vrijednosti, nikada nema naredbu
return u svojoj definiciji (implementaciji).
U klasu Vozilo dodali smo metodu start(). Ova metoda ne vraa vrijednost i ne trai argumente.
Deklariemo je na isti nain kao i funkciju.
Sada emo definisati metodu start(). To radimo unutar vozilo.cpp.
Sada modifikujmo main.cpp. Ranije smo napravili objekat v1 klase Vozilo. Sada emo pozvati metodu
start:
111
ET Tuzla
Startovanjem programa sada se izvrava metod start objekta Vozilo.
Modifikujmo najprije klasu Vozilo. Podesimo da metoda start ispisuje podatke o vozilu koje se startuje
(mijenjamo definiciju klase vozilo.cpp). Metoda ispisuje vrijednosti atributa objekta (ne klase!).
Sada za objekat kojeg deklariemo u main.cpp postavljamo vrijednosti atributa marka i tip, prije no to
pozovemo metodu start:
dot operator koristi se za pristupanje atributima objekta
Atributi objekta su dostupni jer su u klasi deklarisani kao public
Program sada prikazuje
Kreiranje klase
Klasu moemo definisati kao kombinaciju podataka i odgovarajuih operacija. Obino je definiemo u
dva dijela: dekalracioni dio i definicioni dio. Definicioni dio nazivamo i implementacijom klase.
112
ET Tuzla
U deklaracionom dijelu deklariemo atribute (koji omoguavanje memorisanje informacija o stanju
objekata) i metode klase (koji omoguavaju izvravanje razliitih operacija kojima se moe promjeniti
stanje objekta). Deklaracija metoda klase naziva se i deklaracija prototipa metoda.
U implementacionom dijelu definiemo metode ije prototipe smo deklarisali u deklaracionom dijelu.
Oba dijela mogu se pohraniti u istom file-u, ili se deklaracija i definicija mogu odvojiti u dvije datoteka. U
prethodnom primjeru napravili smo dvije datoteke, a taj princip koristit emo i u nastavku ovog kursa.
U optem sluaju, kreiranje klase vrimo po slijedeem obrascu:
// deklaracija klase
class imeKlase
{
Deklaracija atributa
Deklaracija metoda (prototipa)
};
//definicija klase
tipPovratneVrijednost imeKlase::imeMetode(argument metode)
{
Definicja metode
}
Atributi i metode klase nazivaju se lanice klase (class members). Slijedom ove terminologije
promjenljive ili atributi klase nazivaju se lanice podaci ili varijable instance. Metode klase nazivaju se
lanice funkcije ili lanice metode.
Posmatrajmo primjer klase Date:
113
ET Tuzla
Ime klase je Date. Iako nije obavezno, uobiajeno je da je prvo slovo imena klase veliko.
U klasi Date lanice klase su:
-
Promjenljive, atributi ili lanice podaci su: month, day i year.

lanice metode ili lanice funkcije su: Date(), setDate() i showDate()
Kljune rijei private i public odreuju vidljivost lanica klase, o emu e biti rijei u narednim
poglavljima.
Jedan od metoda klase Date je i konstruktor Date(....). O ovoj specijalnoj metodi bie rijei u kasnijim
poglavljima.
Implementacija metoda klase realizuje se u skladu sa pravilima kreiranja funkcija u programskom jeziku
C++. U odnosu na c++ funkciju, metoda klase dodatno sadri i naziv klase i operator rjeavanja opsega
prije imena metode (npr. Date::showDate).
VJEBA 1:
1. Napraviti klasu Film prema UML dijagramu:
Film
naziv
114
ET Tuzla
zanr
ocjena
prikazi()
Metoda prikazi() ispisuje na ekranu Prikazuje se film + naziv.
U glavnom programu napraviti tri objekta klase Film.
2. Napraviti klase i testni program za klase definisane UML dijagramima:
Tacka
x
y
z
udaljenost()
Duz
X1
Y1
X2
Y2
duzina()
Clock
CurrentTime_hh
CurrentTime_mm
CurrentTime_ss
AlarmTime_hh
AlarmTime _mm
AlarmTime _ss
showCurrentTime()
showAlarmTime()
Metoda udaljenost()vraa udaljenost take

od koordinatonog poetka.
Metoda duzina() vraa duinu dui odreene
takama sa koordinatama (x1,y1) i (x2,y2).
Metoda showCurrentTime() ispisuje trenutno
vrijeme u formatu hh:mm:ss. Metoda
showAlarmTime() ispisuje trenutno vrijeme u
formatu hh:mm:ss.
Pitanja za ponavljanje
R.b. Pitanje
1
Ja sam dijagram koji opisuje klasu
Odgovor
a) UML
b) ULM
c) UNL
2
Ja opisujem stanje objekta. Ja mogu neto
a) Atributi
zapamtiti!
b) Varijable instance
c) Metode
3
Ja mogu mijenjati atribute klase. Ja mogu neto
a) Metoda
uraditi!
b) Funkcija
c) Deklaracija
4
Ja sam slubena rije programskog jezika C++
a) declare
kojim zapoinjem deklaracija klase
b) class
c) public
Pogledaj dijagram klase. Naredna 4 pitanja odnose se na tu klasu
Bodovi
1
Ucenik
prezime
ime
razred
smjer
ispisiPrezime()
ispisiIme()
Zaokrui ime atributa a) prezime

klase
b) Ucenik
c) ucenik
d) ispisiPrezime
Zaokrui naziv klase
a) prezime
b) Ucenik
c) ucenik
d) ispisiPrezime
Zaokrui metod klase
a) prezime
b) Ucenik
c) ucenik
115
ET Tuzla
d) ispisiPrezime
8
Ako trebamo objekat klase Ucenik, i odredili smo a) ucenik maturant;
1
da je ime tog objekta maturant, ispravna b)Ucenik maturant;
naredba deklaracije objekta date klase je
c) ucenik Maturant;
9
Ako treba napraviti klasu pod imenom Knjiga, sa atributima naziv i autor (niz karaktera) i 4
metodama ispisiNaziv(), ispisiAutor() i ispisiPodatke(),nacrtaj dijagram klase.
10
Napii C++ kod za deklaraciju klase Knjiga desno od dijagrama klase
4
11
Ja sam klasa. Osnovni elementi klase su
a) atributi i funkcije
1
b) funkcije i metode
c) atributi i metode
12
Ja sam metoda. Moje ime u UML dijagramu moete a) prvi red
1
vidjeti u jednom od tri reda:
b) drugi red
c) trei red
13
Ja opisujem objekte klase. U programu gdje se a) Metoda
1
koristi klasa mogu dobiti konkretne vrijednosti. Ja b) Funkcija
sam...
c) Atribut
14
Ja sam klasa. U programskom jeziku C++ koriste me a) promjenljive
1
za deklaraciju
b) objekta
c) funkcije
Pogledaj dijagram klase. Naredna 4 pitanja odnose se na tu klasu
15
16
17
18
19
20
atributa a) naziv
1
b) Praznik
c) ispisiDatum
d) ispisiNaziv
Zaokrui naziv klase
a) naziv
1
b) Praznik
c) ispisiDatum
d) ispisiNaziv
Zaokrui metod klase
a) naziv
1
b) Praznik
c) ispisiDatum
d) ispisiNaziv
Ako trebamo objekat klase Fudbaler, i odredili smo a) golman Fudbaler;
1
da je ime tog objekta golman, ispravna naredba b)Fudbaler golman;
deklaracije objekta date klase je
c) fudbaler Golman;
Ako treba napraviti klasu pod imenom Fudbaler, sa atributima prezime,ime, pozicija (niz 4
karaktera) i metodama ispisIme() i ispisiPoziciju(), nacrtaj dijagram klase.
Napii C++ kod za deklaraciju klase Fudbaler desno od dijagrama klase
4
Praznik
naziv
datum
neradniDan
opis
ispisiNaziv()
ispisiDatum()
Zaokrui
klase
ime
Privatno i javno
Prava pristupa elementima klase (atributima i metodama) mogu biti javna (public) i privatna (private). To
znai da prilikom dizajniranja klase moemo odrediti ko e ih moi koristiti. Ako npr. atribut klase
definiemo kao privatni, onda mu se moe pristupati samo unutar klase, npr. pomou metoda iste te
klase. Ako je atribut javan, onda ga moemo itati i mijenjati i izvan same klase, tj. unutar programa koji
koriste tu klasu.
116
ET Tuzla
Prava pristupa odreujemo pomou kljunih rijei private i public.
Kontrolisanje prava pristupa elementima klase omoguava kontrolu nad atributima klase. Preporuuje
se da su atributi klase privatni a metode javne. Da bi to bilo mogue, kreiraju se posebne metode
pomou kojih se upisuju ili itaju vrijednosti atributa. Ove metode nazivamo setter i getter.
Ovaj koncept kontrole pristupa lanicama klase naziva se skrivanje podataka (data hiding).
Pored metoda za manipilisanje atributima klase, klasa sadri i specijalnu metodu koja se naziva
konstruktor. To je metoda koja se koristi za kreiranje objekta. Poziva se kada se deklarie objekat date
klase. Ima slijedee osobine:
-
ima isto ime kao i klasa

moe i ne mora imati argument
nikada ne vraa vrijednost, nema tip povratne vrijednosti i naredbu return
Slijedei primjer ilustruju ove osobine.

PRIMJER 1 klasa XYpoint
Potrebno je modelirati klasu taka u xy ravni. Napisati kratki program za testiranje.
XYpoint
double x
double y
void setX( double xx)
void setY(double yy)
double getX()
double getY()
double distance()
UML dijagram sadri tipove podataka atributa klase, tipove povratnih

vrijednosti metoda kao i tipovr podataka argumenata metoda.
x i y su privatni atributi; moe im se pristupiti samo unutar klase
Konstruktor klase Xypoint; koristi se za kreiranje objekta

Setter metoda za postavljanje vrijednosti atributa
Setter metoda za postavljanje vrijednosti atributa
Getter metoda za itanje vrijednosti atributa
Atributima x i y ne moe se pristupati izvan klase. Zbog toga koristimo dodatne metode pomou kojih
pristupamo atributima.
Metode set X i setY omoguavaju upisivanje podataka za atribut x. Kao argument uzimaju vrijednost koja
e se dodijeliti atributima.
117
ET Tuzla
Metode get X i getY omoguavaju itanje vrijednosti atributa. I ove metode definiemo untar deklaracije
klase. Getter metode su istog tipa kao i sami atributi ije vrijednosti vraaju i obino nemaju
argumenata.
Poto se radi o jednostavnim metodama koje samo dodjeljuju vrijednost atributu, moemo ih definisati
unutar deklaracije klase.
Getters metode esto imaju oznaku const jer ne mijenjaju stanje objekta. Tako getters metode klase
XYpoint moemo napisati i ovako:
Definicija klase taka sada bi imala samo definiciju metode za raunanje udaljenosti take od
koordinatnog poetka, kako slijedi:
Slijedi program za testiranje klase
U testnom primjeru napravili smo objekat A. On modelira taku u ravni kao to je prikazano na slici
desno. Pozvaemo metod distance() kako bismo odredili udaljenost take A od koordinatnog poetka.
Ako sada pokrenemo program, dobijemo:
Proirit emo klasu XYpoint dodatnim metodama:
118
ET Tuzla
1. Dodati metodu koja ispisuje koordinate take u obliku (x,y).Metod nazvati getPoint.
2. Dodati metodu translacija, koja omoguava translaciju take u ravni. Argumenti metode su x1 i
y1, a sama metoda pomjera taku sa koordinatama x i y tako da su nakon primjene metode
koordinate take (x+x1, y+y1). Metod nazvati translatePoint.
3. Dodati metodu koja vraa duinu dui koju taka formira sa drugom takom ije koordinate se
prosljeuju kao argumenti metode. Metod nazvatu getLength.
UML dijagram klase XYpoint sada izgleda ovako:
Xypoint
double x
double y
void setX( double xx)
void setY(double yy)
double getX()
double getY()
double distance()
void getPoint()
void translatePoint (double xx, double yy )
double getLength( double xx, double yy )
Modifikujemo datoteke klase kako slijedi:

a) U deklaraciji klase dodajemo metode
b) U definiciji klase definiemo nove metode
Sada u testnom programu moemo pozvati metodu getPoint da bismo ispisali koordinate take:
Metoda za translaciju take treba omoguiti pomjeranje take u

ravni za zadane vrijednosti u pravcu x i y ose. Posmatrajmo taku
iz testnog primjera.
Poetna pozicija: A(3,2)
Nakon translacije sa argumentima (-2,0) taka A je na poziciju
(1,2).
Sada emo definisati metod i testirati ga.
119
ET Tuzla
U testnom primjeru omoguimo korisniku da unese duine za koje se taka translira, pozovimo
metod i ispiimo nakon toga koordinate take:
Napravimo jo metod za raunanje duine dui koju taka formira sa drugom takom ije coordinate se
prosljeuju metodi.
Udaljenost izmeu dvije take odreene koordinatama T1(x1,y1) i T2(x2,y2) odreuje se po formuli:
Definicija metode je:
Testirajmo metod getLength:
120
ET Tuzla
Objekti klase mogu biti elementi niza. Npr. ako u programu trebamo n taaka, moemo deklarisati
jednodimenzionalni niz iji elementi su objekti klase XYpoint. Slijedei primjer ilustruje koritenje niza
Setters metode koristimo u petlji kako bi atributima objekata (koji su
objekata klase XYpoint:
elementi niza) dodjelili vrijednost
Deklaracija niza objekata
Elementu niza (koji je objekat) pristupamo navodjenjem imena niza i
indeksa elementa. Zatim pozivamo METOD nakon DOT operatora
Za svaki element niza (koji je objekat) pozivamo metode:

-
getPoint, da bi ispisali koordinate

distance, za udaljenost od tacke (0,0)
getLength, za udaljenost od tacke (x,y)
PRIMJER 2 objekti klase XYpoint kao elementi niza

Koritenjem klase XYpoint napisati program koji omoguava unos koordinata taaka mnogougla sa
maksimalno 10 uglova. Izraunati obim mnogougla.
121
ET Tuzla
0,1
0,0
1,1
1,0
2,1
2,0
3,1
3,0
4,1
4,0
5,1
5,0
PRIMJER 3 Klasa trougao

Napisati klasu Trougao. Atributi klase su duine stranica trougla. Napraviti konstruktor, getter i setter
metode, kao i metode za raunanje obima i povrine trougla.
122
ET Tuzla
Povrinu
trougla
raunati
prema
Heronovoj
formuli:
Trougao
double a
double b
double c
void setA( double aa)
void setB(double bb)
void setC(double cc)
double getA()
double getB()
double getC()
double getO()
double getP()
Definicija klase
Testni program:
Vjeba:
1. Koristei se klasom XYpoint, napraviti program koji omoguava unos proizvoljnog broja taaka i
odreuju taku koja je najblia koordinatnom poetku. Koordinate taaka uitavati do unosa
take (0,0).
2. Napisati klasu kvadrat. Nacrtati UML dijagram (jedan atribut, metode setters i getters,
konstruktor, metode za raunanje obima i povrine).
123
ET Tuzla
3. Napisati klasu provougaonik. Nacrtati UML dijagram (dva atributa, getters i setters metode,
metode za raunanje obima i povrine, metoda za raunanje dijagonale i konstruktor)
4. Napisati testne programe za obje klase.
5. Napisati program koji omoguava kreiranje jednodimenzionalnog niza (maksimalno 100
elemenata) iji elementi su objekti klase Kvadrat. Izraunati i ispisati koji kvadrat ima najveu
povrinu.
6. Koristenjem klase pravougaonik iz zadatka 2, deklarisati niz od maksimalno 100 elemenata koji
su objekti klase Pravougaonik. Korisnik uitava podatke o n pravougaonika. Ispisati duine
stranica onog pravougaonika koji ima najveu povrinu i onog koji ima najkrau stranicu.
Primjer 4 klasa semafor

Napraviti klasu semafor koja modelira rad semafora. Rad semaforma moe se predstaviti slijedeim
dijagramom:
Semafor moe biti u stanjima: sOFF, sON, sBLINK i sOUT.

Svjetlo semafora moe biti: cNONE, cBLINK, cRED, cYELLOWRED, cGREEN i cYELLOW.
Poetno stanje semafora je sOFF, a svjetla cNONE.
Aktiviranjem odgovarajuih metoda semafor mijenja stanje i svjetlo.
U prethodnoj specifikaciji definisano je da semafor moe biti u 4 stanja, kao i da svjetlo semafora moe
biti u 6 razliitih stanja/boja. U ovakvim situacijama, u kojima se koriste promjenljive koje mogu
poprimiti fiksan, mali broj vrijednosti moemo koristiti konstante.
Npr. za potrebe klase semafor mogli bismo deklarisati slijedee konstante za manipulisanje stanjima
semafora:
124
ET Tuzla
#define
#define
#define
#define
sOFF
sON
sBLINK
sOUT
0
1
2
3
#define je deklarativa koja omoguava da cjelobrojnoj konstanti dodjelimo simboliko ime koje ima specifino
znaenje u program u kojem konstantu koristimo. Imajui u vidu gore definisane konstante, mogli bismo deklarisati
i inicijalizovati promjenljivu state kao:
int state = sOFF;
Ovim bismo inicijalizovali stanje semafora na iskljuen. Isti efekat bismo postigli i ako bismo zadali
slijedeu naredbu:
int state = 0;
Prednost koritenja konstante u odnosu na koritenje cjelobrojnih vrijednosti je to ne moramo pamtiti

vezu vrijednosti koje povezujemo sa nekom drugom vrijednou (npr. 0 iskljueno, 1 ukljueno...).
Kako bismo mogli modelirati svjetlo semafora i razliita stanja semafora, u zadatku emo koristiti
nabrojane konstante. Cilj je napraviti imenovani skup konstanti koje e omoguiti pamenje stanja i boje
semafora. Imenovani skupovi konstanti ponaat e se kao tip podataka.
Nabrojane konstante koje se definiu nabrajanjem u naredbama oblika:
enum ime_nabrajanja { ime_konstante=vrijednost_konstante, ... };
Imena konstanti u nabrajanju su identifikatori simbolikih konstanti kojima se dodeljuju vrijednosti
konstantnih celobrojnih izraza oznaenih sa vrijednost konstante. Ako iza imena neke konstante ne stoji
vrijednost, dodjelie joj se vrijednost koja je za jedan vea od vrijednosti prethodne konstante u nizu,
odnosno koja je nula ako se radi o prvoj konstanti u nizu.
U zadatku emo koristiti dva nabrajanja:
-
enum States {sOFF, sON, sBLINK, sOUT};

enum Colours {cNONE, cBLINK, cRED, cYELLOWRED, cGREEN, cYELLOW};
Klasu semafor moemo predstaviti slijedeim UML dijagramom:

Semaphore
States state
Colours colour
Semaphore();
States
getState()
Colours getColour()
bool turnOn()
bool turnOff();
bool turnBlink();
bool turnOut();
bool repair();
bool changeColour();
125
ET Tuzla
Slijedi kod klase semafor. U header file-u klase definiemo nabrojane konstante, i vrimo deklaraciju
promjenljivih i metoda klase kako slijedi.
Metode pomou kojih se mijenja stanje semafora deklariemo kao boolean metode. Metoda vraa
vrijednost true ako je operacija promjene stanja uspjeno izvrena, ako nije vraa vrijednost false. Slijedi
implementacija metoda klase:
Konstruktor postavlja inicijalno stanje semafora: iskljuen, bez boje. Metode getState i getColour su
zapravo getters metode.
Metode za promjenu stanja semafora implementirane su tako da se postavljaju specifine vrijednosti za
varijable instance. Npr. Metoda turnOn postavlja promjenljivu state u stane sON i postavlja crvenu boju.
126
ET Tuzla
127
ET Tuzla
Metoda changeColour omoguava promjenu boje koja svijetli u sekvenci: crvena uta zelene uta
crvena.
Testni program klase semafor prikazuje meni sa slijedeim opcijama:
VJEBA: Napraviti program koji prikazuje meni komandi kao na prethodnoj slici. Pozivati slijedee
metode:
1
2
3
4
5
6
turnOn
turnoff
turnBlink
turnout
repair
changeColour
Nakon svake promjene stanja semafora (poziva metode) potrebno je prikazati trenutno vrijednosti
promjenljivih instance. S tim ciljem koristiti funkciju printSemaphore definisanu na slijedei nain:
Tako, npr. ako korisnik izabere opciju 1, program nakon poziva metode turnOn poziva i funkciju
printSemaphore koja prikazuje:
128
ET Tuzla
Ako ponovno pozovemo istu metodu, dobijemo slijedee:
VJEBA 5: Klasa FMRadio

Napisati klasu FMRadio. Klasa treba da sadri promjenljive: state, frequency (tipa double) i volume (tipa int).
Frekvencija se nalazi u opsegu od 87.5MHz do 108MHz. Promjena frekvencije se uvijek vri za korak 0.5. Jaina
zvuka se nalazi u opsegu od 0 do 20. Promjena jaine zvuka se uvjek vri za korak 1.
U stanju sOFF i sOUT frekvencija i jaina imaju vrijednost 0.
Kada objekat pree u stanje sON frekvencija se postavlja na 87.5MHz. Frekvencija i jaina zvuka se mogu mijenjati
samo u stanju sON.
Inicijalno stanje je sOFF.
Na slijedeoj slici prikazan je dijagram rada.
129
ET Tuzla
Novi pojmovi
Interfaces, Implementation, Data Hiding
Pojmovi interface i implementation koriste se esto u objektnom programiranju.
Pod pojmom interface podrazumijevamo deklaraciju javnih metoda lanica klase i odgovarajue
komenatare klase.
Implementation se odnosi na definiciju javnih i privatnih metoda lanica i deklaraciju privatnih lanica
promjenljivih.
Implementacija omoguava skrivanje podataka data hiding. Ovaj koncept je u skladu sa principom da
je nain kako je implementirana klase potpuno nebitan programeru koji je koristi. Detalji implamentacije
mogu i treba da budu sakriveni od korisnika kako oni ne bi mogli mijenjati klasu i kompromitovati njenu
funkciju. Sve to je programeru potrebno da bi koristio klasu, a to znai kreirao i koristio objekte te klase
dostupno je u okviru interface-a klase.
Terminologija
Na kraju ovog poglavlja jo jednom emo se osvrnuti na pojmove tipine za objektno-orjentisani pristup
- klasa, objekat.
Klasa
(class) je tip podataka kreiran od strane programera i koristi se za kreiranje objekata. Objekti
se kreiraju na bazi klasa. Moemo napraviti paralelu izmeu odnosa klase i objekta sa odnosom izmeu
ugraenog c++ tipa podataka i promjenljivih. Npr, u slijedeim naredbama deklariemo promjenljivu a
tipa integer i objekat d klase Date.
int a;
Date d;
Objekte nazivamo i instancama klase, a sam proces kreiranja novog objekta nazivamo kao instanciranje
objekta (instantiation of the object). Svaki puta kada se kreira primjerak objekta, kreira se novi skup lanica
podataka za taj objekat, tj. za atribute objekta. Skup trenutnih vrijednosti atributa objekta odreuje
stanje objekta (state).
Kao to je ve pomenuto, klasu moemo posmatrati kao skicu (nacrt, plan) za kreiranje konkretnog
objekta. Svaki primjerak klase (objekat) ima vlastite vrijednosti lanica promjenljivih koje se deklarisane
u klasi.
Pored atributa pomou kojih se evidentira stanje objekta, klasa takoer definie i ponaanje operacije
koje se mogu izvriti nad lanicama podacima. Korisnici objekata klase treba da znaju ta ove metode
mogu da izvre i kako da ih koriste, a, uopteno, ne treba da znaju kako se te operacije uistinu izvravaju.
Stvarna implementacija metoda je sakrivena od korisnika.
130
ET Tuzla
Pitanja i zadaci za ponavljanje
1. Analizirajte slijedee pojmove. Razmislite o njihovom znaenju i definiite ih.
a. Class
b. Object
c. Deklaracija klase
d. Implementacija klase
e. Varijable instance
f. Metode lanice
g. lanice podaci
h. Konstruktor
i. Instanca klase
j. Metoda
k. Interface
2. Napisati deklaraciju klase prema zadatoj specifikaciji. U svim primjerima klase napraviti prototip
metoda konstruktor i metode za prikaz podataka (showData) koja se moe koristiti za prikaz
vrijednosti atributa objekta.
a. Klasa Time sa integer lanicama promjenljivim secs, min i hours.
Kontruktori i destruktori klase

Kao to je ve spomenuto, metoda konstruktor je specijalna metoda, koja, pored ostalih specifinosti,
ima isto ime kao i klasa kojoj pripada. Unutar iste klase moemo definisati vie kontruktora (istog imena)
koji se razlikuju po tome to imaju razliite parametre razliitog tipa.
Uloga konstruktora je da izvri inicijalizaciju lanica promjenljivih objekta date klase. Prilikom deklaracije
objekta klase konstruktor se poziva automatski, ak iako metod konstruktor uopte nije deklarisan. U
tom sluaju kompajler koristi default konstruktor.
Pored ove uloge, konstruktoru moemo dodijeliti i drugaiju ulogu, te se moe isprogramirati ta e se
desiti prilikom kreiranja objekta prema potrebama. U ovom odjeljku bie prikazane razliite mogunosti
konstruktora. Takoer emo upoznati jo jedan metod, destruktor, koji se poziva kada objekat prestaje
da postoji.
Slijedei kod pokazuje opti format metode konstruktor:
imeKlase:: imeKlase (lista parametara)

{
131
ET Tuzla
Naredbe;
}
Prema optem formatu, konstruktor mora imati slijedee osobine:

Ime konstruktora je isto kao i ime klase kojoj pripada
Konstruktor ne vraa vrijednost, nije void
Ako ne deklariemo konstruktor u header file-u, kompajler kreira default konstruktor koji nita ne radi.
Npr. ako imamo slijedeu deklaraciju klase:
class Date
{
private:
int month, day,year;
public:
void setDate(int m,int d,int y);
void showDate();
};
Poto deklaracija ne sadri konstruktor, kompajler kreira default konstruktor:

Date::Date(){}.
Defaulf konstruktor nema parametara i ne vraa vrijednost. Nazivamo ga podrazumijevani konstruktor

bez parametara,
Podrazumijevani konstruktor moemo promijeniti, tako to emo postaviti poetne vrijednosti atributa
klase. Npr. u deklaraciji klase moemo definisati konstruktor ovako:
public:
132
ET Tuzla
Date(int mm, int dd,int yyyy);
Nadalje, u definiciji klase konstruktor se definie tako da postavlja poetne vrijednosti privatnih lanica
klase kako slijedi:
Date::Date(int mm, int dd,int yyyy)
{
month=mm;
day=dd;
year=yyyy;
cout<<Created a new date object with data values:
<<month<<,<<day<<,<<year<<endl;
}
Ovo je primjer podrazumijevanog konstruktora sa parametrima.

Testirajmo klasu kreiranjem objekta klase Date.
Header file klase sadri konstruktor koji dodjeljuje poetne vrijednosti lanicama promjenljivim (dan = 7,
mjesec = 4, godina = 2012.
133
ET Tuzla
134

Programiranje Za 3. Razred

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Programiranje Za 3. Razred

Uploaded by

Copyright:

Available Formats

ET Tuzla

Selma Krajinovi, mag.ing.el.

MODUL 5: DVODIMENZIONALNI NIZ

formiraju -ti red, brojevi

kvadratna matrica reda

. Kod kvadratne matrice brojevi

formiraju glavnu dijagonalu matrice

Matrice obino oznaavamo velikim pisanim slovima, A,B,X,YKoriste se i oznake

je matrica tipa 3x4, s oznaenim drugim retkom,

su primjeri retane odnosno stupane matrice,

kvadratne matrice reda

su jednake ako su istog tipa i ako je

, a ujedno i stupane i retane matrice

C++ : Dvodimenzionalni niz

Dakle, indeks prvog reda je 0, a poslednjeg 2. Indeks prve kolone je 0, a poslednje 4.

Ispisivanje dvodimenzionalnog niza

Ako testiramo kodi zadamo dimenizije niza 3x3, dobijemo

Primjer izvravanja programa

Mnoenje matrice skalarom

Anxk * Bkxm = Cnxm

A3x4 * B4x5 = C3x5

Rezultujua matrica C bie formata 3x5, sa elementima:

Npr. element c23 rauna se kao

Elementi prvog reda nove matrice raunaju se prema formulama:

Elementi drugog reda nove matrice raunaju se prema formulama:

Elementi treeg reda nove matrice raunaju se prema formulama:

Dakle, ako je A dimenzija nxm, tada je AT tipa mxn. Na primjer,

Element transponovane matrice sa indeksom i,j dobiva vrijednost

Za elemente na glavnoj dijagonali vrijedi i=j, tj. na glavnoj

Kreiranje matrice realizuje se u okviru slijedeeg koda:

Posmatrajmo indekse elemenata matrice formata 5x5

Moemo uoiti ovisnost izmeu indeksa elemenata kako slijedi:

U ovoj matrici najmanji element je 0. Prva pojava ovog elementa je u

Zatim, pronaimo traene indekse:

Prepiemo i.ti red ulazne umatrice x u i.ti red matrice y

Sada u memoriji imamo

Za formiranje submatrica koristimo kod:

Sloeni tipovi i strukture podataka

struct kljuna rije koja oznaava poetak definisanja strukture,

Deklaracija promjenljive tipa struktura

U funkciji main testiramo ove dvije funkcije:

Za testiranje koristimo kod:

Elementima niza/ strukture pristupamo ovako:

Struktura kao lan strukture

Zatim definiimo strukturu ija lanica je tipa datum:

Komponenta vInt je integer reprenzentacija vremena koja se rauna kao

Uitavanje elemenata niza vri kod:

Nakon uitavanja podataka, niz sortiramo u opadajuem redoslijedu:

Primjer izvravanja programa:

Ispis uitanih podataka i rang liste

Kocka simboliki oznaava memorijsku lokaciju u kojoj se uva objekat. objekat je

Promjenljiva koja sadri adresu memorijske lokacije u kojoj se uva objekat

// objekat je promjenljiva tipa int

Dereferenciranje - Vraa vrijednost promjenljive koja je na lokaciji na koju pokazuje

Slijede primjeri koritenja operatora.

objekat je promjenljiva koja ima vrijednost 5.

Promjenljiva drugi_objekat dobiva vrijednost koja

U promjenljivu ija je adresa u pokazivau

Primjetimo da se operator * moe imati razliite funkcije:

u deklaraciji pokazivaa int

Ove dvije naredbe moemo objediniti naredbom:

Ovaj kod moemo predstaviti grafiki kako slijedi:

Ako je pokaziva daljinski za tv ureaj, onda naredbom

Ispiite vrijednosti x, y, z, p, q, r, p, q, *r (svakoj vrijednosti prethodi komentar).