Prof. dr.

Savo Stupar

Uvod u C++ programiranje

Sarajevo, 2020.
 Naziv djela:
Uvod u C++ programiranje
Autor:
Prof. dr. Savo Stupar
Izdavač:
Ekonomski fakultet Univerziteta u Sarajevu
Za izdavača:
Dekanesa, Prof. dr. Jasmina Selimović
Recenzenti:
Prof. dr. Mario Spremić
Prof. dr. Aida Habul
Dizajn i tehnička priprema:
Sanela Stupar
Godina izdanja:
2020.
______________________________________________________________________________
CIP - Katalogizacija u publikaciji
Nacionalna i univerzitetska biblioteka
Bosne i Hercegovine, Sarajevo

004.43C++(075.8)

STUPAR, Savo
Uvod u C++ programiranje [Elektronski izvor] / Savo Stupar. - El. knjiga. - Sarajevo :
Ekonomski fakultet, 2020

Način pristupa (URL): http://ebiblioteka.efsa.unsa.ba/xmlui. - Nasl. sa nasl. ekrana. - Opis izvora

dana 26. 6. 2020.

ISBN 978-9958-25-150-4

COBISS.BH-ID 39374086
______________________________________________________________________________

2
 PREDGOVOR

Kada danas govorimo o brzom razvoju nauke i tehnologije i pitamo se šta je tome najviše
doprinijelo, nameće se neizbježan zaključak da je tome najviše doprinio eksplozivni rast
informaciono-komunikacionih tehnologija. Automatizacija poslovanja nije moguća bez
softverskih proizvoda, a jedna od najvažnijih aktivnosti u keriranju softvera je svakako
programiranje. Zbog toga je već dugo vremena, kao što je i sada i kao što će biti i budućnosti,
jedna od veoma aktuelnih tema, tema programiranja. Knjiga „Osnove C++ programiranja“ ima za
cilj da posluži bržem i sveobuhvatnijem savladavanju osnovnih, kako teorijskih koncepata tako i
praktičnih aspekata programiranja u jeziku C++. Namijenjena je prije svega studentima II godine
Ekonomskog fakulteta u Sarajevu, koji slušaju predmet Programiranje i baze podataka na
odsijeku Visoka poslovna škola i smjeru Razvoj poslovnih informacionih sistema, kao i svima onim
koji se počinju baviti programiranjem a nemaju prethodnih znanja i iskustava o tome, kao i onima
koji se trenutno bave programiranjem koristeći tradicionalne programske jezike, a imaju namjeru
usavršavati vještine programiranja korišćenjem savremenih programskih jezika, kao što su C
jezik, C++, Java, C# itd. Teorijski koncepti na kojima su zasnovani C i C++ jezik, čine osnovu na
kojoj su izgrađeni najsavremeniji programski jezici, tako da savladavanje tih koncepta,
predstavlja više od polovine cjelokupnog truda oko usvajanja i korišćenja novih programskih
jezika. Da bi se ostvario osnovni cilj objavljivanja knjige, bilo je neophodno realizovati sljedeće
zadatke:

 Izlaganje složenih teorijskih koncepata na jednostavan i svima prihvatljiv način;

 Izdvajanje bitnih dijelova rečenice boldiranjem, čime se prilikom ponovnog čitanja
postiže skraćenje vremena potrebnog za razumijevanje gradiva;
 Korišćenje prikaza u boji, kako na slikama tako i u tekstu u skladu sa razvojnim
okruženjem Code::Blocks, koje je korišćeno za izradu programa u C++ jeziku, kojima se
ilustruje upotreba pojedinih programskih elemenata (iskaza, naredbi, varijabli,
operatora, literala i ostalih).
 Pronalaženje odgovarajućih praktičnih primjera, koji na pravi način ilustruju teorijske
koncepte

3
 Knjiga se sastoji iz 15 poglavlja u kojima su detaljno objašnjeni osnovni elementi i osnovni
programski koncepti programskog jezika C++, čije usvajanje čitaocima omogućava da pišu
ispočetka veoma jednostavne programe, a kasnije poslije upoznavanja sa naprednijim
konceptima i mnogo složenije programe. Knjiga se mnogo više bazira na programskim
konstrukcijama nego na nekim složenim algoritmima. Opštepoznato je da u svim oblastima
ljudskog djelovanja, koje se bave spoznajom, učenjem i prihvatanjem kako znanja tako i vještina
naročito u nauci, „da slika govori više od hiljadu riječi“. Upravo ova misao je autoru bila i osnovna
ideja vodilja kada je trebalo „teške stvari pokušati objasniti na lak način“. Zbog toga se u svakom
dijelu knjige mogu pronaći, za svaku programsku konstrukciju odgovarajući praktični primjeri iz
prakse, koji su pored napora u pronalaženju pravih riječi za jednostavnije objašnjavanje složenih
koncepata, izuzetno ilustrativni i u vizuelnom smislu. Tri su bitne stvari oko kojih smo se posebno
potrudili u ovoj knjizi, a to su izbor pravih primjera za ilustraciju teorijskih koncepata, izbor načina
izlaganja i objašnjavanja tematike bez nepotrebne i pretjerane upotrebe stručnih termina i izbor
vizuuelnih elemenata prezentacije pojmova počevši od različitih vrsta dijagrama pa do
raznobojnog obilježavanja svakog programskog elementa u prezentiranju programskog koda.

Savo Stupar

4
IZVOD IZ RECENZIJE
Moderno poslovanje teško možemo zamisliti bez potpore informacijskih sustava i
primjerene tehnologije. Informacijski sustavi i pripadajući softver u sve većoj mjeri
automatizmom provode poslovne transakcije, omogućuju izvođenje poslovnih procesa,
podupiru ključne dijelove poslovanja svake organizacije i pružaju podršku odlučivanju. Knjiga
Uvod u C++ programiranje na jasan i prepoznatljiv način obrađuje sveobuhvatnu temu razvoja
softvera i njegove primjene u modernu poslovanju i predstavlja jednu od mnogo knjiga, koje su
napisane na temu programiranja uopće, ali i programiranja u C++ programskom jeziku. Mnogi
autori sličnih knjiga ili publikacija su na različite načine pokušavali 'dočarati' kako izgleda proces
programiranja i na koji se način ta specifična znanja i logičke rutine mogu usvojiti.
Kada je ova knjiga u pitanju, već na osnovu nekoliko početnih stranica, vidljiv je napor i
pokušaj autora da složenu problematiku računalnog programiranja na što lakši i jednostavniji
način prezentira onima kojima je knjiga prvenstveno i namijenjena – početnicima u računalnom
programiranju. Zbog tog napora, koji nije ostao samo na pokušaju, smatram da je upravo to ono
po čemu se ova knjiga razlikuje od velikog broja sličnih knjiga.
Knjiga obrađuje uvijek aktualnu temu, a odlikuje je jasan, terminološki korektan i
razumljiv stil. Sistematizacija će doprinijeti razumijevanju i preglednosti, a metodički pristup
temeljen na primjerima i konkretnim primjenama zasigurno olakšati savladavanje i razumijevanje
sadržaja. Posebna 'dodana vrijednost' knjizi su brojni praktični primjeri, ilustracije i slike.

Prof. dr. sc. Mario Spremić, dipl.inž.mat.

Knjiga „Uvod u C++ programiranje“ ima sličan koncept kao i većina knjiga pisanih na temu
programiranja kao što su obrazlaganje teorijskih elemenata i tehnika programiranja sa malo ili
nedovoljno praktičnih primjera ili nedovoljno adekvatnih primjera, koji bi poslužili za brže i lakše
usvajanje vještine programiranja. Ono po čemu se ova knjiga razlikuje od ostali pisanih na istu
temu, jeste jednostavan i početnicima ili nedovoljno upućenima u ovu oblast, prilagođen način
na koji autor biranjem adekvatnih primjera, kao i nekim posebnim tehnikama postiže lakoću
razumijevanja kod čitaoca. Jedna od tih posebnih tehnika osobito u dijelu knjige koji objašnjava
logiku rada programa jeste obilježavanje ključnih riječi u rečenici bilo boldiranjem
(podebljavanjem zapisa) ili upotrebom različitih boja za razlikovanje različitih objekata u
kompjuterskom programu u skladu sa bojama koje se za istu stvar koriste u editoru, kao jednoj
od osnovnih komponenti razvojnog okruženja (Code::Block), što svakako ubrzava i povećava
stepen razumijevanja gradiva koje je potrebno usvojiti.
Bez obzira na to što je knjiga namijenjena prije svega početnicima u programiranju, zbog
činjenice da se ne bavi samo osnovnim konceptima, nego u značajnoj mjeri i naprednijim
konceptima, može poslužiti i onim iskusnijim programerima, koji se bave programiranjem u
drugim programskim jezicima.

Prof. dr Aida Habul

5
UVOD............................................................................................................................................................ 9
1. BROJNI SISTEMI I ZAPISIVANJE ZNAKOVA U MEMORIJI ........................................................................ 12
1.1. Pretvaranje brojeva iz bilo kojeg brojnog sistema u decimalni ...................................................... 14
1.2. Pretvaranje brojeva iz decimalnog brojnog sistema u bilo koji drugi brojni sistem ....................... 15
1.3. Hijerarhija logičkih jedinica memorije ............................................................................................ 16
2. PROGRAMSKI JEZICI ............................................................................................................................... 17
3. FAZE PROGRAMIRANJA .......................................................................................................................... 20
3.1. Analiza i definisanje problema ........................................................................................................ 21
3.2. Izrada algoritma .............................................................................................................................. 21
3.3. Izrada dijagrama toka...................................................................................................................... 22
3.4. Pisanje pseudokoda ........................................................................................................................ 23
3.5. Pisanje izvornog programa (kodiranje) ........................................................................................... 23
3.6. Prevođenje izvornog koda (kompajliranje) ..................................................................................... 24
3.7. Linkovanje (povezivanje) ................................................................................................................. 25
3.8. Testiranje programa........................................................................................................................ 26
3.9. Implementacija programa............................................................................................................... 27
3.10. Dokumentovanje programa .......................................................................................................... 27
3.11. Eksploatacija programa................................................................................................................. 27
3.12. Održavanje programa ................................................................................................................... 28
4. PROGRAMIRANJE U PRAKSI ................................................................................................................... 30
4.2. Pisanje drugog program u C++ jeziku.............................................................................................. 33
4.3. Pisanje trećeg programa ................................................................................................................. 35
4.4. Pisanje četvrtog programa .............................................................................................................. 36
5. VARIJABLE I DEKLARISANJE VARIJABLI ................................................................................................... 37
6. KONSTANTE ............................................................................................................................................ 39
7. OSNOVNI TIPOVI PODATAKA ................................................................................................................. 41
7.1. Realni tip podataka ......................................................................................................................... 43
7.3. Logički tip podataka ........................................................................................................................ 45
7.4. Nabrojivi (engl. enumerated) tip podataka .................................................................................... 45
7.5 Void tip podataka ............................................................................................................................. 47
8. OPERATORI............................................................................................................................................. 48

6
 8.1. Operatori pridruživanja ................................................................................................................... 48
8.2. Relacioni operatori ili operatori poređenja i operatori jednakosti ................................................. 49
8.3. Aritmetički operatori....................................................................................................................... 50
8.4. Logički operatori ............................................................................................................................. 54
8.5. Uslovni operator grananja .............................................................................................................. 55
8.6. Stream operatori ............................................................................................................................. 56
8.7. Comma (zarez) operatori ili operatori razdvajanja ......................................................................... 57
8.8. Dodatni operatori ........................................................................................................................... 57
8.9. Operator sizeof ............................................................................................................................... 59
8.10. Identifikatori (imena) .................................................................................................................... 61
9.0. NAREDBE ZA KONTROLU TOKA PROGRAMA (KONTROLNE STRUKTURE) ........................................... 63
9.1. Sekvencijalne strukture u C++ jeziku (sekvenca ili blok) ................................................................. 64
9.2. If iskaz izbora ................................................................................................................................... 66
9.3. Struktura selekcije if...else .............................................................................................................. 69
9.4. Struktura selekcije višestruki izbor (switch).................................................................................... 73
10. STRUKTURE PONAVLJANJA (REPETICIJE) ............................................................................................. 78
10.1. Petlja while do............................................................................................................................... 79
10.2. Petlja do while............................................................................................................................... 83
10.3. Petlja for ........................................................................................................................................ 86
11. NAREDBE ZA PROMJENU TOKA IZVRŠAVANJA PETLJI .......................................................................... 93
11.1. Naredba continue ......................................................................................................................... 94
11.2. Naredba break .............................................................................................................................. 97
11.3. Naredba goto ................................................................................................................................ 98
12. FUNKCIJE U C++ PROGRAMSKOM JEZIKU .......................................................................................... 103
12.1. Definicija, poziv i parametri funkcija u C++ ................................................................................. 104
12.1.1. Definicija (deklarisanje) funkcije .............................................................................................. 104
12.1.2. Poziv funkcije ........................................................................................................................... 105
12.1.3. Parametri ili argumenti funkcije .............................................................................................. 107
12.2. Prototip funkcije ......................................................................................................................... 110
12.3. Povratak iz funkcije ..................................................................................................................... 112
12.4. Funkcija exit() .............................................................................................................................. 113
13. OBLAST VAŽENJA VARIJABLI (SCOPE) ................................................................................................ 114
13.1. Lokalna oblast važenja varijabli .................................................................................................. 115

7
 13.2. Globalna oblast važenja varijabli (global scope) ......................................................................... 118
13.3. Memorijske (storage) klase......................................................................................................... 118
13.4. Statička varijabla ......................................................................................................................... 119
13.5. Pravila vidokruga identifikatora (scope rules) ............................................................................ 120
13.6. Rekurzija ...................................................................................................................................... 123
13.7. Funkcije sa praznom listom parametara..................................................................................... 128
13.8. Inline funkcije .............................................................................................................................. 129
13.9. Podrazumijevani (default) argumenti ......................................................................................... 130
13.10. Preklapanje (overloading) funkcija ........................................................................................... 131
13.11. Reference i referentni parametri .............................................................................................. 132
14. NIZOVI ................................................................................................................................................ 134
14.1. Manipulacije sa nizovima ............................................................................................................ 136
14.2. Prekoračenje granica niza ........................................................................................................... 137
14.3. Korišćenje nizova karaktera (polja) za manipulaciju sa stringovima .......................................... 138
14.4. Predaja nizova funkcijama .......................................................................................................... 142
14.5. Višedimenzionalni nizovi............................................................................................................. 144
15. SLOGOVI PODATAKA (STRUKTURE) ................................................................................................... 148
15.1. Pristup članovima strukture ........................................................................................................ 150
15.2. Inicijalizacija ili punjenje struktura.............................................................................................. 151
15.3. Predaja parametara struktura funkcijama .................................................................................. 152

8
 UVOD

Računar se smatra najvećim izumom 20. vijeka, odnosno najvećim izumom do tada. Tu se
prije svega misli na računar opšte (univerzalne) namjene, odnosno digitalni računar, koji za
razliku od analognih računara, koji pretvaraju određene fizičke veličine u druge, funkcioniše na
osnovu određenih stanja (zapisa) na memorijskom mediju. Uz pomoć digitalnih računara
obrađujemo određene vrste podataka. Kako se podaci memorišu u računaru? Koristeći osobinu
računarskih elemenata da mogu poprimati samo dva stanja (struja u nekoj žici ili teče ili ne teče;
struja u nekom elektronskom elementu teče u jednom smjeru npr. smjeru kazaljke na satu ili
drugom, obrnutom smjeru; na magnetnim medijima tipa trake ili diska, podaci se upisuju po
određenim zamišljenim kanalima ili koncentričnim krugovima u obliku namagnetisanih ili
nenamagnetisanih tačaka), koja se simbolički predstavljaju sa 0 ili 1, uz pomoć jednog
elektronskog elementa mi možemo memorisati vrijednost samo jednog najnižeg elementa u
hijerarhiji memorijskih zapisa, koji nazivamo bit.
Podaci su organizovani u hijerarhiju koja započinje bitom i nastavlja se sve do baze
podataka (slika 1). Bit (binarna cifra - binary digit) je najmanja jedinica podatka, koja se može
predstaviti u memoriji računara i koju računar može da obradi. Pojam binarna označava da bit
može da se sastoji samo od nula ili jedinica. Niz od osam bita čini bajt (Byte) i predstavlja jedan
alfanumerički znak. Zašto baš osam bita? Da bi se jedan znak razlikovao od drugih znakova, on
mora biti predstavljen jednistvenom kombinacijom nula i jedinica.
Koliko se različitih znakova (slova, brojeva i specijalnih znakova) može predstaviti ako je
dužina te kombinacije 2, a na raspolaganju nam stoje 2 binarna znaka (0 i 1), a svaki od njih se
može ponavljati u toj kombinaciji onoliko puta koliko je dužina te kombinacije? Dakle, koje su
kombinacije moguće? One su prikazane na tabeli 1.

Broj varijacije (kombinacije Znak koji se kodira Varijacije sa ponavljanjem

1. 0 00
2. 1 01
3. 2 10
4. 3 11

Tabela 1. Varijacije sa ponavljanjem od 2 binarna broja

To znači da sa dužinom kombinacije od 2 znaka, koji se mogu ponavljati u jednoj

kombinaciji (00 i 11) možemo predstaviti samo 4 različita znaka (tabela 1).
Npr. svakom od brojeva 0 do 3, možemo dodijeliti odgovarajuću jedinstvenu kombinaciju:

a) broj 0 se predstavlja dvobitnom kombinacijom 00

b) broj 1 se predstavlja dvobitnom kombinacijom 01
c) broj 2 se predstavlja dvobitnom kombinacijom 10 i
d) broj 3 se predstavlja dvobitnom kombinacijom 11

Dakle, sa dužinom kombinacije od 2 binarna broja (0 i 1), možemo predstaviti samo 4

različita znaka od ukupnog broja znakova, koje je neophodno predstaviti u memoriji računara. A
to su znakovi (slova) engleskog alfabeta (26), deset numeričkih znakova (brojeva od 0-9) i veliki
broj specijalnih znakova, koji su navedeni unutar navodnika, koji takođe predstavljaju specijalni
znak, kao i male otvorene i zatvorene zagrade (“,”,”.”, “<”,”>”, “{“, “}”, “@”, “[“, “]”, “#”, “$”, “%”,
“&” itd.). To znači da moramo povećati dužinu kombinacije na tri binarna broja (trobitna
kombinacija). Sa dužinom od 3 binarna broja, možemo predstaviti 8 kombinacija, odnosno 8
razlićitih znakova, npr. brojeve od 0 do 7 u decimalnom brojnom sistemu (tabela 2).

Znak koji se kodira Kombinacija Cifre oktalnog

(varijacija) brojnog sistema
1 000 0
2 001 1
3 010 2
4 011 3
5 100 4
6 101 5
7 110 6
8 111 7

Tabela 2. Binarne kombinacije oktalnog brojnog sistema

Ako saberemo sve znakove koje moramo predstavaiti u memoriji računara, a to je 26

slova (u našem alfabetu 30), zatim 10 numeričkih znakova (0-9) i preko 40 specijalnih znakova,
to je blizu 80 znakova, gdje svaki od njih mora imati svoju jedinstvenu kombinaciju 0 i 1, jasno je
da niti dužina od 3 binarna broja ne zadovoljava mogućnost predstavljanja svih potrebnih
znakova. Sa dužinom od 4 binarna broja možemo predstaviti 16 različitih (jedinstvenih)
kombinacija. To se lako izračuna uz pomoć statističke formule za varijacije sa ponavljanjem:
2dužina varijacije ili (24), gdje je 2 broj binarnih binarnih brojeva (to su 0 i 1), a dužina varijacije je
ukupna dužina pojedinačne varijacije (tabela 3). Da ne bude zabune, dosad je u radu korišćen
pojam kombinacije, a u statističkom smislu to su varijacije sa ponavljanjem. Formula za

10
izračunavanje kombinacija je sasvim drugačija. Dakle ono što je u radu prethodno nazivano
kombinacijama, u statistici se zove varijacije sa ponavljanjem.
Broj koji se kodira Varijacije sa ponavljanjem Cifre
u decimalnomom od 4 binarna znaka heksadecimalnog
brojnom sistemu brojnog sistema
1 0000 0
2 0001 1
3 0010 2
4 0011 3
5 0100 4
6 0101 5
7 0110 6
8 0111 7
9 1000 8
10 1001 9
11 1010 A
12 1011 B
13 1100 C
14 1101 D
15 1110 E
16 1111 F

Tabela 3. Tabela varijacija sa ponavljanjem od 4 binarna znaka

Kao što se iz tabele 3. vidi, prvih 10 binarnih varijacija se može koristiti za predstavljanje
10 brojeva u decimalnom brojnom sistemu (0 do 9). Posljednjih šest varijacija, predstavlja višak
kodnih kombinacija ili redundantnost koda. Na ovaj način se odvijao i razvoj kodiranja. Kodovi sa
4 binarna znaka, nazivali su se tetradni kodovi, a računari koji su radili na bazi njih, mogli su
predstavljati samo brojeve (od 0 do 9) i raditi (obrađivati) samo računske operacije kao
kalkulator. Sa dužinom varijacije od 5 (25=32) i 6 (26=64), povećao se broj jedinstvenih varijacija,
ali ni jedan ni drugi kod nisu obezbjeđivali dovoljan broj varijacija da bi svi potrebni znakovi imali
jedinstvenu identifikaciju. To se desilo tek sa 7-bitnom, odnosno definitivno sa 8-bitnom
kombinacijom (27=128 i 28=256), tako da je svaki znak predstavljen jedinstvenom 8-bitnom
identifikacijom, koja predstavlja jedan byte.
Kao što je već rečeno, računar “razumije” ili može “prepoznati” ili “pročitati” samo onaj
podatak, koji mu je kodiran (zabilježen na nekom mediju) uz pomoć samo dva različita stanja,
koja se simbolički predstavljaju kao 0 ili 1. Ista je stvar ako se radi o instrukcijama, koje
predstavljaju osnovne elemente kompjuterskog programa. Kada je riječ o kompjuterskom

11
programu, treba razlikovati binarni zapis izvornog programa od binarnog zapisa izvršnog
programa, koji se dobije kompajliranjem izvornog programa (o čemu će biti malo detaljnije riječi
u nastavku), ali i jedan i drugi su faktički samo nizovi nula ili jedinica, odnosno stanja fizičkih
elemenata memorije, kojima su reprezentovani. To drugim riječima znači da bez obzira na to o
koliko moćnom, pametnom i modernom računaru se radi, sve što je u njemu memorisano (kako
u internoj ili eksternoj memoriji), bilo da se radi o numeričkim ili tekstualnim podacima,
fotografijama, audio ili video zapisima, o sistemskim ili aplikativnim programima (izvornim ili
izvršnim), predstavlja samo odgovarajući niz nula i jedinica. Pošto su najmanje dva znaka
neophodna da bi se kreirao neki zapis, kojem se može dodijeliti neko značenje, binarni brojni
sistem, čiju osnovu (bazu) čine 2 znaka (0 i 1), nametnuo se kao jedino rješenje za konstruktore
uređaja (računara), čiji je primarni cilj bio memorisanje i automatska obrada podataka.

1. BROJNI SISTEMI I ZAPISIVANJE ZNAKOVA U MEMORIJI

Brojni sistem predstavlja skup pravila pomoću kojih se jedinstveno identifikuju i zapisuju
brojevi i skupa cifara, koje se koriste u konkretnom brojnom sistemu. Brojne sisteme dijelimo na:
1) Nepozicione brojne sisteme i
2) Pozicione brojne sisteme
Nepozicioni brojni sistemi su oni kod kojih vrijednost cifre (težina pozicije te cifre) u zapisu
brojne vrijednosti (broj sastavljen od osnovnih cifara konkretnog brojnog sistema) ne zavisi od
pozicije te cifre (jedan od osnovnih znakova iz tog brojnog sistema) u tom zapisu. Oni se danas
uglavnom ne koriste, osim rimskog brojnog sistema (tabela 4).

Osnovni znak (cifra) I V X L C D M

Vrrijednost znaka u broju 1 5 10 50 100 500 1000

Tabela 4. Vrijednosti znakova rimskog brojnog sistema u zapisu brojne vrijednosti

Ako uzmemo primjer 1957. godina se piše uz pomoć rimskih brojeva MCMLVII ili
MDCCCCLVII ili MDCDLVII (https://www.periodni.com/hr/pretvaranje_rimskih_brojeva.html).
Pravila za njihovo zapisivanje su:
 ukoliko nekoliko istih cifara stoji jedna pored druge, onda im se vrijednosti
sabiraju (npr. ako je zapis brojne vrijednosti (broj) VVVV, izračunava se njegova
vrijednost kao V + V + V + V, što znači da je vrijednost tog zapisa 20, a može i XX,
a može i IVIVIVIVIV)
 ukoliko su u zapisu brojne vrijednosti, jedna pored druge zapisane dvije različite
cifre od kojih je prvo zapisana ona sa većom vrijednošću, tada se njihove

12
 vrijednosti (težine pozicija) sabiraju (npr. MDL, njegova vrijednost je M + D + L,
radi se o broju 1550)
 ukoliko se u broju (zapisu brojne vrijednosti) nalaze dvije različite cifre od kojih
lijevo ona sa manjom vrijednošću, tada se težina njene pozicije (vrijednost)
oduzima od cifre napisane desno (npr. CM, njegova vrijednost je M - C, a to je
900).

Pozicioni brojni sistemi su oni kod kojih vrijednost cifre u zapisu brojne vrijednosti zavisi
od pozicije te cifre u zapisu.
Ako bazu svakog brojnog sistema definišemo kao broj znakova, koji se koristi u tom
sistemu, onda možemo reći da je bazu decimalnog brojnog sistema, koji je univerzalno prihvaćen
u matematici, predstavlja broj 10, jer ima 10 osnovnih znakova (cifara) od kojih je sastavljen svaki
zapis brojne vrijednosti u tom brojnom sistemu. To su cifre 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 i kao što se
vidi ima ih ukupno 10. Dakle, baza binarnog brojnog sistema je 2, jer imamo samo dva znaka (0 i
1), od kojih su sastavljeni svi brojevi (zapisi brojne vrijednosti) u tom sistemu. U skladu s tim, baza
brojnog sistema, koji sadrži 3 znaka (0, 1, 2) je 3, baza brojnog sistema koji sadrži 4 znaka (0, 1,
2, 3) je 4 itd. Brojni sistemi koji se koriste u informatici osim binarnog brojnog sistema su oktalni
sa bazom 8 i heksadecimalni sa bazom 16 ili F.

Brojni sistemi Baza brojnog sistema Cifre Najveći broj u

(B) brojnom
sistemu (B-1)
Binarni 2 0, 1 1
Oktalni 8 0, 1, 2, 3, 4, 5, 6, 7 7
Decimalni 10 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 9
Hexadecimalni 16 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F F

Tabela 5. Prikaz karakteristika brojnih sistema, koji se koriste u informatici

13
 Decimalni broj Binarni ekvivalent Oktalni Hexdecimalni
Ekvivalent ekvivalent
0 0000 00 0
1 0001 01 1
2 0010 02 2
3 0011 03 3
4 0100 04 4
5 0101 05 5
6 0110 06 6
7 0111 07 7
8 1000 10 8
9 1001 11 9
10 1010 12 A
11 1011 13 B
12 1100 14 C
13 1101 15 D
14 1110 16 E
15 1111 17 F

Tabela 6. Binarni, oktalni i heksadecimalni ekvivalenti brojeva od 0 do 15.

1.1. Pretvaranje brojeva iz bilo kojeg brojnog sistema u decimalni

Ako posmatramo bilo koji broj (zapis brojne vrijednosti) u bilo kojem pozicionom brojnom
sistemu, svaka cifra u tom zapisu ima svoju poziciju i težinu pozicije. Pozicije počinju od 0 i broje
se zdesna ulijevo. Npr. za broj 3327(10), koji je broj sa bazom 10, cifra 7 se nalazi na 0. poziciji,
cifra 2 na 1. poziciji, cifra 3 na 2. poziciji i druga cifra 3 (redom slijeva udesno) na 3. poziciji.

Broj 3 3 2 7
Pozicija cifre u broju 3 2 1 0
Pozicija cifre
Težina pozicije = Baza 10 3
102 101 101
Vrijednost težine pozicije 1000 100 10 1
Tekstualno Hiljadarke Stotice Desetice Jedinice
Vrijednost cifre = cifra x težina
3x1000=3000 3x100=300 2x10=20 7x1=7
pozicije
Vrijednost broja 3000 + 300 + 20 + 7 = 3327(10)

Tabela 7. Izračunavanje vrijednosti broja (zapisa brojne vrijednosti)

Treba zapaziti da broj 3 na poziciji 3 ima vrijednost 3000, a isti broj na poziciji 2 ima
vrijednost 300.

14
 Uzmimo drugi primjer: Broj 10101(2)

Broj 1 0 1 0 1
Pozicija cifre 4 3 2 1 0
Težina pozicije = BazaPozicija cifre 24 23 22 21 20
Vrijednost težine pozicije 16 8 4 2 1
Tekstualno Šesnaestice Osmice Četvorke Dvice Jedinice
Vrijednost cifre = cifra x težina
1x24=16 0x23=0 1x22=4 0x21=0 1x20=1
pozicije
Vrijednost broja 16 + 0 + 4 + 0 + 1 =21(10)

Tabela 8. Pretvaranje binarnog broja u decimalni

Na isti način se vrši pretvaranje brojeva iz bilo kojeg drugog brojnog sistema (npr. iz
oktalnog i heksadecimalnog) u decimalni brojni sistem.

1.2. Pretvaranje brojeva iz decimalnog brojnog sistema u bilo koji drugi brojni sistem

Ovo pretvaranje se vrši tako što se decimalni broj dijeli sa bazom onog brojnog sistema u
koji se pretvara. Ukoliko se pretvara u binarni, dijeli se sa 2, ukoliko se pretvara u oktalni,
decimalni broj se dijeli sa 8 i u slučaju pretvaranja u heksadecimalni broj, dijeli se sa 16. Prvo
dijeljenje sa bazom ima neki rezultata, ali ostatak dijeljenja su cifre 0 i 1 (a to su cifre binarnog
brojnog sistema, ako se dijeli sa 2, zatim 0, 1, 2, 3, 4, 5, 6 i 7, ukoliko se dijeli sa 8 (a to su upravo
cifre oktalnog brojnog sistema. Nakon prvog dijeljenja sa 2, 8 ili 16, rezultat se ponovo dijeli sa 2,
8 ili 16, zavisno od toga u koji brojni sistem želimo pretvoriti decimalni broj. Nakon drugog
dijeljenja imamo neki rezultat, a bilježi se ostatak. Dijeljenje dobivenog rezultata i bilježenje
ostatka dijeljenja se vrši sve dok rezultat dijeljenja ne postane 0. Nakon posljednjeg dijeljenja i
bilježenja posljednjeg ostatka dijeljenja, taj ostatak postaje prva cifra broja u koji pretvaramo
decimalni broj. Ostatak pretposljednjeg dijeljenja postaje druga cifra tog broja, zatim ostatak
prethodnog (predpredposljednjeg) dijeljenja postaje 3 cifra i tako sve do ostatka prvog dijeljenja.
Npr. želimo broj 27(10) pretvoriti u binarni broj, što znači da dijelimo broj sa bazom
binarnog brojnog sistema (2).

Dakle, rezultat pretvaranja je binarni broj 11011(2).

15
Ukoliko želimo provjeriti tačnost rezultata:

Broj 1 1 0 1 1
Pozicija 4 3 2 1 0
Baza 2 2 2 2 2
Težina 24 2 3 2 2 21 20
Vrijednost 16 8 4 2 1
Decimalni broj 1x16 + 1x8 + 0x4 + 1x2 + 1x1 = 27

Tabela 9. Provjera tačnosti rezultata

1.3. Hijerarhija logičkih jedinica memorije

Bajt može biti broj, slovo ili simbol. Logičko grupisanje karaktera u riječi, grupe riječi ili
identifikacioni broj naziva se polje (Field). Na primjer, ime studenta u fajlovima univerzitetskih
računara pojaviće se u polju „ime", a JMBG studenta u polju „JMBG". Polja takođe mogu
sadržavati podatke koji nisu brojevi ili slova, odnosno sliku ili bilo koji multimedijalni zapis. Na
primjer, baza podataka ustanove za registrovanje motornih vozila može da sadrži i slike vlasnika
motornih vozila. Logičko grupisanje srodnih polja (kao što su ime studenta, koji nastavu pohađa,
datum ispita i ocjenu) naziva se zapis (Record). Logičko grupisanje srodnih z.apisa naziva se
datoteka ili tabela (File ili Table). Na primjer, zapisi određenog predmeta na fakultetu (koji se
sastoji od broja predmeta, imena profesora i ocena studenata) čine datoteku o tom predmetu.
Logičko grupisanje srodnih datoteka čini bazu podataka (Database). Po istom principu, datoteka
studenata o predmetima može se grupisati sa datotekom koja sadrži lične podatke o studentu i
datotekom koja sadrži finansijske podatke o studentu da bi se na taj način stvorila baza podataka
o studentima.

Slika 1: Hijerarhija memorijskih zapisa1

1
Kelly Rainer Jr, Efraim Turban Uvod u informacione sisteme, Data status, Beograd, 2009, str. 109

16
2. PROGRAMSKI JEZICI

Pošto je knjiga namijenjena i prilagođena početnicima u programiranju, prvo se moramo

upoznati sa osnovnim pojmovima, kao što su programski jezici i programiranje.
Cilj ove knjige je savladavanje osnovnih elemenata programiranja od kojih se sastoji neki
programski jezik, a to je lakše učiniti uz pomoć objašnjenja programskih konstrukcija, prije nego
razmatranjem složenih algoritama. To će omogućiti zainteresovanim čitaocima da sami prave, na
početku veoma jednostavne programe a kasnije i mnogo složenije.
Svi koncepti i primjeri, kojima se ti koncepti pokušavaju objasniti predočeni su u
programskom jeziku C++, jer se on danas smatra jednim od najčešće korišćenih programskih
jezika. Učenje programiranja u jednom od programskih jezika je slično učenju vožnje automobila.
Osnovni principi programiranja, kao i realizacija osnovnih programskih konstrukcija su slični u
mnogim višim programskim jezicima. Ako naučimo voziti automobil na Golf-u, lako ćemo poslije
toga voziti i Mercedes. Ako naučimo da realizujemo neku programsku konstrukciju u C++, to
ćemo isto moći i npr. u C-u, Javi ili C# jeziku.
Prirodni jezici predstavljaju sredstvo komunikacije između najmanje dva čovjeka.
Očigledno je da jezik mora biti definisan tako da je prihvatljiv za obojicu. Drugim riječima rečeno,
da bi dvojica ljudi uspješno komunicirali (a to znači da razumiju jedan drugog), moraju govoriti
istim jezikom. Ukoliko govore različitim jezicima, onda bi obojica trebala da poznaju neki drugi
jezik, koji se često koristi u toj vrsti komunikacije. Prvi pokušaj da se napravi jedan takav jezik,
koji se zvao Esperanto, kao vještački i nadnacionalni jezik, koji će kao univerzalni jezik služiti za
komunikaciju između ljudi koji govore različitim (nacionalnim) jezicima, propao je, jer je njegovu
ulogu preuzeo engleski jezik, koji je na početku prošlog vijeka bio službeni jezik u velikom broju
država. Ukoliko žele komunicirati Španac i Italijan, koji govore samo svojim jezikom, moraju
obojica naučiti neki srednji jezik (meta jezik) uz pomoć kojeg će komunicirati. Kada Španac nešto
saopšti Italijanu, mora to prevesti na taj srednji jezik (npr. engleski). Nakon toga, da bi shvatio
šta mu Španac saopštava, odnosno da bi se uspostavila komunikacija ili razumijevanje, Italijan
mora to saopštenje prevesti sa engleskog na italijanski. Ova analogija se koristi i u slučaju kada
je u pitanju problem komunikacije između čovjeka i računara. Engleski jezik koji kao meta jezik
služi za komunikaciju između dva čovjeka koji govore različitim jezicima, u komunikaciji između
čovjeka i računara (mašine), zamjenjuje programski jezik, koji mora uvažavati osobine jezika i
jednog i “drugog” i na bazi toga formirati jezik za njihovu komunikaciju. Jezik računara je izgrađen
na bazi “razumijevanja” samo dva stanja, odnosno simbola i kao takav nije prihvatljiv za čovjeka.
S druge strane, pisani ili govorni jezik čovjeka vrlo je složen i bogat raznim mogućnostima, koje
se ne koriste u procesu komunikacije između čovjeka i računara, pa zbog toga nije prihvatljiv kao
jezik računara. Na kraju, mora se tražiti neki novi jezik, koji će biti prihvatljiv i za čovjeka i za
računar. Kao što smo već rekli, jezici koji su kreirani i definisani da zadovolje ovaj uslov, zovu se
programski jezici. U primjeru (analogija između komunikacije stranaca), koji je predočen, radi

17
boljeg razumijevanja programskih jezika i programiranja, programiranje, odnosno pisanje
programa, predstavlja analogiju sa prevodom na engleski, koji mora obezbijediti Španac, kada
nešto saopštava Italijanu, engleski jezik predstavlja programski jezik, a prevođenje sa engleskog
na Italijanski, predstavlja proces kompajliranja. Tek tada je zatvoren krug, odnosno uspostavljena
komunikacija.
Programski jezik mora da uvaži sljedeće zahtjeve:
1) Da obezbijedi što je moguće veći konfor za čovjeka pri prenošenju algoritama na računar
2) Da omogući što većem broju ljudi lako praćenje i razumijevanje programskog algoritma
3) Da omogući formalizovanje (automatizaciju) postupka prevođenja sa programskog na
mašinski (računarski) jezik. (Parezanović, 1979.)
Prvi zahtjev znači da programski jezik mora obezbijediti što lakše i jednostavnije
izražavanje o problemu, koji se želi riješiti uz pomoć računara. Pa pošto se radi o različitim
vrstama problema, koji se rješavaju uz pomoć računara, definišu se i različiti programski jezici za
pojedine oblasti primjene računara. Većina savremenih programskih jezika su opšte namjene, ali
imaju i svoje specifične namjene. C jezik se najčešće primjenjuje u programiranju sistemskog
softvera. Java je jezik, koji se najčešće koristi u programiranju za Internet, mobilne telefone i
poslovne aplikacije. C# se koristi u razvoju video-igara, a Pyton i C++ u razvoju aplikacija Vještačke
inteligencije. Tvorac jezika C++ jezika je okarakterisao C++ programski jezik kao jezik opšte
namjene i srednjeg nivoa (Stroustrup, 1996).
Drugi navedeni zahtjev za programski jezik treba da omogući razmjenu programskih
algoritama među programerima, projektantima i drugim stručnjacima, koji rade na sličnim
oblastima. Drugim riječima, programski jezik mora da bude nezavisan od konstrukcije računara.
Treći zahtjev treba da omogući stvaranje posebnog sistemskog programa, koji će
obezbijediti da računar vrši prevođenje izvornog programa napisanog u konkretnom
programskom jeziku na mašinski, odnosno izvršni jezik. Ovaj program se zove kompajler
(compiler) ili prevodilac. Ulazni podaci u ovaj program su konstrukcije iz programskog jezika, koje
on prevodi u skup naredbi mašinskog jezika. Tek kada je cijeli izvorni program preveden na
mašinski jezik, onda može početi izvršavanje programa na računaru.
Danas je u upotrebi veliki broj programskih jezika, od kojih su neki opštenamjenski, a neki
imaju specijalne majene. Jedan od najpoznatijih podjela programskih jezika prema kriteriju
složenosti za čovjeka programera, kao i vremenu nastanka programskog jezika je podjela na:
1. Niže programske jezike (niskog nivoa) u koje spadaju:
a. Mašinski jezici
b. Asembleri
2. Više programske jezike (visokog nivoa)
Šta znače pojmovi jezik niskog, odnosno visokog nivoa? Osnovna karakteristika jezika
niskog nivoa (nižih programskih jezika), koja ih razlikuje od jezika visokog nivoa (viših programskih
jezika) jeste njihova prilagođenost arhitekturi svakog konkretnog računara, a to znači da

18
programer mora do najsitnijih detalja poznavati arhitekturu računara, da bi na njemu napravio
program, koji ima svoju namjenu. Pošto svaki računar direktno razumije samo svoj mašinski jezik,
programiranje u tom jeziku bi značilo da čovjek mora da nauči jezik računara, dakle jezik dva
stanja, odnosno dva znaka. Kao što je za ljude njihov nacionalni jezik, predstavlja “prirodni” jezik,
tako je mašinski jezik “prirodni jezik” za računare i kao takav dizajniran je tako da ima svoju
jedinstvenu hardversku arhitekturu. Mašinski jezik se često naziva izvršnim ili objektnim kodom,
koji jedini može obavljati neku funkciju u računaru. Mašinski jezici se u principu sastoje od niza
bitova (0 ili 1). Na samom početku pojave računara, ljudi su programirali računare u mašinskom
jeziku, ali zbog teškoće savladavanja tog jezika i dužine trajanja tog procesa, brzo se uvidjelo, da
je takav jezik neprihvatljiv za programere. Poseban problem, koji je u vezi sa mašinskim jezicima
jeste da su oni zavisni od računara (mašine) odnosno program isprogramiran u mašinskom jeziku
na jednoj vrsti (arhitekturi) računara, može se koristiti samo na toj vrsti računara.
Nakon što se pokazalo potpuno neprimjerenim učiti jezik računara i pisati programe na
mašinskom jeziku, programeri su počeli da koriste riječi engleskog jezika da bi prikazali osnovne
(elementarne) operacije računara, što je predstavljalo osnovu za nastanak asemblera kao nove
vrste programskih jezika. Asemblerski jezik ili jednostavno asembler je jezik nižeg nivoa, slično
mašinskom jeziku, orijentisan računaru, odnosno prilagođen arhitekturi računara. Svaki binarni
kod zamijenjen je riječima engleskog jezika (load, add, store, move) tako da je ovaj programski
jezik bio značajno razumljiviji i bliži čovjeku. Asembler i asemblerski jezici imaju osobinu da se
njihove instrukcije (operacioni kod i operandi) pišu simbolima, koje nazivamo mnemonici. U
principu, odnos između takvih mnemoničkih instrukcija i mašinskih instrukcija (a to znači i
operacija u kompjuteru) je 1:1. Svakoj instrukciji u asembleru odgovara jedna instrukcija
mašinskog jezika. Iako je ovo postalo malo jasnije i jednostavnije za programere i predstavljalo
napredak u odnosu na mašinsko programiranje i dalje je bilo veoma teško programirati u
asembleru.
Da bi se pojednostavio i ubrzao proces programiranja za programere, korišćene su nove
ideje i pronalazili su se novi načini programiranja, tako je došlo i do nastanka i razvoja viših
programskih jezika gdje je osnovna ideja bila objedinjavanje više asemblerskih instrukcija u
jednu. Zbog te činjenice su bili bliži ljudskom razmišljanju, odnosno razmišljanju programera, pa
se on mogao više fokusirati na algoritamsko rješavanje problema, a manje vremena trošio na
pisanje konkretnog programskog koda. Zato se može reći da što je neki programski jezik na višem
nivou, on ostavlja više vremena programeru za fokusiranje na problem, a istovremeno je
potrebno neuporedivo manje znati o principima rada računara. Dakle postoji potpuna
nezavisnost konkretnog programskog računara od hardverske arhitekture na kojoj će se program
izvršavati. Ako su niži programski jezici više orjentisani računaru, viši programski jezici su više
orjentisani čovjeku i njegovom načinu razmišljanja.

19
 Osnovne prednosti korišćenja viših programskih jezika:
1. Efikasniji proces programiranja
2. Razumljivost naredbi i programskih konstrukcija zbog toga što se izražavaju riječima i
rečenicama malo modificiranog engleskog jezika, a mogu sadržavati i matematičku
notaciju
3. Potpuna nezavisnost od arhitekture računara
4. Prilagođenost rješavanju specifičnih problema

3. FAZE PROGRAMIRANJA

Programiranje bi se najjednostavnije moglo definisati kao pisanje niza naredbi poredanih

određenim redoslijedom u izabranom višem programskom jeziku, da bi se riješio neki problem ili
obavio neki zadatak. Rezultat procesa programiranja je izvršni program, odnosno program
generisan u mašinskom jeziku. Kompjuterski program možemo definisati kao niz mašinskih
instrukcija, koji se izvršava precizno određenim redoslijedom, a koje svojim izvršavanjem
izazivaju određene operacije u kompjuterskom sistemu, predviđene potrebom rješenja
konkretnog problema.
Programi (aplikacije) koji se izvršavaju na računaru, odnosno programi koji obavljaju neku
funkciju, memorisani su na eksternoj memoriji računara u izvršnom obliku kao datoteke tipa .exe
(engl. executable). Pozivanjem u rad izvršnog programa, on se automatski “učitava” (prenosi) u
internu memoriju računara, nakon čega počinje njegovo izvršavanje, odnosno obavljanje funkcije
zbog koje je i napravljen. Jedino je takav program razumljiv procesoru računara za koji je kreiran
i jedino on može da obavlja funkciju zbog koje je i napravljen. Ovdje treba napomenuti da izvršni
program kreiran na Unix operativnom sistemu, neće se izvršavati na računaru sa Windows
operativnim sistemom.
Da bismo napravili krajnji proizvod (program u mašinskom jeziku), potrebno je proći sljedeće
faze programiranja:

1. Analiza i definisanje problema

2. Izrada algoritma
3. Izrada dijagrama toka
4. Pisanje pseudokoda
5. Pisanje izvornog programa (kodiranje)
6. Prevođenje izvornog koda (kompajliranje)
7. Povezivanje u izvršni kod (linkovanje)
8. Testiranje programa
9. Implementiranje programa
10. Dokumentovanje programa

20
 11. Eksploatacija i
12. Održavanje programa

3.1. Analiza i definisanje problema

Proces programiranja počinje analizom i definisanjem problema. Da bi omogućio i

pojednostavio transformaciju zadataka iz stvarnog svijeta u kojem živi u oblik prihvatljiv
računaru, čovjek mora da se služi mnogim pomoćnim postupcima, kao što su analiza problema,
planiranje načina rješavanja problema, detaljnim opisom problema. Onaj koji uočava i delegira
problem programeru, mora znati razlikovati probleme, koji se mogu rješavati klasičnim
programiranjem, od onih koji zahtijevaju korišćenje nekih drugih metoda. Samo problemi, koji se
mogu rješavati uz pomoć algoritma, odnosno poznavanja načina rješavanja nekog zadatka ili
obavljanja nekog posla, mogu se delegirati programeru. Analizu i definisanje problema može da
obavlja naručilac programa, naručilac i programer ili sam programer. Zbog činjenice da
eventualne greške i propusti u ovoj fazi programiranja mogu obezvrijediti sve ostale faze
programiranja, ova faza predstavlja jednu od najvažnijih faza programiranja, kojoj se nažalost u
praksi veoma često ne posvećuje dovoljno pažnje. Osnovne aktivnosti u ovoj fazi su:

1. Jasna identifikacija problema na bazi analize postojećeg stanja iz domena problema

2. Izvođenje svih aktivnosti i pribavljanje potrebnih podataka kao podloge za izradu
algoritma
3. Optimizacija procedure rješenja problema

3.2. Izrada algoritma

Izrada algoritma je sljedeća faza u razvoju programa. Nakon definisanja problema, treba
pristupiti izboru jedne ili više metoda njegovog rješavanja. Najznačajnije metode, koje se tu
koriste su logičke i/ili aritmetičke metode. Njihovom primjenom, koja zahtijeva posjedovanje
odgovarajućeg metodološkog znanja, stvara se algoritam. (Panian, 1999)
Riječ „algoritam“ dolazi od riječi Alchwarizmi (što je bio nadimak perzijskog pisca, koji se
zvao Abu Ja’far Mohammed Ibn Musa al Khowarizmi iz 825. prije n.e.) i njome se označava skup
pravila, koji vode rješenju nekog matematičkog problema. Ovim pravilima se u procesu
programiranja definiše proces transformacije ulaznih podataka u izlazne podatke (rezultate). Uz
pomoć algoritma se ustvari definiše procedura i redoslijed izvršavanja određenih operacija. U
ručnoj (manualnoj) obradi podataka, algoritam je uputstvo (skup postupaka) kako riješiti neki
zadatak ili obaviti neki posao.

21
 3.3. Izrada dijagrama toka

Izrada dijagrama toka (flow chart) predstavlja narednu fazu procesa programiranja, čiji
se značaj može objasniti jednom rečenicom: „Slika govori više od hiljadu riječi“. Dijagram toka se
može definisati kao grafički prikaz toka programa, odnosno algoritma. Osnovni elementi
dijagrama toka su standardizirani grafićki simboli funkcija, operacija, nosilaca podataka i
informacija, prikazani na slici. (Slika 2.)

Slika 2. Varijanta jednog dijagrama toka: Odlučivanje korištenjem informacija

Izvor: adaptirano prema (Srića, 1988)

22
 3.4. Pisanje pseudokoda

Pisanje pseudokoda je faza programiranja koja nije neophodna, ali predstavlja specifičan
alat koji pomaže u boljem razumijevanju algoritma i povećanju produktivnosti programiranja. To
je vještački i neformalni jezik koji pomaže programerima prilikom razvoja algoritama, jer ne
moraju da brinu o detaljnim i strogo propisanim pravilima nekog programskog jezika. Pseudokod
je sličan svakodnevnom prirodnom jeziku, konvencionalan je i veoma koristan kao podloga
razvoju programa u svim fazama, jer pomaže programerima da više vremena troše na
razmišljanje o algoritmu i rješenju problema a manje o programskom jeziku. Pseudokod je
tobožnji program (grč. pseudos znači laž) jer iako je sličan (opisno) računarskom programu,
ustvari nije napisan ni u kojem programskom jeziku koji bi se mogao direktno ili indirektno (nakon
prevođenja) primijeniti (izvoditi) na bilo kojemu računaru. Pseudokod se sastoji od riječi i
rečenica na govornom jeziku koji opisuju i ukratko objašnjavaju pojedine zadatke algoritma.

3.5. Pisanje izvornog programa (kodiranje)

Prije početka pisanja izvornog koda, neophodno je odabrati jedan od programskih jezik u
kojem će program biti pisan. Pošto programerima na raspolaganju danas stoji veoma veliki broj
programskih jezika, izbor jezika će prvenstveno zavisiti od karakteristika samog problema kojeg
je potrebno riješiti, ali i od znanja, vještina i pregferencija programera. Najveći broj problema,
ako ne i svi, najvjerovatnije se može riješiti primjenom praktično bilo kojeg jezika, samo je pitanje
koliko bi to bilo brzo i elegantno. Pisanje izvornog programa predstavlja pisanje (unos putem
editora) svih potrebnih elemenata nekog od viših programskih jezika u skladu sa razvijenim
algoritmom, odnosno dijagramom toka, poštujući određena formalna pravila (sintaksu), koja su
različita za svaki od njih. Izvorni kod se može upisivati u bilo kojem programu za obradu teksta
(engl. text editor), ali najveći broj današnjih vendora sistemskog softvera, kompajlere i linkera
(povezivače) isporučuje u paketu, zajedno sa ugrađenim editorom, kao sastavnim dijelom tog
paketa, koji omogućava upis i ispravljanje izvornog koda programa. Ti su programski paketi
poznatiji pod nazivom integrisano razvojno okruženje (engl. integrated development
environment, ili skr. IDE).
Kada se završi pisanje i eventualno ispravljanje izvornog koda, on se pohranjuje u
datoteku izvornog koda na disku (sa ekstenzijom koja označava jezik naprimjer .bas za BASIC,
.pas za PASCAL, .for za FORTRAN, .cbl za COBOL, .c za C jezik, cpp za jezik C++ itd. ).

23
 3.6. Prevođenje izvornog koda (kompajliranje)

Prevođenje izvornog koda (kompajliranje) je sljedeća faza u razvoju programa. Ova faza
se obavlja uz pomoć specijalnih sistemskih programa, koji se zovu kompajleri ili prevodici (engl.
Compiler) ili interpreteri (engl. Interpreters). Osnovna funkcija kompajlera i interpretera je
prevođenje programa napisanog u nekom višem programskom jeziku (izvornog programa) u
mašinski jezik (objektni jezik). Osnovna razlika između kompajlera i interpretera je ta što
kompajler prevodi cijeli izvorni program na mašinski jezik odjednom, dok interpreter prevodi
naredbu po naredbu, ili preciznije “čita” naredbu izvornog programa, “prevodi je”, odnosno
“interpretira” na mašinski jezik i “izvodi”, zatim sve te 3 operacije radi sa drugom naredbom
izvornog koda, pa sa trećom itd. Dakle, interpreter ne kreira mašinski program kao rezultat
prevođenja, nego svaki put kada ga pustimo u rad on se obraća izvornom programu, pa čita,
prevodi i izvršava naredbu po naredbu izvornog programa dok ne dođe do kraja. Zbog toga on
radi mnogo sporije od kompajlera. Kada je riječ o C++ jeziku, ulaz u postupak kompajliranja,
predstavlja izvorni program u C++ jeziku, smješten u datoteku na disku, koja ima neko ime i
ekstenziju .cpp, a kao izlaz, odnosno rezultat kompajliranja, ukoliko nema formalnih grešaka,
nastaje datoteka sa istim imenom kao .cpp, ali sa ekstenzijom .o, što znači da se u njoj nalazi
objektni kod. Pored te funkcije, kompajler ima zadatak da provjerava i formalnu ispravnost
napisanog programa, odnosno da otkriva greške, koje nisu u skladu sa sintaksom (formalnim
pravilima) svakog konkretnog programskog jezika. Npr. u C++ jeziku definisano je pravilo da se
svaka naredba treba da se završi sa znakom ”;”. Ukoliko to nije tako, kompajler će prijaviti
formalnu grešku i “tražiti” da se ona ispravi.
U integrisanim razvojnim okruženjima (IDE), kompajler se pokreće se pokreće pritiskom
na neki taster na tastaturi ili odgovarajućom komandom iz nekog menija. Ukoliko kompajler nije
integrisan, poziv se obavlja sa komandne linije operativnog sistema u kojoj se propisanom
procedurom navodi naziv kompajlera, naziv datoteke izvornog programa, naziv datoteke
objektnog programa i eventualno još neke opcije vezane za način kompajliranja.
Kompajler tokom prevođenja izvornog programa, provjerava ispravnost sintakse
napisanog izvornog koda i u slučaju pronađenih ili naslućenih sintaksnih grešaka prikazuje na
ekranu ili štampa na štampaču odgovarajuće poruke o greškama, odnosno poruke o mogućim
greškama (upozorenjima). Greške koje prijavi kompajler nazivaju se formalnim greškama ili
greškama u sintaksi napisanog programa ili greške pri kompajliranju (engl. compile-time errors).
Nakon toga programer putem editora teksta, treba da ispravi sve prijavljene greške i ponovo
poziva u rad kompajliranje ispravljenog izvornog programa. Ovaj se postupak ponavlja sve dok
prevođenje koda ne bude uspješno završeno, odnosno sve dok kompajler ne prijavi poruku da
nema formalnih grešaka. Rezultat prevođenja izvornog koda programa je datoteka objektnog

24
koda (engl. object code), koja se lako prepoznaje po tome što obično ima ekstenziju .o ili .obj.
Nakon što su ispravljene sve prijavljene greške i naslućena upozorenja kompajlera i nakon što je
je kod preveden bez grešaka i upozorenja, prelazi se u sljedeću fazu procesa programiranja, a to
je faza linkovanja.

3.7. Linkovanje (povezivanje)

Linkovanje je faza procesa programiranja u kojoj se povezuju objektni moduli (ekstenzija

.o) u izvršni (mašinski) kod. U većini slučajeva objektni kod, dobiven prevođenjem izvornog koda
programa, koji nije imao grešaka prilikom prevođenja, treba povezati sa postojećim bibliotekama
(engl. libraries) ukoliko se koriste. One se najčešće isporučuju zajedno sa kompajlerom, a mogu
se i posebno kupiti ili ih programeri mogu tokom rada sami kreirati i razvijati. Biblioteke programa
i procedura služe da se u njih pohranjuju (katalogiziraju) dijelovi izvornog koda procedura, koje
programer ili grupa programera često koristi, a cilj je da se izbjegne ponavljanje pisanja i
testiranja tih procedura.
Tipičan primjer, koji opravdava postojanje i razvijanje biblioteka je biblioteka
matematičkih funkcija koja se redovno isporučuje uz kompajlere, a u kojoj su katalogizirane
(pohranjene) sve funkcije poput trigonometrijskih, hiperboličnih, eksponencijalnih i sl. (Motik i
Šribar, 1997). Ukoliko program ne poziva nijednu funkciju niti proceduru iz biblioteke, logično je
zaključiti da je faza linkovanja suvišna. Međutim, to nije tako. Faza linkovanja je obavezna čak
iako nema šta povezivati (kad ima samo jedan objektni modul), zato što kao rezultat mora kreirati
datoteku sa mašinskim programom i ekstenzijom .exe, koja jedina može da izvršava ono zbog
čega je program napravljen, jer jedino nju procesor razumije.
Pored biblioteka sistemskih programa, postoje i biblioteke aplikativnih programa, koje
mogu biti u obliku:
a) Biblioteka izvornih programa
b) Biblioteka procedura
c) Biblioteka prevedenih (kompajliranih) programa (sadrži “object” module)
d) Biblioteka izvršnih programa
Uoči li linker (program za povezivanje) neku nepravilnost tokom procesa povezivanja,
prikazat će poruku o grešci i onemogućiti generisanje izvornog koda. Ove greške nazivaju se
greškama pri povezivanju (engl. link-time errors). Nakon što se isprave i ove greške, kod treba
ponovno prevesti i povezati i kada se nakon tih postupaka ne pojavi nijedna greška, formira se
datoteka sa izvršnim kodom.
Čak ni takav izvršni kod još uvijek nije garancija da će program raditi ono što je autor
predvidio da će taj program raditi. Na primjer, može se dogoditi da program radi ispravno samo
za neke podatke, ali da se u slučaju drugačijih podataka ponaša nepredvidivo. Tada se radi o
logičkim greškama programa, odnosno greškama pri izvođenju (engl. run-time errors). Niko, pa

25
ni oni najiskusniji i najvještiji programeri ne mogu i ne smiju nikada biti sigurni da će program koji
su napisali ispravno proraditi iz prvog pokušaja. Naime, logično je očekivati da će u prvoj, a često
i u naknadnim verzijama programa postojati određene formalne i/ili logičke greške. Formalne
greške (compile-time-errors and/or link-time-errors) proizilaze iz nepridržavanja pravila sintakse
nekog programskog jezika, a logičke (run-time-errors) iz nedosljedne primjene metoda rješavanja
problema (Panian, 1999).

3.8. Testiranje programa

Testiranje programa je jedna od završnih faza programiranja, čiji je osnovni zadatak

provjera njegove tačnosti, odnosno ispravnosti funkcionisanja. Ovo je jedna od najznačajnijih
faza programiranja. Svaki program se pravi da bi duže vremena služio svojoj svrsi, tako da bi svaka
prikrivena greška, koja se ne uoči za vrijeme testiranja, mogla kasnije imati dalekosežne
negativne posljedice za korisnika. Već smo ranije spominjali dvije vrste grešaka, koje je
testiranjem programa neophodno otkloniti: formalne, koje se odnose na greške u sintaksi
programskog jezika, koje otkriva kompajler ili linker i logičke, kojim se otkrivaju funkcionalne ili
proceduralne greške u programu. Pošto je logičku vrstu grešaka znatno teže otkriti, ovom poslu
je potrebno pristupiti na najozbiljniji mogući način. Neophodno je test provesti na tri nivoa:
a) Testiranje pojedinačnih modula sa testnim podacima
b) Testiranje logične ispravnosti glavnog modula na testnim podacima
c) Testiranje cijelog programa sa stvarnim podacima
Tek ovaj posljednji nivo testiranja (sa što većim brojem različitih podataka, koji bi trebali
da omoguće testiranje svih grana programa) daje određenu garanciju ispravnog funkcionisanja
programa. Kada se radi o generisanju testnih podataka, taj posao treba da rade posebni
stručnjaci osposobljeni za to, a nikako ne programeri koji su razvijali program. Za lakše otkrivanje,
ispravljanje i lociranje logičkih grešaka u programu, danas programerima pomažu programi, čija
je to osnovna funkcija, a zovu se debageri (engl. debuggers).
Radi se o programima koji omogućavaju prekid izvođenja izvršnog koda programa koji
testiramo na unaprijed zadanim naredbama, izvođenje programa naredbu po naredbu, ispis i
promjene trenutnih vrijednosti varijabli u programu. Većina današnjih naprednih programa za
otkrivanje grešaka su simbolički (engl. symbolic debugger) - iako se izvodi prevedeni, mašinski
kod, izvođenje programa se prati putem izvornog koda pisanog u višem programskom jeziku. To
omogućava veoma lagano lociranje i ispravljanje grešaka u programu. (Motik i Šribar, 1997)
Najčešće se isporučuju kao sastavni dio integrisanog razvojnog okruženja (IDE) za
konkretan programski jezik.
Testiranje programa može biti vrlo složen i mukotrpan posao, ponekad čak i složeniji nego
sve ostale faze programiranja, ali to je jedini način da se greške otkriju i otklone, a rezultati

26
predviđeni funkcionisanjem programa budu pouzdani i tačni. Sve dok se ne postigne taj cilj,
postupak testiranja će se ponavljati.

3.9. Implementacija programa

Implementacija programa je jedna od posljednjih faza u procesu programiranja, koja

dolazi na red kada je program konačno završen. Zadatak ove faze programiranja je
obezbjeđivanje uslova da se program pusti u eksploataciju. U ovoj fazi se definišu minimalno
potrebni hardverski i softverski resursi za uspješno funkcionisanje programa, piše se
eksploataciono uputstvo (vodič) u kojem se navode postupci i pravila za puštanje programa u
eksploataciju, kao i svi ostali neophodni uslovi za uspješno funkcionisanje programa, te
procedure, kojima se definišu aktivnosti, koje je potrebno preduzeti u slučaju nastanka nekih
kritičnih događaja, da bi se sačuvali podaci, program i rezultati obrade.

3.10. Dokumentovanje programa

Dokumentovanje programa je faza programiranja, koja se u praksi najčešće preskače ili

se svodi na minimalan broj dokumenata. Sa trendom povećanja fluktuacije programera, raste
važnost ove faze programiranja. Situacija u kojoj je potrebna intervencija na programu, a
programer koji je pisao program i bio dužan, a propustio napraviti obimnu dokumentaciju (od
ideje do realizacije), napusti kompaniju ili iz bilo kojeg drugog razloga nije dostupan, može
kompaniji nanijeti neprocjenjivu štetu. Veoma često se dešava da ukoliko je programer i
dostupan, a nije napravio dokumentaciju za program koji je napravljen prije desetak ili više
godina i on sam će se teško snaći u svom programu, jer zaborav čini svoje. Istina je da jedan od
principa agilnog razvoja softvera glasi “Bolje softver koji radi, nego sveobuhvatna
dokumentacija” (Cockburn et al., 2011), ali to još uvijek ne znači da treba potpuno zanemariti
ovu fazu programiranja, nego svesti broj dokumenata o razvoju programa na razumnu mjeru. U
idealnom slučaju, svaku od prethodnih faza programiranja bi trebalo dokumentovati, a u
reduciranoj formi bi trebalo dokumentovati analizu i definisanje problema, izradu algoritma i
listu izvornog koda programa.

3.11. Eksploatacija programa

Eksploatacija programa je pretposljednja faza procesa programiranja i faza u kojoj se

realizuje cilj cijelog procesa programiranja. Nakon izrade eksploatacionog uputstva, odnosno
vodiča za upotrebu (engl. User's Guide) program se pušta u eksploataciju. Pozivanje programa u
rad, najčešće se vrši duplim klikom miša na ikonicu, kojom je simbolički predstavljen program ili
duplim klikom miša na datoteku sa izvršnim kodom ili run naredbom itd. Nakon puštanja

27
programa u rad (izvođenje), izvršni program se prenosi sa eksterne memorije, gdje je stalno
pohranjen u radnu memoriju računara i tada počinje obavljanje funkcije zbog koje je napravljen.
Tokom eksploatacije programa, oni koji ga koriste dužni su bilježiti eventualne neregularnosti u
radu programa, obavještavati programera o tome i tražiti od njega da se one poprave. Dobivanje
povratnih informacija o radu programa u eksploatacionim uslovima ima za programera
neprocjenjivu vrijednost, zbog toga što mu omogućava da “iz prve ruke” sazna o eventualnim
greškama u radu programa.
Eksploatacija programa pretpostavlja rješavanje problema sa kojima su se korisnici
susretali prije nego što su naručili pomenuti program. Jednom razvijeni program davaće jednako
dobre rezultate sve dok se situacija vezana za njegovo korišćenje ne promijeni. Ukoliko se radi o
manjim promjenama, one se mogu ugraditi u programe manjim intervencijama (korekcijama,
prilagodbama ili jednom riječi softverskim “zakrpama”). U tom slučaju se govori o održavanju
programa. Međutim, ako se radi o radikalnim promjenama, onda je neophodno pristupiti
razvijanju potpuno novog programa.

3.12. Održavanje programa

Održavanje programa je u najužoj vezi sa dokumentovanjem programa i eksploatacijom

programa. Ukoliko se javi bilo kakva potreba za izmjenom programa, kako zbog primjećene
logičke greške prikikom eksploatacije programa ili promjene uslova iz domena koji se odnosi na
problem (promjena kamatne ili porezne stope, promjena načina obračuna itd.), potrebno je
ispravljati uočene greške ili ugrađivati nove promjene da bi ga prilagodili promjenama u
okruženju. Sve eventualne ispravke uočenih grešaka ili poboljšanje brzine funkcionisanja, kao i
ugrađivanje novih promjena u program radi prilagođavanja promjenama u okruženju,
predstavljaju održavanje programa. Možemo ga definisati kao postupak mijenjanja programa
tokom životnog vijeka programa bez obzira na razlog njegove promjene.
Informacioni sistemi, posmatrani kao skup aplikativnih programa su promjenljivi sistemi,
koji se prilagođavaju promjenama u kompaniji da bi služili svojoj namjeni. U posljednje vrijeme,
ove promjene su česte i obimne, tako da se programeri za vrijeme razvoja novih aplikativnih
programa, često vraćaju na promjene već završenih programa, što često dovodi do kašnjenja
novih projekata, ali u isto vrijeme govori o izuzetnom značaju faze održavanja softvera.
Svih ovih dvanaest faza može se svesti na manji broj faza ukoliko se integrišu neke faze,
koje zajedno posmatrano, mogu predstavljati jednu cjelinu. Ako pišemo i razmišljamo o
programiranju kao o profesionalnom poslu, onda svaka od opisanih faza ima svoje mjesto.
Međutim, ukoliko programiranje posmatramo kao proces učenja programskog jezika i
programiranja, onda za potrebe početnika i studenata, možemo uvesti pojam “programiranje u
užem smislu”.

28
 Programiranje u užem smislu se sastoji iz 4 faze (slika 3):

1. Pisanje izvornog koda (kodiranje),

2. Prevođenje izvornog koda (kompajliranje),
3. Povezivanje objektnih modula u izvršni kod (linkovanje) i
4. Testiranje programa

Slika 3. Blok dijagram aktivnosti prilikom pravljenja programa

29
4. PROGRAMIRANJE U PRAKSI

4.1. Pisanje prvog programa u C++ jeziku: Prikaz na ekranu jedne linije teksta

Većina knjiga o osnovama programiranja, počinje primjerom (prvim programom) u kojem je

potrebno prikazati jednu liniju teksta na ekranu, najčešće “Hello World! ”. U našem primjeru ta
će rečenica biti malo duža, zbog potrebe dodatnog objašnjenja u narednom primjeru. Iako je ovo
toliko jednostavan program da jednostavniji ne može biti, on će nam pomoći će da ilustrujemo
više važnih karakteristika C++ jezika.

Primjer prvog programa

Slika 3a. Kod programa prvog primjera

Poruka nakon kompajliranja

Rezultat, nakon izvršenja programa:

30
 Slika 3b. Poruka nakon kompajliranja i rezultat izvršenja programa.

Da bi smo shvatili šta to ovaj jednostavni program radi, detaljno ćemo objasniti liniju po
liniju izvornog koda programa. Linije sa rednim brojem 1 i 2, počinju sa znakovima // ili slash
slash. Kada linija u izvornom kodu programa, počinje sa ova dva znaka, to znači da se ona neće
kompajlirati (prevoditi) kada se pozove kompajliranje programa, niti izvršavati kada se pozove
izvođenje programa, nego predstavlja komentar u programu (što bi trebalo koristiti u smislu
dobre prakse), koji objašnjava kod programa ili pruža neke druge veoma važne informacije o
programu, kao što su npr. informacije o tome koje autor programa, kada je kreiran taj program,
koja je verzija programa, šta je njegova namjena, šta je funkcija pojedinih dijelova programa,
objašnjenje koda neke linije, funkcije itd. Drugim riječima, komentar sa svim ovim podacima o
programu, predstavlja minimalnu dokumentaciju programa. Komentar koji počinje sa //, naziva
se još i linijski komentar i završava sa završetkom tekuće linije, što znači da mu je dužina
ograničena dužinom linije (reda). Ukoliko želimo napisati komentar sa više linija, imamo dvije
opcije na raspolaganju: 1. opcija je da svaki red komentara počinje sa // i 2. opcija – korišćenjem
notacije /* na početku komentara */ na kraju komenatara.
Treća linija koda:
#include <iostream> // Bez ove linije ne bi bio moguć prikaz na ekranu niti unos sa tastature
je pretprocesorska naredba, koja predstavlja poruku za C++ pretprocesor. Sve linije koje počinju
sa # (hash) procesiraju se prije nego što se program kompajlira. Ova linija ima funciju da prenosi
pretprocesoru poruku da uključi u program sistemsku biblioteku (library): <iostream>
(input/output stream header file), koji mora biti dio koda za svaki program koji koristi prikaz
podataka na ekran ili ima potrebu za ulaznim podacima (unos podataka) preko standardnog ulaza
(tastature). Ili ukratko rečeno, ova naredba ima zadatak da obezbijedi ulazno-izlazni tok
podataka. Veoma često, početnici u programiranju zaborave da uključe u program ovu naredbu,
pa im tada program neće korektno raditi prilikom pozivanja naredbi koje zahtijevaju ulaz ili izlaz
podataka.
Linija // Funkcija main – početak izvršenja svakog C++ programa, predstavlja još jednu liniju
komentara, koji se odnosi na sljedeću (ne praznu) liniju koda, a pokazuje liniju od koje počinje
izvršavanje programa.
Linije 5. I 10. Su prazne linije, koje imaju samo “estetsku” funkciju i predstavljaju primjer dobre
prakse programiranja, koji obezbjeđuje bolju preglednost i čitljivost koda programa. Šesta linija

31
koda: int main(), predstavlja glavni dio svakog C++ programa. Ovom linijom počinje stvarni
program sa funkcijom koja se naziva main(). Generalno rečeno, funkcija predstavlja dio koda koji
je zadužen obavlja određeni zadatak (radnju). Kada smo kod funkcija, o kojima će detaljnije
kasnije biti riječi, na ovom mjestu treba reći da program u C++ jeziku, može da ima proizvoljan
broj različitih vrsta funkcija, pri čemu je funkcija main() ima specifičan zadatak. To je funkcija koja
se samostalno izvršava. Ostale funkcije se pozivaju iz glavnog programa. Kada god se program
starta, ona se automatski poziva, pa zato možemo reći da je main funkcija u stvari gradivni blok
svakog programa. Lijevo od riječi main (glavna funkcija), u svakom C++ programu, piše se
rezervisana riječ int, (nastala kao skraćenica od engleske riječi integer, što znači cijeli broj) koja
se može koristiti u dva značenja: a) da deklariše (označi) neku varijablu (promjenljivu) kao
cjelobrojnu varijablu, odnosno varijablu u koju je moguće pohranjivati samo cijele brojeve i b) da
označi da će main funkcija, kao rezultat rada, "vratiti" cjelobrojnu vrijednost (int) i pohraniti je u
neimenovani dio memorije, kojem može pristupiti main funkcija. Trenutno govorimo o ovom
drugom značenju.
U svakom programskom jeziku, pa tako i u C++ jeziku, postoji spisak ključnih ili
rezervisanih riječi, (jedna od njih je int), kojima samo ime govori da se te riječi ne mogu koristiti
(jer su rezervisane za specijalne namjene) kao imena koja definiše korisnik, kao što su imena
varijabli, funkcija, labela itd. Ključna riječ je riječ u kodu koja je rezervisana sa C++-om za
specifične namjene.
Kao i sve druge funkcije, tako i main funkcija počinje sa otvorenom vitičastom zagradom
{, i završava zatvorenom vitičastom zagradom }, a sve što se nalazi između ovih zagrada
predstavlja tijelo funkcije ili blok funkcije. U našem primjeru to su 7. i 11. linija koda.
Linija 8: std::cout << "\n\nDobro došli u C++ programiranje!\n"; //Prikazuje poruku
“naređuje” kompjuteru da na standardnom (skraćenica std) izlazu (ekranu ili monitoru) prikaže
(cout izlaz iz C programa, koji se čita “Ce Out”) niz znakova (karaktera), koji se nalaze između
duplih navodnika i koji se često nazivaju string, literal ili poruka. Linija 8 uključuje std, dvije
dvotačke ::, cout, operator <<, string "\n\nDobro došli u C++ programiranje!\n" i tačku zarez ;, i
naziva se iskaz ili statement. Svaki C++ iskaz mora se završiti sa ;. Za pretprocesorske naredbe
(kao što je #include), bitno je da počinju znakom # i da se ne završavaju ukucavanjem bilo kojeg
znaka. Za prikaz stringa na ekranu, korišćena je komanda std::cout, a moguće je koristiti i
komandu cout (bez std:: ispred) u slučaju ako je prethodno navedena komanda: using
namespace std;. Pisanje komande za prikaz niza znakova u formi std::cout, označava da se koristi
funkcija cout, koja pripada imenovanom prostoru (namespace-u) std. Imena cin (standardni
ulazni tok, odnosno tastatura) i cerr (standardni tok za greške, odnosno ekran ) također pripadaju
imenovanom prostoru (namespace-u) std. O tome malo kasnije.
Dakle, ukoliko u kod programa ne uključimo using namespace std;, prije svake upotrebe cout,
cin i cerr u programu, moramo koristiti komandu std::. Ukoliko u kod programa uključimo using
namespace std;, to će omogućiti da izostavimo std:: pri korišćenju cin, cout ili cerr.

32
Operator << (čita se “manje, manje”) se naziva stream insertion operator i koristi se prikaz na
standardnom zlazu, odnosno u trenutku kada se program izvršava, vrijednost desno od operatora
(izlazni string) se insertuje (ubacuje) na izlazni stream (ekran) i to uzrokuje prikaz poruke odnosno
stringa niza znakova (karaktera), koji se nalaze između navodnika i to u redosljedu kako su
napisani u stringu. Ako analiziramo string iz programa: "\n\nDobro došli u C++ programiranje!\n"
i rezultate prikaza, vidjećemo da se znak \n ne prikazuje na ekranu. Karakter \ (backslash) se još
naziva i escape karakter ili esape znak i njegovo navođenje u stringu koji se prikazuje, označava
da iza njega u stringu, slijedi "specijalni" znak, koji treba prikazati na standardnom izlazu. \
(backslash) i taj sljedeći znak u stringu, zajedno predstavljaju escape sekvencu. Escape sekvenca
\n znači skok kursorana početak sljedeće linije. U našem primjeru, kada počne izvršavanje
programa, odnosno prikaz stringa na standardnom ekranu, prije poruke “Dobro došli u C++
programiranje!”, kursor će skočiti sa 1. Reda, gdje mu je inicijalna pozicija, na početak drugog
reda (\n), a onda na početak trećeg reda (drugi escape znak \n), gdje će se tek sada prikazati tekst
poruke. Neke od escape sekvenci su prikazane u tabeli 10.

Escape Značenje
sequence
\n Novi red. Pozicionira kursor na ekranu na početak sljedećeg reda
\t Novi horizontalni tabulator. Pomjera kursor na ekranu na sljedeću tab poziciju
\v Novi vertikalni tabulator. Pomjera kursor na ekranu na sljedeću vertikalnu poziciju
\b Backspace. Vraća kursor za jednupoziciju ulijevo
\’ Jednostruki navodnik (apostrof). Uzrokuje prikaz jednostrukog navodnika
\” Dvostruki navodnik. Uzrokuje prikaz dvostrukog navodnika
\\ Backslash. Uzrokuje prikaz znaka \ (odnosno, silazne kose linije)
\a Alert. Zvučni signal
\r Carriage return. Pozicionira kursor na početak tekućeg reda.

Tabela 10. Escape sekvence

Linija 9: return 0; // Pokazuje da je program izvršen uspješno, predstavlja jedan od više načina
koji se koriste da bi se završilo izvođenje funkcije. Kada se return iskaz koristi na kraju tijela main
funkcije, vrijednost 0, označava da je program uspješno završen. I na kraju: linija 11 se sastoji iz
jednog znaka: } (zatvorena vitičasta zgrada). Ona označava kraj main funkcije, odnosno kraj
programa.

4.2. Pisanje drugog program u C++ jeziku

33
 U ovom dijelu teksta, objašnjavamo na primjerima još dvije opcije prikaza teksta na
ekranu: a) prikaz teksta (stringa) u jednom redu ekrana uz pomoć dvije programske linije i b) i to
i prikaz striga znakova na više linija sa jednom programskom linijom, odnosno jednim iskazom.

Primjer drugog programa

Rezultat nakon izvršenja programa

Slika 4. Prikaz jedne linije teksta sa više iskaza [(slučaj pod a)]

Ovdje treba primjetiti da su u programu korišćena dva std::cout iskaza, a cijeli tekst je prikazan u
jednom redu prilikom izvršenja. Nakon prikaza stringa navedenog u prvom std::cout iskazu,
kursor je ostao na mjestu iza prikaza teksta “… kojim se”, pa se tu nastavlja prikaz stringa iz
drugog std::cout iskaza, koji počinje sa “ilustruju ….”. Vidljivo je da su na tom mjestu spojene
dvije riječi “se” i “ilustruju” i prikazane u poruci kao “…seilustruju…”, pa ih je potrebno razdvojiti
jednim space-om. Taj se space (prazan znak) može dodati na kraju stringa, koji se prikazuje prvim
std::cout iskazom “…kojim se “ ili na početku stringa, koji se prikazuje drugim std::cout iskazom
“ ilustruju…”, pa onda to nakon modifikacije programa, kompajliranja i izvršenja, izgleda ovako:

34
 4.3. Pisanje trećeg programa

Primjer trećeg programa (prikaz više linija teksta jednim cout iskazom)

Slika 5. Prikaz više linija teksta sa jednim cout iskazom [(slučaj pod b)]

Nakon kompajliranja i izvođenja, prikazuje se sljedeći rezultat (slika 5). Ovdje je ukratko potrebno
objasniti liniju 10. programskog koda:
10 std::cout << "\n Ovo je program \n kojim se\n ilustruju karakteristike cout iskaza\n";
U stringu (tekst između navodnika) nalaze se 4 escape sekvence \n, koje kada se pošalju na izlazni
tok (konzolu) uz pomoć std::cout iskaza, tekst koji slijedi iza njih prikazuju od prve kolone
sljedećeg reda. Prva escape sekvenca u stringu, pozicionira kursor na prvu kolonu drugog reda i
počevši od nje, prikazuje nastavak stringa sve do drugog pojavljivanja te iste sekvence, koja opet
pozicionira kursor na prvu kolonu trećeg reda, prikazuje nastavak stringa do trećeg pojavljivanja
oznake za novi red, nakon čega se u četvrtom redu prikazuje tekst “ilustruju karak ….”, a zatim
nakon četvrtog pojavljivanja u stringu, znak za novi red prebacuje kursor u 1. kolonu 5. reda i
program se završava.

35
Deseti red Treceg programa, možemo napisati i ovako:
10 std::cout << "Ovo je program\n” << “kojim se\n“<< “ilustruju karakteristike cout iskaza\n"; ili
ukoliko želimo prikaz stringa u jednom redu, možemo i ovako:
10 std::cout << "Ovo je program,” << “ kojim se“<< “ ilustruju karakteristike cout iskaza";, gdje
se stream insertation operator (<<), a čita se “manje - manje”, pojavljuje 3 puta. Prilikom
izvođenja biće prikazana cijela rečenica, koja je spojena iz 3 dijela teksta: “Ovo je program, kojim
se ilustruju karakteristike cout iskaza”.
Kao što je već ranije rečeno, umjesto std::cout iskaza, može stajati iskaz cout, ukoliko prije main
funkcije u program uvrstimo naredbu using namespace std;, pa ćemo u narednim primjerima
umjesto komandi std::cout, std::cin i std::cerr, koristiti komande cout, cin i cerr.
Umjesto escape sekvence za novi red, možemo koristiti iskaz endl. U tom slučaju bi 10. linija
posljednjeg primjera (gdje jedan tekst treba napisati u tri reda na ekranu), izgledala ovako:
cout<<"Ovo je program”<<endl<<“kojim se“<<endl<<“ilustruju karakteristike cout
iskaza"<<endl;

4.4. Pisanje četvrtog programa

Primjer sabiranja dva cijela broja, unesena sa tastature

Slika 6. Kod programa, koji sabira dva cijela broja, unesena sa tastature

36
5. VARIJABLE I DEKLARISANJE VARIJABLI

Prije nego što se u programu upotrijebi bilo koja varijabla, potrebno ju je prethodno deklarisati.
Varijabla je simboličko ime ili simbolički naziv (definiše ga programer) za memorijsku lokaciju
interne meorije u koju se mogu smjestiti podaci, kojima se može naknadno pristupiti i naknadno
ih mijenjati. Varijable se koriste za privremeno čuvanje (čuvanje za vrijeme izvođenja programa)
vrijednosti podataka. Sve varijable imaju dvije važne karakteristike:
a) Tip, koji se dodjeljuje varijabli kada se ona definiše (npr. cijeli broj, realni broj, karakter,
bool itd.). Kada se jednom definiše, tip varijable u C++ programu se ne može promijeniti.
b) Vrijednost, koja se može promijeniti dodjeljivanjem nove vrijednosti varijabli. Vrsta
vrijednosti koja se može pridružiti nekoj varijabli zavisi od prethodno definisanog tipa
varijable. Npr. varijabla tipa integer može da uzima samo vrijednosti cijelih brojeva (npr.
3, 6, 9, -13 itd.)
Prilikom definisanja varijable, najčešće joj se dodjeljuje samo ime i tip, a njena vrijednost ostaje
nedefinisana sve dok joj se nekom novom komandom ne pridruži neka vrijednost. Dodjeljivanje
vrijednosti nekoj varijabli prvi put naziva se inicijalizacija. Dozvoljena je i veoma praktična
mogućnost da se varijabla prilikom definisanja i inicijalizira. Pošto se dodjeljivanjem nove
vrijednosti varijabli, briše njen prethodni sadržaj (ukoliko nije inicijalizirana, taj sadržaj je preuzet
iz memorije), nije neophodno obezbijediti da se svaka varijabla inicijalizira prije nego se koristi,
osim u slučajevima kada je za prvo korišćenje te varijable u programu, bitan njen trenutni sadržaj.
Primjer različitih načina definisanja i inicijaliziranja varijabli, prikazan je na slici 7.

Slika 7. Primjer različitih načina definisanja i inicijaliziranja varijabli

37
Kada se radi o primjeru sa slike 6, objasnićemo detaljnije svaku od linija programa u kojima se
uvode novi pojmovi. Poći ćemo od linija 9 do 11.

Slika 8. Objašnjenje deklarisanja varijabli

Ove linije predstavljaju način deklarisanja varijabli. Identifikatori broj1, broj2 i zbir su imena
varijabli, a int je tip varijable, što znači da sadržaj tih varijabli može biti samo neki (bilo koji) cijeli
broj. Pošto se više varijabli istog tipa mogu deklarisati sa jednom ili više deklaracija, ova 3 reda u
programu, mogao je zamijeniti jedan red:
9 int broj1, broj2, zbir;
U ovom slučaju, kao što se i vidi, imena varijabli se odvajaju zarezom, a preporučuje se (kao u MS
Word-u) da se poslije zareza ukuca znak ”space” (prazno). Preporučuje se takođe da Ime varijable
bude u skladu sa značenjem u programu, što čini program čitljivijim i razumljivijim, pa se na taj
način mogu izbjeći dodatni komentari. Bez obzira na to što se deklaracije varijabli mogu pisati
bilo gdje u programu pod usovom da se moraju pojaviti prije odgovarajućeg korištenja tih
varijabli u programu, preporučuje se da se deklaracije odvoje od proceduralnih (izvršivih) iskaza.
Objašnjavamo dalje liniju po liniju programa sabiranja dvaju cijelih brojeva.
Linija 12: cout<<endl; pozicionira kursor na 1. kolonu sljedećeg reda, odnosno preskače jedan
red.
Linija 13: cout << " Unesi prvi broj: ";, prikazuje string “ Unesi prvi broj: ” na ekranu. Ova poruka
se naziva još i prompt, jer obavještava korisnika da uradi određenu akciju, da unese broj putem
tastature (standardnog ulaza) i da pritisne taster <ENTER>.
Linija 14: cin >> broj1;, koristi input stream cin i stream operator >> (čita se” veće – veće) da bi
prihvatila vrijednost sa tastature. Čita prvi cijeli broj, koji se unosi sa tastature i smješta ga u
varijablu broj1.
Linija 15: cout << " Unesi drugi broj: ";, prikazuje string “ Unesi drugi broj: ” na ekranu i
obavještava korisnika da unese broj sa tastature.
Linija 14: cin >> broj2;, čita drugi cijeli broj, koji se unosi sa tastature i nakon pritiska na taster
<ENTER>, smješta ga u varijablu broj2.
Linija 17: zbir = broj1 + broj2; sabira brojeve broj1 i broj2, a rezultat se smješta u varijablu zbir,
korištenjem operatora dodjeljivanja =.
Linija 18: cout << " Zbir unesenih brojeva " << zbir << endl; prikazuje poruku " Zbir unesenih
brojeva ", a zatim sadržaj (vrijednost) varijable zbir, iza čega slijedi endl, odnosno tzv. stream
manipulator za novu liniju, koji prebacuje kursor u 1. kolonu sljedećeg reda. Treba obratiti pažnju

38
da se u ovom slučaju jednim cout iskazom prikazuje i string i vrijednost varijabli. Korištenjem
više operatora (<<) u jednom iskazu dobijamo tzv. kaskadni stream operator.
Računanje zbira dvaju cijelih brojeva možemo postići i spajanjem linija 17 i 18 u jedan iskaz. A to
bi izgledalo ovako: cout << " Zbir unesenih brojeva " << broj1 + broj2 << endl;. Na taj način
eliminšemo potrebu za varijablom zbir.

6. KONSTANTE

Konstante imaju gotovo sve iste karakteristike kao varijable (tip podataka, naziv, adresa
memorijske lokacije, veličina u bajtima) osim jedne, a ona se odnosi na fiksni sadržaj, odnosno
nepromjenljivost sadržaja. Dakle, konstante predstavljaju veličine koje ne mijenjaju inicijalnu
vrijednost tokom izvršavanja programa, pa se zbog ovih osobina često nazivaju varijablama
posebnog tipa. Koriste se kada je potrebno zaštititi vrijednost neke varijable od mijenjanja
(pridruživanja nove vrijednosti), odnosno kada je potrebno u cijelom programu zadržati njenu
inicijalnu vrijednost. Konstante mogu biti: a) cjelobrojne ili konstante tipa int, zatim b) konstante
tipa float sa sadržajem iz domena realnih brojeva c) konstante tipa char i d) znakovne konstante
sa sadržajem u formi literala ili poruka. Konstante se mogu deklarisati kao varijable, a mogu se
posebnom komandom i definisati. (slika 7).
Opšti format deklarisanja konstanti je jednostavan i svodi se na dodavanje ključne riječi „const“
ispred tipa podatka te kojem pripada ta konstanta. Npr. deklarisanje konstante tipa int sa
fiksnom vrijednošću 5, vrši se ovako: const int x = 5; ili deklarisanje konstante tipa char sa fiksnom
vrijednošću ‘\t’: const char tabulator = ‘\t’;.
Definisanjem konstanti preprocesorskom komadom #define mogu se definisati vlastita imena
za konstante, koje se vrlo često koriste bez nepotrebnog trošenja memorije. Opšti format
definisanja konstanti je:
#define identifier value, ili
#define identifikator vrijednost
Na primjer:

#define PI 3.14159
#define NEWLINE '\ n'

Ovo definiše dvije nove konstante: PI i NEWLINE. Nakon što su definisane, mogu se koristiti u
ostatku koda kao da su bilo koja druga normalna (deklarisana) konstanta.

39
 Slika 9. Primjer za ilustraciju deklarisanja i definisanja konstanti

Kratko objašnjenje primjera: kada se definisana konstanta tabulator prikaže cout

iskazom na ekranu, ona pomjera kursor za 8 pozicija udesno i na 9. poziciji prikazuje vrijednost
deklarisane konstante x, a to je 5 (u 5. redu programa). Nakon toga se druga definisana
konstanta NEWLINE čiji je sadržaj escape sekvenca za novi red (ima isto značenje kao endl)
prikazuje na ekranu cout iskazom i uzrokuje skok kursora u prvu kolonu novog reda. Nakon toga
ponavlja se komanda iz programa na rednom broju 10. Tabulator uzrokuje skok kursora za 8
pozicija i na 9. poziciji se prikazuje sadržaj prve definisane konstante PI (3.14159). I na kraju
primjer greške:

const float pi=3.14159; // deklarisanje float konstante

pi = 2*pi; // greška, koju će prijaviti kompajler, jer se konstanta ne može mijenjati

40
7. OSNOVNI TIPOVI PODATAKA

Pošto priča o tipovima podataka, podrazumijeva postojanje (definisanje) različitih tipova

podataka, a jasno je da se svi podaci (numerički, slova i specijalni znaci) zapisuju (predstavljaju)
u računaru kao niz 0 i 1, dakle binarno, postavlja se logično pitanje zašto se u programskim
jezicima uvode različite vrste tipova podataka?
Pod tipom podataka podrazumijeva se određena grupa podataka, koja ima zajedničke
karakteristike. Kada ovdje govorimo o podacima, onda mislimo na podatke koji se pohranjuju u
memorijskim lokacijama interne memorije računara u kojima mogu biti pohranjeni podaci koji će
se mijenati (varijable ili promjenljive) tokom izvršavanja programa i podaci u kojima će sve
vrijeme tokom izvođenja programa, ostati ista - inicijalna vrijednost (konstante). Prilikom
programiranja, pohranjujemo varijable (dodjelujemo im neke vrijednosti) u memoriji računara,
ali računaru moramo „saopštiti“ koju vrstu podataka želimo pohraniti, jer ne zauzimaju sve vrste
podataka (tipovi) istu količinu memorije. Drugim riječima, neophodno je „saopštiti“ računaru šta
pohranjujemo u konkretne varijable (ili konstante): da li su to numerički znakovi (brojevi),
alfabetski znakovi (slova), specijalni znakovi itd. Pored zauzimanja različitog kapaciteta memorije,
različite vrste podataka imaju i različit, ali precizno definisan skup vrijednosti (domen), na koje se
odnose, kao i skup operacija, koje se mogu obavljati na toj vrsti podataka. Sve su to razlozi za
uvođenje različitih tipova podataka u programske jezike.
Matematički posmatrano, tip podatka je linearno uređeni (skalarni) skup sa grupom
funkcija, koje se mogu izvršavati na tom skupu. Te funkcije često se nazivaju i standardne funkcije
tog tipa podatka.

Neka je skup T skup kojeg čini n objekata: T := {v1, v2, .....vn}, n > 1.
Ako su svi objekti istih karakteristika, tako da se na njih, u okviru pravila programskog
jezika, može primjeniti određeni skup operacija, onda je skup T, predstavlja tip podatka. U smislu
kompjuterskog programiranja može se reći da tip podatka određuju:

 Skup vrijednosti (domen) koje podatak može da ima,

 Memorijski prostor potreban za pohranjivanje podatka i
 Skup operacija koje mogu da se vrše nad tim podatkom.
Osnovni tipovi podataka, definisani uz pomoć skupa vrijednosti i funkcija, koje se mogu
obavljati na tom skupu su:
1. Int - skup Z (skup cijelih brojeva, skraćeno od integer) zajedno sa standardnim funkcijama
(cjelobrojni tip): + Z, * Z, - Z, / Z, = Z, ≥ Z, > Z, ≤ Z, <Z
2. Real - skup R (skup realnih brojeva ili decimalnih brojeva) zajedno sa standardnim
funkcijama (realni tip): + R, * R, - R, / R, = R, ≥ R, > R, ≤ R, <R

41
 3. Bool - skup B (true ili false) zajedno sa standardnim funkcijama (logički tip): NOT (!),
AND(∧) i OR(∨)
4. Char - skup C (skup ASCII znakova) zajedno sa standardnim funkcijama (karakter tip) sa
funkcijama: CHR, ASC, = C, ≥ C, > C, ≤ C, < C

Cjelobrojni tip podatka (Integer) prima vrijednosti iz određenog skupa, koji je podskup
skupa cijelih brojeva, pozitivnih i negativnih:

T := {minint, minint + 1, ... ,-1, 0, 1, ...maxint - 1, maxint} ili ....,-3, -2, -1, 0, 1, 2, 3,...

 Tip podatka unsigned integer ili cardinal ima vrijednosti iz podskupa skupa cijelih pozitivnih
brojeva. Veličina tog podskupa zavisi od konkretnog programskog jezika i kompjuterskog
sistema, odnosno od dužine kompjuterske riječi i iznosi 2m – 1, gdje je m broj bita u
kompjuterskoj riječi. Npr. za 16-bitni sistem T := {0, 1, ............, 65535}
 Short integer je u većini slučajeva isto što i integer, a long integer ima dvostruko veći prostor
za smještanje broja. Uz integer tip podataka vezuje se i neoznačeni (unsigned) tip podataka.
Ovaj tip podataka sadrži samo pozitivne brojeve. I na short i na long tip podataka, može se
primjeniti i unsigned oznaka.

Rezervisane riječi u C++ jeziku za cjelobrojni tip su:

Cjelobrojni tipovi podataka Raspon brojeva Zauzeće memorije

(u byte-ima)
int -32,768 do 32767 2
short int (short) -32,768 do 32767 2 ili manje
long int (long) -2,147,483,648 do 2,147,483,648 4
unsigned int 0 do 65535 2
unsigned short 0 do 65535 2
unsigned long 0 do 4,296,967,295 4

Rezultat operacija na integer tipu podataka, nesmije biti izvan ranga vrijednosti jer u tom
slučaju dolazi do prekoračenja vrijednosti u odnosu na definisani tip, npr. kod unsigned integer
tipa podataka radi se o cikličnoj aritmetici. To znači da kada se izađe izvan ranga (prekorači
posljednja vrijednost u rangu), brojanje se vraća, odnosno ponovo počinje od 0.

unsigned short int i; // pretpostavimo da je rang od i = 0...65535

i=65535; // najveća moguća vrijednost
i++; // ciklična aritmetika i=0

42
 7.1. Realni tip podataka

Realni tip podataka je podskup skupa realnih brojeva. Na tipu realnih brojeva, definisane
su operacije realne aritmetike: sabiranje, oduzimanje, množenje, dijeljenje. Za operacije
definisane na tipu integer u svim slučajevima osim prekoračenja važe poznati zakoni cjelobrojne
aritmetike. Nešto je drugačija situacija sa realnim tipom. Svi su tipovi podataka konačni skupovi,
pa to predstavlja problem u odnosu na realni tip podataka. Poznato je da svaki proizvoljno mali
interval na realnoj osi sadrži beskonačno mnogo vrijednosti, te da je realni tip podataka konačan
skup predstavnika intrervala na realnoj osi. Zbog toga se računarske operacije sa ovim tipom
podataka, ustvari vrše ne sa tačnim nego sa približno tačmim vrijednostima. Ocjena veličine
greške do koje dolazi kod ovakvih približnih računanja predstavlja veliki problem u situacijama
kada se traži izuzetna preciznost. Do sada je postojalo više tehnika za predstavljanje realnih
brojeva u cilju dobijanja što veće tačnosti, a trenutno se uglavnom koristi rad sa tehnikom
pomičnog zareza (floating point tehnika).
U C++ jeziku, realne varijable se deklarišu sa float tipom podataka. Ako varijablu
deklarišemo sa float, radi se o single precision floating point tipu podataka ili kratko float.
Primjeri tih deklaracija su:

float r1=1.323;
float r2=-9.1818;
float r3=-454.545E-3;//To je -454.545 * 10-3 ili -454.545 * (1/1000) = -454.545/1000=-0,454545

Slika 10. Ilustracija deklaracije i upotrebe realnog tipa podataka

43
Float sa duplom preciznošću nazivaju se double u C++-u:.
double p1;

Realni tipovi podataka Raspon brojeva Byte-a

Single precision floating point (float) 1.2E - 38 do 3.4E38 4
(≈7 cifara)
Double precision floating point (double) 2,2E - 38 do 1.8E308 8
(≈15 cifara)
Long double precision floating point (long double) +/- 1.7e +/- 308 8
(~15 cifara)

Tabela 11. Raspon brojeva i dužina floating point varijabli

7.2. Karakterni tip podataka

Iako su se računari u početku obrađivali prije svega numeričke podatke, brzo se javila
potreba za obradom i pretežno nenumeričkih podataka. Danas nenumeričke aplikacije kao što
su različite vrste tekst-procesora, edukativnih programa, različite baze podataka sa pretežno
alfabetskim podacima, prevladavaju u odnosu na matematičke aplikacije. Osim toga i finansijske
aplikacije, koje su pretežno numeričke, zahtjevaju korišćenje ovog tipa podataka, kao što su npr.
adresa dobavljača, naziv konta, naziv proizvoda, nazivi izvještaja itd.
Svakom računaru je na raspolaganju unaprijed definisan skup znakova kojima su
dodjeljene jednoznačne brojne vrijednosti. Varijabli karakternog tipa moguće je dodjeliti tačno
jedan znak iz datog skupa znakova. Prema tome dužina promjenjive karakternog tipa je 1 bajt i
ona je u memoriji smještena kao brojna vrijednost, koja odgovara internom predstavljanju
dodjeljenog znaka. Prilikom prvobitnog dodjeljivanja vrijednosti (inicijalizacije) ovom tipu
podataka, kao i prilikom svakog sljedećeg dodjeljivanja, koriste se jednostruki navodnici.
Varijabla karakter se definiše tipom podataka char. Ovaj tip podataka zauzima samo
jedan bajt koji predstavlja ustvari kod, odnosno način binarnog predstavljanja (zapisivanja) nekog
znaka u memoriji računara ili tačnije redni broj ASCII kombinacije, koja se koristi za predstavljanje
konkretnog znaka. Najčešći sistem, odnosno standard za kodiranje znakova je je ACSII (Amercan
Standard Code for Information Interchange). Na primjer, karakter Z ima ASCII kod 90 (to je
dekadna vrijednost binarne kombinacije, kojom je predstavljeno slovo Z u u ASCII kodu. Karakter
z je predstavljen ASCII kombinacijom 122.
Kao i interger tip podataka, tako i karakter tip može da bude signed i unsigned. Tako,
signed karakter može da sadrži numeričke vrijednosti između -128 i 127, a unsigned 0 do 255.

44
 U C++ jeziku, deklaracija varijable tog tipa i rezervisana riječ za karakterni tip je:

char c1 ;

Dodjela vrijednosti varijabli karakternog tipa, svodi se na dodjeljivanje jednog znaka, koji
se smješta između jednostrukoih navoda (apostrofa). Primjer deklaracije i inicijalizacije karakter
varijable:

char slovo=’Z’;

7.3. Logički tip podataka

U domen vrijednosti logičkog tipa spadaju samo dvije vrijednosti: tačno (true) i pogrešno
(false) ili istina i laž, 0 i 1, uključeno i isključeno, dan i noć itd.
Ovaj tip je važan zbog činjenice da operatori za poređenje dvaju vrijednosti (relacioni
operatori tipa =, <, > itd.), predstavljaju funkcije, koje kao rezultat poređenja vraćaju vrijednost
logičkog tipa. Npr. ako se porede dvije vrijednosti (zapisane u varijablama ili direktno) putem
operatora =, rezultat se smješta u varijablu logičkog tipa, u koju se zapisuje da je rezultat tog
poređenja tačan ili netačan. Isto tako, If iskaz, koristi logički tip podataka da bi zabilježio rezultat
ispunjavanja ili neispunjavanja nekog uslova u If naredbi.
U nekim jezicima tip boolen se definiše na sljedeći način: type boolean=(false,true), a u C++
jeziku, ovaj tip se ne definiše kao poseban tip, nego se za tu svrhu koristi tip integer sa sljedećim
tumačenjem: 1-tačno, 0-pogrešno.

7.4. Nabrojivi (engl. enumerated) tip podataka

U jeziku C++ nabrojivi tip podataka predstavlja ustvari način na koji korisnici mogu
definisati svoj tip podataka. Osnovna funkcija nabrojivih tipova je poboljšanje čitljivosti programa
i njegovo lakše razumijevanje.
Opšti oblik za definisanje nabrojivog tipa je: enum type_name {value_1,
value_2,...,value_n};, gdje type_name predstavlja ime nabrojivog tipa, a value_1,
value_2,...,value_n, predstavljaju uređeni skup nabrojanih imena, koja su ustvari konstante tipa
type_name.
Dakle, nabrojivi tipovi predstavljaju konačan skup vrijednosti, od kojih svaka ima svoj
naziv i svaka ima svoje specifično mjesto u određenom redoslijedu, odnosno poretku, koji je
određen njihovim nabrajanjem. Deklarišu se korišćenjem rezervisane riječi enum, te navođenjem
imena tipa koji se želi definisati i spiska mogućih vrijednosti tog tipa. Unutar vitičastih zagrada

45
(kao moguće vrijednosti sa spiska mogu se koristiti bilo koja imena, koja nisu prethodno
upotrijebljena u programu).

Na primjer, pomoću deklaracija:

enum mjeseci {januar, februar, mart, april, maj, juni, juli, avgust, septembar, oktobar, novembar,
decembar};
enum godisnja_doba {proljeće, ljeto, jesen, zima};

Ovom deklaracijom uvode se 2 nova tipa podataka - mjeseci i godišnja_doba, pa u prvom

slučaju 12 nepromjenjivih imena (januar, februar, mart …) tog tipa, a u drugom 4 nepromjenljiva
imena tog tipa. Ukoliko programer eksplicitno ne navede drugačije, value_1 će inicijalno biti
jednako 0, value_2 će biti 1 i tako redom, Naravno programer uvijek može da dodijeli vrijednosti
na način koji će njemu najviše odgovarati na osnovu radi uspješnijeg rješenja problema. U
korištenim primjerima, prvom imenu (odnosi se na oba tipa) kompajler dodjeljuje vrijednost 0
(januar i proljeće), drugom 1 (februar i ljeto), trećem 2 (mart i jesen), četvrtom 3 (april i zima)
itd. Ukoliko želimo da niz počinje nekom drugom vrijednošću (a ne vrijednošću 0), tada je
neophodno eksplicitno dodijeliti tu željenu vrijednost. Npr. ukoliko ne želimo da u tipu
godisnja_doba, proljeće bude predstavljeno vrijednošću 0, nego vrijednošću 1, to ćemo napisati
na sljedeći način:
enum godisnja_doba {proljeće = 1, ljeto, jesen, zima};
U tom slučaju identifikator ljeto, poprimiće vrijednost 2, jesen 3 i zima 4. Na isti način je
moguće direktno dodijeliti vrijednost drugom identifikatoru u nizu, pa bi to izgledalo ovako:
enum godisnja_doba {proljeće, ljeto=3, jesen, zima};
U ovom slučaju vrijednost identifikatora bi bila, 0, 3, 4 i 5, što znači da se za jedan
povećavaju vrijednosti identifikatora, koji slijede u nizu nakon identifikatora, kojem je eksplicitno
promijenjena vrijednost.
Kako se deklarišu varijable tog novog tipa? Na isti način na koji se deklarišu varijable bilo
kojeg tipa. Ukoliko je potrebno tim varijablama dodijeliti i inicijalne vrijednosti, onda bi to
izgledalo ovako:

mjeseci parni = februar;

mjeseci neparni;
godisnja_doba prvo=proljece;
godisnja_doba hladno;
mjeseci prvi;

46
 Varijable nabrojivog tipa (npr. godisnja_doba), mogu se deklasirati i prilikom definicije
nabrojivog tipa:

enum godisnja_doba {proljeće, ljeto, jesen, zima} prvo, hladno;

Nakon puštanja u rad programa dobićemo rezultat:

Slika 11. Ilustracija upotrebe nabrojivog tipa varijabli

7.5 Void tip podataka

Tip podataka void je dobio ime po engleskoj riječi, koja znači prazan ili ispražnjen. Pošto ne sadrži
nikakvu vrijednost, koju bi bilo potrebno memorisati, ovaj tip ne zauzima ni prostor u memoriji
računara. Koristi se kod funkcija koje ne vraćaju nikakvu vrijednost, pa će o njemu više biti riječi
u dijelu knjige koji se odnosi na funkcije.

47
8. OPERATORI

Operatori (engl. operators) predstavljaju simbole, koji zamjenjuju određene vrste

operacija. S obzirom na vrstu operacija, koje zamjenjuju, dijele se na:

1. Operatore pridruživanja
2. Relacione operatore ili operatore poređenja
3. Aritmetičke operatore
4. Logičke operatore
5. Uslovni operator
6. Stream operatore
7. Comma (zarez) operatore
8. Dodatne operatore
9. Sizeof operator

Za razliku od drugih programskih jezika čiji su operatori najčešće rezervisane (ključne)

riječi, operatori u C ++ jeziku su uglavnom kreirani od znakova koji nisu sastavni dio abecede, ali
su dostupni na gotovo svim vrstama tastatura. Zbog toga je kod C ++ programa kraći i
prilagođeniji standardima većine nacionalnih jezika, jer se manje oslanja na engleske riječi i
zahtijeva manje vremena u procesu učenja programskog jezika.

8.1. Operatori pridruživanja

Operator pridruživanja (engl. assignment) služi za dodjelu vrijednosti nekoj varijabli, koja
ima svoje ime i lokaciju u memoriji računara. To je znak =. Varijabli koja se nalazi sa njegove lijeve
strane pridružuje se (memoriše se u lokaciju varijable) određena vrijednost izraza koja se nalazi
sa njegove desne strane u iskazu pridruživanja. Tip vrijednosti izraza treba odgovarati tipu
varijable, odnosno to moraju biti isti tipovi.
Veoma često se pogrešno misli da znak = (jednako) znači da lijeva strana izraza treba da
bude jednaka desnoj. Ispravno značenje znaka = (jednako) jeste da ono što se nalazi na desnoj
strani znaka jednakosti (a to može biti, broj, znak, niz znakova ili izraz) dodijeli varijabli
(memoriše u lokaciju varijable) na lijevoj strani znaka jednakosti.
Uz ovaj operator, koji spada u unarne operatore (sastoji se od jednog znaka) mogu se
dodati i drugi unarni aritmetički operatori, pa se tako dobiju binarni operatori pridruživanja, čija
je osnovna funkcija da reduciraju veličinu kôda C++ programa. Najčešće korišćeni binarni
operatori pridruživanja, njihove oznake i objašnjenja, prikazani su u Tabeli 12.

48
 Operator Opis Primjer Značenje
pridruživanja
= Pridruživanje vrijednosti x = 2; x = 2;
+= Pridruživanje vrijednosti nakon uvećavanja za x += 2; x = x + 2:
-= Pridruživanje vrijednosti nakon umanjenja za x -= 2; x = x - 2;
*= Pridruživanje vrijednosti nakon množenja sa x *= 2; x = x * 2;
/= Pridruživanje vrijednosti nakon dijeljenja sa x /= 2; x = x / 2;
%= Pridruživanje vrijednosti nakon izvršenja modulo x %= 2; x = x % 2;
operacije

Tabela 12. Operatori pridruživanja

8.2. Relacioni operatori ili operatori poređenja i operatori jednakosti

Relacione operatore možemo definisati kao funkcije koje vraćaju vrijednost logičkog tipa.
Relacionim operatorima se definiše rezultat poređenja vrijednosti dviju varijabli, funkcija ili
izraza. Osnocni princip rada računara svodi se upotrebu jednostavne (binarne) logike, odnosno
logike, koja koristi samo dvije vrijednosti: a) ako je uslov istinit (true), vrijednost je 1; b) ako je
uslov lažan (false), vrijednost je 0. Relacioni operatori su prikazani u tabeli 13.

Simbol u Algebarski Objašnjenje C++ Značenje C++ Primjer 0/1

C++ operator uslov uslova
> > veće x>y x je veće od y 5>4 1
< < manje x<y x je manje od y 6.3 < -3.6 0
>= ≥ veće ili jednako x >= y x je veći ili jednak y -7.2 >=4.5 0
<= ≤ manje ili jednako x <= y x je manji ili jednak y 9.0 <=9.0 1
Operatori jednakosti
== = jednako x == y x je jednak y 5.4==5.4 1
!= ≠ različito x != y x nije jednak y -4.5!=4.5 1

Tabela 13. Relacioni i operatori jednakosti

Relacioni operatori se najčešće koriste u komandama za grananje toka programa (if, if

else ili switch iskazi), gdje se zavisno od toga da li je uslov zadovoljen ili nije, izvođenje programa
nastavlja u različitim granama programa. Zato će o njima detaljnije biti riječi, prilikom
objašnavanja tih komandi.

49
 Ono što je na ovom mjestu još potrebno napomenuti i razjasniti jeste uočavanje bitne
razlike između operatora jednakosti C++ jezika (==) i znaka za pridruživanje vrijednosti nekoj
varijabli (=). Ukoliko greškom napišemo samo znak =, umjesto znaka ==, tada će program izvršiti
pridruživanje pa će logički izraz uvijek biti tačan i vraćati logičku vrijednost 1. Ovo je česta greška
prilikom pisanja programskog koda, koju ne prave samo početnici, a otkriva se tek prilikom
izvršavanja programa.
Operandi nekog relacionog operatora, odnosno varijable koje se porede moraju biti
brojevi. Ali, pošto i varijable tipa karakter takođe predstavljaju brojnu vrijednost, to znači da se i
one mogu porediti relacionim operatorima.

8.3. Aritmetički operatori

Većina simbola, koji se koriste za predstavljanje aritmetičkih operatora u C++ jeziku je ista kao i
odgovarajući standardni matematički simboli aritmetičkih operacija. Ovi operatori se primjenjuju
na cjelobrojni (integer) tip podataka, pa se zato često nazivaju integer operatori. Skup operacija,
koje se mogu obavljati na varijablama integer tipa, uključuju 4 osnovne operacije: sabiranje,
oduzimanje, množenje i dijeljenje, pa se svaka od tih operacija predstavlja odgovarajućim
aritmetičkim simbolom, koji je isti kao i standardni matematički simbol za konkretnu aritmetičku
operaciju.

Operator u Operacija Opšti format izraza Konkretan rimjer u C++ jeziku

C++ jeziku u C++ jeziku
+ Sabiranje x+y 5.4 + 4.5 // rezultat 9.9
- Oduzimanje x-y 18.09 – 9.09 // rezultat 9.00
* Množenje x*y 3 * 9 // rezultat 27
/ Dijeljenje x/y 36 / 3 // rezultat 12
% Modulo x%y 18 % 5 // rezultat 3

Tabela 14. Binarni aritmetički operatori

Pošto se jedino operator modulo ne spada u standardne aritmetičke simbole za aritmetičke

operacije, potrebno ga je posebno objasniti. Operator modulo (%) kao rezultat vraća ostatak
dijeljenja dva cijela broja.
U matematici dijeljenje dva cijela broja, npr. a/b proizvodi dvije vrijednosti, količnik q i ostatak r,
pa se može napisati da je a=q*b+r
U C++ jeziku operator / se koristi za vraćanje količnika q, a drugi operator % vraća ostatak
cjelobrojnog dijeljenja r. Pa tako npr. izraz 35/13 daje kao rezultat dijeljenja broj 2, a izraz 35%13,
kao rezultat (ostatak dijeljenja) daje broj 9.

50
 int n = 35;
int m = 13;
cout << (n % m) << endl; // prikazuje 9

U odnosu na broj operanada na koje se odnose, aritmetičke operatore dijelimo u dvije

grupe: unarne i binarne. Unarni operatori su oni operatori, koji vrše neku operaciju nad samo
jednim operandom (jednom varijablom), a binarni su oni koji vrše operacije nad dva operanda
(dvije varijable). Binarni operatori su prikazani u tabeli 4., a unarni se nalaze u tabeli 15.

Unarni Značenje Varijante sa istim

operator značenjem
+x Postavlja pozitivan (+) predznak varijabli x
-x Postavlja negativan (-) predznak varijabli x
x++ Uvećavanje vrijednosti varijable x za 1 nakon prikaza x=x+1, c+=1
++x Uvećavanje vrijednosti varijable x za 1 prije prikaza
x-- Smanjenje vrijednosti varijable x za 1 nakon prikaza x=x-1, c-=1
--x Smanjenje vrijednosti varijable x za 1 prije prikaza

Tabela 15. Unarni aritmetički operatori

Uključivanjem operatora za skraćivanje izraza u kojima su zastupljeni operatori povećanja

npr. varijable x (x++) i operatori smanjenja (x--), koji povećavaju ili smanjuju za 1 vrijednost
pohranjenu u varijabli, dobivaju se sljedeći zamjenski izrazi x+=1 i x-=1, respektivno. Dakle, izrazi
x++, x+=1 i x=x+1 imaju potpuno istu funkcionalnost: svi povećavaju za 1 vrijednost varijable x.
svi su jednaki u svojoj funkcionalnosti: njih troje se povećavaju za jednu vrijednost c.
Karakteristika ovog operatora je da se može koristiti i kao prefiks, odnosno prije identifikatora
varijable i kao sufiks (poslije identifikatora varijable). Bilo da se ovaj operator koristi kao prefiks
ili sufiks, suštinsko značenje je isto: povećanje (increment) vrijednosti varijable za 1. U čemu je
razlika? Ona se objašnjava sljedećim primjerom:

Primjer 1 - prefiks Primjer 2 - sufiks

b=6; b=6;
a=++b; a=b++;
// Sadržaj varijabli: a=7 i b=7 //Sadržaj varijabli: a=6 i b=7

Tabela 16. Ilustracija prefiks i sufiks identifikatora

51
 U primjeru 1 (prefiks), varijabla b se povećava za 1 prije nego što se njena vrijednost
dodijeli varijabli a (prvo se varijabla b povećava za 1 i dobije vrijednost 7, a nakon toga se 7
dodjeljuje varijabli a), dok se u primjeru 2 (sufiks) prvo inicijalna vrijednost varijable b (6)
dodjeljuje varijabli a i tek nakon toga se varijabla b povećava za 1.
Još jedno objašnjenje (slika 7) uz pomoć kojeg se može jednostavno uočiti razlika između
upotrebe unarnog operatora kao prefiksa i njegove upotrebe kao sufiksa, odnosi se na prikaz
vrijednosti varijable koristeći cout iskaz. Ako se varijabli x dodijeli vrijednost 3 putem iskaza int
x=3; i nakon toga iskazom cout<<" "<<x<<endl;, program će prikazati inicijalnu vrijednost
varijable x, odnosno tu istu vrijednost 3. Nakon iskaza cout<<" "<<(++x)<<endl;, program će prvo
povećati sadržaj varijable x za 1, a onda na konzoli prikazati njen novi sadržaj, odnosno broj 4.
Sljedeća naredba (red 9: cout<<" "<<x<<endl;) prikazuje ponovo sadržaj varijable x, odnosno broj
4. Zatim naredbom u redu 10 (cout<<" "<<(x++)<<endl;), ponovo prikazuje vrijednost varijable x,
odnosno broj 4, a tek nakon toga uvećava vrijednost varijable x za 1 i u narednom redu, redu 11,
iskazom (cout<<" "<<x<<endl;), prikazuje tu uvećanu vrijednost, odnosno broj 5.

Slika 12. Prefix i Postfix operatori sabiranja

Varijable, kojima se dodaju aritmetički operatori formiraju izraze. Primjer izraza: x –

y/z*(n + m). Da bi se definisao redosljed izvršavanja aritmetičkih operacija na cijelim brojevima,
koriste se matematička pravila. Zagrade se koriste za promjenu redosljeda izvršavanja operacija,

52
definisanog tim matematičkim pravilima. U tabeli 17., prikazan je redosljed izvršavanja operatora
u složenim izrazima.

Operatori Operacije Redosljed izračunavanja

() Zagrade Imaju najveći prioritet. Prvo se
izračunava ono što je u
zagradama. Ako su zagrade
ugnježdene, prvo se izračunava
izraz u unutrašnjem paru
zagrada.
* Množenje Ove operacije su drugi prioritet.
/ Dijeljenje Ako ih ima više izračunavaju se s
% Ostatak cjelobrojnog dijeljenja lijeva na desno.
+ Sabiranje Ove operacije imaju zadnji
- Oduzimanje prioritet. Ako ih ima više
izračunavaju se s lijeva na
desno.

Tabela 17. Redoslijed izvršavanja aritmetičkih operacija

Slika 13. Kružna aritmetika, Izvor: Adapt. prema (Motik i Šribar, 1997)

53
 8.4. Logički operatori

Kao što je već rečeno u dijelu knjige koji govori o relacionim operatorima, za ispitivanje,
odnosno provjeravanje tačnosti jednog uslova, koriste se naredbe za grananje toka programa (if,
if else, switch) i relacioni operatori ili tačnije rečeno za provjeravanje tačnosti jednog uslova,
koristi se samo jedan relacioni operator. Veoma često postoji potreba da se istovremeno testiraju
dva ili više izraza ili uslova (sa dva ili više relacionih operatora), pa se zavisno od rezultata
poređenja tačnosti dva ili više testova (složeni uslov), koji opet mogu biti tačni ili netačni, izvode
odgovarajuće komande, odnosno grane programa. To je moguće ostvariti uz pomoć logičkih
operatora, koji služe za povezivanje (kombinovanje) dvaju ili više jednostavnih uslova - izraza (sa
samo jednim relacionim operatorom).
Dakle, C++ obezbjeđuje logičke operatore koji se koriste da formiraju kompleksne
uslove, kombinujući jednostavne uslove.
C++ jezik koristi 3 logička operatora: a) ! – (logička negacija ili logičko ne ili engl. logical
NOT), b) && - (logičko i ili engl. logical AND) i c) ||- (logičko ili ili engl. logical OR). Ovi operatori
sa simbolima, značenjem i primjerima, prikazani su u tabeli 18. Slično relacionim operatorima za
jednostavne iskaze, rezultat pri korištenju logičkih operatora za složene iskaze je 0 (false) ili 1
(true).
Logički operator ! (ili engl. NOT) je unarni operator, koji se zapisuje ispred varijable i
mijenja njenu logičku vrijednost: vrijednost tačno (true ili 1) mijenja u netačno (false ili 0) ili
obrnuto.
Logički operator && (ili engl. AND) se koristi ukoliko je u programu potrebno testirati sve
rezultate složenog iskaza (sastavljenog od dva jednostavna iskaza) tako da se testiraju sve
kombinacije tačnosti kada je potrebno da oba iskaza budu tačna da bi složeni iskaz bio tačan i
zavisno od rezultata složenog iskaza, program se grana u odgovarajuće dijelove programa (tabela
19).

Simbol operatora Značenje Primjer

! Logička negacija (NOT) !(9 == 9) // daje 0
&& Logičko i (AND) 3 < 6 && 9 < 9 // daje 0
|| Logičko ili (OR) 3 < 6 || 9 < 6 // daje 1

Tabela 18. Logički operatori u C++ jeziku

54
 Uslov_1 (Izraz_1) Uslov_2 (Izraz_2) Uslov_1 && Uslov_2
False (netačno) 0 False (netačno) 0 False (netačno) 0
False (netačno) 0 True (tačno) 1 False (netačno) 0
True (tačno) 1 False (netačno) 0 False (netačno) 0
True (tačno) 1 True (tačno) 1 True (tačno) 1

Tabela 19. Tabela istinitosti za && logički operator

Logički operator || (OR) se koristi ukoliko je u programu potrebno testirati sve rezultate složenog
iskaza (sastavljenog od dva jednostavna iskaza) tako da se testiraju sve kombinacije tačnosti kada
je dovoljno da bilo jedan ili drugi iskaz bude tačan da bi složeni iskaz bio tačan i zavisno od
rezultata složenog iskaza, program se grana u odgovarajuće dijelove programa (tabela 20).

Uslov_1 (Izraz_1) Uslov_2 (Izraz_2) Uslov_1 || Uslov_2

False (netačno) 0 False (netačno) 0 False (netačno) 0
False (netačno) 0 True (tačno) 1 False (netačno) 1
True (tačno) 1 False (netačno) 0 False (netačno) 1
True (tačno) 1 True (tačno) 1 True (tačno) 1

Tabela 20. Tabela istinitosti za || logički operator.

8.5. Uslovni operator grananja

U C++ jeziku se koristi i uslovni operator grananja, koji ima slično značenje kao if - else iskaz, o
kojem će kasnije biti detaljnije riječi. Operator grananja je jedini operator sa tri (ternarni)
operanda u programskom jeziku C++. Opšti format ovog operatora je:
rezultat=izraz_1?izraz_2:izraz_3;, gdje su, „?“ (upitnik) i „:“ (dvotačka) simboli operatora, a
izraz_1 , izraz_2 i izraz_3 su izrazi, pri čemu izraz_1 predstavlja izraz_uslov. Kako radi uslovni
operator grananja? Da bi obavio funkciju za koju je predviđen, uslovni operator grananja prvo
izračunava izraz_1. Ukoliko je vrijednost izraza_1 različita od 0 (odnosno, ukoliko je ovaj izraz
logički tačan) biće izračunat izraz_2 i njegova vrijednost će biti pridružena varijabli rezultat, što
će i predstavljati konačni rezultat ove operacije.
Ukoliko je vrijednost izraza_1 jednaka 0 (odnosno ukoliko je ovaj izraz logički netačan) biće
izračunat izraz_3 i njegova vrijednost će biti pridružena varijabli rezultat i predstavljati konačan
rezultat upotrebe uslovnog operatora grananja.

55
 Slika 14. Primjer upotrebe uslovnog operatora grananja

U primjeru sa slike, program prvo izračunava tačnost izraza_1. Izraz_1 je (x>y). Pošto izraz_1
(3>9), nije tačan (vraća vrijednost false), vijednost varijable y (a to je broj 9) pridružuje se varijabli
z i prikazuje na monitoru. Kada nakon toga y varijabli pridružimo vrijednost manju od 3, npr. 1,
pa ponovo upotrijebimo isti uslovni operator grananja, tada će izraz_1 biti tačan i program će
prikazati vrijednost varijable x, a to je broj 3.

8.6. Stream operatori

U C++ jeziku postoje 3 stream operatora: a) operator za izlazni stream (<<) ili insertion stream
operator, b) operator za ulazni (input) stream (>>) i c) operator za kaskadni stream operator.

56
 Operator << (stream insertion operator) je operator koji se koristi za izlaz podataka na
standardni izlazni stream - ekran. To se vrši iskazom cout. Opšti format cout iskaza je:
cout<<”poruka”; Kada se program izvršava, vrijednost desno od operatora <<, koja se prikazuje
između navodnih znakova (poruka, literal ili string), insertuje se na izlazni stream (ekran) i to
uzrokuje prikazivanje poruke, odnosno stringa (niza) karaktera između navodnika u redosljedu
kako su zapisani u poruci.
Operator za ulazni (input) stream (>>) je operator koji se koristi za ulaz podataka sa
standardnog ulaznog streama – tastature. To se vrši iskazom cin. Opšti format cin iskaza je:
cin>>ime_varijable;. Da bi program prihvatio vrijjednost, koja se unosi sa tastature i pohranio ga
u varijablu ime_varijable, koristi se input stream cin i stream operator >>. Kada se unutar
programa izvršava prethodni iskaz, čeka se (prompt) da korisnik unese vrijednost za varijablu
ime_varijable. Korisnik odgovara ukucavajući vrijednost i pritiskom na taster <enter> potvrđuje
njen unos.
Kaskadni stream operator se dobiva korištenjem više operatora << u jednom iskazu C++
jezika. Primjer upotrebe ovog operatora je iskaz:
cout<<”Zbir broja “<<broj_1<<” i broja “<<broj_2<<”= “<<zbir<<endl;,
s tim što uz ostale neophodne iskaze, prethodno moraju biti deklarisane sve 3 varijable iskazom:
int broj_1, broj_2, zbir;.

8.7. Comma (zarez) operatori ili operatori razdvajanja

Operator razdvajanja predstavljen znakom “zarez” (,) se koristi za odvajanje dva ili više izraza koji
su uključeni tamo gdje se očekuje samo jedan izraz. Izrazi razdvojeni zarezom se izvode
postepeno, s lijeva na desno. Na primjer, sljedeći kod:

a = (b = 3, b + 2);

načio bi da se prvo dodjeljuje vrijednost 3 varijabli b, a zatim vrijednost (b + 2), odnosno 5

varijabli a, što dalje znači da bi na kraju varijabla a sadržavala vrijednost 5, dok bi varijabla b
sadržavala vrijednost 3.

8.8. Dodatni operatori

Kao dodatne operatore, koji ne spadaju niti u jednu od prethodno opisanih kategorija
operatora, ovdje ćemo objasniti još dva operatora: a) operator dodjele tipa (type cast ili cast) i
b) operator sizeof.
Ponekad se u programu pojavi potreba da se isti podatak (ista vrijednost neke varijable
određenog tipa na određenoj memorijskoj lokaciji) tretira na drugačiji način, odnosno da joj se

57
dodijeli novi, drugačiji tip podataka. Pretvaranje izraza ili varijable određenog tipa podataka u
drugi tip poznato je kao type casting ili samo cast. Postoje dvije vrste te konverzije: implicitna i
eksplicitna.
Implicitna konverzija ne zahtijeva upotrebu bilo kakvog operatora za konverziju. Ona se
automatski izvodi, kada se vrijednost varijable (ili izraza) kopira u kompatibilni tip varijable. Npr:

short a = 2007;
int b;
b=a;

Ovdje treba napomenuti da je tip short, ustvari short int, a da se cijeli broj (tip integer)
može definisati pomoću tipova short, int i long. Jedina razlika je u tome da int koristi više ili
barem isto bajta kao short, a long koristi više ili barem isto bajta nego int, što zavisi od računara
na kojem se izvodi program. Dakle radi se o kompatibilnim tipovima podataka, pa nije potrebno
koristiti nikakav operator za casting. To je poznato kao standardna konverzija. Standardna
pretvaranja se odnose na osnovne tipove podataka i dopuštaju konverzije kao što su konverzije
između brojčanih tipova (short u int, int u float, double u int itd.),
Međutim, za eksplicitnu promjenu tipa varijable primijenjujemo operator dodjele tipa (engl.
type casting, ili samo cast):

int broj_1 = 1;
int broj_2 = 3;
float kolicnik = (float)broj_1 / (float)broj_2;

Upotrebom rezervisane riječi float u zagradama ispred operanada broj_1 i broj_2,

njihove vrijednosti se pretvaraju u decimalne (realne) brojeve prije operacije dijeljenja, tako da
je rezultat korektan. Ovdje još treba napomenuti da bi bilo dovoljno operator dodjele tipa
primijeniti samo na jedan operand, pa bi prema pravilima aritmetičke konverzije i drugi operand
bio sveden na float tip, a varijable broj_1 i broj_2 bi i dalje ostali tipa int, tako da bi njihovo
naknadno dijeljenje: float pogresan_kolicnik = broj_1 / broj_2;, opet rezultiralo cjelobrojnim
dijeljenjem (slika 15).

58
 Slika 15. Primjer eksplicitne primjene operatora dodjele tipa (cast)

8.9. Operator sizeof

Operator sizeof je unarni operator, koji kao rezultat “vraća” broj bajtova, koje operand
zauzima u memoriji računara. Operand sizeof operatora može biti tip ili varijabla određenog tipa
npr. int, float, double, char ili neki konkretni objekat, koji je već deklarisan (slika 16.)

59
Slika 16. Primjer programa, koji ilustruje primjenu Sizeof operatora

60
 8.10. Identifikatori (imena)

U arhitekturi C++ programa postoje elementi programa, koji imaju obavezna imena
(nazive ili identifikatore), kao i elementi kojima korisnici (programeri) moraju definisati imena.
Obavezna imena imaju naredbe, klauzule, neke funkcije, operatori kao alternativni naziv za
simbol, većina tipova podataka, odnosno tipova varijabli itd. Sva ova obavezna imena
predstavljaju rezervisane ili ključne riječi. Popis ključnih riječi i alternativnih naziva operatora,
nalaze se u tabeli 21. i tabeli 22. Elementi programa, kojima nazive (identifikatore) definišu
programeri su varijable, funkcije klase, korisnički tipovi podataka, nazivi labela (dijelova koda
izvornog programa) itd. Imena koja programeri dodeljuju tim elementima su u principu
proizvoljna uz uslov da se poštuju tri ograničavajuća pravila:

1. Identifikator može da se sastoji od kombinacije malih (a - z) i velikih slova (A – Z) engleske

abecede (case-senzitivan naziv), zatim brojeva (0 - 9) i donje crte ( _ )
2. Prvi znak identifikatora ne može biti broj niti specijalni znak nego mora da bude slovo ili
donja crta ili jednom rječju rečeno nedigitalni znak.
3. Identifikator ne smije da bude neka ključna, odnosno rezervisana riječ iz tabele 9, niti neki
alternativni naziv operatora, iz tabele 22. To ne znači da ključna riječ ne može da bude
dio identifikatora, ali takve nazive treba izbjegavati da ne bi došlo do zabune.

61
 alignas alignof asm auto bool
break case catch char char8_t
char16_t char32_t class concept const
consteval constexpr constinit const_cast continue
co_await co_return co_yield decltype default
delete do double dynamic_cast else
enum explicit export extern false
float for friend goto if
inline int long mutable namespace
new noexcept nullptr operator private
protected public register reinterpret_cast requires
return short signed sizeof static
static_assert static_cast struct switch template
this thread_local throw true try
typedef typeid typename union unsigned
using virtual void volatile wchar_t
while

Tabela 21. Rezervisane (ključne) riječi

Izvor: (Smith, 2020)

and and_eq bitand bitor compl

not not_eq or or_eq xor
xor_eq

Tabela 22. Alternativne oznake operatora u C++ jeziku po ISO standardu za C++ 20
Izvor: (Smith, 2020)

C++ praktično ne postavlja ograničenje na dužinu naziva, odnosno broja karaktera

(znakova) u nekom identifikatoru. Međutim, iako većina C++ kompajlera ima ograničenje od 255
znakova za dužinu identifikatora, ali pošto se radi o zaista velikom broju, to suštinski ne
predstavlja nikakvo ograničenje.
Bez obzira što postoji apsolutna sloboda definisanja identifikatora, nakon što se ispoštuju
pomenuta ograničenja, ipak zbog bolje čitljivosti koda i boljeg razumijevanja funkcije programa,
treba poštovati još jedno pravilo: potrebno je elementima programa koje definiše korisnik davati
imena u skladu sa njihovim značenjem u realnom svijetu. Npr. ukoliko se u programu pojavljuju

62
kupci koji su uglavnom fizička lica, za izbor identifikatora varijable za fizičko lice, logičnije je dati
naziv Ime_kupca ili samo Kupac, nego npr. Naziv_kupca ili samo Naziv.

9.0. NAREDBE ZA KONTROLU TOKA PROGRAMA (KONTROLNE STRUKTURE)

Ako kompjuterski program posmatramo kao niz naredbi (iskaza), koji se izvršavaju
naredba za naredbom tačno utvrđenim redoslijedom zapisanim u programu u kojem nema
preskakanja koda, onda govorimo o sekvencijalnom izvršavanju programa. Međutim u praksi se
rijetko dešava da se program izvodi pravolinijski, odnosno bez potrebe da se određene naredbe
programa izvode samo u slučaju kada je ispunjen neki uslov ili više njih ili bez potrebe da se
određeni dijelovi programa ponavljaju određeni broj puta. Iskazi koji omogućavaju programeru
da specificira naredbe programskog koda, koje je potrebno izvršiti a da to nisu sljedeće naredbe
u nizu (sekvenci), zovu se naredbe za transfer kontrole. Jedna od najčešće korišćenih naredbi,
koje omogućavaju grananje toka programa i ponavljanje dijelova kôda jeste naredba goto.
Međutim, prečesto mijenjanje toka kontrole programa sa destinacije na destinaciju u istom
programu, dovodilo je do nečitljivog koda, koji se zbog toga često nazivao „špageta“ kod.
Istraživanja Böhm and Jacopini (1966) (https://dl.acm.org/doi/10.1145/355592.365646)
pokazala su da se programi mogu pisati bez goto iskaza. To je dovelo do pojave metode
strukturiranog programiranja čija je jedna od paradigmi programiranje sa što manje upotrebe
goto naredbe ili potpuno bez nje. Primjenom ove metode, odjeljenja za razvoj softvera su
značajno reducirali vrijeme razvoja softverskih projekata, postalo je mnogo lakše isporučiti
softver u dogovorenom roku i u granicama propisanog budžeta, a pokazale su se značajne
prednosti i u fazi testiranja i održavanja softvera. Formula uspjeha se sastojala u primjeni principa
strukturiranog programiranja, koji su rezultirali jasnijim (čitljivijim) kodom, koji je zbog toga bio
brži i lakši za otklanjanje grešaka (debagiranje), testiranje i modificiranje.
Jedan od osnovnih principa strukturiranog programiranja je da se svi programi mogu pisati uz
pomoć 3 kontrolne strukture:

 sekvencijalna struktura (sequence)

 strukture selekcije (select) i
 strukture ponavljanja (repetition)

Dakle, naglasak je na korištenju što je više moguće upravljanja nad tokom programa pomoću
odvajanja dijelova kôda u blokove (sekvencijalne strukture), uslova (if-then-else ili struktura
selekcije ili izbora), for i while petlji (strukture ponavljanja) i posebnih funkcija, ili dijelova koji
rade odvojeno (subrutina), a pritom maksimalno izbjegavati naredbu goto, dakle bezuslovni skok
iz kôda u proizvoljnu drugu tačku u njemu.

63
 9.1. Sekvencijalne strukture u C++ jeziku (sekvenca ili blok)

Sekvencijalne strukture su sastavljene od više iskaza koji se izvršavaju jedan za drugim,

redosljedom u kojem su zapisani u programu. Unified Modeling Language (UML) dijagram
aktivnosti (slika 11) ilustruje tipičnu sekvencijalnu strukturu (blok) sa dva iskaza koja se izvršavaju
u redosljedu u kojem su zapisani. C++ dozvoljava da se blok sastoji iz proizvoljnog broja iskaza u
sekvenci.

Slika 17. Struktura sevence (blok) prikazana UML dijagramom

Na slici 17, u blok (sekvencu) su uključena dva iskaza: prvi dodaje vrijednost varijable
bodovi na ukupan iznos bodova (total varijablu), a drugi dodaje vrijednost 1 na varijablu brojač.
Sve je to grafički prikazano uz pomoć UML dijagrama aktivnosti.
UML dijagram aktivnosti je vrsta grafičkog alata, koji je veoma sličan dijagramima toka
koji su se dugo koristili kao jedini alat za prikazivanje algoritama ili dijela algoritma. UML dijagram
aktivnosti se sastoji od specijalnih simbola: pravouganika zaokruženih ivica za prikaz aktivnosti,
romba za odluku, kružića za označavanje početaka i kraja aktivnosti i strelica tranzicije koje
spajaju simbole u cilju prikaza toka aktivnosti. Slično kao pseudokod i dijagrami toka, UML
dijagrami aktivnosti pomažu programerima u bržem i lakšem razvoju i predstavljanju algoritama.
U skladu sa dokazanim pravilom da slika vrijedi više od 1000 riječi, UML dijagram aktivnosti
pokazuje jasnije od bilo kakvog tekstualnog objašnjenja logiku izvršavanja kontrolnih struktura.
Jednostavna (elementarna) naredba je svaka naredba koja završava znakom “tačka-zarez”.

64
 Definicije varijabli i izrazi koji završavaju sa tačka-zarezom su neki primjeri elementarnih
akcija, koji se ne mogu podjeliti na manje (prostije) dijelove, koji bi i sami bili naredbe:

int broj_1; // deklaraciona naredba

++broj_1; // naredba sa popratnim efektom
double d = 10.5; // deklaraciona naredba za float varijablu sa duplom preciznošću
d + 5; // beskorisna naredba

Posljednji primjer pokazuje beskorisnu naredbu, jer nema nikakvih popratnih efekata, a
najjednostavniji oblik naredbe, odnosno specijalan slučaj elementarne programske naredbe je
prazna naredba. To je linija koja sadrži samo znak “tačka-zarez” i zove se null-naredba. Prazna
naredba nema nikakav uticaj na izvršenje programa i ona se može pojaviti na svakom mjestu u
programu gdje i elementarna naredba. Ali, i ovakva naredba ponekad ima smisla. Ona se koristi
kada sa jedne strane sintaksa jezika zahtijeva naredbu, dok sa druge strane sam program na tom
mjestu ne vrši nikakvu akciju.
Ukoliko imamo niz iskaza koji čine neku cjelinu tada se radi o sekvenci iskaza. Mnogi
programski jezici uvode sintaksnu formu iskaza za sekvencu i nazivaju ga blok.
Blok strukture su naročito značajne kod struktura izbora, podprograma, funkcija.
U programskom jeziku C++, blok struktura se obilježava između {}, a u nekim jezicima (poput
PASCAL-a) sa begin i end:

Primjer sekvence u C-u:

{
broj_1=9;
broj_2=6;
proizvod=broj_1*broj_2;
cout<<proizvod<<endl;
}

Slika 17. Strukture izbora (selekcija) u C++ jeziku

C++ obezbjeđuje 3 tipa struktura (iskaza) izbora:

1. Jednostruki izbor (if iskaz) izvršava akciju ako je uslov ispunjen, ili u suprotnomje
preskače. Ova struktura je poznata i kao opcija.
2. Izbor jedne od dvije akcije (if…else iskaz), izvršava jednu akciju ako je uslov tačan, inače
ako je netačan izvršava drugu. Ova struktura je poznata i kao alternativa.

65
 3. Višestruki izbor (switch iskaz) izvršava jednu od više različitih akcija u zavisnosti od
vrijednosti uslova (izraza). Ova struktura se naziva još i varijanta.

9.2. If iskaz izbora

Programi koriste strukturu selekcije za izbor izvršenja ili neizvršenja akcije. Blok dijagram
jednostrukog izbora u slučaju da je Uslov U tačan (slika 18a), pokazuje da se nakon toga izvodi
akcija A. Ukoliko Uslov U nije tačan, akcija A se preskače (ne izvršava), a izvođenje programa se
nastavlja izvođenjem prve naredbe, koja slijedi nakon akcije A.
U drugoj varijanti, kada je Uslov U netačan, izvodi se akcija A, a kada je tačan, preskače se
izvođenje akcije A (slika 18b).

Slika 18. a) If iskaz izbora, kada je uslov tačan b) If iskaz izbora, kada uslov nije tačan

Opšti format if naredbe izgleda ovako:

If (izraz)
naredba_1;

Izraz može biti uslov ili logički izraz, a naredba_1 predstavlja neku akciju (iskaz) ili niz akcija
(skaza), koje tada predstavljaju blok naredbi, koje u tom slučaju moraju biti unutar (između)
vitičastih zagrada na 2 načina, kao u primjeru ispod.

66
 if (izraz) { naredba_1; naredba_2; … naredba_n} if (izraz)
{
naredba_1;
naredba_2;
…
naredba_n;
}

Tabela 23. Primjer upotrebe if naredbe

U sljedećem primjeru, kojim ilustrujemo upotrebu if strukture izbora (opcije), zadatak

koji program treba da riješi jeste prebrojavanje osoba muškog pola. Pretpostavimo da je simbol
za ženske osobe 1, a za muške 2. Pseudo kod za rješenje jednog takvog zadatka bi bio sljedeći:

If The_sex_of_the_person is equal 2,
add 1 to male_counter.
(Ako je pol_osobe jednak 2,
povećaj za 1 brojač_muških_osoba.)

To znači, da if naredba ispituje uslov (pol_osobe = 2), pa ukoliko je uslov tačan, povećava
za 1 brojač muških osoba, a ukoliko nije tačan neće ništa uraditi.

Ovo se u C++ jeziku može napisati:

If (pol_osobe==2)
male_counter=male_counter + 1;

Na slici 19 uz pomoć UML dijagrama aktivnosti, prikazano je izvršavanje if iskaza. Simbol

odluke je u obliku romba. Odluka se zasniva na osnovu uslova pol_osobe==2. Uslov se ispisuje
na strelicama tranzicije.

67
 Slika 19. UML dijagram aktivnosti za primjer ilustracije if iskaza

Ukoliko program, poslije zadovoljenog uslova treba da izvrši više od jednog iskaza (dva ili
više iskaza ili složeni iskaz), svi oni moraju biti unutar vitičastih zagrada. To bi izgledalo ovako:

If (pol_osobe==2)
{
male_counter=male_counter + 1;
cout << “Broj osoba muškog pola je: “<< male_counter;
}

Slika 20a. Primjer upotrebe složenog iskaza nakon ispunjenog uslova u if naredbi

68
 Slika 20b. Rezultat upotrebe složenog iskaza nakon ispunjenog uslova u if naredbi

Iz primjera se vidi da će u slučaju ispunjenog uslova (pol_osobe==2) program izvršiti 2

akcije, odnosno dva iskaza. Ukoliko bi se greškom izostavile vitičaste zagrade, tada bi se i u slučaju
kada je pol_osobe !=2 (različit od 2), ispisao literal “Broj osoba muškog pola: “ na ekranu i nakon
toga vrijednost varijable male_counter, koja bi u ovom slučaju bila 7.
Struktura jednostruke selekcije je najčešće upotrebljavana kontrolna struktura. Jedan od važnijih
razloga široke upotrebe ove strukture jeste jednostavnost korišćenja relacionih operatora, koji
su sastavni dio izraza kojim se testira uslov u if naredbi. Kao što je već rečeno u dijelu knjige o
operatorima, relacioni operatori predstavljaju svojevrsne funkcije, koje vraćaju vrijednost
logičkog tipa, a te vrijednosti mogu biti samo 0 (kada uslov nije ispunjen) ili 1 (kada je uslov
ispunjen).

9.3. Struktura selekcije if...else

Koristeći if jednostruki izbor (opciju) programer može izabrati da program ili izvrši neku
akciju ili da je ne izvrši. Za razliku od nje, if...else struktura izbora omogućava programeru da
specificira akciju ili akcije koje treba izvršiti ukoliko je uslov tačan, a u isto vrijeme da odredi koju
akciju ili akcije treba izvršiti ukoliko uslov nije tačan. Opšti format if … else strukture i njen
pesudokod, prikazani su u tabeli 24.

Opšti format Pseudokod

If (izraz) Ako je Uslov U tačan
naredba_1; izvedi akciju A1,
else inače
naredba_2; Izvedi akciju A2.

Tabela 24. Opšti format if … else strukture i njen pseudokod

69
 Na slici 21, prikazan je blok dijagram if … else naredbe.

Slika 21. Grafički prikaz if … else naredbe

U konkretnom primjeru if … else strukture, pseudo kod bi izgledao ovako:

If The_sex_of_the_person is equal 2,
add 1 to male_counter
else
add 1 to female_counter.

Ukoliko je uslov tačan, potrebno je povećati za 1 brojač osoba muškog pola, a ukoliko nije
tačan, treba povećati za 1 brojač osoba ženskog pola. Odgovarajući kod u C++ jeziku bi izgledao
ovako:

If (pol_osobe==2)
male_counter=male_counter + 1;
else
female_conter=female_counter + 1;

70
 Slika 22. UML dijagram aktivnosti za primjer koji ilustruje if … else strukturu

Ako posmatramo opšti format if … else strukture, onda umjesto iskaza naredba_1 i/ili naredba_2,
može da stoji više iskaza (složeni iskaz) ili blok, koji se sastoji od niza jednostavnih iskaza, koji se
u tom slučaju moraju nalaziti unutar vitičastih zagrada {}. To se može ilustrovati sljedećim
primjerom:

If (pol_osobe==2)
{
male_counter=male_counter + 1;
cout<<” Broj osoba muskog pola: “<<male_counter;
}
else
{
female_conter=female_counter + 1;
cout<<” Broj osoba zenskog pola: “<<female_counter;
}

71
Slika 23. Primjer upotrebe blokla naredbi unutar vitičastih zagrada iza ključne riječi else

U slučaju kada se koriste zagrade iza else, program će raditi ispravno, odnosno izvršiti
oba iskaza u zagradama i prikazati izgled ekrana kao na slici 23. U slučaju kada je pol_osobe
jednak 1, a iza else se ne koriste vitičaste zagrade, izgled ekrana nakon izvršenja programa će biti
isti. Međutim, ukoliko u prethodnom primjeru, umjesto naredbe int pol_osobe=1;, napišemo
naredbu int pol_osobe=2; i pozovemo program u rad, dobićemo sljedeći izgled ekrana kao na
slici 23a.

72
 Slika 23a. Rezultat rada programa sa promijenjenom opcijom (pol_osobe=2)

što na prvi pogled ne izgleda nelogično, ali kada se pogleda, koji je zadatak programa [prikazuje
na ekranu ukupan broj muških osoba, kada je pol osobe muški (vrijednost 2) i ukupan broj ženskih
osoba, kada je pol osobe ženski (vrijednost 1)], tada program greškom prikazuje jednu liniju viška.
Radi se o logičkoj grešci u programu.

9.4. Struktura selekcije višestruki izbor (switch)

Kao što je već rečeno, ova struktura selekcije izvršava jednu od više različitih akcija u
zavisnosti od vrijednosti uslova (izraza), odnosno bira jedna od više mogućnosti (varijanti) izbora.
Opšti format switch strukture izgleda ovako:

switch (izraz)
{
case vrijednost_1:
iskaz_1;
break;
case vrijednost_2:
iskaz_2;
break;
.
.
.
case vrijednost_n:
iskaz_n;
break;
default:
default iskaz;
break;
}

uz napomenu da se prvo izračunava izraz, koji može biti cjelobrojni izraz i davati cjelobrojni
rezultat ili karakter izraz i davati karakter rezultat, zatim iskaz_1, iskaz_2, … iskaz_n, mogu biti

73
jednostavni ili složeni iskazi (odnosno blokovi prostih iskaza, koji se moraju pisati unutar vitičastih
zagrada), a vrijednost_1, vrijednost_2, pa sve do vrijednost_n, predstavljaju ili neku konstantu ili
cijeli broj.
Vrijednost izraza iza ključne riječi switch se poredi sa vrijednostima navedenim iza
ključne riječi case. Ukoliko je bilo koje od tih poređenja tačno (na osnovu jednakih vrijednosti
izraza i specificirane vrijednosti iza case), tada se izvršava iskaz koji je pridružen toj vrijednosti
izraza i izvodi break iskaz, te time završava switch naredba i počinje se izvoditi prva naredba iza
switch naredbe. Ukoliko vrijednost izraza i specificirana vrijednost iza case nisu jednake,
provjeravanje, odnosno evaluacija se nastavlja sa sljedećom vrijednošću specificiranom iza
ključne riječi case. Ukoliko se testiranjem eksplicitno ustanovi da nijedna vrijednost izraza ne
odgovara vrijednostima navedenim u case varijantama, tada se izvršava default iskaz.

74
Na slici 24, dat je blok dijagram switch strukture izbora.

Slika 24. Blok dijagram switch strukture izbora

75
 Ako je u switch strukturi selekcije za dvije ili više varijanti predviđeno izvođenje istog
iskaza ili bloka naredbi, tada je potrebno nabrajati case iskaze sa pripadajućim vrijednostima i
odvajati ih dvotačkom. Npr. za određeni dan u sedmici, koji će se ukucati sa tastature, program
treba da prikaže radno vrijeme za taj dan.

Slika 25. Primjer upotrebe switch strukture izbora sa izvođenjem istog iskaza za više varijanti

76
U prethodnom primjeru (slika 19) switch struktura izbora se koristi tako da za više varijanti ( 5
radnih dana u sedmici ), program izvrši isti iskaz ili blok iskaza (prikaz na ekranu poruke: “Radno
vrijeme je: od 8:00 do 16:00”), a za drugu varijantu (6. dan u sedmici) prikaže drugu poruku:
“Radno vrijeme je: od 8:00 do 16:00” i za treću varijantu (7. dan u sedmici) prikaže poruku:
“Neradni dan”.

Slika 26. Ilustracija ugnježdene if naredbe za računanje ocjene na osnovu ukupnog broja bodova

77
 Ovaj program će biti modifikovan radi još jedne ilustracije switch-case strukture izbora.
umjesto redova 27 I 28, biće ubačen sljedeći kod:

Slika 27. Program za ilustraciju svitch-case strukture izbora

10. STRUKTURE PONAVLJANJA (REPETICIJE)

Strukture ponavljanja se odnose na situacije prilikom programiranja kada je potrebno više

puta primjeniti, odnosno izvoditi (ponavljati) jednu ili više akcija. Ovo ponavljanje se može
izvoditi konačan broj puta ili beskonačan broj puta. Neograničeno ponavljanje, odnosno
beskonačna petlja nije u skladu sa definicijom algoritma, koji se definiše kao postupak rješenja
78
problema, koji sadrži konačan broj akcija, pa zbog toga predstavlja neprihvatljivu strukturu za
upotrebu u strukturiranom programiranju. Definisanje konačnog broja ponavljanja jedne ili više
akcija (naredbi) u programskoj strukturi, ostvaruje se na jedan od dva načina:

a) brojanjem ciklusa ponavljanja do zadanog broja i

b) testiranjem uslova.

Da bi počelo odbrojavanje ciklusa ponavljanja strukture, koja se ponavlja, mora se

unaprijed definisati broj ponavljanja na jedan od slijedećih načina:

a) definisanjem konačnog skupa vrijednosti kontrolne promjenljive pojedinačnim

navođenjem njihovih vrijednosti.
b) definisanjem raspona (početne i krajnje vrijednosti, te koraka promjene, odnosno
skoka) kontrolne varijable.

Evaluacija uslova se vrši tako što se uslov definiše koristeći relacione operatore tako da
njegova provjera daje samo jedan od rezultata: tačno (true) ili netačno (false), a ponavljanje se
vrši dok god je uslov tačan.
Strukture ponavljanja (repeticije) često nazivamo petlje. Postoje 3 različite vrste petlji:

1. WHILE DO petlja
2. DO WHILE petlja
3. FOR petlja

10.1. Petlja while do

WHILE DO je naziv za strukturu ponavljanja, odnosno komanda kojom se realizuje

ponavljanje izvođenja jedne ili više akcija određeni broj puta. Ono po čemu je ova petlja
karakteristična jeste to da broj ciklusa ponavljanja nije unaprijed poznat, nego zavisi od istinitosti
uslova za ulazak u petlju. Drugačije rečeno, kada ne znamo da li će se pri svakom pokretanju
while-do petlje, ona izvršiti jednom, dva puta ili neki drugi broj puta ili možda nijednom. Iako je
češći slučaj da se while-do petlja koristi kada nije unaprijed poznat broj ponavljanja, ova petlja se
može koristiti i kada je broj ponavljanja poznat. Iz prevoda naziva strukture sa engleskog jezika,
jasno je da će se ponavljanje jedne ili niza akcija vršiti sve dok je uslov tačan ili drugačije rečeno
sve do trenutka, kada uslov postaje netačan.

79
 Slika 28. Grafički prikaz toka izvršavanja while do petlje

Prvi korak kod izvođenja while do petlje jeste testiranje istinitosti uslova. Uslov se mora
provjeravati svaki put prije nego što se pristupi izvršenju akcije A. Ukoliko je uslov ispunjen
(istinit, tačan ili true) to se manifestuje vraćanjem broja 1 u varijablu logičkog tipa podataka
nadležnu za provjeru istinitosti uslova, pa se tek tada izršava akcija A, koja može biti jedan ili više
iskaza. Izvršavanje akcije A se ponavlja sve dok je uslov ispunjen. Kada uslov postane netačan,
program “iskače” iz petlje, a izvođenje se nastavlja prvom naredbom, koja slijedi iza petlje.
Redoslijed izvršavanja koraka u while do petlji, može se opisati i na sljedeći način:

1. Provjeravanje istinitosti logičkog izraza, odnosno uslova U, odnosno uslova za ulazak

i ponavljanje petlje
2. Ako je rezultat jednak logičkoj neistini (uslov U nije ispunjen), preskače se akcija A i
program se nastavlja od prve naredbe iza koda petlje
3. Ako je rezultat jednak logičkoj istini (uslov U ispunjen), izvodi se akcija A. Zatim se
program vraća na novo provjeravanje uslova U (tačka 1).

80
 While do struktura ne garantuje konačan broj ponavljanja akcije A, pa zbog toga treba
obratiti posebnu pažnju na uslov, koji u jednom trenutku mora postati netačan, da bi se završilo
izvođenje petlje. Ako je prije prvog izvršenja akcije A uslov tačan, a akcijom A se ne mijenja uslov,
odnosno akcija A nema uticaja na uslov, onda se ulazi u ponavljanje akcije A neograničen broja
puta, čime “ulazimo” u beskonačnu petlju, što nije prihvatljivo sa stanovišta definicije algoritma.
U suprotnom, ukoliko je uslov pri prvoj provjeri neistinit (vraća 0) akcija A se neće nijednom
izvršiti, što znači da se iz petlje “iskače” prije nego što je ona uspostavljena i nastavlja izvođenje
prve naredbe, koja slijedi iza koda za definisanje petlje.

Opšti formati while do strukture su:

while (uslov) while (uslov) naredba_1;

naredba_1;
while (uslov) while (uslov) {
{ naredba_1;
naredba_1; naredba_2;
naredba_2; …
… naredba_n;}
naredba_n;
}

Tabela 25. Opšti formati while do strukture

Ovdje treba napomenuti, kao što je i vidljivo iz sintakse while-do petlje, gdje se koristi
samo ključna riječ while, ali ne i ključna riječ do, iako smo kao naziv za ovu strukturu ponavljanja
koristili dvije riječi while do. Za to postoje dva razloga:

1. Korišćenje ove iste strukture ponavljanja u nekim drugim programskim jezicima pod
nazivom while do.
2. Lakše razlikovanje ove strukture od strukture do while.

Sljedeći primjer, ilustruje primjenu while do strukture: Zadatak, koji je potrebno riješiti u ovom
primjeru odnosi se na izračunavanje i prikaz na ekranu zbira brojeva od 1 pa do nekog broja koji
je potrebno unijeti sa tastature. Kod programa je prikazan na slici 23.

81
Slika 29. C++ program, koji rješava zadatak uz pomoć while do strukture.

Najčešće greške, koje prave programeri, koristeći ovu strukturu su:

1. Uslov prije ulaska u petlju nije na očekivanoj vrijednosti, što znači da je bilo potrebno
inicijalizirali varijablu i na 1. Da to nije učinjeno, bila je moguća varijanta da se petlja

82
 nikada ne izvrši ili da se izvrši određeni broj puta, koji nije jednak broju unesenom sa
tastature (u slučaju da nije incijalizirana, varijabla i ima neku nedefinisanu vrijednost,
koja se preuzima iz memorije računara na kojem se izvršava program)
2. Da je upisan znak ; (tačka-zarez) iza while (uslov) iskaza,

while ( i<broj+1);
{
zbir=zbir+i;
i++;
}

dobili bismo beskonačnu petlju jer će se stalno provjeravati da li je tačan uslov: (i < broj
+ 1), a on će stalno biti tačan jer je i = 1, a 1 < od unesenog broja).
3. Ukoliko se zaboravi uticati na uslov unutar tijela while do petlje, odnosno u
konkretnom slučaju kada se izostavi iskaz i++. I na ovaj način se dobije beskonačna
petlja, jer se ne mijenja vrijednost varijable i.
4. Ukoliko se zaboravi iskaze koji pripadaju while petlji (složeni iskaz) staviti u vitičaste
zagrade, tako da čine blok.

while ( i<broj+1);

zbir=zbir+i;
i++;

I na ovaj način se dobije beskonačna petlja, jer u tijelo petlje ne bi ulazila naredba i++, pa
se varijabla i ne bi mijenjala. Ukoliko se zamijene iskazi i++ i zbir=zbir+i, dobila bi se petlja koja
ne bi radila ono što se od nje očekuje, odnosno ne bi ispravno riješila problem.

10.2. Petlja do while

Druga vrsta strukture ponavljanja, odnosno drugi način realizacije ponavljanja akcije A,
jeste provjera tačnosti uslova za ponavljanje nakon izvršenja akcije A. Petlja do while isto kao i
petlja while do, koristi se kada broj ponavljanja neke akcije ili akcija nije unaprijed poznat, ali
za razliku od for i while petlje ovdje se akcija ili blok akcija izvrši bar jednom. Osnovna razlika
između ove strukture u odnosu na while do i for petlje, jeste to što se kod ove petlje prvo izvrši
naredba ili više njih, pa se zatim provjerava uslov, a kod for i while petlje se prvo provjerava
uslov, pa se zatim izvršava naredbe ili više njih, koje se ponavljaju.

83
 Ukoliko uslov nije ispunjen, ponavlja se izvršenje akcije A, a zatim ponovo provjerava
uslov. Ako je uslov zadovoljen ne vrši se novi ciklus ponavljanja, nego se “iskače” iz strukture kao
što je i prikazano na slici 30. Negacijom uslova može se postići suprotno. I ova struktura repeticije
nosi sa sobom opasnost neograničenog ponavljanja. Ukoliko akcija A nema uticaj na vrijednost
uslova U, onda će se desiti jedna od dvije mogućnosti:

a) Akcija A ili niz akcija će se izvršti samo jednom i to u slučaju da je uslov ispunjen prije
ulaska u ponavljajuću strukturu ili će doći do
b) Beskonačnog ponavljanja, odnosno ponavljanja neograničen broj puta i ulaska u
beskonačnu petlju, ukoliko uslov nije ispunjen.

Čak i kada se akcijom A mijenja istinitost uslova, neophodno je da ta promjena bude takva
da u željenom trenutku uslov dobije vrijednost istinito, da bi se izašlo iz petlje i izvođenje
programa nastavilo izvođenjem prve naredbe iza do while petlje.

Slika 30. Grafički prikaz toka izvršavanja do while petlje

84
Opšti formati do while strukture su:

do do naredba_1; while (uslov);

naredba_1;
while (uslov);
do do {naredba_1;
{ naredba_2;
naredba_1; …
naredba_2; naredba_n;} while (uslov);
…
naredba_n;
}
while (uslov);

Tabela 26. Opšti formati do while strukture

Slika 31. C++ program, koji rješava prethodni zadatak uz pomoć do while strukture

85
 10.3. Petlja for

Ciklusi ili iteracije naredbi, koje se ponavljaju predstavljaju kontrolne strukture, koje se
nazivaju petlje. Prema načinu određivanja broja iteracija, odnosno broja ponavljanja određenih
naredbi, koje čine tijelo petlje, petlje se mogu podijeliti na:

1. petlje koje ponavljaju određene naredbe sve dok je neki uslov tačan (while do)
2. petlje koje ponavljaju određene naredbe sve dok je neki uslov netačan (do while) i
3. petlje sa unaprijed poznatim brojem ponavljanja ili petlje brojanja (for petlje)

Kada je unaprijed poznat broj ponavljanja neke naredbe ili niza naredbi, a to je često
slučaj kod rješavanja velikog broja problema, koji se mogu rješavati uz pomoć kompjuterskog
programiranja, koriste se for petlje.
Pošto ima više načina univerzalnog objašnjenja funkcionisanja petlji, ovdje navodimo
jedan od tih načina, koji se čini najinformativnijim:

int i; // indeks petlje //

int low, high; // limiti petlje //
i=low; // inicijalizacija indeksa petlje na najnižu vrijednost//
while ( i<=high ) // izračunavanje “exit” (izlaznog) izraza /
{
naredba_1;
naredba_2;
…
naredba_n;
i++; // increment indeksa i //
}

86
Opšti formati for petlje u C++ jeziku se mogu predstaviti na sljedeći način:

1. for ( inicijalni_izraz; izraz_uslov; izraz_korak ) naredba_1;

2. for ( inicijalni_izraz; izraz_uslov; izraz_korak)
naredba_1;
3. for ( inicijalni_izraz; izraz_uslov; izraz_korak)
{
naredba_1;
naredba_2;
…..
naredba_n;
}
4. for ( inicijalni_izraz; izraz_uslov; izraz_korak) {
naredba_1;
naredba_2;
…..
naredba_n;}

Tabela 27. Opšti formati for petlje

Sva tri izraza u for petlji ( inicijalni_izraz; izraz_uslov; izraz_korak ) su opcionalna, što
znači da nijedan nije obavezan. Tijelo for petlje se može izvršiti više puta, a ne mora nijednom,
odnosno tijelo petlje će se izvršavati sve dok izraz-uslov ne postane netačan. Inicijalni_izraz i
izraz_korak u kontrolnom dijelu for petlje su izrazi koji služe za inicijalizaciju i promjenu
vrijednosti za vrijeme izvršenja for petlje.
Često je varijabla koja kontroliše for petlju (sastavni dio izraza_uslov) potrebna i koristi
se samo unutar petlje. Zbog toga se ona najčešće i deklariše u dijelu for petlje, zaduženom za
inicijalizaciju (inicijalni_izraz). Veoma je važno znati da je u tom slučaju domen važenja kontrolne
varijable (scope) samo for petlja, te da ona izvan nje nije vidljiva.?
Prvi korak u izvršenju for petlje je izvođenje izraza inicijalni_izraz (ukoliko nije
izostavljen). Zatim se vrši testiranje istinitosti izraza_uslov sa tri moguća rezultata:

1. Ukoliko je izraz_uslov istinit (nije nula) izvodi se tijelo petlje, a zatim se izvršava
izraz_korak (ako je naveden). Proces se zatim ponavlja uz provjeru istinitosti
izraza_uslov.

87
 2. Ukoliko je izraz_uslov preskočen, smatra se da je on istinit, pa se izvršavanja nastavlja
kako je opisano pod tačkom 1. Ako for petlja nema izraz_uslov, kraj izvršenja petlje se
može postići samo izvršenjem break, goto ili return iskaza u tijelu petlje.
3. Ukoliko je izraz_uslov netačan, izvršenje for petlje se završava i kontrola prelazi na prvu
slijedeću naredbu u programu.

Često je varijabla koja kontroliše for petlju (sastavni dio izraza_uslov) potrebna i koristi
se samo unutar petlje. Zbog toga se ona najčešće i deklariše u dijelu for petlje, zaduženom za
inicijalizaciju (inicijalni_izraz). Veoma je važno znati da je u tom slučaju domen važenja kontrolne
varijable (scope) samo for petlja, te da ona izvan nje nije vidljiva.
Prekid izvršenja for petlje se može postići iskazima break, goto ili return, čak i kada je naveden
izraz_ uslov u njenom kontrolnom dijelu.
Na primjeru zadatka, kojim je ilustrovana upotreba while do i do while petlje, a odnosi se na
izračunavanje i prikaz na ekranu zbira brojeva od 1 pa do nekog broja koji je potrebno unijeti sa
tastature, ilustrovaćemo i upotrebu for petlje (slika 32).

Slika 32. Primjer upotrebe for petlje za rješavanje zadatka računanja zbira brojeva od 1 do nekog
broja između 1 i 100, koji se unosi sa tastature

Rezultati rada programa će biti potpuno isti kao kada se koristi while do ili do while
struktura slika 29). Za ilustraciju sve 3 petlje, korišten je isti primjer, tako da se lakše mogu uočiti
sličnosti i razlike između njih.

88
 Prilikom upotrebe for petlji, najčešće se prave sljedeće greške:

1. Izostanak inicijaliziranja početne vrijednosti indeksa (brojača) petlje (u prethodnom

primjeru – izostanak iskaza “i=1”
2. Izraz_uslov nije dobro postavljen – u prethodnom primjeru “i<(uneseni_broj + 1)”
3. Izostavljen izraz_korak, koji utiče na indeks (brojač) petlje – u primjeru “i++”
4. Znak ; (tačkazarez) upisan iza for petlje

Primjer posljednje nabrojane greške:

for (i=1, zbir=0; i<11;i++);// Program koji daje zbir brojeva od 1 do 10

{
zbir=zbir+i;
cout <<“Zbir brojeva od 1 do 10 je: ” << zbir;
}

Kompajliranje programa neće otkriti grešku u sintaksi, ali iskazi

{
zbir=zbir+i;
cout <<“Zbir brojeva od 1 do 10 je: ” << zbir;
}

bi se izvršili samo jednom.

Važno je zapamtiti da se izraz_uslov u kontrolnom dijelu petlje uvijek provjerava prije

ulaska u petlju. To znači da se tijelo for petlje neće izvršiti nijednom ako je vrijednost kontrolnog
izraza na početku false.

for (int counter=9; counter<6; counter++)

cout<<counter; // Ovako napisanim kodom, ova naredba se nijednom neće izvršiti

Tijelo ove petlje, koje se sastoji od samo jedne naredbe, neće se izvršiti nijednom, jer je
vrijednost njene kontrolne promjenljive counter veća od 6 kada se prvi put uđe u petlju.
Izraz_uslov (counter<6) vraća vrijednost false, jer je netačno da je 9 < 6, a kada je uslov ulaska u
petlju netačan, onda se ne izvršava tijelo petlje, a izvođenje programa nastavlja prvom
naredbom, koja slijedi poslije koda petlje.

89
 Zbog velikog broja mogućih varijacija, for petlja je jedna od najčešće upotrebljavanih i
najkorisnijih naredbi u C++ jeziku. Npr. kontrolna linija for petlje omogućava upotrebu više
kontrolnih varijabli:

Int n, m;
for (n=0, m=9, n =< m; ++n, --m)
cout<<n<<” “<<m<<endl;

U ovom primjeru postoje dva izraza za inicijalizaciju (dva inicijalna_izraza), odvojena

zarezom, i dva izraza za inkrementaciju (dva izraza_korak), odvojene zarezom. Oni moraju biti
odvojeni zarezom, da bi kompajler “znao” da se radi o dva inicijalna i dva inkrementalna izraza.
Primjer cijelog programa i rezultat izvođenja programa su prikazani na slici 33.

Slika 33. Primjer upotrebe dva inicijalna inkrementalna i dva izraza u jednoj for petlji

Kao što je već rečeno na početku priče o for petlji, za razliku od ostalih programskih jezika,
C++ jezik omogućava da se svaki od izraza u kontrolnoj liniji for petlje može a i ne mora
upotrijebiti. Slijedi primjer for petlje bez inkrementa (slika 34):

90
 Slika 34. Primjer for petlje bez inkrementa

U ovom primjeru, izostavljen je inkrement, odnosno izraz_korak. Prije nego što se izvede
tijelo petlje, svaki put se provjerava da li kontrolna promjenljiva (iz izraza_uslov) ima vrijednost
999. Praktično se radi o beskonačnoj petlji iz koje se izlazi kada se sa tastature ukuca broj 999,
jer tada će rezultat poređenja u izrazu uslov biti odgovor na pitanje: da li je tačno da 999 nije
jednako 999? Taj odgovor će biti netačno ili false. Upravo to je uslov za izlazak iz petlje.
Još jedan primjer različitog načina upotrebe for petlje, odnosi se na mogućnost da se
inicijalni_izraz izmjesti izvan for petlje (slika 35).
U ovom primjeru je inicijalni_izraz izostavljen iz kontrolne linije petlje, odnosno izmješten
izvan tijela petlje. Najčešće se ovo izmještanje radi onda kada je inicijalna vrijednost rezultat nego
računanja u programu i nema veze sa tijelom petlje. Ovim primjerom se ilustruje i izostavljanje
izraza_korak (inkrementa) iz kontrolne linije u tijelo petlje (x++).

91
Slika 35. Varijacija upotrebe for petlje sa izmještanjem inicijalnog izraza izvan petlje

Kada govorimo o varijacijama for petlje, navešćemo još dva primjera. Prvi primjer se
odnosi na mogućnost da for petlja nema ni tijelo petlje, nego samo kontrolnu liniju. Ovom
varijacijom for petlje možemo riješiti i već često eksploatisani zadatak prikaaza zbira brojeva od
1 do 10. Osnovni dio koda bi izgledao ovako:

Slika 36a. Primjer upotrebe for petlje bez tijela petlje

92
 Slika 36b. Primjer upotrebe for petlje bez tijela petlje

Da bi primjer bio razumljiviji, koristićemo prikaz vrijednosti varijabli i izraza po ciklusima

izvođenja (Tabela 28)

Broj ciklusa x broj Izraz_uslov Izraz_korak

x<10 broj=broj+(++x)
1. 0 0 0<10 1
2. 1 1 1<10 3
3. 2 3 2<10 6
4. 3 6 3<10 10
5. 4 10 4<10 15
6. 5 15 5<10 21
…
10. 9 45 9<10 55
11. 10 55 10=10 (exit)

Tabela 28. Prikaz vrijednosti kontrolne varijable i izraza for petlje po iteracijama

Kao izraz_koraku primjeru se koristi izraz: broj=broj+(++x), a se može napisati i na drugi

način, odnosno kao: broj=broj+ ++x ili broj+=++x.
I na kraju, drugi primjer, kojim se želi pokazati kako se uz pomoć for petlje najjednostavnije može
napraviti beskonačna petlja. Dovoljna je samo jedna linija koda:

for (;;) {}.

11. NAREDBE ZA PROMJENU TOKA IZVRŠAVANJA PETLJI

Bez obzira što su petlje takve programske strukture, koje putem vrijednosti kontrolne
varijable, odnosno izaza_uslov, mogu upravljati ulaskom u petlju (ponavljanje tijela petlje),
trajanjem petlje (brojem ponavljanja naredbi tijela petlje) te izlaskom iz petlje, u C++ jeziku
postoje i posebne naredbe, koje nisu sastavni dio strukture ponavljanja, uz pomoć kojih je to isto
omogućeno. To su naredbe continue, break, return i goto.

93
 11.1. Naredba continue

Naredba continue prekida izvođenje naredbi u tijelu petlje i preusmjerava kontrolu programa na
slijedeći ciklus ponavljanja kod while do, do while ili for petlje, zaobilazeći na taj način ostale
naredbe u tijelu tih petlji. Unutar while do i do while petlje, sljedeća iteracija počinje sa novim
testiranjem na istinitost uslova petlje (u prvom slučaju prije, a u drugom nakon izvršenja tijela
petlje), a unutar for petlje, slijedeća iteracija počinje sa evaluacijom izraza_uslov u kontrolnoj
liniji te petlje. Jednostavnije rečeno, naredba continue dovodi do skoka programa na kraj
petlje, ali se nakon toga njeno ponavljanje nastavlja. Primjer upotrebe naredbe continue,
prikazan je na slici (37). Radi se o zadatku izračunavanja i prikaza kvadrata dvocifrenih brojeva.

Slika 37. Primjer upotrebe continue naredbe

94
 Na ovom primjeru ćemo usput objasniti još dvije stvari: operator smanjenja vrijednosti
varijable za 1 kao sufiks i upotreba while do petlje bez naredbe za inkrement ili dekrement u
tijelu while do petlje. Kako radi program sa slike 31? Redovi 6 i 7 u programu deklarišu varijable
i, broj, te kvadrat_broja kao integer varijable. Pri tome je varijablu i potrebno inicijalizirati,
odnosno dati joj početnu vrijednost (u ovom slučaju to je vrijednost 1). Ovaj program ne bi radio
da je početna vrijednost varijable i 0. Zašto? Zato što izraz i— prvo uzima početnu vrijednost
varijable i, a to je 0 i poredi da li je 0>0, da bi se izračunao izraz uslov (i-- >0) iza while ključne
riječi. Pošto 0 nije veća 0, nego je jednaka, izraz uslov je netačan (false), a kada je ovaj uslov
netačan izlazi se iz petlje, odnosno završava se izvođenje petlje a da nije izvršena nijedna naredba
u tijelu petlje. Tek nakon izlaska iz petlje vrijednost varijable i (zbog sufiksa) se povećava za 1 i
iznosi 1.
Ako je inicijalna vrijednost varijable i jednaka 1 (kao što je u programu), kada se
izračunava (testira) izraz uslov (i-- >0), poredi se da li je 1>0 i dobiva rezultat tačno (true), te
izvodi prva naredba u tijelu petlje (linija 13), koja na ekranu prikazuje tekst “Unesite dvocifreni
broj: ”. Zatim se sa tastature unosi dvocifreni broj i nakon pritiska na taster “Enter”, taj unos
postaje sadržaj varijable broj. Linija 15 i 16 uz pomoć if naredbe (struktura pod nazivom opcija)
provjerava da li je uneseni broj veći od 99, što znači da ukoliko se sa tastature unese broj 100 ili
veći (trocifreni brojevi), prekida se izvođenje tijela petlje zbog upotrebe continue naredbe i ide
se u drugu iteraciju (ciklus ponavljanja), a pri tome se preskaču sve naredbe u tijelu petlje do prve
pojave znaka } ili zatvorene vitičaste zagrade, koja označava kraj tijela petlje. U ovom slučaju to
su linije 17, 18 i 19. Nakon toga izvođenje programa se nastavlja 2. iteracijom, odnosno novom
provjerom istinitosti izraza uslov. Sada je Izraz uslov netačan (false), jer je vrijednost varijable
sada = 0, a logička vrijednost izraza i-- >0 je netačno (false), pa se prekida izvođenje petlje i
nastavlja izvođenjem prve naredbe nakon tijela petlje, a to je naredba return 0, koja znači kraj
programa.
Ukoliko se sa tastature unese broj manji od 99 ili 99, rezultat poređenja u uslovu iza if
naredbe je netačno (false), jer uneseni broj npr. 45 nije veći 99. Tada se izvodi linija 17. U 17.
liniji programa izračunava se kvadrat_broja, kao proizvod dvije iste vrijednosti unesenog broja,
a u 19. liniji se prikazuje vrijednost (sadržaj) varijable kvadrat_broja.
Na kraju, treba primjetiti da se u ovom primjeru naredba continue koristi za prekid izvođenja
tijela petlje, preskaču neke naredbe u tijelu petlje i nastavlja izvođenje programa sa 2. iteracijom.
Ali pošto provjera uslova u drugoj iteraciji daje rezultat netačno (false), završava se izvođenje ne
samo petlje nego i cijelog programa, što najčešće nije slučaj kod upotrebe continue naredbe.
Najčešće se dešava da se program nastavlja sa drugom, trećom itd. iteracijom i završi tek kada
izraz uslov postane netačan. Sljedeći primjer (slika 38) to ilustruje.

95
Slika 38. Primjer upotrebe continue naredbe sa više iteracija

Na slici 38. je prikazan primjer programa, koji ponavlja prikaz poruke na ekranu za unos
dvocifrenog broja i nakon unosa tog broja, prikaz izračunatog kvadrata tog broja. Dvije prve
iteracije se odnose na brojeve 16 i 99, a treća iteracija je prekinuta continue naredbom, jer je
uslov u if naredbi tijela petlje bio tačan (broj>99, odnosno uneseni broj 100 je veći od 99), pa se
izvršila continue naredba, a to znači da je prekinuto izvođenje tijela petlje u trećoj iteraciji,
odnosno preskočen prikaz (nije prikazan) kvadrata broja 100, nego se izvođenje programa
nastavilo izvođenjem 4. iteracije, pa 5. itd. Treba primjetiti da se program nalazi u beskonačnoj
petlji iz koje nije moguće izaći continue naredbom, koja ima funkciju da prekida izvođenje tekuće
iteracije i izvođenje programa nastavlja narednom iteracijom.

96
 11.2. Naredba break

Break naredba se koristi samo u switch strukturi izbora i u svim strukturama ponavljanja.
Svojim pojavljivanjem u tim strukturama, prekida izvođenje, odnosno dovodi do izlaska iz do
while, while do i for petlje, te switch strukture izbora. Nakon izvršenja break naredbe, kontrola
programa se prenosi na naredbu koja slijedi iza prekinute strukture (petlje ili switch strukture).
Break naredba se ne može koristiti izvan struktura ponavljanja (while do, do while i for) niti izvan
strukture višestrukog izbora (switch).
Ukoliko se naredba break koristi unutar ugniježdene (unutarnje) petlje, prekinuće
izvođenje samo te petlje i nastaviti izvođenje petlje vanjske petlje. Naredba break se najčešće
koristi za prekid izvođenja (izlazak iz) beskonačnih struktura ponavljanja. Uz naredbu goto i
return, predstavlja jedan od 3 moguća načina izlaska iz beskonačne petlje.
Na sljedećem primjeru, pokazaćemo jedan od najčešćih načina upotrebe break naredbe
(slika 39).

Slika 39. Primjer upotrebe i poređenja continue i break naredbe

97
 Ovaj isti primjer bez upotrebe break iskaza je prikazan na prethodnoj slici (slika 32). Kao
što se vidi iz koda programa na slici 33, prvo se na ekranu pojavljuje poruka “Unesite neki
dvocifreni broj: “, koja je praktično prva naredba u tijelu while do petlje. Nakon toga se unosi
broj sa tastature (15) i on se dodjeljuje varijabli broj. Zatim se vrši provjera istinitosti uslova
broj>99, pa pošto je uneseni broj 15<99, uslov je netačan (false) nastavlja se izvođenje druge
naredbe tijela petlje, odnosno provjera istinitosti uslova broj==99 (uslov nije tačan i ne izvodi se
naredba break) pa izračunavanje kvadrata unesenog broja i njegov prikaz na ekranu (prikaže se
poruka “Kvadrat broja 15 je broj: 225”). Izvođenje programa se nastAvlja ulaskom u drugu
iteraciju nakon provjere kontrolnog uslova petlje i>0 (koji je tačan, jer varijabla i sada ima
vrijednost 2, a 2 je veće od 0). Sada se u 2. iteraciji unosi novi broj sa tastature (a to je broj 100)
i ponovo provjerava istinitost uslova broj>99, pa pošto je uslov istinit (true, jer je broj 100 zaista
veći od 99) izvršava se naredba continue, koja preskače izvršenje naredbi do kraja tijela petlje i
preusmjerava izvođenje programa na 3. Iteraciju. U 3. Iteraciji, nakon provjere vrijednosti
kontrolne varijable, odnosno tačnosti uslova i>0 (uslov je tačan jer je vrijednost varijable i ista,
kao u prethodnoj iteraciji, to je 2), unosi se treći po redu broj sa tastature (99). Pošto 99 nije veće
od 99 (uslov nije tačan i ne izvodi se continue naredba iza if naredbe), kontrola programa je na
sljedećoj if naredbi, gdje se provvjrava uslov broj==99, pa pošto je 99 jedanko 99 (uslov je tačan)
izvodi se break naredba, koja prekida izvođenje 3. Iteracije, ali i cijele petlje. Nakon toga
program izvodi prvu naredbu iza petlje, a to je u primjeru naredba return 0;, kojom se završava
izvođenje programa.

11.3. Naredba goto

Najčešće se definiše kao bezuslovni (apsolutni) skok iz jednog dijela (tačke) programa u
neki drugi dio programa, koji ima svoj naziv, odnosno identifikator iza koga slijedi dvotačka (:).
Ovu karakteristiku goto naredbe treba veoma oprezno koristiti, budući da njeno izvršenje
uzrokuje bezuslovni skok ignorišući bilo koju vrstu ograničenja (pravila) struktura ponavljanja.
Način osmišljavanja programskih struktura i njihovih karakteristika u C++ jeziku, koje smo dosad
spominjali i objašnjavali (strukture sekvencije, selekcije i ponavljanja) zajedno sa njihovim
sastavnim elementima, prilagođen je jednom jedinom cilju, a to je strukturirano programiranje.
Poštovanje pravila dizajniranja i upotrebe u programu tih struktura, nameću određenu disciplinu
u strukturiranju programa. Pored ovakvih pravila, koja su u skladu sa principima strukturiranog
programiranja, većina programskih jezika u širokoj paleti naredbi ima i naredbu, koja dozvoljava
kreiranje programa na gotovo proizvoljan način. Kada se to kaže onda se najčešće misli na
izbjegavanje struktura ponavljanja, koje imaju svoja stroga pravila za ulazak u njih, trajanje i
izlazak. Naredba, koja to omogućava je goto naredba.

98
 Osnovni argumenti za izbjegavanje goto naredbe su onemogućavanje proizvoljnih
skokova sa jednog mjesta u programu na drugo, izbjegavanje ili onemogućavanje kreiranja
dijelova programskog koda koji nisu strukturirani, pa kao takvi postaju teški za razumijevanje,
ispravljanje programa i testiranje.
Naredbe goto, koje izazivaju skokove iz dijela koda programa izvan strukturiranog niza
naredbi (npr. dio koda izvan petlji) u dio koda unutar te strukture, ne samo da nisu prihvatljivi
sa konceptualne tačke gledišta, jer mogu dovesti do nepredvidljivog načina rada programa, nego
su zbog toga i zabranjeni.
Argumenti za korišćenje goto naredbe su česte potrebe za obavljanjem posebnih
zadataka, čije rješavanje na efikasan način nije moguće uz pomoć strukturiranih iskaza, nego
zahtijeva upotrebu specifičnih programskih struktura, pa to rezultira kompleksnim kodom koji
može biti i i nečitljiv i nerazumljiv. Bitnije od toga je da program rješava problem i da je
funkcionalan.
Dakle, pošto je u nekim situacijama nemoguće izbjeći korišćenje goto naredbe ili se
njenim korišćenjem problem efikasnije rješava, ne treba po svaku cijenu izbjegavati korišćenje
goto naredbe. Isto tako ne treba ni pretjerivati u količini njene upotrebe, odnosno treba je
izbjegavati gdje god se ona može zamijeniti nekim strukturiranim iskazom, a da to nije na uštrb
prije svega efikasnosti i funkcionalnosti programa.
U mnogim programskim jezicima naredbe exit, break, return se koriste da završe neki
strukturirani niz naredbi (i prenesu kontrolu na prvu naredbu iza tog niza) umjesto da se on
završava uz pomoć goto naredbe, koja kontrolu izvođenja programa prenosi na naki drugi dio
programa, što uzrokuje nečitljivost programa, teškoće oko praćenja toka izvođenja programa, a
ponekad i neprdvidivost rada programa.

Opšti format goto naredbe je jednostavan i izgleda ovako:

goto naziv_naredbe;
...
...
naziv_naredbe:
naredba_1;
naredba_2;
...
naredba_n;

Bezuslovni iskaz goto prebacuje kontrolu izvođenja programa direktno na prvu naredbu
(naredba_1) specificiranu iza identifikatora naziv_naredbe. Naredba_1 se izvršava odmah nakon
izvršenja goto naredbe. Ukoliko se naredba_1 sa pripadajućim identifikatorom (naziv_naredbe)
ne nalazi u istoj funkciji, pojavljuje se greška.

99
 Int kodgreske;
Int main ()
{
…
if (kodgreske > 0)
goto kraj;
...
...
…
kraj:cout<< “Kod greške ”<< kodgreske;
return 0;
}

U ovom slučaju smo mogli umjesto goto, koristi break naredbu. Slijedeći primjer ilustruje
jedan specijalni slučaj gdje se upotreba goto naredbe pokazuje kao svrhishodna.
...
for ( ...)
{ ...
for ( …)
{ ...
for ( …)
{
…
if (indikator_greske)
goto greska;

}
}
}
...
greska: cout<< “Greška ”;

Ovaj program bi se mogao realizovati i bez korišćenja naredbe goto, ali bi to bilo mnogo
teže i neefikasnije. Korišćenjem naredbe break u if naredbi (kada bi ona mijenjala goto naredbu)
došlo bi do prekida (iskakanja iz) samo one petlje unutar koje je if. Eventualno traženje greške bi
se tada moralo izvršiti za svaku iterativnu naredbu posebno. Nasuprot tome, rješenje sa
naredbom goto je jednostavno, jer se dijelu programa za otkrivanje greške može pristupiti iz
svakog dijela programa.

100
 ...
for ( ...)
{ ...
for ( …)
{ ...
for ( …)
{
…
if (indikator_greske)
goto break;
}
…
if (indikator_greske)
goto break;
}
…
if (indikator_greske)
goto break;
}
...
if (indikator_greske)
cout<< “Greška ”;

Na slici 40 prikazan je kod programa, koji uz pomoć if i goto naredbe kreira strukturu ponavljanja.

Slika 40. Primjer upotrebe goto naredbe

101
 Još jedan primjer korišćenja goto iskaza, prikazan je na slici 41.

Slika 41 Primjer upotrebe goto iskaza, tipičan za nestrukturirane programske jezike

Ovaj primjer upotrebe goto iskaza, karakterističan je za starije programske jezike, koji
nisu podržavali strukturirano programiranje, odnosno programske jezike koji nisu imali
mogućnost korišćenja (unaprijed zadatih propisanim formatom) struktura ponavljanja, odnosno
petlji, nego su programeri u svakom pojedinačnom slučaju sami definisali uslove ulaska u petlju,
trajanje petlje (broj ponavljanja) i uslove izlaska iz petlje. U svakom slučaju, na ovaj način su
programeri imali veću slobodu i mogli da kreiraju labavije programske strukture, koje su s druge
strane bile teže za razumijevanje, ispravljanje i testiranje. Iako najnoviji programski jezici
dozvoljavaju mogućnost korišćenja goto naredbe, ipak se preporučuje njeno izbjegavanje kad

102
god je to moguće i što je god više to moguće i to ne samo zbog već spomenutih razloga, nego
izbog mogućnosti nepravilnog i nedisciplinovanog korišćenja goto naredbe, koja bi rezultirala
nepredvidivim ponašanjem programa.

12. FUNKCIJE U C++ PROGRAMSKOM JEZIKU

Funkcija se može definisati kao gradivni element programske strukture (potprogram,

programski segment ili dio programskog koda), koji se sastoji iz niza naredbi kojim se rješava
određeni zadatak, a koji se može više puta pozivati iz bilo koje tačke u glavnom programu.
Ustvari, glavni program, iz kojeg se pozivaju potprogrami (funkcije) nije ništa drugo nego funkcija,
koju zovemo glavna ili main funkcija. Na samom početku knjige, već je rečeno da prva linija
svakog C++ programa int main(), predstavlja definiciju glavne funkcije, koja će se prva pozvati u
izvođenje nakon pokretanja programa i koja će pozivati sve ostale funkcije (podprograme), te čiji
će završetak ujedno značiti i završetak glavnog programa.
Postoji više razloga, zbog kojih se upotrebljavaju funkcije:

 Kada je određeni programski segment potrebno izvršiti više puta na različitim mjestima
unutar programa.
 Dio koda, kojim se rješava neki specifični zadatak, bolje je napisati jednom kao funkciju i
poslije je pozivati kad zatreba, nego svaki put kad zatreba kopirati taj dio koda. Na ovaj
način se izbjegavaju moguće greške koje mogu nastati kopiranjem koda sa jednog mjesta
u programu na drugo.
 Čak i onda kada se programski segment izvršava samo jednom, korisno ga je, ukoliko
izvršava određeni zadatak, izdvojiti u potprogram kao posebnu funkciju sa ciljem lakšeg
testiranja, dokumentovanja i čitljivosti.

Većina C++ programa koji koriste principe strukturiranog programiranja, kreiraju se

kombinacijom novih funkcija i klasa, koje sam programer napiše sa funkcijama i klasama
raspoloživim u C++ standardnim bibliotekama funkcija i klasa. Zbog toga program možemo
prevashodno posmatrati kao skup funkcija u koje su smještene instrukcije programskog koda.
C++ standardne biblioteke funkcija sadrže bogatu kolekciju matematičkih funkcija, string
funkcija za manipulaciju sa stringovima, karakter funkcija za manipulaciju sa karakterima,
input/output funkcija za unos ili prikaz podataka i mnogih drugih korisnih operacija. To značajno
olakšava posao programeru jer ove funkcije zadovoljavaju najveći dio programerskih potreba.

103
 12.1. Definicija, poziv i parametri funkcija u C++

Osnovni elementi od kojih se sastoji funkcija su:

 Deklaracija koja definiše povezivanje funkcije sa programom i ostalim funkcijama i

koja uključuje ime funkcije, listu ulaznih parametara (ukoliko postoje) i tip podatka za
povratnu (izlaznu) vrijednost (ako postoji).
 Lokalne deklaracije koje su dostupne samo unutar tijela funkcije.
 Izvršne naredbe

12.1.1. Definicija (deklarisanje) funkcije

Opšti format definicije funkcije je:

tip_povratne_vrijednosti ime_funkcije (lista_parametara)

{
lokalne deklaracije i iskazi;
return naredba;
}

Ime_funkcije ili naziv_funkcije je identifikator, kojim korisnik imenuje funkciju, vodeći

računa da se pri tome ne koriste rezervisane (ključne) riječi, niti imena drugih funkcija.
Tip_povratne_vrijednosti je tip podataka za rezultat koji vraća funkcija. Povratna vrijednost void
znači da funkcija ne vraća ništa. Ako nije specificiran tip_povratne_vrijednosti, podrazumijeva
se tip int. Ako se radi o povratnoj vrijednosti bilo kojeg drugog tipa podataka, mora se navesti
ključna riječ za taj tip. Većina funkcija vraća neku (samo jednu) vrijednost i zato se ispred imena
funkcije navodi tip varijable koji će funkcija vratiti. Ukoliko funkcija ne treba da vrati nikakvu
vrijednost, tada se umjesto tipa varijable navodi riječ void.
Lista_parametara (argumenti koje funkcija prima) se sastoji od deklaracije parametara
predatih funkciji prilikom njenog poziva iz glavnog programa (parametri su odvojeni zarezom).
Ako funkcija ne prima vrijednosti, onda je lista_parametara void. Tip podatka se mora
eksplicitno navesti za svaki parametar u listi_parametara funkcije. Broj argumenata nije
ograničen.
Loklalne deklaracije i iskazi unutar vitičastih zagrada, formiraju tijelo funkcije. Funkcije
ne mogu biti definisane unutar drugih funkcija, što znači da moraju biti definisane iz glavne
funkcije. Za povratak iz funkcije sa return iskazom, koriste se sljedeće varijante:
 return; // povratak u glavni program iz funkcije koja ne vraća vrijednost
 return iskaz; // povratak u glavni program iz funkcije koja vraća vrijednost
 povratak iz funkcije dolaskom do kraja tijela funkcije, odnosno znaka }.

104
 Dakle, možemo zaključiti da se definicija funkcije sastoji od dva glavna dijela:

a) Zaglavlja ili interfejsa [tip_povratne_vrijednosti ime_funkcije (lista_parametara)] i

b) Tijela funkcije (lokalne deklaracije i iskazi; i return naredba;)

Neki zaglavlje funkcije nazivaju i prototip funkcije. Njime se definiše kako se funkcija
može koristiti. Tijelo funkcije sadrži računske postupke (naredbe) kojima se rješava neki zadataka
i koji su svrha upotrebe funkcije.

12.1.2. Poziv funkcije

Upotreba funkcije se obavlja njenim pozivanjem. Poziv funkcije se sastoji od imena

funkcije, iza čega slijede zagrade (), unutar kojih može da se ne pojavljuje niti jedan ili se
pojavljuje jedan ili više argumenata, odnosno parametara, koji su odvojeni zarezom. Broj
argumenata bi trebao odgovarati broju ulaznih parametara funkcije. Svaki argument je izraz,
čiji tip bi trebao odgovarati tipu odgovarajućeg parametra definisanog u listi_parametara,
odnosno u interfejsu funkcije.

Format poziva funkcije iz glavnog programa može biti i ovakav:

ime_varijable=ime_funkcije (lista_parametrara);

gdje je, ime_varijable ustvari identifikator ili naziv varijable u koju se smješta rezultat funkcije,
koji mora odgovarati po tipu podatka koji funkcija vraća. Lista_parametara su varijable (izrazi,
vrijednosti) koje se predaju funkciji kao ulazne vrijednosti.
Šta znači pozvati funkciju u rad? Nakon linije koda u kojoj se poziva funkcija, prekida se
izvođenje tekućeg sekvencijalnog niza instrukcija, odnosno izvođenje programa se ne nastavlja
sljedećom instrukcijom u sekvencijalnom nizu, nego nizom sekvencijalnih instrukcija unutar tijela
funkcije, nakon čega se izračunava povratna vrijednost i dodjeljuje varijabli ime_varijable.
Funkcije se kreiraju izvan glavne funkcije odnosno main funkcije, a pozivaju unutar
main funkcije, odnosno iz main funkcije. Na ovaj način se osigurava bolje razumijevanje i čitljivost
kôda. U C++ programu, kod funkcije je moguće napisati ispred main funkcije ili iza main funkcije.
Ukoliko kod deklaracije funkcije navodimo ispred main funkcije, ta funkcija će odmah biti
spremna za upotrebu. Ukoliko funkciju deklarišemo iza main funkcije tada ćemo morati koristiti
prototip funkcije. Prototip funkcije je prvi red definicije funkcije (tip podatka koji vraća funkcija,
ime funkcije, parametri) koji se u kodu navodi prije main funkcije. Razlog za to je potreba da
prilikom izvođenja programa, kada kompajler dođe do dijela programa koji poziva neku funkciju
napisanu iza main funkcije, “zna” namjeru programera. Budući da se programi izvode odozgo

105
prema dolje i u trenutku kada kompajler “naiđe” na funkciju sa kojom se još nije “susreo”, on “ne
zna” što mu programer pokušava saopštiti. Korištenjem prototipa funkcije, saopštava se
kompajleru da će se negdje u kôdu pojaviti funkcija određenog imena i da je ona deklarisana
negdje iza main funkcije. Kada kompajler u kôdu programa, “naiđe” na funkciju koja je
deklarisana iza main funkcije, a na početku joj je naveden prototip, kompajler će “znati” da je ta
funkcija negdje i zapisana u kodu programa, te će je potražiti i poređenjem prototipa i koda
funkcije provjeriti formalnu ispravnost njene upotrebe.
Primjer na slici 36 ilustruje definiciju funkcije koja izračunava vrijednost stepenovanja
cijelog broja na neki eksponent, koji je takođe cijeli broj. U sredini linije 8 [stepen (2, 9)],
predstavlja poziv funkcije stepen, kojoj se predaju dvije vrijednosti, odnosno dva argumenta.
Vrijednosti navedene između zagrada i odvojene zarezom, predstavljaju argumente koji se
prosljeđuju funkciji stepen, pri čemu se vrijednost svakog argumenta kopira redom u
odgovarajući parametar. To znači da se u pozivu funkcije stepen (2, 9), vrijednost 2 kopira u
varijablu baza, a 9 u varijablu eksponent. Kada se argumenti prosljeđuju funkciji, prvom
parametru se dodjeljuje vrijednost prvog argumenta, drugom parametru vrijednost drugog
argumenta itd. Redoslijed prosljeđivanja vrijednosti se određuje na bazi pozicije).
Linija 11 definiše zaglavlje (interfejs) funkcije. Ona počinje tipom funkcije koji se vraća (u
ovom slučaju int). Nakon toga je dato ime funkciji (stepen), a zatim njena lista parametara.
Funkcija stepen ima dva parametra (baza i eksponent) koji su tipa int. Sintaksa navođenja
parametara je slična sintaksi deklarisanja varijabli (nakon definisanja tipa, daje se ime
parametra). Međutim, nije ispravno nakon tipa navesti niz parametara odvojenih zarezom.

int stepen (int baza, eksponent) // Ovo je pogrešno!

Zagrada { u liniji 12 predstavlja početak tijela funkcije. Linija 13 definiše lokalnu varijablu
rezultat.
Linije 14 i 15 računaju rezultat stepenovanja vrijednosti varijable baza na varijablu
eksponent (2 ^ 9) pomoću for petlje. Rezultat se pohranjuje u varijablu rezultat. U liniji 16 vraća
se vrijednost varijable rezultat kao rezultat funkcije. Zagrada } u liniji 17 predstavlja kraj tijela
funkcije.

106
 Slika 42 Primjer koji ilustruje deklaraciju i poziv (upotrebu) funkcije

12.1.3. Parametri ili argumenti funkcije

Da bi funkcija mogla da obavi svoj zadatak, zbog kojeg se i koristi u programiranju, moraju
joj se na neki način proslijediti podaci koje će ona računati. Funkcijama je moguće proslijediti
jednu ili više vrijednosti. Vrijednost koja se prosljeđuje funkciji, zove se argument. Kada se
definiše funkcija, koja prima jedan ili više argumenata, moraju se deklarisati i varijable koje
primaju te argumente. Te varijable se zovu parametri funkcije.
Ako se nakratko vratimo na definiciju funkcije (objašnjenje pojma funkcije), gdje je rečeno
da su funkcije programski segmenti (dijelovi koda) koji se mogu višestruko uključivati u program
(pozivati) sa svih potrebnih mjesta u programu, tome treba dodati da najčešće svaki poziv
funkcije zahtijeva da se kod u tijelu funkcije izvršava sa različitim podacima. Način kako uticati na
izvršavanje tijela funkcije je predaja podataka (parametara ili argumenata) da bi se obavilo
računanje unutar funkcije. Podaci se predaju funkciji u formi niza vrijednosti koji se naziva
parametri. Koncept je preuzet iz matematike gdje se matematičkim funkcijama predaju ulazni
argumenti, na osnovu kojih se računanjem unutar funkcije dobije rezultat.

107
 Kada su argumenti funkcije u pitanju, treba jasno razlikovati dvije vrste parametara:

 Formalni parametri predstavljaju deklaracije koje se pojavljuju u deklaraciji funkcije

(zaglavlje funkcije ili interfejs). Računanje u tijelu funkcije se obavlja korišćenjem imena
ovih parametara.
 Aktuelni parametri predstavljaju vrijednost, koju program iz kojeg se oni pozivaju šalje
funkciji.

U primjeru koji slijedi:

int i, j;
char a;
void funkcija_p ( int a, char b )// zaglavlje funkcije sa formalnim parametrima
{
i = a + ( int ) b;
}

funkcija_p ( i, a ); //prvi poziv funkcije_p

funkcija_p ( i + j, ’x’); //drugi poziv funkcije_p

formalni parametri funkcije_p su “a” i “b”, dok su aktuelni parametri prvog poziva “i” i “a”, a
drugog poziva ( i + j ) i ’x’. Ovdje je bitno je napomenuti da aktuelni parametri mogu biti
vrijednosti, konstante i izrazi a ne samo varijable, dok formalni parametri mogu imati ista imena
kao i stvarni, ali funkcija radi samo sa formalnim parametrima. Parametar “a” u glavnom
programu je potpuno nezavisan od parametra “a” u funkciji.
Predaja parametara funkciji se zasniva na tome da se vrijednost aktuelnog parametra
predaje u formalni parametar. Formalni parametar je samo varijabla definisana unutar
funkcije, tako da je predaja parametara mehanizam kopiranja vrijednosti aktuelnog parametra u
memorijsku lokaciju formalnog parametra. Ovaj mehanizam se naziva predaja parametara po
vrijednosti (copy-in semantics ili call-by-value). O načinima predaje parametara će detaljnije biti
riječi malo kasnije.
Još jedan primjer definicije funkcije i poziva funkcije, odnosi se na izračunavanje
kvadrata brojeva od 1 do 10 korišćenjem funkcije kvadrat, koju ćemo definisati u programu (slika
43).
U tabeli 29 su prikazane pripadnosti varijabli po funkcijama i vrijednsoti varijabli po
iteracijama. U liniji 5 se definiše prototip funkcije kvadrat kao int kvadrat (int); ili int kvadrat (int
x);. U liniji 10 koristi se for petlja (sa kontrolnom varijablom x) za ponavljanje izračunavanja
kvadrata brojeva od 1 do 10. Ukoliko je u liniji 5 korišćen 2. oblik protoptipa funkcije [int kvadrat
(int x);], onda će kontrolna linija for petlje izgledati ovako: for (x=1; x<11; x++). Tijelo for petlje

108
se sastoji iz dvije naredbe. Jednom se poziva funkcija kvadrat [rezultat=kvadrat(x);], a dobiveni
(vraćeni) rezultat se smješta u varijablu rezultat. Pošto je inicijalna vrijednost varijable “x” u 1.
iteraciji 1, vrijednost 1 se predaje (prenosi) u funkciju kvadrat, pa treba izračunati kvadrat(1).
Aktuelni parametar x, predajom vrijednosti funkciji kvadrat, postaje formalni parametar y.
Drugim riječima, sadržaj varijable iz for petlje (x), postaje sadržaj varijable u funkciji (y), odnosno
sada se x (aktuelni parametar) pretvara u y (formalni parametar). Parametar y egzistira samo
unutra funkcije. Unutar funkcije kvadrat deklariše se još jedna varijabla rez, u koju se smješta
rezultat rada funkcije kvadrat (povratna vrijednost), a to je y*y. I ova varijabla je lokalnog tipa,
odnosno vrijedi samo unutar funkcije kvadrat. Komandom return rez;, u kojoj je smješten
rezultat rada funkcije, formalni prametar rez, postaje aktuelni parametar rezultat, odnosno vraća
rezultat (povratnu vrijednost funkcije) varijabli rezultat. U ovoj varijabli se nalazi vrijednost 1 i
kontrola programa se opet vraća u for petlju. Izvodi se prikaz rezultata rada funkcije kvadrat na
ekranu (cout <<" "<<rezultat<<" ";) i ide na novu iteraciju for petlje sa novom vrijednošću
kontrolne varijable x, ato je 2. Isti postupak se ponavlja dok vrijednost varijable x ne bude 11.
Tada program iskače iz petlje i završava se njegovo izvođenje.

Slika 43. Primjer definisanja prototipa funkcije, definicije funkcije i poziva funkcije

109
 Iteracije Funkcija Varijabla Vrijednost Poziv Nakon poziva funkcije kvadrat
funkcije (rezultat=povratna vrijednost
kvadrat funkcije kvadrat)
1. Main x 1 kvadrat(1)
2. Kvadrat y 1
rez 1=1*1
3. Main rezultat=1
4. Main x 2 kvadrat(2)
5. Kvadrat y 2
rez 4=2*2
6. Main rezultat=4
7. Main X 3 kvadrat(3)
8. Kvadrat y 3
rez 9=3*3
9. Main rezultat=9
...

Tabela 29. Vrijednosti varijabli u pojedinim tačkama programa

12.2. Prototip funkcije

Iako je o prototipu funkcije već podosta rečeno, ovdje treba opisati još neke njegove
karakteristike. Jedno od važnih unapređenja C++ programskog jezika u odnosu na C jezik jeste
prototip funkcije. On kompajleru, pored tipa povratne vrijednosti funkcije “saopštva” i broj
parametara, koji funkcija očekuje da primi, tipove parametara, i redosljed u kojem se očekuje
njihovo primanje. Kompajler koristi prototip funkcije da bi provjerio validnost poziva funkcije.
Ranije verzije C jezika nisu vršile ovu vrstu provjere, tako da je bilo moguće pozvati funkciju sa
pogrešnim brojem ili tipom parametara a da kompajler ne otkrije grešku.

110
 Slika 44. Primjer upotrebe funkcije za određivanje maksimuma od 3 unesena broja

Na primjeru programa koji određuje i prikazuje na ekranu maksimum od 3 unesena broja

(slika 38) može se primjetiti da je prototip funkcije isti kao zaglavlje (interfejs) definicije
funkcije, osim što imena parametara (x, y, z) nisu uključena prilikom navođenja prototipa
funkcije.

111
 Imena parametara mogu biti uključena u prototip funkcije zbog kvalitetnijeg
dokumentovanja programa. Kompajler ne reaguje na ta imena. Ono što je još bitno znati u vezi
sa prototipom funkcije jeste pravilo da poziv funkcije, koji ne odgovara tipu funkcije uzrokuje
sintaksnu grešku, koju prijavljuje kompajler.

12.3. Povratak iz funkcije

U prethodno navedenim primjerima upotrebe funkcija, nakon poziva i izvršavanja tijela

funkcije, izvođenje programa se vraćalo na prvu liniju koda iza linije iz koje je funkcija pozvana.
Iako je to prihvatljivo za većinu funkcija, nije primjenljivo na sve funkcije. Često je potrebno
precizno kontrolisati kada se funkcija završava odnosno “vraća”. Za tu namjenu služi naredba
return. Naredba return ima dva formata: a) jedan koji vraća vrijednost i b) drugi koji ne vraća
ništa. Ako govorimo o naredbi return, koja ne vraća vrednost, te ukoliko je povratni tip funkcije
void (što znači da ona ne vraća ništa), onda se koristi format return;. Kada se naiđe na ovaj
format naredbe return, izvršavanje funkcije se prekida i vraća na mjesto odakle je funkcija
pozvana, odnosno na prvi red iza poziva funkcije. Kod koji se nalazi iza naredbe return; u tijelu
funkcije, ignoriše se, odnosno ne izvodi se.

Slika 45. Program ilustruje povratak iz funkcije, koja ne vraća ništa uz pomoć return naredbe

112
 Funkcija može imati nekoliko naredbi return. Ipak, povratak iz funkcije na više mjesta
može da naruši njenu strukturu i da oteža razumevanje koda, pa više naredbi return u istoj
funkćiji treba koristiti samo kada olakšavaju njeno razumevanje.
Kao što smo naveli u većini prethodnih primjera, funkcija najčešće vraća vrijednost
pozivaocu, odnosno glavnom programu, pa u tom slučaju naredba return služi za dobijanje
informacija od funkcije, što joj je i osnovni zadatak. Za vraćanje vriednosti koristi se drugi oblik
naredbe return:

return vrijednost;

Ovdje je se vrijednost odnosi na ono što funkcija vraća kao rezultat, a mora biti istog tipa
kao što je i tip funkcije. Ukoliko se tip funkcije i tip vrijednosti iza naredbe return ne podudaraju,
kompajler će prijaviti formalnu (sintaksnu) grešku. Dozvoljeno je da tip funkcije bude bilo koji
važeći C++ tip podataka osim niza.

12.4. Funkcija exit()

C++ program završava izvođenje kada stigne do kraja funkcije main(), odnosno do zatvorene
vitičaste zagrade } ili do naredbe return 0; u funkciji main(). Kada se izvršavaju ostale funkcije
(potprogrami), program se ne završava, već se kontrola izvođenja programa vraća na naredbu
odmah iza poziva funkcije. Ponekad je potrebno ili čak neophodno da se program završi u nekoj
funkciji koja nije main() funkcija. Da bi se to postiglo, koristi se funkcija exit (), koja bezuslovno
prekida izvršavanje programa, bez obzira na to koja funkcija ili kontrolni mehanizam se izvode.
Da bi se koristila funkcija exit (), neophodno je koristiti biblioteku cstdlib.

113
 Slika 46. Primjer C++ programa, koji ilustruje upotrebu exit(); naredbe

Funkcija exit () ima jedan cjelobrojni argument koji se koristi za prosljeđivanje izlaznog
koda operativnom sistemu; vrijednost 0 standardno (kao i return 0; u main funkciji) označava
uspješan završetak funkcije.

13. OBLAST VAŽENJA VARIJABLI (SCOPE)

U prethodnim primjerima smo koristili varijable ne objašnjavajući na kojem mjestu u

programu mogu da se deklarišu, iz kojeg dijela programa im se može pristupati i koliko ostaju
važeće. Te karakteristike su određene pravilima vidokruga varijabli (scope rules) u jeziku C++,
koja upravljaju vidljivošću (visibility) i životnim vijekom (lifetime) i područjem važenja (scope)
varijabli. Svaka deklaracija varijable se odnosi na tri karakteristike:
a) Područje varijable (scope) je dio (segment) programa unutar kojeg je varijabla definisana.
Često se naziva i oblast važenja. Oblast važenja neke varijable, odnosno podatka
zabilježenog u njoj može biti lokalna, globalno ograničena i globalno neograničena.
b) Varijabla je vidljiva (visibility) unutar oblasti važenja ukoliko joj se može direktno
pristupiti po imenu.

114
 c) Vrijeme života varijable (lifetime) je vremenski interval izvođenja funkcije u kojem je
memorija dodijeljena varijabli. Vrijeme života varijable zavisi i od načina dodjeljivanja
memorije varijabli, koji zavisi od memorijskih klasa.

13.1. Lokalna oblast važenja varijabli

Lokalna oblast važenja se određuje u bloku naredbi, koje se nalaze između otvorene i
zatvorene vitičaste zagrade {...}. Kad god se otvori novi blok, kreira se i nova oblast važenja
varijabli (scope). Varijabla koja je definisana unutar bloka zove se lokalna varijabla. Sve varijable,
koje su definisane unutar bloka naredbi, imaju lokalnu oblast važenja, a to je samo taj blok. To
znači da nisu vidljive niti dostupne izvan njega. U principu, kada se deklariše lokalna varijabla,
ona se “lokalizuje”, što znači da se onemogućava njeno neovlašćeno korišćenje i mijenjanje.
Lokalne varijable “žive” (traju) samo dok se izvodi dio koda u zagradama (blok koda) u kome su
definisane. Može se reći da one nastaju unutar bloka (definišu se u bloku) i nestaju kada se završi
izvođenje bloka. Blokovi koda, koji se najčešće koristi za definisanje lokalnih varijabli su funkcije
Pošto se tijelo funkcije nalazi između zagrada, funkcija predstavlja blok, odnosno jedinstvenu
cjelinu čijim naredbama i podacima se ne može pristupiti izvan nje (slika 47). Npr. nije dozvoljeno
koristiti, odnosno pozvati goto naredbu izvan tijela funkcije adresiranu na naredbu unutar neke
funkcije.
Nepisano je pravilo da se sve varijable potrebne u funkciji deklarišu na početku tijela
funkcije, prije svega zbog toga što funkcija postaje razumljivija i čitljivija. Ali, to ne mora uvijek
biti tako. Lokalna varijabla se može deklarisati bilo gdje unutar bloka s tim što se ta deklaracija
mora navesti prije njene prve upotrebe.
Varijable parametara funkcije imaju oblasti važenja unutar funkcije, odnosno one su
lokalne za funkciju i osim što prihvataju vrijednosti argumenata, ponašaju se kao i sve druge
lokalne varijable.
Budući da se lokalna varijabla kreira i uništava pri svakom ulasku i izlasku iz bloka u kome
je deklarisana njena vrijednost neće biti zapamćena između dva izvršenja naredbi iz bloka. Isti
princip se odnosi i na korišćenje lokalnih varijabli unutar funkcije. Ove varijable se kreiraju pri
ulasku u funkciju, a uništavaju izlaskom iz nje, što znači da ne mogu da zadrže vrijednost između
dva poziva funkcije.

115
 Slika 47. Program koji ilustruje lokalnu oblast važenja varijable

Ukoliko se lokalna varijabla inicijalizira, onda se inicijalizacija ponavlja prilikom svakog

izvršenja bloka, odnosno poziva funkcije (slika 48).

116
Slika 48. Primjer ponavljanja inicijalizacije varijable svakim izvršenjem tijela funkcije

Iz ovog primjera je vidljivo da se funkcija, koja je u programu definisana identifikatorom

funkcija_prikaza_teksta, poziva 3 puta uz pomoć for petlje i bez obzira na to što se varijabla_1
u tijelu funkcije povećava za 1, njena vrijednost se mijenja novom iteracijom, odnosno novom
inicijalizacijom promjenljive varijabla_1, tako da njena vrijednost u sve tri iteracije ostaje ista. U
ovom primjeru treba zapaziti još nešto. Ukoliko varijablu i deklarišemo unutar main funkcije ili
tačnije unutar kontrolne linije for petlje na način da ta kontrolna linija izgleda ovako (linija 9 u
programu): for (int i=1; i<4; i++) funkcija_prikaza_teksta(); i pokušamo njenu vrijednost u 1.
Iteraciji, a to je vrijednost 1, koristiti unutar funkcije, kompajler će prijaviti sintaksnu grešku,
upozoravajući da tako nešto nije moguće. U ovom slučaju, varijablu i je moguće koristiti samo
unutar main funkcije, ali ne i izvan nje. Njena oblast važenja je main program, odnosno mogu je
koristiti sve naredbe unutar vitičastih zagrada main funkcije, ali ne i naredbe unutar tijela neke
funkcije, koja se poziva iz main funkcije. Međutim, ukoliko varijablu i deklarišemo prije main
funkcije (kao što je u primjeru na slici 42), onda se njeno područje važenja proteže na cijeli
program, pa i na funkciju [(funkcija_prikaza_teksta();], koju pozivamo iz glavne funkcije (linija
9). Isti bi slučaj bio i da se varijabla i koristi i unutar neke druge funkcije istog programa.

117
 13.2. Globalna oblast važenja varijabli (global scope)

Globalnu oblast važenja varijable imaju varijable, koje se deklarišu izvan svih funkcija,
pa time i main funkcije. Globalne varijable dostupne su u cijelom programu, odnosno njihova
oblast važnosti je cijeli kod programa, i zadržavaju svoju vrijednost tokom cijelog izvršavanja
programa. To znači da je njihova oblast važenja cijeli program (varijabla i sa slike 42). One se
nazivaju globalne varijable. Iz primjera sa slike 42 i teksta koji objašnjava globalni scope varijable
i, može se zaključiti da se globalne varijable deklarišu izvan svih funkcija, a to znači prije main
funkcije. Pošto se svaka varijabla mora deklarisati prije prvog korišćenja, najbolje je da se
globalne varijable deklarišu na samom početku programa, izvan svih funkcija i prije funkcije
main, kaako bi bile dostupne cijelom programu.
Globalne varijable se inicijaliziraju kada program počne da se izvršava. Ukoliko globalna varijabla
nije inicijalizirana nijednom vrijednošću (prilikom deklaracije nije navedena njena početna
vrijednost), onda se ona inicijalizira na 0. Globalne varijable se pohranjuju u posebnu oblast
memorije rezervisanu za tu namjenu. Koriste se kada je isti podatak (vrijednost varijable)
potrebno upotrijebiti u više funkcija, ili kada postoji potreba da neka varijabla zadrži vrijednost
sve vrijeme tokom izvođenja programa.

Korišćenje globalnih varijabli treba izbjegavati iz više razloga: (Irina Branović: Objektno
orjentisano programiranje: C++, Univerzitet Singidunum, Beograd, 2011)
 zauzimaju memoriju sve vrijeme tokom izvršavanja programa, a ne samo onda kada su
potrebne
 ako se globalna promjenljiva koristi u funkciji, ona postaje manje samostalna jer se
oslanja na promjenljivu koja je definisana izvan funkcije
 globalne promjenljive prouzrokuju greške u programima koje se teško otkrivaju, zbog
promjena vrijednosti na raznim mjestima u programu

13.3. Memorijske (storage) klase

Memorijske klase su vrste memorije u C++ jeziku u koje se pohranjuju određene varijable,
odnosno podaci, koji predstavljaju sadržaj tih varijabli zavisno od načina njihovog deklarisanja. U
C++ jeziku postoje 4 vrste memorijskih klasa (Hancock & Krieger, 1986):

 auto,
 register,
 extern i
 static.

118
 Pri deklaraciji varijabli, memorijska klasa se navodi ispred tipa varijabli:

vrsta_memorijske_klase tip_varijable ime_varijable;

Ove četiri memorijske klase se mogu podijeliti u dvije kategorije:

 automatska klasa (auto i register) i

 statička klasa (extern i static)

Rezervisane riječi auto i register se koriste da deklarišu varijable automatske klase

memorije. Takve varijable se deklarišu unutar bloka u kojem će važiti, postoje dok se blok izvodi,
i uništavaju se kada se blok završi. Podrazumijeva se (po default-u) da se lokalne varijable
funkcija smještaju u automatke memorijske klase i umjesto da se piše auto float x, y;, piše se
samo float x, y;. Ako nekoj varijabli dodijelimo register memorijsku klasu ona se smješta u
registarsku vrstu memorije. Npr.

register int counter = 1;

Rezervisane riječi extern i static se koriste za deklaraciju identifikatora za varijable i

funkcije statičke memorijske klase. Takve varijable postoje (imaju vrijednost i može im se
pristupiti) od početka izvršavanja programa i traju sve do kraja izvršavanja programa.
Podrazumijeva se da su globalne varijable koriste specifikator extern. Globalne varijable se
kreiraju tako što se bira mjesto za deklaraciju takvih varijabli izvan bilo koje funkcije, pa čak i
izvan main funkcije, a to mjesto u C++ jeziku je prije main() funkcije.

13.4. Statička varijabla

Umjesto korišćenja globalnih varijabli u funkcijama kada je potrebna varijabla koja pamti
vrijednosti između različitih poziva iste funkcije bolje je koristiti statičke varijable. Deklaracija
statičke varijable, postiže se dodavanjem rezervisane riječi static ispred tipa varijable.
Lokalna varijabla, deklarisana uz pomoć rezervisane riječi static je poznata samo u funkciji u kojoj
je definisana, ali za razliku od lokalne varijable, koja nije deklarisana kao static, njena vrijednost
se zadržava i poznata je pri svakom narednom pozivu funkcije. Drugim riječima rečeno, ova
varijabla se ponaša kao globalna varijabla ali za razliku od nje ne odnosi se na nivo programa
nego na nivo funkcije.

static int broj = 0;

119
 Statičkoj varijabli se dodjeljuje početna vrijednost samo jednom, pri prvom izvršavanju
funkcije. Ona pamti svoje vrijednosti sve vrijeme dok se izvršava program, a dostupna je u onom
bloku u kojem je i deklarisana (slika 49).

Slika 49. Primjer programa kojim se ilustruje upotreba static lokalne varijable

Dakle, bez obzira na to što se lokalna varijabla counter, deklarisana modifikatorom klase
static, inicijalizira vrijednošću 0 na početku tijela funkcije brojanje_poziva, ona u 1. pozivu te
funkcije ima vrijednost 1 (++counter), a u njenom drugom pozivu ne inicijalizira se vrijednošću 0,
kao što bi bio slučaj da se ne koristi ključna riječ static prilikom njene deklaracije u funkciji
brojanje_poziva, nego se na vrijednost varijable counter iz prethodnog poziva (1), dodaje 1, pa
se prikazuje tekst “ Ovo je 2. poziv funkcije” itd.

13.5. Pravila vidokruga identifikatora (scope rules)

Vidokrug varijable (scope) je segment programa u kojem se identifikator (naziv) može

referencirati. Npr. kada se deklariše lokalna varijabla u bloku, ona se može referencirati (pozivati)
samo u bloku ili blokovima koji su ugnježdeni unutar bloka.

120
 Postoje 4 vrste vidokruga za identifikator:

 vidokrug funkcije (function scope),

 vidokrug datoteke (file scope),
 vidokrug bloka (block scope) i
 vidokrug prototipa funkcije (function prototype scope)

Identifikator deklarisan ispred bilo koje funkcije ima vidokrug na nivou cjele datoteke
(file scope). Takav identifikator je vidljiv (poznat) u svim funkcijama od mjesta gdje je
identifikator deklarisan do kraja datoteke. Vidokrug datoteke (file scope) imaju globalne
varijable, definicije funkcija i funkcijski prototipi smješteni izvan funkcije
Oznake naredbi (labele ili identifikatori koji označavaju naredbu na koju se referencira sa
goto naredbom) su jedini identifikatori sa funkcijskim vidokrugom (function scope). Labele se
mogu koristiti bilo gdje u funkciji u kojoj se pojavljaju, ali se ne mogu referencirati izvan tijela
funkcije.
Identifikatori deklarisani unutar bloka imaju block scope. Lokalne varijable deklarisane
na početku funkcije imaju blok scope kao parametri funkcije. To su lokalne varijable za funkcije.
Svaki blok može imati deklaraciju varijabli. Kada se radi o ugnježdenim blokovima, tada i
identifikator u vanjskom bloku ima isto ime kao i identifikator u unutrašnjem bloku, a
identifikator u vanjskom bloku je “sakriven” dok se ne završi unutrašnji blok.
Identifikatori sa vidokrugom prototipa funkcije se koriste u listi parametara prototipa
funkcije. Osnovna namjena primjera sa slika 50 i 51 je objašnjnje i razlikovanje pojmova globalna
varijabla, lokalna varijabla, te vidljivost globalne i lokalne varijable iz različitih dijelova programa.
U programu se prvo prikazuje vrijednost varijable x deklarisane u main funkciji (to je njena
inicijalna vrijednost 5. Ova varijabla ima isto ime kao i globalna varijabla deklarisana prije main
funkcije, ali su to dvije različite varijable, jer ova druga je memorisana u različitoj memorijskoj
klasi. Uočava se da je globalna varijabla vidljiva u cijelom programu (primjer varijable x
deklarisane izvan svake funkcije, odnosno prije main funkcije, čija je inicijalna vrijednost 1).
Lokalna je vidljiva samo u funkciji ili bloku u kojem je deklarisana, a to je u primjeru varijabla x,
kojoj se u funkciji a dodjeljuje inicijalna vrijednost 25, povećava za 1 u istoj funkciji i prikazuje
vrijednost 26. Ako je varijabla static memorijske klase i deklarisana u funkciji ona je vidljiva samo
u toj funkciji, ali zadržava vrijednost sve vrijeme tokom izvršavanja programa (primjer static
varijable x u funkciji b). Ovo je u programu primjer 3. varijable koja ima isto ime, ali su to sve
različite varijable jer se njihov sadržaj memoriše u različitim memorijskim klasama. U ovom
slučaju je vidljivo da ukoliko globalna i lokalna varijabla imaju isto ime, u funkciji u kojoj je
deklarisana lokalna varijabla, onda lokalna varijabla ima veću važnost u odnosu na globalnu
istog imena. Kada se izvršava funkcija b (pozvana iz main funkcije, prvo se prikazuje inicijalna
vrijednost static lokalne varijable 50, a nakon povećanja za jedan, prikazuje vrijednost 51.

121
 Funkcija c prikazuje inicijalnu vrijednost globalne varijable x, postavljene na samom
poćetku prije main funkcije, a to je vrijednost 1, te nakon povećanja za 1 u funkciji b, prikazuje
vrijednost 2. Kod drugog poziva funkcije a, prikazuju se iste vrijednosti kao i u prvom pozivu. Kod
drugog poziva funkcije b, karakteristično je da se statička lokalna varijabla ne inicijalizira, nego
zadržava posljednju vrijednost iz prethodnog poziva, a to je vrijednost 51, prikazuje je, te nakon
povećanja za jedan pokazuje vrijednost 52. Kada se radi o drugom pozivu funkcije c, pošto je riječ
o globalnoj varijabli, ona zadržava vrijednost iz prethodnog poziva, a to je vrijednost 2 i prikazuje
ga, te nakon povećanja za 1 prikazuje vrijednost 3. I na kraju, prikazuje se sadržaj varijable x u
main funkciji, deklarisane i inicijalizirane sa vrijdnošću 5 unutar funkcije main. Njena vrijednost
se nije mijenjala, pa i dalje ostaje 5. Ova x varijabla pripada vidokrugu bloka (block scope).

Slika 50. Primjer koji ilustruje upotrebu globalnih, te static i auto lokalnih i varijabli

122
 Slika 51. Prikaz vrijednosti varijabli različitog vidokruga, a istog imena (x).

13.6. Rekurzija

Sasvim je uobičajeno da se iz neke funkcije može pozivati druga funkciju, iz ove druge
neka treća i tako unedogled. Međutim, malo je neobična i na prvi pogled nejasna mogućnost da
se iz neke funkcije može pozvati ta ista funkcija. Za rješavanje nekih problema ova mogućnost da
imamo funkcije koje pozivaju same sebe je veoma korisna. Rekurzivna funkcija je funkcija koja
poziva sama sebe direktno ili indirektno preko neke druge funkcije. Ideja, koja je u osnovi
upotrebe rekurzije slična je ideji korišćenja struktura ponavljanja, a cilj je da se naredbe iz tijela
funkcije ponavljaju, a jednom od tih naredbi pozovu izvođenje te iste funkcije određeni broj puta
dok se ne zadovolji neki uslov, nakon čega se prekida dalje pozivanje te iste funkcije. Postoji
određeni broj problema, koji je veoma pogodan za elegntno rješavanje uz pomoć rekurzije. Takav
primjer je rješavanje matematičke funkcije faktorijel i izračunavanje Fibonačijevog niza brojeva.

123
Slika 52. Primjer upotrebe rekurzivne funkcije za izračunavanje funkcije faktorijel za neki broj

Kako radi program? U liniji 4, int faktorijel (int broj) se definiše funkcija faktorijel tako što
će ulazni parametar u funkciju biti cjelobrojna varijabla broj, a i u rezultatu funkcije će biti
cjelobrojna vrijednsot, odnosno funkcija će vraćati cjelobrojnu vrijednost. Funkcija faktorijel je
definisana sa dvije premise:

1. Faktorijel od 0 je 1 i
2. Faktorijel pozitivnog broja n je n puta faktorijel od n-1, npr. faktorijel od 6 je
6*faktorijel(5)

Na osnovu toga, tijelo funkcije (linije 6 i 7) će se sastojati od jedne naredbe (if alternativna
struktura izbora), pa ćemo je detaljnije objasniti. Ukoliko je varijabla broj (koja se unosi sa
tastature i za koju treba izračunati funkciju faktorijel) jednaka 0, tada funkcija faktorijel vraća

124
vrijednost 1. To je realizacija prve gore navedene premise. Ukoliko se želi izračunati funkcija
faktorijel za neki drugi broj, npr. 3, tada se taj broj unosi putem tastature, smješta u varijablu
broj. Nakon toga u liniji 16, taj se broj prikazuje na ekranu zajedno sa uskličnikom, a zatim se
poziva funkcija faktorijel, kojoj se predaj broj 3 (unesen sa tastature i smješten u varijabli 3). Sada
se pozivom funkcije izvodi jedna jedina naredba iz tijela funkcije faktorijel, naredba iz 6. I 7. Linije,
naredba if...else. Prvo se provjerava istinitost uslova iza if naredbe (da li je 3 jednako 0), pa pošto
je uslov netačan (false), izvodi se naredba iza else iskaza, a to je naredba return. Kako se izvodi
naredba return? Prvo se izračunava vrijednost iskaza navedenog iza return naredbe. Taj iskaz je
ustvari ponovni poziv funkcije faktorijel (drugi po redu od početka izvođenja programa), ali sada
je ulazni parametar u funkciju faktorijel 2, odnosno rezultat izraza (broj-1). Dakle prvi poziv je bio
faktorijel(3) i ta funkcija nije vratila nijednu vrijednost, nego je pozvala funkciju faktorijel(2).
Funkcija faktorijel(2) ispituje da li je dva jednako 0, pa pošto nije, opet se ide na naredbu iza else,
a ona ponovo, sada 3. put poziva istu funkciju, ali sa ulaznim parametrom za jedan manjim od
varijable broj, a njena vrijednost je sada 1. Dalje, funkcija faktorijel(1) provjerava da li je 1
jednako 0, pa pošto nije ponovo se izvodi naredba return iza else naredbe, ali da bi se izvela do
kraja, ona ponovo poziva funkciju faktorijel, ali sada sa ulaznim parametrom 0, dakle faktorijel(0).
Ovo je bio 4. po redu poziv funkcije faktorijel, a još nijedna od tih funkcija nije završila svoje
izvođenje. Da se podsjetimo da tek kada iskaz return vrati neku vrijednost funkciji, tek tada se
završava njeno izvođenje. Do ovog trenutka nijedna funkcija od 4 pozvane funkcije [faktorijel(3),
faktorijel(2), faktorijel(1) i faktorijel(0)] nije vratila ni jednu vrijednost. Tek sada 4. pozivom
funkcije faktorijel(0), ispunjen je uslov iz if naredbe (true), jer je 0 jednako 0, izvodi se iskaz return
1, što znači da funkcija faktorijel (0) sada vraća vrijednost 1. Pošto je funkcija faktorijel (0)
pozvana iz funkcije faktorijel(1), sada se tek završava izvođenje funkcije faktorijel(1), koja vraća
vrijednost 1 [faktorijel (0)*1]. Sada kad je završeno izvođenje funkcije faktorijel (1) vraćanjem
vrijednosti 1, sada se tek završava i funkcija faktorijel 2) i izračunava izraz faktorijel (1)*2, a to je
1*2=2. Tek sada, kada je završeno izvođenje funkcije faktorijel(2) i ta funkcija vratila vrijednost 2
moguće je izračunati faktorijel (3), a to je faktorijel (2)*3, pa na kraju dobijemo rezultat 6.

Primjer rekurzivne funkcije je Fibonači serija brojeva. Primjer Fibonači serije je: 0, 1, 1, 2,
3, 5, 8, 13, 21, 34, 55, … Fibonači serija počinje bilo sa 0 i 1 i ima osobinu da svaki slijedeći Fibonači
broj predstavlja sumu prethodna dva Fibonači broja. Fibonači serija se može definisati rekurzivno
na sljedeći način:

fibonacci(0) = 0
fibonacci(1) = 1
fibonacci(n) = fibonacci(n-1) + fibonacci(n-2)

125
Slika 53. Primjer upotrebe rekurzivne funkcije za vraćanje vrijednosti broja u Fibonačijevom nizu

Poziv funkcije fibonacci iz main funkcije nije rekurzivan, ali su svi ostali (sljedeći) pozivi
rekurzivni zbog toga što funkcija fibonacci poziva samu sebe. Lako je zapaziti da Fibonacci broj
vrlo brzo postaje velik. Zbog toga se u primjeru koristi tip podataka unsigned long za deklarisanje
tipa parametra i tipa povratne vrijednosti.
Objašnjnje rada programa: Rekurzivna fibonacci funkcija je nagoviještena putem
prototipa funkcije prije main funkcije (linija 5). Varijable cijeli_broj i rezultat su deklarisane u
tijelu funkcije main, kao tipovi varijabli unsigned long (linija 8). Ukoliko se uz pomoć cin funkcije
putem tastature unese cijeli broj npr. 6, on postaje sadržaj varijable cijeli_broj (linija 12). Nakon
toga se rezultat izvršenja funkcije fibonacci(6), memoriše u varijablu rezultat (linija 14). Ovom
linijom se poziva izvršenje funkcije fibonacci sa parametrom 6 - fibonacci(6). Pozivom funkcije
počinje izvršavanje naredbi iz tijela funkcije (linije od 20 do 25). Predajom vrijednosti, sadržaj
varijable cijeli_broj se dodjeljuje varijabli n. Zatim se provjerava tačnost složenog uslova 6 = 0 ili

126
6 =1, pa pošto nijedan od dva prosta uslova, koja čine složeni uslov nije tačan, rezultat provjere
je false, izvršava se iskaz iza else, a to je naredba return fibonacci(n-1) + fibonacci(n-2);. Tom
naredbom, nakon return iskaza, koji se ne može završiti dok se ne izračuna vrijednost izraza koji
slijedi iza njega. Vrijednost izraza se ne može trenutno izračunati jer je pozvana rekurzivna
funkcija fibonacci(5), pa sve dok ova funkcija ne dobije povratnu vrijednost (dok joj se ne vrati
vrijednost), izvršavanje programa neće ići na sabiranje sa rezultatom funkcije fibonacci((n-2),
nego se vraća na početak funkcije fibonacci sa ulaznim parametrom 5. Budući da opet složeni
uslov iz if naredbe nije zadovoljen, izvršava se naredba iza else, a ona sada poziva ponovo
funkciju fibonacci, ali sada sa parametrom 4 - fibonacci(4). I sada se program praktično vrti u
petlji: poziva se 3. Funkcija fibonacci(3), pa fibonacci(2). U tom trenutku pozvane su 4 fibonacci
funkcije, a nijednoj od njih nije vraćena vrijednost. Tek kada se bude izvršavala sljedeća 5. po
redu fibonacci funkcija, koja će algoritmom biti pozvana - funkcija fibonacci(1), tada će bit
ispunjen složeni uslov (true)) iz if naredbe u tijelu funkcije (n=1), pa će ova posljednja funkcija
dobiti povratnu vrijednost 1, pa će fibonacci(1) biti jednako 1. Tada i pretposljednja (po redu)
pozvana funkcija fibonacci(2) treba da dobije povratnu vrijednost, tako što se sada izračunava
vrijednost izraza fibonacci(2-1) + fibonacci(2-2), odnosno fibonacci(1) + fibonacci(0). Pozivom
funkcije fibonacci (0), dobiva se povratna vrijednost 0, pa je vrijednost cijelog izraza 1. To je
povratna vrijednost funkcije fibonacci(2). Kada je ova funkcija dobila povratnu vrijednost,
izračunava se i povratna vrijednost funkcije fibonacci(3), a ona je fibonacci(2) + fibonacci(1), a to
je 2. Funkcija fibonacci(3) je bila pozvana iz funkcije fibonacci(4) i kada je funkcija fibonacci(3)
dobila povratnu vrijednost (a to je 2), tada se izračunava i izraz za povratnu vrijednost funkcije
fibonacci(4), a to je vrijednost 3, jer je fibonacci(3) + fibonacci(2) = 2 + 1 = 3. Kada je funkcija
fibonacci(4) dobila vrijednost (3), na redu je da se završi funkcija fibonacci(5), koja je pozvala
funkciju fibonacci(4). Funkcija fibonacci(5) se završava izračunavanjem (dobivanjem) povratne
vrijednosti, a to je fibbonacci(4) + fibonacci(3) = 3 + 2 = 5. I na kraju, iz main funkcije je pozvana
funcija fibonacci(6), koja je pozvala funkciju fibonacci(5), pa kada je fibonacci(5) dobila povratnu
vrijednost, a to je 5, računa se vrijednost funkciije fibonacci(6), a ona je fibonacci(5) + fibonacci(4)
= 5 + 3 = 8. Tek tada se vrši predaja vrijednosti (8) iz varijable n u varijablu rezultat i prikazuje na
ekranu poruku “Fibonacci(6)=8”.
Svaki problem koji se moze riješiti rekurzivno može i iterativno, odnosno uz pomoć
struktura ponavljanja. Ponekad je to mnogo jednostavniji način za rješenje problema. Rekurzivni
pristup se obično bira u odnosu na iterativni pristup jedino u onim slučajevima kada se problem
može riješiti jedino rekurzivnim pristupom. Medutim, rekurzivni pristup se izbjegava zbog
oduzimanja dodatnog vremena i trošenja dodatne memorije. Mnogi algoritmi pretraživanja (npr.
binarno pretraživanje) i algoritmi sortiranja (npr. algoritam quick sort) su rekurzivni.
Prethodni primjer (izračunavanje funkcije faktorijel), može se riješiti i uz pomoć petlje.
Primjer funkcije, koja to rješava prikazana je na slici 54.

127
Slika 54. Izračunavanje funkcije faktorijel uz pomoć while do petlje

13.7. Funkcije sa praznom listom parametara

U C++ jeziku prazna lista parametara se navodi na dva načina ili specificiranjem
rezervisane riječi void ili jednostavno praznim zagradama (), odnosno ne stavljajući ništa u
zagrade. Npr. deklaracija: void funkcija_f();, specificira da funkcija_F neće primati argumente i
neće vraćati nikakvu vrijednost.

128
Slika 55. Primjer deklarisanja funkcije sa praznom listom parametara

13.8. Inline funkcije

Kreiranje programa kao skupa funkcija je potpuno u skladu sa principima strukturiranog

programiranja i softverskog inžinjeringa, odnosno komponovanja programa iz segmenata
programa, koji su dobro istestirani i obavljaju funkcionalnosti koje su im namijenjene. Međutim,
česti pozivi funkcija ponekad mogu značajno da povećaju vrijeme izvršavanja programa.
Kvalifikator inline, koji se navodi prije tipa povratne vrijednosti funkcije (u deklaraciji funkcije, za
kompajler znači da on treba da generiše kopiju koda funkcije da bi izbjegao poziv funkcije. Drugim
riječima, Inline funkcije prave štede u vremenu izvršavanja programa na taj način što kompajler
njihov kod umeće u kod programa umjesto da na tim mjestima u programu poziva izvođenje
funkcija. Pošto se na taj način smanjuje broj poziva funkcija, koje oduzimaju mnogo vremena,
jasno je da se time značajno skraćuje vrijeme izvođenja programa.
Inline kvalifikator se najčešće koristi kada treba da zamijeni male, često pozivane funkcije.
Istina je da Inline funkcije, kao što smo već i rekli reduciraju vrijeme izvršavanja programa, ali je

129
isto tako istina i da istovremeno povećavaju veličinu programa, pa zauzimaju puno više prostora
radne memorije prilikom izvršavanja.

Slika 56. Primjer deklarisanja i upotrebe Inline fukcije pri izračunavanju zapremine kocke

Prilikom prevođenja programa (pretprocesiranja) linija koda br. 12

cout << " Zapremina kocke je: "<< cube(side) <<endl;

se mijenja sa :

cout << " Zapremina kocke je: "<< side*side*side <<endl;

tako da se za vrijeme izvršavanja programa ne obavlja poziv funkcije, odnosno ne izvršava se

funkcija cube, nego kod tijela te funkcije (s * s * s), postaje dio koda programa. Na taj način se ne
gubi vrijeme na poziv funkcije, već se dio koda koji je kopiran u program iz funkcije, izvršava
zajedno sa ostalim naredbama programa.

13.9. Podrazumijevani (default) argumenti

Prilikom poziva funkcije, predaju se i pojedinačne vrijednosti parametara u funkciju.

Programer može definisati takve argumente kao podrazumijevane argumente i može
obezbjediti podrazumijevanu vrijednost za takve parametre. Ako su podrazumijevani argumenti

130
izostavljeni prilikom poziva funkcije, oni automatski poprimaju podrazumijevane (unaprijed
specificirane) vrijednosti.
Podrazumijevani argumenti se navode kao prvi zdesna argumenti u listi parametara
funkcije. Kada se poziva funkcija sa dva ili više podrazumijevanih (default) argumenata, ako
izostavljeni argument nije prvi zdesna argument u listi argumenata, svi argumenti desno od
toga argumenta moraju takođe biti izostavljeni. Podrazumijevane argumente neophodno je
specificirati sa prvim pojavljivanjem imena funkcije, najčešće u prototipu.
Npr. ako je data sljedeća funkcija za računanje zapremine neke kutije:

inline int zapremina_kutije (int duzina = 1, int sirina = 1, int visina = 1)

{
return duzina*sirina*visina;
}

analizom poziva i povratne vrijednosti ove funkcije, dobićemo:

Povratna vrijednost
pozivi: zapremina_kutije() 1
zapremina_kutije(10) 10
zapremina_kutije(10,5) 50
zapremina_kutije(10,5,2) 100

Sva tri argumenta imaju podrazumijevane vrijednosti 1. Prvi poziv inline funkcije
zapremina_kutije() je bez specificiranih argumenata i zbog toga koristi sva tri podrazumijevana
argumenta. Drugi poziv koristi vrijednost varijable dužina, a ostala dva parametra imaju default
vrijednosti. Treći poziv koristi default vrijednost za varijablu visina, a ostale dvije vrijednosti za
dužinu i širinu su default vrijednosti. Zadnji poziv predaje parametre i za sve tri varijable dužinu,
širinu i visinu, te ne koristi default vrijednosti.

13.10. Preklapanje (overloading) funkcija

C++ jezik omogućava definisanje više funkcija sa istim imenom i to može trajati toliko
dugo koliko ove funkcije imaju različit skup parametara. Ova mogućnost naziva se preklapanje
funkcija (function overloading). Kada se preklopljena funkcija, odnosno funkcija koja ima isto
ime kao neka prethodna funkcija ili neke prethodne funkcije, pozove u rad, C++ kompajer bira
jednu od njih ispitujući broj, tip i redosljed argumenata u pozivu. Function overloading se
najčešće koristi za kreiranje različtih funkcija istog imena koji rade sličan zadatak ali nad
različitim tipovima podataka.

131
 Primjer preklapanja funkcija, dat je na slici 57.

Slika 57. Primjer preklapanja funkcija

U programima sa funkcijama, koje se preklapaju, a koje imaju istu listu parametara, a

različite povratne tipove, kompajler će otkriti sintaksnu grešku, jer on jedino listu parametara
koristi za razlikovanje funkcija istog imena.

13.11. Reference i referentni parametri

U većini programskih jezika postoje dva načina za predaju parametara funkciji iz

programa:

a) predaja parametara po vrijednosti (pass-by value) i

b) predaja parametara po referenci (pass-by reference)

Kada se vrši predaja argumenata po vrijednosti nekoj funkciji, tada se pravi kopija
vrijednosti argumenta i predaje se pozivom funkcije. Bitna karakteristika ove aktivnosti je da
kreiranje kopije i predaja kopije ne utiču na orginalnu vrjednost podataka u pozivu. Jedan od
osnovnih nedostataka ovog načina predaje parametara jeste problematična situacija u slučaju

132
kada se predaju velike količine podataka, pa predaja kopije podataka može značajno povećati
vrijeme izvršavanja i opteretiti dragocjeni memorijski prostor. To svakako bio jedan od razloga
zašto se pojavila potreba za drugim načinima predaje parametara.
Kada je riječ o predaji parametara po referenci (pass-by-reference), funkcije direktno
pristupaju podacima specificiranim u pozivu funkcije i na taj način ih mogu po potrebi i mjenjati.
Ovaj način predaje parametara je dobar zbog perfomansi, koje su rezultat eliminisanja potrebe
za kopiranjem velike količine podataka, ali je manje siguran jer se mogu oštetiti podaci.
Referencni parametar je ustvari drugi naziv za odgovarajući argument u pozivu funkcije.
Da bi se znalo da li je parametar funkcije predat po referenci, jednostavno je potrebno slijediti
tip parametra u prototipu funkcije sa & i koristiti istu konvenciju za tipove parametara u zaglavlju
funkcije. Npr. deklaracija int &count, u zaglavlju funkcije znači “count je referenca na int”.
Prilikom poziva funkcije, jednostavno se označi varijabla sa imenom i ona će biti predata sa
referencom. To znači da se varijabla označena sa imenom parametra u tijelu pozvane funkcije
ustvari refrencira na orginalnu varijablu, pa je funkcija može direktno mijenjati.

Slika 58a. Program poređenja predaje parametara po vrijednosti i predaje po referenci

133
Slika 58b. Primjer rezultata poređenja predaje parametara po vrijednosti i predaje po referenci

Kao što se vidi iz primjera, pozivom funkcije kvadrat_po_vrijednosti nije se promijenila

vrijednost orginalne variajble, dok se pozivom druge funkcije kvadrat_po_referenci promijenila
originalna vrijednost.

14. NIZOVI

Za nizove je karakteristično da se koriste za transformaciju podataka realnog svijeta u

matematičke modele vektora i matrica. Niz (array) je skup varijabli istog tipa podataka, kojima se
pristupa preko jednog zajedničkog imena (identifikatora). Nizovi mogu imati samo jednu
dimenziju (skalari u matematici) ili više dimenzija (matrice), mada se najčešće koriste
jednodimenzionalni nizovi. Nizovi predstavljaju pogodan način za pravljenje liste povezanih
varijabli, a najčešće se koriste nizovi znakova. Elementi niza nisu obilježeni sa različitim
identifikatorom nego svi koriste jedno jedinstveno ime i poziciju (indeks) unutar niza, odnosno
redni broj elementa niza kada se radi o jednodimenzionalnim nizovima ili identifikaciju sa dva, tri
ili više indeksa (brojeva), gdje svaki od tih brojeva predstavlja osnovu za identifikaciju elementa
niza. Moć i potencijal niza kao tipa podatka, dolazi od sposobnosti efikasnog pristupa elementu
niza korišćenjem indeksa. Pošto su svi elementi istog tipa moguće je računati lokaciju specifičnog
elementa množenjem indeksa sa veličinom elementa. Korišćenjem indeksa veoma je lako
pretraživati niz tražeći specifični element ili sortirati ili preurediti elemente niza.
C++ programski jezik ograničava tip indeksa na cijeli broj (integer). Prilikom deklaracije niza
potrebno je specificirati broj elemenata (komponenti) niza. Opšti format deklaracije niza bi bio:

tip_elementa_niza ime_niza [broj_elemenata];, gdje je

tip_elementa_niza je neki elementarni ili složeni tip podataka,

ime_niza identifikator kojim se prepoznaje i poziva niz, a
broj_elemenata je konstanta kojom se definiše koliko elemenata ima niz.

134
 Npr. int c[9]; je deklaracija za jednodimenzionalni niz koji ima 18 elemenata. Element niza
je: ime_niza[indeks_elementa]. Indeks_elemenata_niza je u rangu od 0 do za jedan manje (n-
1) od ukupno n elemenata niza. Dakle, prvi element niza ima indeks 0, drugi indeks 1, treći indeks
2, itd. Za niz c[18] elementi su: c[0], c[1], c[2], c[3], c[4], c[5], c[6], c[7], c[8].

Slika 59. Karakteristike niza

Elementi niza mogu biti bilo kojeg tipa. Npr.:

int radnici[27]; // deklaracija niza radnici, koji ima 27 elemenata tipa int
double prosjek[90]; // deklaracija niza od 90 elemenata koji su tipa float

Često se broj elemenata niza deklariše kao konstanta, pa u tom slučaju imamo sljedeće
deklaracije:

const int max = 4;

float temperatura [max];//deklaracija niza temperatura od max (4) elemenata tipa float

Inicijalizacija niza je dodjeljivanje početnih vrijednosti elementima niza ili cijelom nizu.
Može se izvršiti prilikom deklaracije niza, navođenjem unutar vitičastih zagrada vrijednosti za
pojedinačne elemente niza. Npr.:

float ocjene[5] ={0.0,0.0,0.0,0.0,0.0}; //inicijalizacija niza prilikom deklaracije

//u ovom slučaju svi elementi niza imaju vrijednost 0

135
 Isto se može postići i na drugi način:

int n[ 10 ] = { 0 }; // inicijalizacija svih 10 elemenata na 0

Ako je veličina niza izostavljena iz deklaracije niza koji ima inicijalizacijsku listu, tada
kompajler odreduje broj elemenata niza brojanjem elemenata.

Npr. sa: int x[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 }; se deklariše niz od 9 elemenata.

Ako su veličina niza i inicijalna lista specificirani u deklaraciji niza, broj inicijalizatora mora
biti manji ili jednak veličini niza.
Deklaracija niza int y[ 6 ] = { 18, 27, 63, 36, 72, 54, 45 }; nije ispravno urađena, pa će
kompajler prijaviti sintaksnu grešku, jer je detektovao 7 inicijalnih vrijednosti za 6 elemenata
niza.

14.1. Manipulacije sa nizovima

Pod manipulacijom sa nizovima, podrazumijevamo operacije učitivanja vrijednosti

elemenata niza, ispisivanje vrijednosti elemenata niza, procesiranje vrijednosti elemenata niza i
štampanje vrijednosti elemenata niza. Sve te operacije se najčešće rade u kombinaciji sa
strukturama ponavljanja (for petljom, while do petljom, do while petljom itd.) da se ne bi
pojedinačno procesirao element po element niza.

Primjer inicijalizacije niza pomoću for petlje

for ( i = 0; i < 12; i++ ) // svi elemeni niza dobivaju vrijednost 36

plata[i]=36;

Svakom pojedinačnom elementu niza od 0 do 11 (12 elemenata) se dodjeljuje početna

vrijednost 36.Ovaj način punjenja niza se može smatrati zamjenom za dio koda:

plata[0]=36 ;
plata[1]=36 ;
plata[2]=36 ;
plata[3]=36 ;
plata[4]=36 ;
.....
plata[11]=36 ;

136
 Unos pojedinačnih elemenata niza sa standardnog ulaza pomoću for petlje:

for ( i=0; i < 12; i++ )

{
cout <<“Unesite platu za “ << (i + 1) << “. mjesec: “;
cin >>plata[i];
}

14.2. Prekoračenje granica niza

U jeziku C++ jeziku, elementi niza se smještaju u susjedne memorijske lokacije. Prvi element niza
zauzima lokaciju na najnižoj adresi, a poslednji na najvišoj. Direktna dodjela jednog niza drugom
nije dozvoljena, već se vriednosti moraju dodjeljivati element po element. Dalje, jezik C++ ne
provjerava granice niza što znači da programera ništa ne ograničava da "prekorači” kraj niza.
Drugim riječima, ako je indeks posljednjeg elementa niza npr. 12, može da se indeksira element
sa indeksom većim od 12, a da to ne izazove nikakve greške tokom kompajliranja ili izvršavanja
programa. Zato se može reći da je prekoračenje ograničenja indeksa najčešća greška koja dovodi
do neispravnog rada programa što se vidi na sljedećem primjeru koda:

int a[10]; // deklaracija niza

// petlja koja inicijalizira elemente niza tako što njihov indeks, odnosno vrijednost varijable i
// množi sa 2 i smješta u pojedinačne elemente niza
for ( i=0 ; i<=10 ; i++ )
a[i]=2*i;

Tijelo petlje se izvršava i u slučaju kada je i = 10, ali budući da je posljednji element niza
a[9], tada dolazi i do promjene memorijske lokacije, koja nije rezervisana deklaracijom niza a[10],
pa program neće raditi ispravno.
Imamo i drastičniji primjer greške, koja može biti katastrofalna za ispravnost izvođenja
programa. Pretpostavimo da je u ovom istom primjeru u kontrolnoj liniji for petlje uslov izlaska
iz petlje i<100. Dakle bez obzira što je niz a[10] deklarisan da ima 10 elemenata, for petlja ga
puni sa dodatnih 90, odnosno ukupno 100. To će prouzrokovati mijenjanje memorijskih lokacija
koje nisu dodijeljene nizu. Prekoračenje granica niza može da prouzrokuje katastrofalne
posljedice. Ako se prekoračenje granice desi u operaciji dodjele inicijalne vrijednosti, mijenja se
memorija u kojoj se mogu naći neke druge promjenljive, a ako se desi tokom čitanja, program
će raditi sa neispravnim podacima. Medutim, kada bi provjera granica niza bila ugrađena u C++
jezik (kao što je to slučaj npr. u programskom jeziku Java), C++ kôd ne bi bio toliko brz i
efikasan.Zato je odgovornost prebačena na programera od koga se očekuje da bude oprezan,

137
odnosno da deklariše niz tako da sadrži potreban broj elemenata i da ne dozvoli prekoračenje
granice.

14.3. Korišćenje nizova karaktera (polja) za manipulaciju sa stringovima

Kao što je već rečeno, pojedinačni elementi niza mogu biti i karakternog tipa, odnosno
tipa char. Ovi nizovi se mogu inicijalizirati korišćenjem stringova ili literala. Često se za niz čiji
su elementi znakovi (karakteri) koristi naziv string. Najčešće se jednodimenzionalni nizovi
koriste za pohranjivanje znakova. Jezik C++ podržava dvije vrste niza znakova (stringova). Prvi je
niz znakova koji se završava nulom ili tačnije null-terminated stringom ili null karakterom,
naslijeđen iz jezika C. On sadrži znakove koji sačinjavaju string, i na kraju null (odnosno znak '\0').
Ova vrsta stringova se koristi često zato što je veoma efikasna i programeru omogućuje detaljnu
kontrolu nad operacijama sa stringovima. Druga vrsta je klasa string koja se nalazi u biblioteci
klasa jezika C++. Treba se podsjetiti da u jeziku C++, string nije osnovni odnosno nije ugrađen tip.
Kada se deklariše niz znakova koji se završava nulom, on treba da se deklariše tako da bude za
jedan duži od broja znakova u stringu koji treba da sadrži. Na primjer, ako želimo da deklarišemo
niz imena string_1 u koji treba da stane string od deset znakova, deklarisaćemo ga kao char
string_1[11];
Npr.: char string_2[] = "first";, deklariše niz sa nazivom string_2 i elemente niza
inicijalizira na “first”. Treba uočiti da se string “first” sastoji od 5 znakova (karaktera) plus
specijalni znak za terminiranje (oznaka kraja) stringa, koji se naziva null karakter.
Tako, da niz string_2 stvarno sadrži 6 elemenata. Karakter konstanta koja predstavlja null
karakter je '\0'. Niz karaktera koji predstavljaju string moraju uvijek biti deklarisani tako da
mogu sadržavati zahtijevani broj znakova plus terminirajući null karakter.
Nizovi karaktera, takođe mogu biti inicijalizirani sa pojedinačnim karakterima u inicijalnoj listi kao
u primjeru:

char string_1[] = { 'f', 'i', 'r', 's', 't', '\0' };

Za svaku karakter konstantu se koriste jednostruki navodnici i eksplicitno je obezbijeđen

terminirajući null karakter ('\0'). Zato što je string ustvari niz karaktera, može se pristupiti
individualnim karakterima (znakovima) u stringu direktno. Npr. string_1[0] je karakter 'f',
string_1[3], kao četvrti po redu element niza je znak 's' i string_1[5] je null karakter.
Takođe, string se može učitati direktno u niz tipa char sa standarnog ulaza korišćenjem
cin iskaza i operatora >>. Npr. deklaracija - char string_2[20]; kreira niz znakova u koji se može
smjestiti 19 znakova stringa i null karakter. Iskaz cin >> string_2; učitava string sa tastature u
string_2 i dodaje null karakter na kraj unesenog stringa. Prethodni iskaz obezbjeđuje samo ime
niza ali ne i dodatne informacije o dužini niza. Neophodno je voditi računa da je niz u koji se

138
učitava string sa ulaza dovoljne veličine da se uneseni string u njega smjesti. Iskaz cin učitava
znakove sa tastature dok se ne pojavi neki space karakter ili do kraja veličine niza.
Iskaz cout << string_2; prikazuje niz string_2 na standardni izlazu. Iskaz cout <<, kao i cin >>, ne
vodi računa kolike je dužine niz karaktera.
Niz karaktera se može procesirati i karakter po karakter, npr sa for petljom, što je i
prikazano donjim programskim iskazom.

for ( int i = 0; string_1[ i ] != ”\0”; i++ )

cout << string_1[ i ] << ” ”;

Iz primjera je vidljivo da bi se prikazao „znak po znak” niza, elementima niza se prilazi

pomoću for petlje, koja terminira kada u nizu naiđe na null karakter, odnosno prikazuje znak po
znak iz stringa sve dok je izraz string_1[ i ] != '\0' tačan. Kada izraz string_1[ i ] != '\0' postane
netačan, odnosno kada neki element niza (zadnji) bude jednak '\0', završen je prikaz svih
elemenata niza i petlja se završava.
Primjer prebrojavanja znakova (slova) u zadatom nizu uz pomoć jednodimenzionalnih
nizova i for petlje, prikazan je na slikama 60a i 60b.

Slika 60a. Program prebrojavanja znakova, dodijeljenih nizu u programu

139
 Slika 60b. Rezultati rada programa prebrojavanja znakova, dodijeljenih nizu u programu

Ukoliko čitalac iz znatiželje pokuša provjeriti tačnost dobivenog rezultata, uočiće da se

ukupno u navedenoj rečenici glas 'r' pojavljuje 12 puta, a rezultat u programu je 11. Budući da je
u programu zadato pretraživanje znaka 'r' (malo slovo), a ne 'R' (veliko slovo), a računar razlikuje
mala slova od velikih, rezultat pretraživanja je tačan, jer prilikom pretraživanja ne uzima u obzir
veliko slovo 'R', kojim počinje rečenica. Da bi pretraživao i veliko i malo slovo za neki glas, treba
promijeniti dio koda u liniji 18, naveden kao if(x[i]=='r') sa kodom if((x[i]=='r' II (x[i]== 'R')).
Sličan primjer, kojim se rješava malo složeniji zadatak u odnosu na primjer sa slike 54, odnosi se
na pretraživanje i prebrojavanje pojavljivanja jednog znaka u 2 niza, prvo u jednom nizu, zatim u
drugom, a onda u oba niza, prikazan je na slici 61.

140
Slika 61. Primjer pretraživanja niza i prebrojavanja znakova u 2 niza

141
 14.4. Predaja nizova funkcijama

Da bi predali niz kao argument funkciji, potrebno je specificirati ime niza kao parametar
i to bez zagrada. Npr.: ako je niz mjesečni_prihodi deklarisan kao

int mjesečni_prihodi[12];,

tada poziv npr. funkcije

porezi (mjesečni_prihodi, 12);,

predaje niz mjesečni_prihodi i njegovu veličinu funkciji porezi. Kada se niz predaje funkciji,
normalno predaje se i veličina, tako da funkcije mogu procesirati specifične elemente u nizu.
C++ predaje niz funkciji preko reference tako da funkcije imaju mogućnost mijenjanja vrijednosti
elemenata originalnog niza. Pojedinačni elementi niza mogu se predati funkciji i po vrijednosti.
Za funkcije koje primaju niz preko poziva funkcija, listom parametara funkcije se mora
specificirati da funkcija očekuje da primi niz. Npr. zaglavlje funkcije za funkciju porezi može biti
napisano kao:

void porezi(int x[], int duzina_niza)

i znači da funkcija porezi, očekuje da primi niz cjelobrojnih vrijednosti u parametar x i broj
elemenata niza u parametar duzina_niza.

Prototip se može napisati i kao:

void porezi( int [], int; )

jer kako što je već poznato, kompajler ignoriše imena varijabli u prototipu funkcije pa se ona niti
ne moraju navodit. Prototip funkcije saopštava kompajleru broj i tip argumenata, te redoslijed
u kojem se argumenti očekuju. Primjer predaje nizova i pojedinačnih elemenata funkciji, prikazan
je na slikama 62a i 62b .

U ovom primjeru su definisane dvije funkcije:

1. modifyArray koja prima dva parametra - niz i broj elemenata niza. Ovoj funkciji se
parametar predaje po referenci.
2. modifyElement koja prima jedan parametar - vrijednost elementa niza

142
 Odgovarajući pozivi funkcija su:

modifyArray( a, arraySize );
modifyElement( a[3] );

Efekti izvršenja funkcija su:

a) modifyArray mijenja orginalni niz, dok funkcija

b) modifyElement ne mijenja originalnu vrijednost elementa.

Postoji mnogo situacija kada se funkciji ne bi trebalo dozvoliti da mijenja elemente niza.
Zbog toga C++ jezik obezbjeđuje kvalifikator const, koji se koristi da spriječi modifikaciju
elemenata niza. Kada je funkcijom specificiran niz kao parametar ispred kojeg je const
kvalifikator, elementi niza postaju konstantni u tijelu funkcije. Pokušaj da se modifikuje element
niza u tijelu funkcije rezultira kompilacijskom greškom.

Slika 62a. Primjer predaje nizova i pojedinačnih elemenata funkciji

143
Slika 62b. Rezultat rada programa (primjera) predaje nizova i pojedinačnih elemenata funkciji

14.5. Višedimenzionalni nizovi

Iako se jednodimenzionalni nizovi najviše koriste, postoje i situacije koje zahtijevaju

upotrebu nizova sa dvije, tri, ili više dimenzija. U suštini svaki višedimenzionalni niz je niz
jednodimenzionalnih nizova. Organizacija niza u memoriji računara je ista kao i kod
jednodimenzionalnih nizova, odnosno predstavlja neprekidnu sekvencu elemenata niza.
Dvodimenzionalni nizovi se često koriste za predstavljanje informacija smještenih u redove i
kolone neke dvodimenzonalne tabele. Da bi identifikovali određeni element u tabeli moraju se
specificirati dva indeksa, odnosno indeks reda i indeks kolone, kada su u pitanju tabele. Najčešće
je indeks reda redni broj reda, koji počinje sa 0 pa nastavlja sa 1, 2, 3, 4 itd., a indeks kolone redni
broj kolone, koji isto počinje sa 0 i nastavlja sa 1, 2, 3, 4 itd. Da bi se tačno odredilo o kojem se
konkretno elementu niza radi, prvo se identificira redni broj reda elementa, pa zatim redni broj
kolone. Dakle, na presjeku odgovarajućeg reda i odgovarajuće kolone, nalazi se konkretno polje,
koje sadrži podatak, a to polje u teoriji o nizovima zovemo elemenat niza, a tabelu bilo da je
jednodimenzionalna ili višedimenzionalna zovemo polje (engl. array) ili niz.

144
 Slika 63. Prikaz dvodimenzionalnog niza

U C++ jeziku, deklaracija prikazanog niza se postiže iskazom:

int a[3][4];

Elementi niza su: a[0][0], a[0][1], ... a[2][3];

Isto kao i za jednodimenzionalne nizove, inicijalizacija dvodimenzionalnih nizova,

učitavanje, prikaz i ispisivanje, uglavnom se vrši pomoću struktura ponavljanja sa onoliko
ugnježdenih petlji koliko niz ima dimenzija. Direktna inicijalizacija dvodimenzionalnog niza se vrši:

int tab[3][4]={
{36,45,72,81},
{63,54,27,42},
{90,09,18,99}
};

145
U ovom slučaju elemnti niza su:

tab [0] tab [0] tab [0] tab [0]

[0]=36; [1]=45; [2]=72; [3]=81;
tab [1] tab [1] tab [1] tab[1]
[0]=63; [1]=54; [2]=27; [3]=42;
tab [2] tab [2] tab [2] tab [2]
[0]=90; [2]=09; [2]=18; [3]=99;

Tabela 30. Tabela Inicijalizacija višedimenzionalnog niza int pom[10] [10]; pomoću for petlje:

// postavljanje elemenata niza na vrijednost 10

for (i=0; i<10; i++) // indeks prve dimenzije - red
for (j=0; j<10; j++) // indeks druge dimenzije - kolone
pom [i] [j]=10;

Primjer inicijalizacije svih elemenata dvodimenzionalnog niza, te čitanja, odnosno prikaza

svih elemenata niza deklarisanog kao int matrica[10] [20]; uz pomoć for petlje, prikazan je na
slici 64.
Na programskoj liniji 8, deklariše se dvodimenzionalni niz (tabela) dimenzija 10 redova
sa 20 kolona tipa integer: int matrica[10] [20];. Prvim parom for petlji (varijabla i je zadužena za
redove i maksimalna vrijednost za definisanje ovog niza joj je 9, a varijabla j je zadužena za kolone
i maksimalna vrijednost joj je 19), inicijaliziraju se sve varijable od varijable matrica[0][0] do
varijable matrica[9][19] inicijalnom vrijednošću 27. Inicijalizacija ide tako da se prvo inicijaliziraju
sve varijable u nultom redu od varijable matrica[0][0] do varijable matrica[0][19], a to je ukupno
10 varijabli. Nakon toga se varijabla i, iz prve for petlje povećava sa 0 na 1, pa se popunjava 1.
red varijabli od varijable matrica[1][0] do varijable matrica[1][19]. Za taj rast od 0 do 19 je
zadužena varijabla j iz druge for petlje. I tako se to ponavlja sve dok se i posljednji elemenat
dvodimenzionalnog niza - varijabla matrica[9][19], ne popuni vrijednošću 27.
Kada je završena inicijalizacija (punjenje elemenata niza određenim početnim vrijednostima),
drugim parom for petlji, počinje učitavanje, odnosno prikaz vrijednosti svih elemenata
dvodimenzionalnog niza po istom principu kao i punjenje, pa se na ekranu kao krajnji rezultat
ispisa dvodimenzionalne matrice pojavi 10 redova sa po 20 istih vrijednosti (inicijalna vrijednost
27) u svakom redu.

146
Slika 64. Primjer inicijalizacije, čitanja i prikaza elemenata dvodimenzionalnog niza

147
15. SLOGOVI PODATAKA (STRUKTURE)

Slog podataka ili struktura podataka je grupa različitih vrsta podataka, grupisanih pod
jednim imenom. U zavisnosti od programskog jezika, slogovi se nazivaju strukture, instance,
polja, komponente ili članovi. U C++ jeziku, slog se naziva struktura, a sastavni elementi sloga se
najčešće nazivaju članovi ili komponente. Najjednostavnije rečeno, struktura je složeni tip
podataka koji se sastoji od više članova, pri čemu svi članovi mogu biti različitog tipa.
Slog ili tačnije strukturu sloga (sastav sloga) definišemo u slučaju kada želimo da karakteristike
nekog objekta (entiteta) posmatramo kao cjelinu. Objekat posmatranja (entitet) može biti npr.
student, zaposleni radnik, pacijent ili odsjek na fakultetu. Ako je objekat posmatranja Student,
opisujemo ga sa imenom, prezimom, brojem indeksa, godinom studija, odsjekom studija,
smjerom studija itd. Ako je objekat posmatranja Radnik, opisujemo ga imenom, prezimenom,
matičnim brojem, radnim mjestom itd. Svi relevantni podaci o jednom studentu ili o jednom
radniku, bez obzira na činjenicu kojeg su tipa (znakovni, cjelobrojni ili neki dr.) predstavljaju skup
podataka (polja sa podacima o karakteristikama objekta posmatranja) koji se naziva slog ili u C++
jeziku struktura. Kao što se slog sastoji iz različitih polja u kojima su zapisani podaci o obilježjima
objekta prikupljanja, tako se i struktura u C++ jeziku sastoji iz članova te strukture, koji mogu biti
različitog tipa podataka i različite dužine.
Opšti format strukture u c++ jeziku je:

struct structure_name
{
member_type_1 member_name_1;// tip_1_člana ime_člana_1
member_type_2 member_name_2;// tip_2_člana ime_člana_2
member_type_3 member_name_3;// tip_3_člana ime_člana_3
.
.
.
} object_names;// imena_objekata

pri čemu je structure_name (ime_strukture) opisni naziv za tip strukture, a object_names

(imena_objekata) može biti skup validnih identifikatora za objekte, koje imaju tip ove strukture.
Unutar zagrade {} postoji lista sa članovima (members), a svaki je naveden sa tipom i validnim
identifikatorom kao njegovim imenom.

148
 Sintaksa se može prikazati i na drugi opisniji način:

struct [opisno_ime_strukture]
{
lista_ članova_ strukture
} deklaracija_varijabli

Sljedeća deklaracija u C++ jeziku, predstavlja strukturu koja se sastoji od 4 člana:

a) prvi član (model) je string tipa,

b) drugi član (cijena) je realnog tipa,
c) treći i četvrti član su integer tipa, i predstavljaju godinu proizvodnje i zapreminu
rezervoara za gorivo.

struct {
char model [20];
float cijena;
int god_proiz;
int gorivo;
}

Ukoliko želimo da deklarišemo varijablu “automobil”, koja je tipa gore deklarisane

strukture, tada pišemo:

struct {
char model [20];
float cijena;
int god_proiz;
int gorivo;
} auto_1;

Ako želimo da deklarišemo više varijabli tog tipa npr. auto_1 i auto_2, koje su istog tipa
strukture, pisaćemo:

struct {
char model [20];
float cijena;
int god_proiz;
int gorivo;
} auto_1, auto_2;

149
 Ukoliko koristimo opisno ime strukture, koje nije obavezno kod deklarisanja struktura,
tada uvođenje opisnog imena strukture (a) i deklaracija varijabli (b) zgledaju ovako:

a) struct automobil {
char model [20];
float cijena;
int god_proiz;
int gorivo;
}

b) struct automobil auto_1, auto_2;

Postoji i drugi način za uvođenje tipa podataka automobil. Taj drugi način se odnosi na
upotrebu komande typedef.

typedef struct {
char model [20];
float cijena;
int god_proiz;
int gorivo;
} automobil;

Tada se deklaracija varijabli auto_1, auto_2, vrši na sljedeći način:

automobil auto_1, auto_2;

Tip “automobil” je korisnički definisan tip podataka i može se koristi na svim mjestima
gdje je dozvoljeno korišćenje i elementarnih tipova podataka.
Na ovom mjestu je važno zapaziti da je prvi korak u radu sa strukturama definisanje strukture i
eventualno uvođenje novog tipa podataka, a nakon toga se vrši deklarisanje objekata (varijabli
i konstanti) tog tipa podataka. Zato npr. iskaz automobil a_1, a_2;, predstavlja deklaraciju
varijabli a_1 i a_2, koji su tipa automobil (to je složeni tip podataka, odnosno struktura).

15.1. Pristup članovima strukture

U nekim drugim programskim jezicima, ovaj naslov bi označavao pristup poljima u

strukturi sloga u kojima su zabilježeni podaci o karakteristikama objekta prikupljanja podataka.
Pristup pojedinim članovima strukture (members), može se vršiti direktno ili indirektno.
Direktan način pristupa pojedinim članovima vrši tako što se navede:

varijabla_tipa_strukture.ime_člana (sve zajedno)

150
 Npr. za auto_1 članovi (polja u strukturi sloga) su:

auto_1.model
auto_1.cijena
auto_1.god_proiz
auto_1.gorivo

Bitna karakeristika članova strukture je da se oni isto kao polja u strukturi sloga, koriste
kao i sve druge varijable elementarnog tipa u C++ jeziku. Na isti način će se npr. ponašati varijabla
auto_1.cijena u iskazu auto_1.cijena=auto_1.cijena*porez;, kao što se ponaša bilo koja druga
varijabla tipa float u sličnim iskazima. Selektirani član strukture je varijabla tipa selektiranog
polja. Prilikom unosa ili ispisa varijable tipa strukture, mora se navoditi član po član. Drugim
riječima nije moguće odmah unijeti niti prikazati sadržaj cijele strukture. Strukture se mogu
izjednačavati, odnosno kopirati sadržaj iz jedne u drugu strukturu ukoliko su istog tipa.
Npr.:
auto_1=auto_2;

15.2. Inicijalizacija ili punjenje struktura

Kao i kod elementarnih tipova podataka, tako se i prilikom deklaracije varijabli tipa
strukture mogu dodijeljivati inicijalne vrijednosti toj varijabli tako što se unutar vitičastih
zagrada navode vrijednosti za članove strukture i to onim redoslijedom kojim su deklarisani ti
članovi strukture. Vrijednosti koje se na taj način navode, moraju se odvajati zarezima.
Npr.:
struct {
char model [20];
float cijena;
int god_proiz;
int gorivo;
} auto_1= (“KIA”,12500.00,2012,80);

Inicijalizacija je ista i kada se radi o drugim varijantama deklaracije varijabli tipa

strukture.
Na osnovu strukture se izvode klase u objektno orijentisanim programskim jezicima. Klasa
objedinava unutar sebe i atribute (podatke) kao i funkcije (ponašanje) i predstavlja osnovni
koncept prilikom programiranja u objektno orijentisanim programskim jezicima.
Primjer interaktivne inicijalizacije strukture i ispisa unesenih podataka, prikazan je u programu
na slikama 65a i 65b.

151
 15.3. Predaja parametara struktura funkcijama

Kao i kod ostalih tipova podataka, tako i kod tipova struktura, sadržaj strukture se može
predati funkciji modelom predaje po vrijednosti tako da se predaje član po član te strukture
funkciji. Strukture i njeni članovi se također mogu predati funkciji po referenci, tako što se
predaje ili referenca ili pointer.
Da bi se struktura predala funkciji po referenci, potrebno je predati adresu strukture
objektu. Predaja struktura po referenci je mnogo efektivniji način nego predaja po vrijednosti,
osobito kod velikih struktura, jer predaja parametara po vrijednosti podrazumijeva kopiranje
kompletnog sadržaja strukture, što naravno usporava izvršenje programa. Primjer programa koji
ilustruje predaju parametra strukture funkciji po referenci, prikazan je na slici 58.

Slika 65a. Primjer punjenja strukture i njenog prikaza

152
Slika 65b. Primjer punjenja strukture i njenog prikaza

Slika 66a. Primjer predaje parametra tipa strukture funkciji po referenci

153
Slika 66b. Rezultati rada programa predaje parametra tipa strukture funkciji po referenci

154
LITERATURA

Cockburn, A. i dr., Beck, K., Beedle, M., Bennekum, van A., Manifesto for Agile Software
Development, (2011), http://www.agilemanifesto.org/

Corrado, B., & Jacopini, G.,(1966), Flow Diagrams, Turing Machines And Languages With Only
Two Formation Rules, International Computation Centre and Istituto Nazionale per le
Applicazioni del Calcolo, Roma, Italy

Hancock L., Krieger M., (1986), The C Primer, Mc Graw-Hill

Motik, B., Šribar, J., (1997), Demistificirani C++, Element, Zagreb

Panian, Ž., (1999), Poslovna informatika - koncepti, metode i tehnologija, Informator, Zagreb,.
79 str i str 80

Parezanović, N., Petrić Z., Mitrinović D., (1979), Računske mašine i programiranje - programski
jezik COBOL, Beograd, str 7

Smith, R., (2020), Working Draft, Standard for Programming Language C++, 1.4.2020., str. 24

Srića, V., (1988), Uvod u sistemski inžinjering, Informator, Zagreb, str. 86

Stroustrup, B., (1996). A History Of C++: 1979-1991. Objavljeno u knjizi autora Bergin, T.,
Gibson, R.; History of Programming Languages II, str. 699-769.

Turban, E., Rainer K. Jr, (2009), Uvod u informacione sisteme, Data status, Beograd, 2009, str,
109

https://dl.acm.org/doi/10.1145/355592.365646
http://open-std.org/JTC1/SC22/WG21/docs/papers/2020/n4861.pdf
https://www.periodni.com/hr/pretvaranje_rimskih_brojeva.html

155
POPIS SLIKA
Slika 1: Hijerarhija memorijskih zapisa
Slika 2. Varijanta jednog dijagrama toka: Odlučivanje korištenjem informacija
Slika 3. Blok dijagram aktivnosti prilikom pravljenja programa
Slika 4. Prikaz jedne linije teksta sa više iskaza [(slučaj pod a)]
Slika 5. Prikaz više linija teksta sa jednim cout iskazom [(slučaj pod b)]
Slika 6. Kod programa, koji sabira dva cijela broja, unesena sa tastature
Slika 7. Primjer različitih načina definisanja i inicijaliziranja varijabli
Slika 8. Objašnjenje deklarisanja varijabli
Slika 9. Primjer za ilustraciju deklarisanja i definisanja konstanti
Slika 10. Ilustracija deklaracije i upotrebe realnog tipa podataka
Slika 11. Ilustracija upotrebe nabrojivog tipa varijabli
Slika 12. Prefix i Postfix operatori sabiranja
Slika 13. Kružna aritmetika, Izvor: Adapt. prema (Motik i Šribar, 1997)
Slika 14. Primjer upotrebe uslovnog operatora grananja
Slika 15. Primjer eksplicitne primjene operatora dodjele tipa (cast)
Slika 16. Primjer programa, koji ilustruje primjenu Sizeof operatora
Slika 17. Struktura sevence (blok) prikazana UML dijagramom
Slika 17. Strukture izbora (selekcija) u C++ jeziku
Slika 18a. If iskaz izbora, kada je uslov tačan
Slika 18b. If iskaz izbora, kada uslov nije tačan
Slika 19. UML dijagram aktivnosti za primjer ilustracije if iskaza
Slika 20a. Primjer upotrebe složenog iskaza nakon ispunjenog uslova u if naredbi
Slika 20b. Rezultat upotrebe složenog iskaza nakon ispunjenog uslova u if naredbi
Slika 21. Grafički prikaz if … else naredbe
Slika 22. UML dijagram aktivnosti za primjer koji ilustruje if … else strukturu
Slika 23. Primjer upotrebe blokla naredbi unutar vitičastih zagrada iza ključne riječi else
Slika 23a. Rezultat rada programa sa promijenjenom opcijom (pol_osobe=2)
Slika 24. Blok dijagram switch strukture izbora
Slika 25. Primjer upotrebe switch strukture izbora sa izvođenjem istog iskaza za više varijanti
Slika 26. Ilustracija ugnježdene if naredbe za računanje ocjene na osnovu ukupnog broja
bodova
Slika 27. Program za ilustraciju svitch-case strukture izbora
Slika 28. Grafički prikaz toka izvršavanja while do petlje
Slika 29. C++ program, koji rješava zadatak uz pomoć while do strukture.
Slika 30. Grafički prikaz toka izvršavanja do while petlje
Slika 31. C++ program, koji rješava prethodni zadatak uz pomoć do while strukture
Slika 32. Primjer upotrebe for petlje za rješavanje zadatka računanja zbira brojeva od 1 do
nekog
Slika 33. Primjer upotrebe dva inicijalna inkrementalna i dva izraza u jednoj for petlji
Slika 34. Primjer for petlje bez inkrementa
Slika 35. Varijacija upotrebe for petlje sa izmještanjem inicijalnog izraza izvan petlje
Slika 36a. Primjer upotrebe for petlje bez tijela petlje

156
Slika 36b. Primjer upotrebe for petlje bez tijela petlje
Slika 37. Primjer upotrebe continue naredbe
Slika 38. Primjer upotrebe continue naredbe sa više iteracija
Slika 39. Primjer upotrebe i poređenja continue i break naredbe
Slika 40. Primjer upotrebe goto naredbe
Slika 41 Primjer upotrebe goto iskaza, tipičan za nestrukturirane programske jezike
Slika 42 Primjer koji ilustruje deklaraciju i poziv (upotrebu) funkcije
Slika 43. Primjer definisanja prototipa funkcije, definicije funkcije i poziva funkcije
Slika 44. Primjer upotrebe funkcije za određivanje maksimuma od 3 unesena broja
Slika 45. Program ilustruje povratak iz funkcije, koja ne vraća ništa uz pomoć return naredbe
Slika 46. Primjer C++ programa, koji ilustruje upotrebu exit(); naredbe
Slika 47. Program koji ilustruje lokalnu oblast važenja varijable
Slika 48. Primjer ponavljanja inicijalizacije varijable svakim izvršenjem tijela funkcije
Slika 49. Primjer programa kojim se ilustruje upotreba static lokalne varijable
Slika 50. Primjer koji ilustruje upotrebu globalnih, te static i auto lokalnih i varijabli
Slika 51. Prikaz vrijednosti varijabli različitog vidokruga, a istog imena (x).
Slika 52. Primjer upotrebe rekurzivne funkcije za izračunavanje funkcije faktorijel za neki broj
Slika 53. Primjer upotrebe rekurzivne funkcije za vraćanje vrijednosti broja u Fibonačijevom
nizu
Slika 54. Izračunavanje funkcije faktorijel uz pomoć while do petlje
Slika 55. Primjer deklarisanja funkcije sa praznom listom parametara
Slika 56. Primjer deklarisanja i upotrebe Inline fukcije pri izračunavanju zapremine kocke
Slika 57. Primjer preklapanja funkcija
Slika 58a. Program poređenja predaje parametara po vrijednosti i predaje po referenci
Slika 58b. Primjer rezultata poređenja predaje parametara po vrijednosti i predaje po referenci
Slika 59. Karakteristike niza
Slika 60a. Program prebrojavanja znakova, dodijeljenih nizu u programu
Slika 60b. Rezultati rada programa prebrojavanja znakova, dodijeljenih nizu u programu
Slika 61. Primjer pretraživanja niza i prebrojavanja znakova u 2 niza
Slika 62a. Primjer predaje nizova i pojedinačnih elemenata funkciji
Slika 62b. Rezultat rada programa (primjera) predaje nizova i pojedinačnih elemenata funkciji
Slika 63. Prikaz dvodimenzionalnog niza
Slika 64. Primjer inicijalizacije, čitanja i prikaza elemenata dvodimenzionalnog niza
Slika 65a. Primjer punjenja strukture i njenog prikaza
Slika 65b. Primjer punjenja strukture i njenog prikaza
Slika 66a. Primjer predaje parametra tipa strukture funkciji po referenci
Slika 66b. Rezultati rada programa predaje parametra tipa strukture funkciji po referenci

157
POPIS TABELA

Tabela 1. Varijacije sa ponavljanjem od 2 binarna broja

Tabela 2. Binarne kombinacije oktalnog brojnog sistema
Tabela 3. Tabela varijacija sa ponavljanjem od 4 binarna znaka
Tabela 4. Vrijednosti znakova rimskog brojnog sistema u zapisu brojne vrijednosti
Tabela 5. Prikaz karakteristika brojnih sistema, koji se koriste u informatici
Tabela 6. Binarni, oktalni i heksadecimalni ekvivalenti brojeva od 0 do 15.
Tabela 7. Izračunavanje vrijednosti broja (zapisa brojne vrijednosti)
Tabela 8. Pretvaranje binarnog broja u decimalni
Tabela 9. Provjera tačnosti rezultata
Tabela 10. Escape sekvence
Tabela 11. Raspon brojeva i dužina floating point varijabli
Tabela 12. Operatori pridruživanja
Tabela 13. Relacioni i operatori jednakosti
Tabela 14. Binarni aritmetički operatori
Tabela 15. Unarni aritmetički operatori
Tabela 16. Ilustracija prefiks i sufiks identifikatora
Tabela 17. Redoslijed izvršavanja aritmetičkih operacija
Tabela 18. Logički operatori u C++ jeziku
Tabela 19. Tabela istinitosti za && logički operator
Tabela 20. Tabela istinitosti za || logički operator.
Tabela 21. Rezervisane (ključne) riječi
Tabela 22. Alternativne oznake operatora u C++ jeziku po ISO standardu za C++ 20
Tabela 23. Primjer upotrebe if naredbe
Tabela 24. Opšti format if … else strukture i njen pseudokod
Tabela 25. Opšti formati while do strukture
Tabela 26. Opšti formati do while strukture
Tabela 27. Opšti formati for petlje
Tabela 28. Prikaz vrijednosti kontrolne varijable i izraza for petlje po iteracijama
Tabela 29. Vrijednosti varijabli u pojedinim tačkama programa
Tabela 30. Tabela Inicijalizacija višedimenzionalnog niza int pom[10] [10]; pomoću for petlje:

158