Sunteți pe pagina 1din 72

Sadržaj:

0. Uvod:................................................................................................................................................3
1. Programski jezici .............................................................................................................................4
1.1 Programska podrška...................................................................................................................4
1.2 Naredbe - program......................................................................................................................4
1.3 Programski jezik – ključne riječi................................................................................................4
1.4 Programski jezik - sintaksa.........................................................................................................4
1.5 Prevođenje u binarni oblik..........................................................................................................4
1.6 Programski jezici - podjela.........................................................................................................5
1.7 Strojni jezik................................................................................................................................5
1.8 Simbolički jezik niske razine......................................................................................................5
1.10 Simbolički jezici visoke razine.................................................................................................5
1.11 C...............................................................................................................................................5
2. Algoritam..........................................................................................................................................7
2.1 Elementi algoritma.....................................................................................................................7
2.2 Dijagram tijeka...........................................................................................................................7
2.3 Osnovne algoritamske strukture.................................................................................................7
2.4 Slijedni algoritam.......................................................................................................................8
2.5 Grananje.....................................................................................................................................8
2.6 Petlja...........................................................................................................................................8
3. Nastanak programa...........................................................................................................................9
3.1 Objekti........................................................................................................................................9
3.2 Objektno orijentirani program....................................................................................................9
3.3 C++.............................................................................................................................................9
3.4 Borland C++ Builder..................................................................................................................9
3.5 Nastanak programa...................................................................................................................10
3.6 Izvorni kod................................................................................................................................10
3.7 Izvršni oblik..............................................................................................................................10
3.8 Biblioteke.................................................................................................................................10
3.9 Povezivač..................................................................................................................................11
3.10 Izvršna datoteka......................................................................................................................11
3.11 Projekt.....................................................................................................................................11
3.12 Pogreške.................................................................................................................................11
3.13 Provjera programa..................................................................................................................12
3.14Borland C++ Builder...............................................................................................................12
3.15 C++ datoteka izvornog koda..................................................................................................12
...........................................................................................................................................................14
4. C++ podaci.....................................................................................................................................15
4.1 Podaci.......................................................................................................................................15
4.2 Memorijske adrese ...................................................................................................................15
4.3 Varijable...................................................................................................................................15
4.4 Oznaka tipa podatka.................................................................................................................16
4.5 Pridruživanje vrijednosti..........................................................................................................16
4.6 Tipovi podataka........................................................................................................................17
4.7 Brojevi......................................................................................................................................17
4.8 Cijeli brojevi - int.....................................................................................................................17
4.9 Broj bez predznaka...................................................................................................................17
4.10 Realni brojevi - float...............................................................................................................17
4.11 Eksponencijalni prikaz broja..................................................................................................17
4.12 Realne varijable......................................................................................................................18
4.13 Znakovi - char.........................................................................................................................18
4.14 Znakovni niz...........................................................................................................................19
4.15 Konstante................................................................................................................................20
5. C++ osnovna struktura programa...................................................................................................21
5.1 Funkcije....................................................................................................................................21
5.2 Deklaracija funkcije..................................................................................................................21
5.3 Definicija funkcije....................................................................................................................21
5.4 Kraj naredbe.............................................................................................................................21

5.5 Primjer funkcije........................................................................................................................22


5.6 Funkcija main...........................................................................................................................23
5.7 Deklaracija funkcije main.........................................................................................................23
5.8 Pretprocesorske naredbe...........................................................................................................23
5.9 Biblioteka.................................................................................................................................24
5.10 Ulazni i izlazni tokovi............................................................................................................24
5.11 iostream..................................................................................................................................24
5.12 cout.........................................................................................................................................25
5.13 endl.........................................................................................................................................25
5.14 cin...........................................................................................................................................27
5.15 Pogreške pri unosu podataka..................................................................................................28
5.16 Pogreške pri učitanju..............................................................................................................28
6. C++ operatori..................................................................................................................................30
6.1 Aritmetički operatori................................................................................................................30
6.2 Binarni aritmetički operatori....................................................................................................30
6.3 Unarni aritmetički operatori.....................................................................................................30
6.4 Tip podatka operanada i rezultata...........................................................................35
6.5 Komentari.................................................................................................................................38
6.6 Operatori obnavljajućeg pridruživanja.....................................................................................38
6.7 Logički tip podataka - bool.......................................................................................................39
6.8 Logički operatori......................................................................................................................40
6.9 Logički I...................................................................................................................................40
6.10 Logički ILI..............................................................................................................................40
6.11 Usporedba...............................................................................................................................42
6.12 String......................................................................................................................................43
7. C++ Grananje.................................................................................................................................45
7.1 Grananje...................................................................................................................................45
7.2 Blok naredbi.............................................................................................................................45
7.3 Naredbe grananja......................................................................................................................46
7.4 Grananje naredbom if...............................................................................................................46
7.5 Grananje – dvije neovisne grane..............................................................................................47
7.6 Naredba goto............................................................................................................................49
7.7 Ulančana if naredba..................................................................................................................50
7.8 Ugnježđivanje if naredbi..........................................................................................................51
7.9 Uvjetna naredba – kratki oblik.................................................................................................52
7.10 Grananje naredbom switch.....................................................................................................53
8. C++ petlje.......................................................................................................................................54
8.1 Petlja.........................................................................................................................................54
8.2 for petlja....................................................................................................................................54
8.3 Beskonačna petlja.....................................................................................................................58
8.4 Ugniježđene for petlje..............................................................................................................61
8.5 while petlja...............................................................................................................................64
8.7 Naredba break...........................................................................................................................68
8.8 Naredba continue......................................................................................................................69
9. Zaključak........................................................................................................................................71

2
10. Literatura......................................................................................................................................72

0. Uvod:
U danasnje doba, zivot nam postaje skoro nezamisliv bez racunala. Svjedoci smo ogromnom
tehnoloskom napretku. Velik trud se ulaze u tehnoloski napredak, no pritom se zaboravlja na moc
koju on donosi, te potrebnu pripadajucu mu sigurnost. Ovim kratkim tekstom zagrebsti cu povrsinu
racunalne sigurnosti, odnosno
pokusat cu vam objasniti kako pristupiti izradi programa sa sigurnoscu na pameti.

3
1. Programski jezici

1.1 Programska podrška


Računalo može rješavati različite zadatke uz pomoć programske podrške. Programska podrška je
skup svih programa koji se mogu izvršavati na računalu. Dio programa korisnik obično kupuje pri
nabavi sklopovlja, a ostale nabavlja ovisno o svojim potrebama.

1.2 Naredbe - program


Računalo može riješiti postavljeni zadatak samo ako dobije uputstvo (niz naredbi) kako to učiniti.
Kombinacijom naredbi nastaje program. Programer pišući program niže naredbe u smislenom
redoslijedu. Naredbe moraju biti u obliku u kojem će ih računalo razumjeti.

1.3 Programski jezik – ključne riječi


Programski jezici su jezici kojima se pišu računalni programi. Svaki programski jezik koristi
vlastiti, ograničeni skup riječi koje imaju posebna značenja. Takve ćemo riječi nazivati ključnim
riječima.

1.4 Programski jezik - sintaksa


Za svaki su programski jezik propisana pravila slaganja ključnih riječi u naredbe. Takva se pravila
nazivaju sintaksa. Ako se ne zadovolji propisana sintaksa, program će biti neispravan i neće se moći
izvršiti.

1.5 Prevođenje u binarni oblik


Središnja jedinica za obradu (procesor) razumije samo programe napisane u strojnom (binarnom)
obliku. Svaki drugi oblik zapisa programa potrebno je prije izvođenja prevesti u binarni oblik.
Program u binarni oblik prevodi program prevodioc (npr. kompajler).

4
1.6 Programski jezici - podjela
Postoji mnogo programskih jezika, a svaki od njih ima svoje prednosti i nedostatke. Programski
jezici se mogu podijeliti na:
• strojne jezike,
• simboličke jezike niske razine,
• simboličke jezike visoke razine.

1.7 Strojni jezik


Strojni jezik je najniža razina prikaza programa. Program pisan strojnim jezikom je u binarnom
obliku. Strojni je jezik vezan uz građu računala.
Svaki tip središnje jedinice za obradu (procesora) ima sebi svojstven strojni jezik. Pisanje programa
u strojnom jeziku je vrlo složeno i zahtijeva dobro poznavanje građe računala. Pisanjem programa
strojnim jezikom bave se usko specijalizirani stručnjaci.

1.8 Simbolički jezik niske razine


Simbolički su jezici nastali kako bi ljudima olakšali programiranje jer ljudi lakše pamte simbole
nego binarne brojeve. Asembler (engl. assembler) je sibolički jezik u kome je svaka binarna
naredba strojnog jezika predočena odgovarajućim simbolom.
Naredbe strojnog jezika predočuju se simbolima koji se najčešće sastoje od kombinacije nekoliko
slova, npr.: ADD, SUB, CMP. Svaka od tih kombinacija slova obično je kratica engleskog opisa
naredbe pa se lako pamti.
Program napisan u asembleru mora biti preveden u binarni oblik da bi ga središnja jedinica za
obradu razumjela. Simbole u binarni oblik prevodi program prevoditelj.

1.9 Simbolički jezik (asembler)


Programi pisani u asembleru su nešto čitljiviji i lakši za razumijevanje od binarnog zapisa, ali ih je
još uvijek vrlo teško pisati i ispravljati. I oni ovise o vrsti i unutarnjoj građi računala (procesoru) pa
se u načelu mogu izvršavati samo na procesoru za koji su pisani.

1.10 Simbolički jezici visoke razine


Da bi se još više olakšalo programiranje i da bi se isti program mogao izvršavati na različitim
računalima (procesorima) stvoren je niz simboličkih jezika visoke razine. Kod simboličkih jezika
visoke razine se više naredbi strojnog jezika predočuje jednom simboličkom naredbom.
Programi napisani u nekom od viših programskih jezika u načelu su neovisni o računalu (točnije o
procesoru) na kome se izvršavaju. Naredbe viših programskih jezika mnogo su više nalik govornom
jeziku, lakše su za pamćenje i upotrebu od naredbi simboličkih jezika niže razine.
Simbolički jezici visoke razine. Simbolički jezici visoke razine mogu biti jezici opće namjene ili
jezici prilagođeni određenoj vrsti problema. U drugoj polovini 20.-og stoljeća nastaju programski
jezici FORTRAN, COBOL, BASIC, PASCAL, programski jezik C i mnogi drugi.

1.11 C
C jezik (autor Denis M. Ritchie) je jezik opće namjene, velikih mogućnosti, u načelu neovisan o
računalu na kojem se izvodi. Postigao je vrlo velik uspjeh jer su njime razvijani različiti operacijski

5
sustavi i namjenski programi (programi namijenjeni rješavanju određenih zadataka izravno
zanimljivih korisniku).
Programski jezik C nema mnogo ključnih riječi, prema ANSI (engl. American National Standard
Institute) C standardu samo 32. C je modularan jezik jer omogućava podjelu programskog zadatka
na manje cjeline koje se mogu neovisno rješavati i provjeravati, a po završetku ugraditi u glavni
program.

6
2. Algoritam

Računalo zadatak može riješiti samo ako dobije upute kako to učiniti. Takve se upute nazivaju
algoritmom. Algoritam je popis radnji (operacija, uputstava) koje treba izvršiti u navedenom
redoslijedu da bi se dobilo rješenje postavljenog zadatka. Mnoge radnje u svakodnevnom životu
izvršavamo prema unaprijed naučenom algoritmu (npr. slanje SMS poruke mobilnim telefonom).
Promjena poretka izvršavanja osnovnih radnji algoritma najčešće dovodi do neželjenih rezultata
(algoritam se mora izvršiti točno prema uputstvu).

2.1 Elementi algoritma

ULAZ OBRADA IZLAZ


(ulazni podaci) (algoritam) (rezultat)

Algoritam treba provjeriti sa što više ulaznih podataka za koje je poznata izlazna vrijednost. Većina
zadataka se može riješiti na više različitih načina pa je za njihovo rješenje moguće napisati više
različitih algoritama. Autor algoritma redovito nastoji pronaći algoritam koje najbrže,
najučinkovitije i najsigurnije dovodi do rezultata. Zadatak je moguće riješiti pomoću računala ako
se algoritam predoči naredbama odabranog programskog jezika (napiše program).

2.2 Dijagram tijeka


Algoritam se može prikazati grafički. Grafički prikaz algoritma naziva se dijagram tijeka. Takav je
prikaz koristan jer pregledno prikazuje algoritam, omogućava analizu problema, lakšu provjeru i
traženje boljih postupaka rješavanja zadatka.

Znakovi dijagrama tijeka:

• početak ili kraj programa

• ulaz podataka (ili )

• donošenje odluke,
grananje u programu

• obrada podataka (jedna ili više naredbi obrade)

• izlaz podataka (ili )

2.3 Osnovne algoritamske strukture


Osnovne algoritamske strukture mogu se svrstati u tri skupine. To su:
• slijedni algoritam (slijed, niz),
• grananje,
• petlja.

7
2.4 Slijedni algoritam
Samo u slučaju rješavanja najjednostavnijih zadataka, algoritam je pravocrtan, tj. uvijek se izvršava
u istom slijedu naredbi. Takav ćemo algoritam nazivati slijedni algoritam (slijed, niz).

Primjer: Korisnik unosi dva broja,


brojevi se zbrajaju pa se ispisuje
dobiveni zbroj. (Treba uočiti da se
bez obzira na ulazne brojeve
naredbe uvijek izvršavaju istim
redoslijedom.)

Dijagram tijeka slijednog algoritma za zbrajanje dva broja:

2.5 Grananje
Često je algoritam ovisan o međurezultatima ili ulaznim podacima pa se redoslijed izvršavanja
naredbi mijenja ovisno o tim podacima. Takva se struktura algoritma naziva grananje jer se ovisno
o stanju podataka odvija jedan od mogućih dijelova (grana) algoritma.

Primjer: Korisnik unosi cijeli


broj, računa se apsolutna
vrijednost tog broja pa se ispisuje
rezultat. (Treba uočiti da
redoslijed izvršavanja naredbi
ovisi o međurezultatu.)

Dijagram tijeka grananja za računanje apsolutne vrijednosti broja:

2.6 Petlja
Često se dijelovi algoritma trebaju ponoviti više puta (iterirati). Takva se struktura algoritma naziva
algoritamska petlja. Ponavljati se može:
• unaprijed zadani broj puta,
• sve dok se ne ispuni određeni uvjet.

Primjer: Potrebno je
ispisati prvih 100
prirodnih brojeva.
(Treba uočiti da se dio
naredbi izvršava
opetovano sto puta.)

Dijagram tijeka petlje za ispis prvih sto prirodnih brojeva:

8
3. Nastanak programa

Računalo se sastoji od mnogo komponenti. Pouzdanost i djelotvornost računala ovisi o pouzdanosti


i djelotvornosti svake od ugrađenih komponenata. Kada bi se konstruktor računala morao baviti
unutarnjom građom svake od sastavnih komponenti te poboljšanjima njihove kvalitete i
pouzdanosti, njegov bi se posao bitno povećao, a pouzdanost računala smanjila. Za olakšanje rada
konstruktoru računala posao se dijeli, pa o građi i pouzdanosti svake od komponenti brine njen
proizvođač. Proizvođač pojedine komponente tehnološki je specijaliziran baš za tu komponentu, pa
su njegovi proizvodi kvalitetni i pouzdani. Komponente su normirane pa se mogu ugraditi u
različite elektroničke uređaje što omogućava proizvodnju velikih serija i sniženje cijena.
Konstruktor koristi gotove komponente i ne mora poznavati unutarnju građu svake od njih,
dovoljno je da zna zadaću koju ta komponenta obavlja i način njezina spajanja s ostalim dijelovima
računala. To mu bitno olakšava posao i omogućuje izradu pouzdanijih i djelotvornijih računala.

3.1 Objekti

Zamisao uporabe gotovih komponenti pri gradnji složenih sustava primjenjena je i pri izradi
programa. Programski se zadatak dijeli na manje dijelove koji se mogu neovisno rješavati i
provjeravati. Gotovi dijelovi programa nazivaju se objekti (engl. object). Objekti se mogu pisati i
provjeravati odvojeno od cjeline i rabiti u različitim programima.

3.2 Objektno orijentirani program

Programi koji koriste objekte nazivaju se objektno orijentirani programi (engl. OOP, object
oriented programs). U objektno orijentirani program ugrađuju se gotovi objekti. Ovakav način rada
povećava djelotvornost programera i kvalitetu programa, a snižava cijenu izrade programa.

3.3 C++

Jezik C++ je jedan od objektno orijentiranih programa. Jezik je nastao osamdesetih godina 20.tog
stoljeća. Autor jezika je Bjarne Stroustrup. Na tržištu postoji više inačica prevoditelja jezika C++.
Neke su komercijalne, a neke besplatne. Najpoznatije su:
• Microsoft Visual C++,
• Borland C++ Builder,
• Dev C++

3.4 Borland C++ Builder

Osnove programiranja biti će pokazane pomoću


programa Borland C++buildera.

9
3.5 Nastanak programa

Nastanak programa može se podijeliti na:


• pisanje izvornog koda,
• prevođenje izvornog koda,
• povezivanje u izvršni kod,
• provjeravanje programa.

3.6 Izvorni kod

Kombinacijom naredbi programskog jezika nastaje izvorni kod (engl.


source code). Izvorni je kod moguće pisati u bilo kojem programu za
uređivanje teksta (engl. text editor). Danas se uglavnom programi za
pisanje izvornog koda objedinjuju u cjelinu sa prevodiocem i
povezivačem (integrirana razvojna okolina, IDE). Izvorni kod
programa C++ sprema se u datoteku izvornog koda pod smislenim
imenom i nastavkom *.cpp

3.7 Izvršni oblik

Programi se mogu izvršiti na računalu samo ako su u binarnom obliku. Takav se oblik programa
naziva izvršni oblik (engl. executable). Izvorni se kod mora prevesti u izvršni. Prevodi se pomoću
programa koji se nazivaju prevoditelj (engl. compiler) i povezivač (engl. linker). Program
prevoditelj prevodi izvorni kod iz višeg programskog jezika u strojni oblik te provjerava sintaksu
napisanog izvornog koda. Ako pronađe pogreške (engl. compile-time error), ispisuje poruke i
upozorenja o njima. Otkrivene pogreške treba ispraviti pa ponovo pokrenuti program za prevođenje.

Prevođenjem nastaje datoteka objektnog koda (engl. object code),


nastavka *.obj. Objektni kod nije izvršni program i ne može se izravno
izvršiti na računalu. Objektni kod je međukorak do izvršnog koda i uz
ostalo omogućava uključivanje gotovih dijelova programa iz drugih
datoteka.

3.8 Biblioteke

Datoteke koje sadržavaju gotove dijelove programa nazivaju se biblioteke (engl. libraries). Takvi se
gotovi dijelovi programa mogu rabiti u drugim programima. Kada se koriste biblioteke više nije
potrebno uvijek iznova zapisivati radnje (funkcije) koje se često rabe. Takve se radnje u program
uključuju iz postojećih biblioteka. Npr. može postojati biblioteka formula za izračunavanje površina
geometrijskih likova čije formule mogu rabiti drugi programi.

10
3.9 Povezivač

Program koji povezuje objektnu datoteku s bibliotekama i drugim


potrebnim datotekama naziva se povezivač (engl. linker). Ako se pri
povezivanju pojavi pogreška (engl. link-time error), bit će ispisana poruka
o tome. Pogrešku valja ispraviti pa ponovno pokrenuti prevođenje i
povezivanje. Rezultat uspješnog povezivanja je izvršna datoteka (*.exe). U
načelu, izvršnoj datoteci nisu potrebni nikakvi dodaci pa se može
izvršavati i bez izvornog programa, objektnih datoteka, prevoditelja,
povezivača itd.

3.10 Izvršna datoteka

Izvršna datoteka je oblik programa i može se izravno izvršiti na računalu za koji je prevedena.
Primjerice IBM i Apple računala su međusobno nesukladna (nekompatibilna, tj. nisu udruživa), pa
se izvršni program preveden za IBM PC sukladno računalo ne može se izvršiti na Macintosh
računalu i obrnuto.

3.11 Projekt

a bi se stvorila izvršna datoteka C++ programa potrebno je pokrenuti nekoliko programa (tekst
editor, prevoditelj, povezivač). Kao posljedica nastaje više datoteka koje su međusobno vezane.

Korisniku koji zadatak riješava C++ programom nepraktično je pamtiti koje programe i kojim
redoslijedom treba pokrenuti, te koje su sve datoteke potrebne za stvaranje izvršne datoteke. Stoga
se korisniku posao olakšava pomoću takozvanog projekta (engl. project). Projekt je datoteka u kojoj
su zapisane sve potrebne informacije o prevoditelju, povezivaču, datotekama, bibliotekama i
ostalom potrebnom za izradu izvršne datoteke. Projekt dakle “brine” o svemu što je potrebno učiniti
da bi od izvornog koda nastala datoteka izvršnog koda.

3.12 Pogreške

Tijekom rada mogu se javiti tri vrste pogrešaka:


• sintaktičke pogreške (otkriva ih program prevoditelj),
• pogreške povezivanja (otkriva ih program povezivač),
• logičke pogreške (mora ih pronaći korisnik sam).

11
3.13 Provjera programa

Za otkrivanje logičkih pogrešaka (onih koje dovode do pogrešnih rezultata) potrebno je provjeriti
program s podacima za koje je unaprijed poznat krajnji rezultat. Ispravljanje pogrešaka nastalih u
ovoj fazi (engl. run-time error) je najteže. Logičke pogreške otkriva i ispravlja čovjek a ne
računalni program.

3.14Borland C++ Builder

Program Borland C++ builder se pokreće na uobičajeni način:


Start/Programs→ Borland C++ Builder6→ C++ builder 6
Da bi se započelo s radom treba birati:
New
U prozoru New treba birati:
Console Wizard

3.15 C++ datoteka izvornog koda

Da bi se stvorila nova datoteka izvornog koda potrebno je u pogledu


FileView označiti stavku Source Files koja se nalazi pod nazivom
projekta. Nakon toga File→New, u prozoru New treba birati:
Files→ C++ Source File.
Nakon toga treba zadati ime datoteke. Stvorena je datoteka izvornog
koda, nastavka *.cpp. Otvara se radno područje za unos izvornog
koda.

Primjer: Unijeti sljedeći kod.


#include<iostream.h>
int main()

12
{
cout<<"Puno uspjeha u ucenju!“<<endl;
System(pause);
return 0;
}

Po unosu, kod je potrebno prevesti i povezati. To možemo odabirom izbornika: Build→Build il


odabirom za to predviđenog dugmeta u alatnoj traci .

Ako nije bilo pogrešaka, u donjoj će se plohi pojaviti poruka ovakva oblika:

Ukoliko u programu postoje pogreške bit će ispisane poruke i upozorenja o njima. Uz svaku je
pogrešku ispisan, osim njenog opisa i broj retka u kojem je pogreška nastala. Sve pogreške treba
ukloniti. Nakon toga je potrebno ponovno pokrenuti prevođenje i povezivanje.

Krajnji je rezultat datoteka izvršnog koda.

Datoteku izvršnog koda pokreće se: Build→Execute ili dugmetom u alatnoj traci. Pokretanjem

izvršne datoteke otvara se DOS prozor (ili Command Prompt). U njemu se po potrebi upisuju ulazni
podaci i ispisuje rezultat programa. Izvršnu se datoteku može pokrenuti dvoklikom sa mjesta na
koje je pohranjena.

Može se dogoditi da se DOS prozor u kome je ispisan rezultat zatvori prebrzo, pa korisnik ne može
pročitati rezultat. Prebrzo zatvaranje DOS prozora može se spriječiti tako da se prethodni primjer
dopuni na sljedeći način:
#include<iostream.h>
#include<conio.h>
int main()
{
cout<<"Puno uspjeha u ucenju!“<<endl;
getch();

return 0;
}

13
Dopuna uvodi čekanje unosa znaka s tipkovnice prije nastavka izvođenja programa.

14
4. C++ podaci

4.1 Podaci
Program obrađuje podatke. Podaci se spremaju u memoriju računala. Računalo za svaki podatak
predviđa i rezervira mjesto u memoriji.

4.2 Memorijske adrese


Računalo rezervirana mjesta u memoriji razlikuje pomoću memorijskih adresa. Korisnicima je
takav način bilježenja mjesta pohrane podataka neprikladan. Da bi se korisnicima olakšao rad uvodi
se pojam varijable.

4.3 Varijable
Mjesto u memoriji rezervirano za pohranu podatka naziva se varijabla. Da bi se varijable
međusobno razlikovale, dodjeljuju im se simbolička imena. Umjesto da korisnik rezervirana mjesta
u memoriji razlikuje pomoću memorijskih adresa, može ih razlikovati na temelju njihovih
simboličkih imena. Simboličko se ime naziva još i identifikator. Simboličko ime određuje korisnik
poštujući pravila:
• Smiju se rabiti slova engleske abecede, brojevi i znak _ (podcrtavanje).
• Simboličko ime mora početi sa slovom ili sa znakom _ (podcrtavanje).
• Broj znakova u simboličkom imenu (dužina) nije ograničen.

Napomene:
• u simboličkom imenu ne smije se rabiti razmak.
• u simboličkom imenu ne smiju se rabiti naši dijakritički znakovi (č,ć,ž,š,đ).
• u simboličkom imenu ne smiju se rabiti ključne riječi ili oznake operatora programskog
jezika.

Program razlikuje velika i mala slova:


ViMslova, vimslova – ovo su dva različita imena

Ako se koristi ime sastavljeno od više riječi, riječi se odvajaju znakom za podcrtavanje, ili se riječi
pišu spojeno s velikim početnim slovom.

Ispravna simbolička imena: Neispravna simbolička imena:


x 1Y (ne smije početi brojem)
promjer_kruga x[1] (ne smije sadržavati zagrade)
_kon1 Datum Upisa (ne smije sadržavati razmak)
DatumUpisa cout (ne smije biti ključna riječ)
Val23m1_X brojač1 (ne smije sadržavati naše dijakritičke znakove)

15
4.4 Oznaka tipa podatka

Postoje različite vrste podataka, npr. cijeli brojevi, realni brojevi, znakovi, nizovi itd. Stoga svakoj
varijabli osim imena treba dodijeliti i oznaku tipa podatka koji će u nju biti smješten. Dodjela
oznake tipa je potrebna da bi računalo “znalo” koliko mjesta u memoriji treba predvidjeti za
pohranu tog podatka. Program prevoditelj će pravilno prevesti izvorni kod samo ako je za svaku
varijablu prije korištenja jednoznačno određen tip podatka. Za podatak kome je dodijeljen tip
računalo “zna” koliko će mjesta zauzeti u memoriji, koji su mu rasponi vrijednosti, te kakve su
operacije s tim podatkom moguće.

Deklariranje
Postupak pridjeljivanja simboličkog imena varijabli i određivanje tipa podatka naziva se
deklariranje.
int a;
float b;

oznaka tipa podatka simboličko ime podatka


(Značenje oznaka tipa int i float objašnjeno je u nastavku.)

Ako je podataka više, odvaja ih se zarezom.


int c, d, e;
Gornji se izraz može čitati ovako: “određuje se (deklarira) da su varijable c, d i e tipa int”.

4.5 Pridruživanje vrijednosti


Svaka se varijabla mora deklarirati. Deklariranoj varijabli se može pridružiti vrijednost. Varijabli se
može pridružiti vrijednost pomoću operatora pridruživanja. Operator pridruživanja je znak =. Ovdje
se treba naviknuti na novo značenje znaka =, koji više ne označava izjednačavanje (jednakost) kao
u matematici! Objektu s lijeve strane operatora pridruživanja pridružuje se vrijednost sa njegove
desne strane.
a = 5 ;
Gornji se izraz može čitati kao: “neka varijabla a poprimi vrijednost 5”. Objekti s lijeve strane
operatora pridruživanja moraju biti varijable.

S obzirom na novo značenje znaka jednakosti, u C++ ispravan je i sljedeći izraz:


a=a+3;
Treba ga čitati: “Vrijednost varijable a uvećaj za 3”
(Podatku koji se nalazi u varijabli a dodaj vrijednost 3 i zatim taj zbroj pohrani u varijablu a.)

U istoj se naredbi može koristiti i više operatora pridruživanja (smjer operacije ide s desna na
lijevo).
a=b=c=5;
Treba čitati: “Neka varijabla c poprimi vrijednost 5, a varijabla b poprimi istu vrijednost koju ima
varijabla c. Neka varijabla a poprimi istu vrijednost koju ima varijabla b.”

16
4.6 Tipovi podataka

Podaci se mogu podijeliti u osnovne i ostale tipove. Osnovni tipovi su:


• brojevi (cijeli i realni),
• znakovi.

4.7 Brojevi
C++ razlikuje dvije osnovne vrste brojeva. To su:
• cijeli brojevi (engl. integer),
• realni brojevi (engl. floating point).

4.8 Cijeli brojevi - int


Ako je podatak cijeli broj njegova oznaka tipa je int. Varijabla označena sa int je cjelobrojna
varijabla.
int a=10;
Cjelobrojnoj varijabli može se pridijeliti samo cijeli broj. Za pohranu cijelog broja u memoriji su
predviđena 4 bajta (32 bita). Prvi je bit rezerviran za predznak, pa za pohranu broja ostaje 31 bit. 31
bit omogućava pohranu brojeva iz raspona:
[-231, 231-1] to jest od
-2.147.483.648 do 2.147.483.647

4.9 Broj bez predznaka


Sve cjelobrojne varijable mogu biti deklarirane sa ili bez predznaka. Ako se deklarira cijeli broj bez
predznaka potrebno je ispred oznake tipa staviti ključnu riječ unsigned.
unsigned int a;
U slučaju cijelog broja bez predznaka bit za predznak više nije potreban. Najveću je vrijednost sada
moguće prikazati sa 32 bita. Najveći broj koji se može prikazati sa 32 binarne znamenke je
232-1=4294967295.

4.10 Realni brojevi - float


Ako je podatak realni broj njegova oznaka tipa je float. Varijabla označena sa float je realna
varijabla.
float a=4.67;
Za pohranu realnog broja u memoriji su predviđena 4 bajta (32 bita). Omogućena je pohrana
brojeva u rasponu:
od [-3.4*1038 do -1.17*10-38] do [1.17*10-38 do 3.4*1038]

4.11 Eksponencijalni prikaz broja


Realne je brojeve praktično prikazati u eksponencijalnom prikazu. Eksponencijalni prikaz broja je
oblika:
M·10E
17
M označava dio broja koji se naziva mantisa, a E je eksponent broja (baze) 10.
Mantisa se zapisuje tako da je prva znamenka različita od nule lijevo od decimalne točke.
6.345 = 6.345·100
1236.345 = 1.236345·103
0.000765 = 7.65·10-4

Broj se u eksponencijalnom prikazu može zapisati i ovako:


9.11e-31

Broj iza slova e je eksponent baze. Broj ispred slova e je mantisa. (Kod dekadskih brojeva baza je
10.)
Slovo e može biti zapisano kao malo ili veliko slovo, praznine unutar zapisa broja nisu dozvoljene
(prazninu prevoditelj prihvaća kao kraj broja).

6.345 = 6.345·100 = 6.345e0


3
1236.345 = 1.236345·10 = 1.236345E+3
0.000765 = 7.65·10-4 = 7.65e-4

4.12 Realne varijable


U realnu se varijablu sprema samo 7 decimalnih znamenki mantise. Ako se unese više od sedam
znamenki, prilikom prevođenja će biti zanemarene najmanje vrijedne decimalne znamenke (po
potrebi se zaokružuje). Treba uočiti razliku između broja decimalnih znamenki koje se spremaju i
broja znamenki koje se prikazuju na zaslonu! Broj znamenaka prikaza na zaslonu se po potrebi
može proširiti odgovarajućom naredbom. Najmanje vrijedne decimalne znamenke (ako ih je
uneseno više od 7) se zanemaruju (zaokruženje).
Uobičajeno se realni brojevi prikazuju sa do 6 znamenaka, računajući od prve razičite od 0. Ako se
broj ne može prikazati sa toliko znamenaka bit će prikazan u eksponencijalnom prikazu.
Ako navedena točnost ne zadovoljava ili ako se žele koristiti brojevi manji od 10-38 ili veći od 1038,
mogu se upotrijebiti varijable veće točnosti. To su varijable tipa:
• double (eksponent 308), sa točnošću 15 decimalnih znamenki,
• long double (eksponent 4932) sa točnošću 18 decimalnih znamenki.

4.13 Znakovi - char


Ako je podatak znak, njegova oznaka tipa je char. Podatak tipa char je predstavljen jednim znakom
unutar jednostrukih navodnika ili ASCII vrijednošću tog znaka.
char slovoA = 'A';
char SLOVOA = 65;

Za pohranu znakovnog podatka je u memoriji predviđen 1 bajt (8 bitova). Pošto je 28 = 256, moguće
je prikazati 256 različitih znakova. Znak se pohranjuje kao broj koji predstavlja ASCII vrijednost
odabranog znaka.

Neke ASCII vrijednosti:


• zvučni signal ('\a')
• praznina (' ')
• (48 – 57) znamenke '0'-'9'
• (65 – 90) velika slova 'A' do 'Z'
• (97 –122) mala slova 'a' do 'z'
18
U primjeru ja prikazano pridruživanje podatka varijabli tipa char. Prvoj je pridružen znak označen
jednostrukim navodnicima, a drugoj dekadska ASCII vrijednost tog znaka.

#include<iostream.h>
int main()
{
char a,b;
a='A';
b=65;
cout<<a<<endl;
cout<<b<<endl;
System(pause);
return 0;
}

Ako je potreban znak koji se ne može prikazati na zaslonu, koristi se slijed koji počinje lijevom
kosom crtom (engl. backslash). U primjeru je prikaz zvučnog signala (engl. alert), te pomak u novi
red.

#include<iostream.h>
int main()
{
char zvuk='\a';
char novi_red='\n';
cout<<zvuk<<zvuk<<novi_red;
System(pause);

return 0;
}

4.14 Znakovni niz


Za pohranu teksta se koriste znakovni nizovi (engl. character strings). Za sada je dovoljno znati da
se sadržaj znakovnog niza navodi unutar para dvostrukih navodnika. Npr.:
“Ovo je znakovni niz”

Primjer ispisa znakovnog niza: Treba ispisati znakovni niz “Prvi niz znakova”, nakon toga znak
zareza pa niz “drugi niz znakova”.

#include<iostream.h>
int main()
{
cout<<"Prvi niz znakova"<<", "<<"drugi niz znakova.";
System(pause);
return 0;
}

19
4.15 Konstante

U programima se koriste vrijednosti koje se tijekom odvijanja programa ne smiju mijenjati. Takve
se vrijednosti nazivaju konstante. Konstante se mogu spremiti u rezervirana mjesta u memoriji zbog
lakšeg rukovanja s njima. Konstantu treba zaštititi od mogućih neželjenih promjena tijekom
odvijanja programa. Za zaštitu se koristi ključna riječ const koja se dodaje ispred oznake tipa
varijable.
const float pi = 3.141593

Ako se u programu pokuša promijeniti vrijednost konstante, prilikom prevođenja će program


prevoditelj (engl. compiler) javiti pogrešku.

20
5. C++ osnovna struktura programa

5.1 Funkcije

U svakom se složenijem programu mogu izdvojiti nizovi naredbi koji čine logičke cjeline a
obavljaju određene radnje. Kada se neka od takvih radnji želi ponoviti sa drugim vrijednostima, niz
naredbi treba ponovno zapisati. Kako bi se izbjeglo ponovno zapisivanje niza naredbi, taj se niz
naredbi može izdvojiti, imenovati i spremiti. Takav se izdvojeni niz naredbi koje čine logičku
cjelinu naziva funkcija.

5.2 Deklaracija funkcije


Svaku funkciju valja deklarirati. Pri tom treba odrediti:
• argumente funkcije, to jest podatke koji se predaju funkciji da ih ona obradi na željeni način
• naziv funkcije
• tip podatka koji funkcija vraća pozivatelju.

Deklaracija funkcije je oblika:


tip_funkcije naziv_funkcije (popis argumenata)

tip podatka kojeg funkcija broj i tip podataka (argumenata) koji se


vraća pozivatelju predaju funkciji prilikom njenog poziva

Kada se u programu javi potreba za izvršenjem radnje koju može obaviti neka funkcija, funkciju
treba pozvati. Funkcija se poziva navođenjem njenog naziva i potrebnih parametara. Funkcije se
ponašaju kao zasebne cjeline pa korisnik ne mora brinuti o tome kako one rade već mora znati što
one rade.

5.3 Definicija funkcije


Definicija funkcije je skup naredbi koje određuju što i kako funkcija radi. Skup naredbi od kojih je
sačinjena funkcija čini tijelo funkcije. Tijelo funkcije započinje nakon otvorene vitičaste zagrade, a
završava zatvorenom vitičastom zagradom. Tijelo funkcije se zbog preglednosti redovito piše
uvučeno u odnosu na ostali izvorni kod. Svaka funkcija završava ključnom riječi return. Uz return
je podatak kojeg funkcija kao rezultat vraća pozivatelju.

5.4 Kraj naredbe


Sve što prevoditelj nađe nakon znaka točka-zarez (;) smatra se sljedećom naredbom. Naredbe se
mogu protezati i kroz nekoliko redaka, važno je samo da na kraju bude znak ;. Više naredbi može se
zapisati u jednom retku ali svaka od njih mora završiti s ;

21
5.5 Primjer funkcije
float volumen_kvadra (float a, float b, float c)
{
return a*b*c;
}
Funkcija računa volumen kvadra. Prikaz poziva ove funkcije iz glavnog programa:

#include<iostream.h>
float volumen_kvadra (float a, float b, float c)
{
return a*b*c;
}

int main()
{
float a,b,c,v;
cout<<"Unesi vrijednosti duljina bridova kvadra:"<<endl;
cin>>a>>b>>c;
v=volumen_kvadra(a,b,c);
cout<<"Volumen kvadra zadanih duljina bridova iznosi”
<<v<<endl;
System(pause);
return 0;
}

22
5.6 Funkcija main

Programi se mogu sastojati od mnogo funkcija. Kako bi se “znalo” s kojom funkcijom početi
izvođenje uvodi se funkcija main. Svaki C++ program će uvijek započeti izvođenje tako da najprije
izvrši funkciju main. Funkcija main se zato naziva “ulazna točka”. Svaki C++ program mora imati
najmanje jednu funkciju (može ih imati i mnogo), a to je funkcija main. Svaki C++ program mora
imati funkciju main. Ako nema funkcije main, program prevoditelj će javiti pogrešku jer “ne zna” s
kojom funkcijom započeti.

5.7 Deklaracija funkcije main


Postoji više oblika funkcije main a u ovim će se vježbama koristiti oblik:
int main()
Tip podatka kojeg funkcija main vraća pozivatelju je cijeli broj (int), a argumenata nema, tj. popis
argumenata je prazan ().
main() – return 0
U deklaraciji funkcije main je definirano da će rezultat funkcije biti cijeli broj, stoga se naredbom
return pozivatelju mora vratiti cijeli broj. Funkcija main završava naredbom return 0. U slučaju
da neka od naredbi funkcije main izazove prekid programa, pri izvršenju se neće stići do naredbe
return 0 i ona se neće izvršiti. Dakle, 0 je poruka pozivatelju (a to je obično operacijski sustav) da
su sve naredbe funkcije main izvršene ispravno. Prema dogovoru funkcija main vraća 0, pa se
stoga piše return 0 na kraju funkcije main. Što će operacijski sustav poduzeti ako nakon return
nije 0, ovisi o operacijskom sustavu. Stoga, zbog dogovora i ujednačenosti valja pisati return 0 (a
ne neku drugu vrijednost) na kraju main funkcije.

Prvi program
int main()
{
return 0;
}

Ako se napiše ovakav program pa se nakon toga pokrene prevođenje i povezivanje, sve će proći bez
pogreške. Kada se ovakav program pokrene, na zaslonu se neće dogoditi ništa jer nema tijela
funkcije (između vitičastih zagrada nema naredbi osim return 0).

5.8 Pretprocesorske naredbe

Prije glavne, main funkcije navode se pretprocesorske naredbe. Pretprocesorske naredbe su naredbe
koje se izvršavaju prije početka prevođenja. Pretprocesor dopunjuje izvorni kôd te se takav
dopunjeni kôd prevodi. Pretprocesorske naredbe započinju znakom #. Opći oblik pretprocesorske
naredbe je:
#naredba parametri

Za razliku od ostalih naredbi, pretprocesorske naredbe ne završavaju znakom točka-zarez (;).

23
Jedna od pretprocesorskih naredbi je naredba include. Naredba include ima oblik:
#include <.......>

Naredbom include se u izvorni kod programa uključuje sadržaj datoteke koja je navedena unutar
znakova < i > iza naredbe include. Npr. naredba include <iostream.h> uključuje datoteku iostream
u program. U programu se može uporabiti proizvoljni broj naredbi include (on ovisi o broju
datoteka čiji se sadržaj na taj način želi uključiti u izvorni kod).

5.9 Biblioteka

Biblioteke (engl. library) su posebne vrste datoteka koje sadrže skupove funkcija. U biblioteke se
pohranjuju funkcije za koje se pretpostavlja da bi mogle biti upotrebljive korisnicima koji pišu
programe u C++. Postoje razne biblioteke u koje su smještene funkcije razvrstane po smislenosti.
Kada programer naredbom include uključi željenu biblioteku, na raspolaganju su mu sve funkcije
te biblioteke. Unutar znakova < i > navodi se naziv željene datoteke biblioteke. Posljedica je ista
kao da je umjesto naredbe #include <naziv_biblioteke> zapisan cjelokupni sadržaj željene
datoteke biblioteke. S gledišta korisnika nije bitno znati podrobnosti uključivanja datoteka
biblioteka naredbom include. Potrebno je samo znati koja datoteka biblioteka sadrži one funkcije
(programe) koje korisnik želi rabiti u svome programu te kako je uključiti naredbom include.

5.10 Ulazni i izlazni tokovi

Da bi program bio upotrebljiv mora omogućiti komunikaciju s ulazno/izlaznim uređajima


(tipkovnicom, monitorom, diskom i sl.). Komunikacija s ulazno/izlaznim uređajima se u C++u
ostvaruje uz pomoć ulaznih i izlaznih tokova (engl. input and output streams).

Izlazni tok prima podatke od programa i prosljeđuje ih izlaznom uređaju. Izlazni tok brine da podaci
na ispravan način stignu do izlaznog uređaja. Ulazni tok prima podatke od ulaznog uređaja i predaje
ih programu. Ulazni tok brine da podaci na ispravan način stignu od ulaznog uređaja do programa.
Svaki program prima podatke posredstvom ulazno-izlaznih tokova i rezultat predaje okolini
posredstvom ulazno-izlaznih tokova. Stoga je, s gledišta programa, sasvim svejedno koji se ulazni i
izlazni uređaji rabe jer se svi podaci u program unose i iz programa predaju okolini na isti način.
Izlazni tok šalje podatke konzoli. Izlazna konzola može biti bilo koji izlazni uređaj ali je to
praktično u svim slučajevima monitor. Ulazni tok prima podatke od konzole. Ulazna konzola može
biti bilo koji ulazni uređaj ali je to praktično u svim slučajevima tipkovnica. Što će biti izlazna i
ulazna konzola određuje se naredbama operacijskog sustava. Npr. može se odrediti da ulazna
konzola bude tipkovnica, a izlazna datoteka na disku. Pri takvoj se promjeni s gledišta korisničkog
programa ništa ne mijenja (ne treba mijenjati niti jednu naredbu).

5.11 iostream

Biblioteka (datoteka) iostream sadrži niz ulazno-izlaznih funkcija koje omogućavaju rukovanje
ulazno-izlaznim tokovima a programer ih poziva prema potrebi u svoj program. Točan popis, nazivi
i djelovanje funkcija pohranjenih u biblioteku iostream može se naći u dokumentaciji iostream
biblioteke. Dvije ulazno-izlazne funkcije koje se često koriste su cout i cin:

24
5.12 cout

Podaci se na zaslon monitora ispisuju pomoću funkcije cout i operatora ispisa <<. Npr.:
cout<<13;
će ispisati broj 13 na zaslon monitora. Sa desne strane operatora ispisa može biti bilo koji tip
podataka.

#include<iostream.h>
int main()
{
float a=56.78;
cout<<34;
cout<<a;
cout<<"Moguc je i ispis niza znakova";
System(pause);
return 0;
}

5.13 endl

U prethodnom primjeru su svi podaci ispisani u istome retku. Ako korisnik želi svaki od podataka
ispisati u zasebnom retku, treba rabiti konstantu endl. Zadatak joj je da pokazivač ispisa pomiče na
početak sljedećeg retka na zaslonu. Konstanta endl je pohranjena u biblioteci iostream. Ako se u
prethodni primjer doda endl, ispis će izgledati ovako:

#include<iostream.h>
int main()
{
float a=56.78;
cout<<34<<endl;
cout<<a<<endl;
cout<<"Moguc je i ispis niza znakova"<<endl;
System(pause);
return 0;
}

25
Ulančavanje operatora <<
Moguće je ulančavanje operatora ispisa koje se izvodi s lijeva na desno.

#include<iostream.h>
int main()
{
float a=56.78;
cout<<34<<a<<" Moguc je i ispis niza znakova";
System(pause);
return 0;

Ako se pri ulančavanju operatora ispisa predugi redak želi prelomiti, to je potrebno učiniti ispred
operatora ispisa. Npr:
cout<<34<<a<<" Moguc je i ispis niza znakova";
može se prelomiti i zapisati ovako:
cout<<34<<a
<<" Moguc je i ispis niza znakova";

26
5.14 cin

Podaci se sa tipkovnice čitaju pomoću funkcije cin i operatora unosa >>. Npr.:
cin>>x
očekuje unos podatka s tipkovnice koji će biti pohranjen u prethodno deklariranu varijablu x (treba
upisati podatak i pritisnuti tipku Enter). Sa desne strane ulaznog operatora može se naći bilo koji tip
podataka.

#include<iostream.h>
int main()
{
int a;
float b;
cout<<“upisati cijeli broj";
cin>>a;
cout<<“upisati realni broj“;
cin>>b;
System(pause);
return 0;
}

Posljedica naredbe unosa je prekid izvršenja nastavka programa sve dok se ne unese podatak i
pritisne tipka [Enter] (program “čeka” na podatak).

Ulančavanje operatora >>


Moguće je ulančavanje ulaznih operatora koje se izvodi s lijeva na desno. Svaki sljedeći unos se
nastavlja od mjesta na kome je pretodni unos završio.

#include<iostream.h>
int main()
{
int a;
int b;
cout<<"Upisi dva cijela broja:"<<endl;
cin>>a>>b;
cout<<endl<<a<<endl;
cout<<b<<endl;
System(pause);
return 0;
}

27
U ovom primjeru više se ulaznih podataka upisuje u istome retku, odvojeni prazninama. U tome
slučaju tek nakon posljednjeg unosa treba pritisnuti tipku [Enter].

5.15 Pogreške pri unosu podataka

Vjerojatno je da se prilikom unosa podataka ponekad načini pogreška. Npr. jedna od mogućih
pogrešaka je unos pogrešnog tipa podatka. U tom se slučaju operacija unosa prekida.

5.16 Pogreške pri učitanju


U primjeru se unose pa ispisuju dva cijela broja.

#include<iostream.h>
int main()
{
int a,b;
cout<<"Upisi dva cijela broja:"<<endl;
cin>>a;
cin>>b;
cout<<endl<<"Pohranjeni su ovi podaci:"<<endl;
cout<<"prvi podatak= "<<a<<endl;
cout<<"drugi podatak= "<<b<<endl;
System(pause);
return 0;
}

28
Nekoliko mogućih pogrešaka pri unosu podataka u navedenom primjeru:
• Umjesto prvog cijelog broja upisan je realan broj. On je uzrokovao prekid daljnjeg unosa.
Dio do decimalne točke je pohranjen kao prvi broj, a zbog preostalog dijela je nastala
pogreška.
• Umjesto drugog cijelog broja upisan je niz znakova “broj”. Prvi je podatak pohranjen
ispravno, a zbog drugog je nastala pogreška.
• Umjesto drugog cijelog broja upisan je realan broj. Prvi je podatak pohranjen ispravno, a
kod drugog je dio do decimalne točke pohranjen kao cijeli broj (preostali dio je odbačen).

29
6. C++ operatori

Operatori su simboli koji predstavljaju (zamjenjuju) određene funkcije. U C++ je definirano


nekoliko skupina operatora:
• aritmetički operatori
• logički operatori
• operatori uspoređivanja
• ostali operatori.

6.1 Aritmetički operatori


Aritmetički operatori mogu biti:
• binarni (djeluju na dvije varijable)
• unarni (djeluju na samo jednu varijablu)

6.2 Binarni aritmetički operatori


Binarni operatori za izvođenje osnovnih aritmetičkih funkcija:
+ zbrajanje
− oduzimanje
* množenje
/ dijeljenje
% modulo (rezultat je ostatak djeljenja dvaju cijelih brojeva)

6.3 Unarni aritmetički operatori


Unarni operatori djeluju samo na jednu varijablu. Postoje sljedeći unarni operatori:
• za promjenu predznaka,
• za uvećavanje (inkrementiranje),
• za umanjivanje (dekrementiranje).

–a Unarni minus (mijenja predznak broja)


a++ Operator za uvećavanje (uvećava broj za 1 nakon što se varijabla dobavi iz memorije)
a–– Operator za umanjivanje (umanjuje broj za 1 nakon što se varijabla dobavi iz
memorije)
++a Operator za uvećavanje (uvećava broj za 1 prije nego se varijabla dobavi iz memorije)
––a Operator za umanjivanje (umanjuje broj za 1 prije nego se varijabla dobavi iz
memorije)

Pri uporabi unarnih operatora važno je paziti na položaj operatora (da li se nalazi prije ili poslije
varijable) jer se njegovo djelovanje u jednom i drugom slučaju razlikuje. Ako je operator ispred
varijable (npr. ++a) tada se u izrazu računa s uvećanom/umanjenom vrijednošću varijable. U
primjeru
a=1;
b=++a +5;
po izvršenju naredbi, sadržaj varijable b=7. (Prvo se poveća vrijednost varijable a za 1 a zatim se
računa vrijednost izraza.) Ako je operator iza varijable (npr. a++) tada se vrijednost varijable
uveća/umanji tek nakon izračunavanja izraza. U primjeru
30
a=1;
b=a++ +5;
po izvršenju naredbi, sadržaj varijable b=6. (Prvo se računa vrijednost izraza, a nakon toga se
povećava vrijednost varijable a za 1.)
Zadatak 1 (binarni aritmetički operatori): Treba izračunati zbroj, razliku, umnožak i kvocijent
dvaju realnih brojeva. Ispis neka bude oblika:
Unesi prvi broj:
unesi drugi broj:
.... + .... = ....
.... - .... = ....
.... * .... = ....
.... / .... = ....
Na početku deklarirati dvije realne varijable. Aritmetički operatori i znak = mogu se unijeti kao
znakovni nizovi.

#include<iostream.h>
int main()
{
float a,b;
cout<<"Unesi prvi broj:"<<endl;
cin>>a;
cout<<"unesi drugi broj:"<<endl;
cin>>b;
cout<<a<<"+"<<b<<"="<<a+b<<endl;
cout<<a<<"-"<<b<<"="<<a-b<<endl;
cout<<a<<"*"<<b<<"="<<a*b<<endl;
cout<<a<<"/"<<b<<"="<<a/b<<endl;
System(pause);
return 0;
}

Upozorenje: Ako se aritmetički izraz zapiše unutar navodnika, postaje znakovni niz!
cout<<a<<"+"<<b<<"="<<”a+b”<<endl;
cout<<a<<"-"<<b<<"="<<”a-b”<<endl;
Rezultat tada neće biti vrijednost aritmetičkog izraza!

31
Zadatak 2 (aritmetički operator modulo): Potrebno je izračunati cjelobrojni kvocijent i ostatak
dijeljenja dvaju cijelih brojeva. Ispis neka bude oblika:

Upisi djeljenik:
Upisi djelitelj:
... : ... = ...cijelih, a ostatak je ...

Deklarirati četiri cjelobrojne varijable (dvije za ulazne veličine, a dvije za pohranu rezultata).
#include<iostream.h>
int main()
{
int a,b,ostatak,kvoc;
cout<<"Upisi djeljenik:";
cin>>a;
cout<<"Upisi djelitelj:";
cin>>b;
kvoc=a/b;
ostatak=a%b;
cout<<a<<":"<<b<<"="<<kvoc
cijelih, a ostatak je "<<ostatak<<endl
System(pause);
return 0; <<";

Ako se varijable za pohranu ulaznih podataka deklariraju kao realne, javit će se pogreška! Ako se
varijable za izlazne podatke deklariraju kao realne, javit će se upozorenje.

Zadatak 3 (redoslijed izvršavanja operatora): Potrebno je izračunati srednju vrijednost po volji


izabrana četiri realna broja. Ispis neka bude oblika:

Unesi cetiri realna broja,


32
odvoji ih prazninama:
Srednja vrijednost brojeva
...., ...., .... i .... je .....

Na početku deklarirati pet realnih varijabli (četiri za pohranu podataka koje odabire korisnik i jednu
za pohranu rezultata). Obratiti pozornost na redoslijed izvršavanja operatora (osnovnih
matem.operacija).
#include<iostream.h>
int main() {
float a,b,c,d,srvr;
cout<<"Unesi cetiri realna broja,"<<endl;
cout<<"odvoji ih prazninama."<<endl;
cin>>a>>b>>c>>d;
srvr=(a+b+c+d)/4;
cout<<endl<<"Srednja vrijednost brojeva: "<<endl;
cout<<a<<", "<<b<<", "<<c<<" i "<<d<<" je " <<srvr<<endl;
System(pause);
return 0

Ako se srednja vrijednost računa prema ovoj formuli, rezultat nije dobar: srvr=a+b+c+d/4.
Rezultat je neispravan zbog redoslijeda izvršavanja operatora. Računa se: a+b+c+(d/4). Ispravno je
rješenje dobiveno uporabom zagrada: srvr=(a+b+c+d)/4. Ako ispis nije pregledan, između riječi i
brojeva treba staviti razmake (potrebno ih je predvidjeti unutar znakova navodnika).

Zadatak 4 (unarni operator za promjenu predznaka): Potrebno je unijeti cijeli broj, a zatim mu
unarnim operatorom promijeniti predznak. Ispis neka bude oblika:
Unesi broj:
Kada se broju .... promijeni predznak, on postaje ....

#include<iostream.h>
int main()
{
int a;
cout<<"Unesi broj:";
cin>>a;
cout<<endl<<"Kada se broju "<<a
<<" promijeni predznak, on postaje "<<-a<<endl;
System(pause);
return 0;
33
}

Zadatak 5 (unarni operator za uvećavanje nakon dobave iz memorije): Potrebno je unijeti cijeli
broj i pohraniti ga u varijablu a, a zatim na taj broj primijeniti unarni operator za uvećavanje nakon
dobave iz memorije (a++). Ispis neka bude oblika:
Unesi broj za operaciju a++:
Kad operacija zavrsi x= ...
Kad operacija zavrsi a= ...

#include <iostream.h>
int main()
{
int x, a;
cout<<"Unesi broj za operaciju a++: ";
cin>>a;
x=a++;
cout<<"Kad operacija zavrsi x= "<<x<<endl;
cout<<"Kad operacija zavrsi a= "<<a<<endl;
System(pause);
return 0;
}

Zadatak 6 (unarni operator za uvećavanje prije dobave iz memorije): Potrebno je unijeti cijeli
broj i pohraniti ga u varijablu a, a zatim na taj broj primijeniti unarni operator za uvećavanje prije
dobave iz memorije (++a). Ispis neka bude oblika:
Unesi broj za operaciju ++a:
Kad operacija zavrsi x= ...
Kad operacija zavrsi a= ...

#include <iostream.h>
int main()
{
int x,a;
cout<<"Unesi broj za operaciju ++a: ";
cin>>a;
x=++a;
cout<<"Kad operacija zavrsi x= "<<x<<endl;
cout<<"Kad operacija zavrsi a= "<<a<<endl;
System(pause);
return 0;
}

34
6.4 Tip podatka operanada i rezultata

Tip rezultata aritmetičkog izraza ovisi o tipovima operanada iz izraza. (Ako su operandi u izrazu
tipa float i rezultat aritmetičkog izraza je također tog tipa.) Kada se u izrazu nađe više različitih
tipova operanada, tip rezultata aritmetičkog izraza ovisi o definiranim pravilima pretvorbe. Podaci
se prvo svode na zajednički tip, prije zadane operacije. Pravila pretvorbe različitih tipova podataka
usmjerena su prema višem tipu podataka.
Primjer pokazuje moguću grešku:
int a;
float b = 3.5;
float c = 5.0;
int d = 2;
a = b * c / d;
Podaci se prvo svode na zajednički tip i to viši,float. Rezultat izraza je 8.75.Pošto se rezultat
pohranjuje u varijablu a koja je određena kao cjelobrojna (int) bit će pohranjena samo vrijednost 8.
Da bi se izbjegla moguća greška i neočekivani rezultati treba nastojati ne miješati varijable
različitih tipova.

Zadatak 7 (svođenje rezultata na zajednički tip s operandima): Treba izračunati kvocijent


dvaju cijelih brojeva i spremiti ga u realnu varijablu. Ispis neka bude oblika:
Unesi prvi broj:
unesi drugi broj:
kvocijent iznosi: ....
Varijable a i b deklarirati kao cjelobrojne (int). Deklarirati varijablu kvocijent (tip float) za pohranu
rezultata dijeljenja.
#include<iostream.h>
int main()
{
int a,b;
float kvocijent;
cout<<"Unesi prvi broj:";
cin>>a;
cout<<"unesi drugi broj:";
cin>>b;
kvocijent=a/b;
cout<<"kvocijent iznosi:"<<kvocijent<<endl;
System(pause);

35
return 0;
}

Pošto su podijeljena dva cijela broja i rezultat izraza je cijeli broj! Pridruživanjem rezultata realnoj
varijabli kvocijent postignuto je samo to da se dobiveni rezultat pohrani kao realni broj.
Zadatak 8 (svođenje operanada na zajednički tip): Treba izračunati kvocijent dva broja od kojih
je jedan cijeli, a drugi realan. Rezultat spremiti u cjelobrojnu varijablu. Ispis neka bude oblika:
Unesi prvi broj:
unesi drugi broj:
Vrijednost izraza a/b= ....
Sadrzaj varijable kvocijent iznosi: ....
Jednu od varijabli deklarirati kao cjelobrojnu (int), a drugu kao realnu (float). Deklarirati varijablu
kvocijent (tip int) za pohranu rezultata dijeljenja.
#include<iostream.h>
int main()
{
int a , kvocijent;
float b;
cout<<"Unesi prvi broj:";
cin>>a;
cout<<"unesi drugi broj:";
cin>>b;
cout<<"Vrijednost izraza a/b= "<<a/b<<endl;
kvocijent=a/b;
cout<<"Sadrzaj varijable kvocijent iznosi:"
<<kvocijent<<endl;
System(pause);
return 0;
}

36
Zbog toga što su operandi različitog tipa, prvo se pretvaraju u viši tip, a to je float. Po izračunu,
rezultat (16.797) se pridružuje varijabli kvocijent koja je cjelobrojna.

Zadatak 9: Treba unijeti godinu rođenja i tekuću godinu. Računaju se godine starosti. Ispis neka
bude oblika:
Upisi godinu svog rodjenja:
Koja je godina sada?
Sada imas .... godina.

#include<iostream.h>
int main()
{
int god,god1,god2;
cout<<"Upisi godinu svog rodjenja: ";
cin>>god1;
cout<<"Koja je godina sada? ";
cin>>god2;
god=god2-god1;
cout<<endl<<"Sada imas "<<god<<" godina."<<endl;
System(pause);
return 0;
}

37
6.5 Komentari

U izvornom programu (kôdu) korisno je opisati što program radi, što su argumenti, objasniti
deklaraciju varijabli i sl. Takvi pomoćni opisi se nazivaju komentari. Njihova temeljna namjena je
olakšati razumijevanje programa. Komentar može biti napisan u istom redu s naredbom ili u
zasebnom redu. Komentar je tekst koji započinje s dvostrukom kosom crtom //, a završava krajem
reda. Komentari su obično prikazani u drugoj boji (zbog preglednosti). Pri prevođenju izvornog
kôda komentar se ne prevodi. Osim za opis programa komentar se ponekad rabi za privremeno
isključivanje dijelova izvornog kôda. Komentar koji se proteže na više redaka zapisujemo između
oznaka /* i */.

Zadatak 9a: Nadopuniti izvorni kod zadatka 9 komentarima. Privremeno isključiti dio izvornog
koda: god=god2-god1. Pokrenuti program pa uočiti posljedice učinjenog.
...
//god=god2-god1;
...
Posljedica je lako uočljiva, vrijednost podatka god nije izračunata. Umjesto točnog izračuna dobit
ćemo zapis sličan sljedećem:
Sada imaš -858993460 godina.

6.6 Operatori obnavljajućeg pridruživanja

Operatori obnavljajućeg pridruživanja omogućavaju kraći zapis aritmetičkih izraza. Sastoje se od


znaka jednakosti i odgovarajućeg aritmetičkog operatora. Npr. izraz a=a+8, može se zapisati kao
a+=8.
Neki od operatora obnavljajućeg pridruživanja:

+= –= *= /= %=
a = a + .... a = a – .... a = a * .... a = a / .... a = a % ....

38
Zadatak 10 (operatori obnavljajućeg pridruživanja): Potrebno je unijeti realni broj i pridružiti
ga varijabli a. Sadržaj varijable a prvo treba uvećati za 5, pa umanjiti za 8, na kraju pomnožiti sa 3.
Koristiti operatore obnavljajućeg pridruživanja. Ispis neka bude oblika:
Upisi zeljeni broj:
Sadrzaj varijable a se uvecava za 5. Sada a iznosi: ....
Od trenutnog sadrzaja varijable a se oduzima 8. Sada a iznosi: ....
Trenutni sadrzaj varijable a se mnozi sa 3. Sada a iznosi: ....

#include<iostream.h>
int main()
{
float a;
cout<<"Upisi zeljeni broj:";
cin>>a;
cout<<"Sadrzaj varijable a se uvecava za 5. Sada a \
iznosi:"<<(a+=5)<<endl;
cout<<"Od trenutnog sadrzaja varijable a se oduzima 8.\
Sada a iznosi:"<<(a-=8)<<endl;
cout<<"Trenutni sadrzaj varijable a se mnozi sa 3.\
Sada a iznosi:"<<(a*=3)<<endl;
System(pause);
return 0;
}

6.7 Logički tip podataka - bool

Logički podaci su podaci koji mogu poprimiti samo jednu od dvije vrijednosti. Npr.:
• true/false,
• da/ne,
• istina/laž,
• 1/0.

39
Osim do sada navedenih tipova podataka (int, float, char) postoje i mnogi drugi. Varijabla koja je
pogodna za pohranu logičkog podatka je tipa bool. Takav tip podataka može poprimiti vrijednosti
true ili false. Pri ispisu se true pretvara u 1, a false u 0.

6.8 Logički operatori


Logičke funkcije se izvode uporabom logičkih operatora. Logički operatori mogu biti:
• unarni,
• binarni.
! Negacija (unarni operator koji 1 pretvara u 0 i obratno)
&& Logički I (engl. AND)
|| Logički ILI (engl. OR)

Logički se operatori uglavnom rabe u naredbama za grananje programa.


Način rada logičkih operatora I i ILI najjednostavnije je prikazati strujnim krugom u kome se nalaze
dvije sklopke. Stanje otvorene sklopke može se označiti sa 0, a zatvorene sa 1. Stanje u kome
žaruljica svijetli može se označiti sa 1, a kada ne svijetli sa 0.

6.9 Logički I
Način rada logičkog I može se prikazati sa sklopkama koje su spojene serijski. Žaruljica će svijetliti
samo kada su obje sklopke zatvorene. Kao što pokazuje tablica stanja, logički operator I vraća
jedinicu samo ako su oba uvjeta true (ispunjen uvjet, istina, 1). U ostalim stanjima rezultat je 0.
A B (A&&B)
0 0 0
1 0 0
0 1 0
1 1 1

6.10 Logički ILI


Način rada logičkog ILI može se prikazati sa sklopkama koje su spojene paralelno. Žaruljica će
svijetliti ako je bilo koja (ili obje) sklopke zatvorene. Kao što pokazuje tablica stanja, logički
operator ILI vraća jedinicu ako je ispunjen samo jedan od uvjeta (true, 1) ili ako su ispunjena oba
uvjeta. U situaciji u kojoj nije ispunjen niti jedan od uvjeta, rezultat rada operatora je 0.
A B (A||B)
0 0 0
1 0 1
0 1 1
1 1 1

Zadatak 11 (uporaba logičkih operatora): Potrebno je unijeti dva logička podatka A i B. Ispisuje
se negacija od A, vrijednost (A I B) te (A ILI B). Ispis neka bude oblika:
Vrijednost logickog podatka A=
Vrijednost logickog podatka B=
Ako je logicki podatak A= ... tada je suprotno od A ....
Za A= .... i B= .... (A I B) = .... Za A= .... i B= .... (A ILI
B)= ....

40
Deklarirati dvije logičke varijable (bool). Operator ILI (||)zapisuje se kombinacijom tipki Alt Gr +
W. (a||b)
#include<iostream.h>
int main()
{ bool a,b;
cout<<"Vrijednost logickog podatka A=";
cin>>a;
cout<<"Vrijednost logickog podatka B=";
cin>>b;
cout<<endl<<"Ako je logicki podatak A="<<a
<<" tada je suprotno od A="<<!a<<endl;
cout<<"Za A="<<a<<" i B="<<b<<" (A I B)="<<(a&&b)<<endl;
cout<<"Za A="<<a<<" i B="<<b<<" (A ILI B)="<<(a||b)<<endl;
System(pause);
return 0;
}

Ispravna bool varijabla može imati vrijednost samo 0 ili 1. Kod nekih se prevoditelja sve različito
od 0 smatra podatkom true, a kod nekih ne. Da bi se izbjegla moguća pogreška treba rabiti samo
vrijednosti 0 i 1.

41
6.11 Usporedba

Dva se broja mogu uspoređivati, a rezultat usporedbe je podatak tipa bool. Ako je napisani izraz
istinit, rezultat usporedbe će biti 1 (true), a ako nije rezultat će biti 0 (false). Uspoređuje se
upotrebom operatora usporedbe:
< manje
<= manje ili jednako
> veće
>= veće ili jednako
== jednako
!= različito
Operatori usporedbe se najčešće koriste u naredbama za grananje.

Zadatak 12 (operatori usporedbe): Potrebno je unijeti dva cijela broja. Nakon toga se ti brojevi
uspoređuju (<, >, ==, !=) i ispisuje se rezultat usporedbe. Ispis neka bude oblika:
Vrijednost prvog broja=
Vrijednost drugog broja=
Je li.... < .... odgovor: ....
Je li.... > .... odgovor: ....
Je li.... == .... odgovor: ....
Je li.... != .... odgovor: ....

#include<iostream.h>
int main()
{
int a,b;
cout<<"Vrijednost prvog broja=";
cin>>a;
cout<<"Vrijednost drugog broja=";
cin>>b;
cout<<endl<<"Je li"<<a<<"<"<<b<<" odgovor: "<<(a<b)<<endl;
cout<<endl<<"Je li"<<a<<">"<<b<<" odgovor: "<<(a>b)<<endl;
cout<<endl<<"Je li"<<a<<"=="<<b<<" odgovor: "<<(a==b)<<endl;
cout<<endl<<"Je li"<<a<<"!="<<b<<" odgovor: "<<(a!=b)<<endl;
System(pause);
return 0;
}

Svaki se od izraza uspoređivanja, npr. a<b treba zapisati unutar zagrada (a<b). Ako se izraz ne
zapiše unutar zagrada, bit će prijavljena pogreška.
42
6.12 String

Za lakše baratanje znakovnim nizovima promjenjive duljine u standardnoj je biblioteci jezika C++
definiran tip podataka string. Tip podataka string “brine” o prostoru kojeg treba predvidjeti u
memoriji, te podržava funkcije i operacije vezane uz znakovne nizove. Biblioteka string sadrži niz
funkcija koje omogućavaju rukovanje sa znakovnim nizovima, treba je uključiti pretprocesorskom
naredbom #include.
#include<string.h>

Primjer ispisa znakovnog niza


#include<iostream.h>
#include<string.h>
int main()
{ string a;
a = “Prvi niz znakova”;
cout<<a<<”, ”<<”drugi niz znakova.”<<endl;
System(pause);
return 0;
}

Znakovni niz “Prvi niz znakova” pohranjen je u varijablu a koja je deklarirana kao string. Niz
“drugi niz znakova” unesen je izravno u retku programa.

Zadatak 13 (korištenje podacima tipa string): Nadopuniti zadatak 9 tako da se unosi i ime
korisnika programa. Ispis neka bude oblika:
Upisi svoje ime:
Upisi godinu svog rodjenja:
Koja je godina sada?
..... ima .... godina.

Naredbom include uključiti biblioteku string zbog rukovanja sa znakovnim nizom. Deklarirati
jednu varijablu tipa string. Paziti na razmake kod ispisa.

43
#include<iostream.h>
#include<string.h>
int main()
{ int god, god1, god2;
string ime;
cout<<"Upisi svoje ime:";
cin>>ime;
cout<<endl<<"Upisi godinu svog rodjenja:";
cin>>god1;
cout<<endl<<"Koja je godina sada? ";
cin>>god2;
god=god2-god1;
cout<<endl<<ime<<" ima "<<god<<" godina."<<endl;
System(pause);
return 0;
}

44
7. C++ Grananje

7.1 Grananje

Tijek programa katkad ovisi o ulaznim podacima ili o međurezultatima obrade. Struktura kod koje
se ovisno o stanju podataka odvija jedan od mogućih dijelova (grana) programa, naziva se grananje.
Kao primjer grananja može poslužiti ovaj zadatak:

Zadatak: Treba izračunati i ispisati


apsolutnu vrijednost broja kojeg
upiše korisnik. (Uočavamo da
redoslijed izvršavanja naredbi ovisi o
ulaznom podatku).

Dijagram tijeka grananja:


Dijagram toka grananja za računanje apsolutne vrijednosti broja.

7.2 Blok naredbi

Dijelovi programa koji se uvjetno izvode objedinjavaju se u blokove naredbi. Blokovi naredbi se
pišu uvučeno (zbog preglednosti). Svaki se blok naredbi omeđuje parom otvorena-zatvorena
vitičasta zagrada (osim slučaja kada se blok sastoji od samo jedne naredbe, tada se zagrade mogu
izostaviti).

Ako se varijable deklariraju unutar bloka, vidljive su samo unutar bloka u kome su deklarirane i u
glavnoj funkciji ne postoje. Varijable deklarirane unutar bloka nazivaju se lokalne i mogu zakloniti
istoimene varijable prethodno deklarirane izvan bloka. (Zbog toga unutar bloka nije uputno
deklarirati varijable istog imena kakvo je korišteno izvan bloka jer to može izazvati zabunu.)

Zadatak 1 (varijabla deklarirana unutar bloka): Treba deklarirati cjelobrojnu varijablu x unutar
zasebnog bloka, pa joj pridružiti vrijednost. Pokušati ispisati vrijednost te varijable u glavnoj
funkciji. Ispis neka bude oblika: Upisi cijeli broj u bloku: bloku:
Vrijednost varijable iz bloka x=....

#include<iostream.h>
int main(){
{
int x;
cout<<endl<<"Upisi cijeli broj u bloku:";
cin>>x;
}
cout<<endl<<"Vrijednost varijable iz bloka x="<<x<<endl;;
return 0;}

45
Pri pokušaju prevođenja bit će prijavljena pogreška.

Varijable deklarirane unutar bloka vidljive su samo unutar tog bloka. U glavnoj funkciji varijabla x
ne postoji. Zato se pri prevođenju javlja pogreška.

7.3 Naredbe grananja

Struktura grananja se može ostvariti naredbama:


 if (if – else, if – else if - else),
 switch – case.

7.4 Grananje naredbom if

Naredba if omogućava uvjetno grananje programa. Daljnji tijek programa ovisi o ispunjenju uvjeta
navedenog iza ključne riječi if. Uvjet (logički izraz) se upisuje unutar para okruglih zagrada. Na
kraju naredbe if ne stavlja se znak ;

Naredba if – osnovni oblik


if (logički izraz)
{
blok naredbi
}
naredba iza bloka

Ako je vrijednost logičkog izraza istina (1), izvodi se blok naredbi koji se nalazi iza naredbe if. Ako
je vrijednost logičkog izraza neistina (0), blok se preskače i izvođenje se nastavlja od prve naredbe
iza bloka.

Zadatak 2 (osnovni oblik naredbe if): Treba unijeti cijeli broj pa provjeriti da li je negativan ili
pozitivan. U oba slučaja ispisati apsolutnu vrijednost broja. Ispis neka bude oblika:
Upisi broj:
Broj...je.... Njegova apsolutna vrijednost je....

Primjer će biti riješen pomoću dvije if naredbe. Ako je (a < 0) izvršit će se blok naredbi nakon if
naredbe. Ako uvjet nije zadovoljen, blok naredbi nakon prve if naredbe se preskače i izvođenje
programa se nastavlja od prve naredbe iza bloka. Prva naredba iza bloka je provjera drugog uvjeta
(a > 0). Ako nije ispunjen niti prvi niti drugi uvjet (tj. ako je a = 0), blok naredbi nakon druge if
naredbe se preskače i izvođenje programa se nastavlja od naredbe iza drugog bloka.

46
#include<iostream.h>
int main()
{
int a;
cout<<"Upisi broj:";
cin>>a;
if(a<0)
{
cout<<"Broj "<<a<<" je negativan. Njegova apsolutna \
vrijednost je "<<-a<<endl;
}
if(a>0)
{
cout<<"Broj "<<a<<" je pozitivan. Njegova apsolutna \
vrijednost je "<<a<<endl;
}
system(„pause“);
return 0;
}

Ako nije ispunjen ni prvi ni drugi uvjet, program se prekida. (a = 0)

7.5 Grananje – dvije neovisne grane

if (logički izraz)
prvi blok naredbi
else
drugi blok naredbi
naredba iza bloka

Ako je vrijednost logičkog izraza istina (1), izvodi se prvi blok naredbi. Po njegovom završetku
izvođenje se nastavlja od prve naredbe iza drugog bloka.

47
Ako je vrijednost logičkog izraza neistina (0), preskače se prvi blok i izvodi se drugi blok naredbi
(iza else). Nakon toga se izvode naredbe kako slijede.

Zadatak 3 (oblik naredbe if – else): Treba unijeti cijeli broj različit od 0 pa provjeriti je li negativan
ili pozitivan. U oba slučaja ispisati apsolutnu vrijednost broja. Ispis neka bude oblika:
Upisi broj razlicit od 0:
Broj...je....Njegova apsolutna vrijednost je....

Primjer je riješen uz pomoć if – else naredbe. Uneseni broj mora biti različit od 0. Ako je (a < 0)
izvršit će se prvi blok naredbi. Ako a nije manje od 0, preskače se prvi blok i izvodi se drugi blok
naredbi.

#include<iostream.h>
int main()
{
int a;
cout<<"Upisi broj razlicit od 0:";cin>>a;
if(a<0)
{
cout<<"Broj "<<a<<" je negativan. Njegova apsolutna\
vrijednost je "<<-a<<endl;
}
else
{
cout<<"Broj "<<a<<" je pozitivan. Njegova apsolutna\
vrijednost je "<<a<<endl;
}
System(pause);
return 0;
}

48
Što ako korisnik ne pročita uputu pažljivo, pa unese broj 0? Rezultat neće biti ispravan:
Broj 0 je pozitivan. Njegova .....
Stoga bi bilo dobro izbjeći takvu situaciju. Ako korisnik unese nulu, neka dobije upozorenje, pa
neka ponovi unos broja koji će zadovoljiti postavljeni uvjet. Da bi se program mogao nastaviti od
odabranog programskog retka (u ovome slučaju od naredbe unosa broja), potrebna je odgovarajuća
naredba koja će to i omogućiti.

7.6 Naredba goto

Naredba goto je naredba bezuvjetnog skoka (omogućava nastavak programa od odabranog


programskog retka). Opći oblik je:
goto ime_oznake;
ime_oznake je simbolički naziv odabranog programskog retka od kojeg se program želi nastaviti.
Simbolički se naziv stavlja ispred naredbe na koju se želi "skočiti" (preusmjeriti program). Iza
simboličkog naziva dolazi znak dvotočka (:). Naredba na koju se želi skočiti može se nalaziti bilo
gdje. Naredba goto najčešće smanjuje razumljivost i preglednost kôda pa ju nije preporučljivo
rabiti.

#include<iostream.h>
int main()
{
int a;
upis:cout<<"Upisi broj razlicit od 0:";cin>>a;
if(a==0)
{
cout<<"Pogresan unos. Ponovi!"<<endl;
goto upis;
}
if(a<0)
System(pause);
return 0;
{

49
7.7 Ulančana if naredba

Blokovi if naredbi se mogu ulančiti.

if (logički izraz 1)
prvi blok naredbi
else if (logički izraz 2)
drugi blok naredbi
.....
else
zadnji blok naredbi

Ako je vrijednost logičkog izraza1 logička istina (1), izvodi se prvi blok naredbi. Po njegovom
završetku izvođenje se nastavlja od prve naredbe iza zadnjeg bloka naredbi. Ako vrijednost
logičkog izraza1 nije logička istina (0), provjerava se vrijednost logičkog izraza2 i ovisno u
njegovoj vrijednosti izvodi se drugi blok naredbi ili se program nastavlja iza njega. Ako niti jedna
vrijednost logičkih izraza nije logička istina izvodi se zadnji blok naredbi iza naredbe else.

Zadatak 4 (oblik ulančene naredbe if): Zadatak 3 treba dopuniti tako da se u slučaju unesene nule
ispiše odgovarajuća poruka. Ispis neka bude oblika:
Upisi broj:
Broj...je....Njegova apsolutna vrijednost je....
ili
Unio si 0. Apsolutna vrijednost od 0 je 0.

#include<iostream.h>
int main()
{
int a;
cout<<"Upisi broj:";cin>>a;
if (a==0)
{
cout<<"Unio si 0. Apsolutna vrijednost od 0 je 0. " <<endl;
}
else if (a<0)
{
cout<<"Broj "<<a<<" je negativan. Njegova apsolutna \
vrijednost je "<<-a<<endl;
}
else
{
cout<<"Broj "<<a<<" je pozitivan. Njegova apsolutna \
vrijednost je "<<a<<endl;
}
System(pause);
return 0;

50
}

Ako se unese 0, poruka će biti:


Unio si 0. Apsolutna vrijednost od 0 je 0.
U ostalim slučajevima, provjera je ista kao u primjeru 36.

7.8 Ugnježđivanje if naredbi

Moguće je ugnježđivati if naredbe jedne unutar drugih. Ugnježđivanje će biti prikazano na


sljedećem primjeru.

Zadatak 5 (oblik ugnježđenih naredbi if): Treba upisati cijeli broj različit od 0. Treba provjeriti je li
broj veći ili manji od 100, te je li paran ili neparan. Ispis neka bude oblika:
Upisi broj:
Uneseni broj je ... od 100 i ....

Vanjska if naredba provjerava je li broj veći ili manji od 100. Ako se unese broj 100, ispisuje se
odgovarajuća poruka. Unutarnje if naredbe (neovisno o tome je li broj veći ili manji od 100)
provjeravaju parnost broja. Parnost se provjerava operatorom modulo (ostatak dijeljenja sa 2 se
uspoređuje sa 0).

51
#include<iostream.h>
int main()
{
int a;
cout<<"Upisi broj razlicit od 0:";
cin>>a;

if (a<100)
{
cout<<"Uneseni broj je manji od 100 i ";
if (a%2==0)
cout<<" paran je."<<endl;
else
cout<<" neparan je."<<endl;
}
else if (a>100)
{
cout<<"Uneseni broj je veci od 100 i ";
if (a%2==0)
cout<<" paran je."<<endl;
else
cout<<" neparan je."<<endl;
}
else
{
cout<<"Unesen je broj 100, on je paran“<<endl;
}
System(pause);
return 0;
}

7.9 Uvjetna naredba – kratki oblik

Ako su uvjet (logički izraz) i naredbe blokova kratki, umjesto if – else naredbi može se rabiti
skraćeni oblik zapisa.
(logički izraz) ? (1. blok naredbi) : (2. blok naredbi)
Ovaj se oblik koristi kada logički izraz i naredbe blokova stanu u jedan redak.

52
if (a<0)
cout<<-a;
else ⇒ (a<0)?(cout<<-a):(cout<<a)
cout<<a;

Zadatak 6 (uvjetna naredba skraćenog oblika): Treba unijeti cijeli broj različit od 0 pa ispisati
apsolutnu vrijednost broja. Ispis neka bude oblika:
Upisi broj:
Apsolutna vrijednost je....

#include<iostream.h>
int main()
{
int a;
cout<<"Upisi broj:";
cin>>a;
(a<0)?(cout<<"Apsolutna vrijednost je “
<<-a):(cout<<"Apsolutna vrijednost je "<<a);
System(pause);
return 0;
}

7.10 Grananje naredbom switch

Naredba switch – case omogućava višestruko grananje. Iza naredbe switch dolazi cjelobrojni izraz
u zagradi. Rezultat cjelobrojnog izraza je cjelobrojna konstanta. Ovisno o vrijednosti konstante
izvodi se odgovarajući blok naredbi (grana).
switch – case (opći oblik)

switch (cjelobrojni izraz){


case (1. konstanta):
prvi blok naredbi
break;
case (2. konstanta):
drugi blok naredbi
break;
.........
default:
zadnji blok naredbi
}
Prvo se izračunava vrijednost cjelobrojnog izraza u zagradi (to je postavljeni uvjet). Zatim se
dobivena vrijednost izraza (konstanta) uspoređuje s nizom zadanih konstanti. Ako je dobivena
vrijednost izraza jednaka bilo kojoj od zadanih konstanti izvršava se blok naredbi pridružen toj
konstanti. Po završetku bloka naredba break označava izlaz iz swith – case bloka. Ako dobivena
vrijednost izraza nije jednaka niti jednoj od zadanih konstanti, izvršava se blok naredbi pridružen
default naredbi. Cjelokupni switch – case blok zapisuje se unutar para otvorena-zatvorena vitičasta
zagrada.

53
8. C++ petlje

8.1 Petlja

Ponekad se dijelovi programa trebaju ponoviti više puta (iterirati). Struktura koja to omogućava
naziva se programska petlja. Ponavljati se može:
• unaprijed zadani broj puta,
• sve dok je ispunjen određeni uvjet.

Primjer petlje
Potrebno je ispisati prvih 100 prirodnih brojeva. Treba
uočiti da se dio naredbi izvršava opetovano sto puta.

Primjer dijagrama toka petlje za


ispis prvih sto prirodnih brojeva.

Struktura petlje se može ostvariti naredbama:


• for,
• while,
• do – while.

8.2 for petlja

for petlja se najčešće koristi ako se dijelovi programa trebaju ponoviti konačan broj puta. Osnovni
oblik for petlje:
for (početno stanje; uvjet; prirast)
{
blok naredbi
}

Prvo se zadaje početno stanje kontrolne varijable petlje.


Zatim se računa vrijednost uvjeta. Rezultat mora biti
tipa bool (0 ili 1). Blok naredbi se izvršava sve dok je
vrijednost uvjeta jednaka logičkoj istini (1). Kad
vrijednost uvjeta postane neistina (0) petlja se prekida.
Na kraju se računa prirast (prirast je najčešće iznos za
koji se mijenja vrijednost kontrolne varijable petlje).

Dijagram toka:

54
Zadatak 1: Potrebno je ispisati brojeve od 1 do 20. Ispis neka bude oblika:
Ispis brojeva od 1 do 20:
1 2 3 4 5 6 7 8 9 ..................20
Treba zadati početnu vrijednost kontrolne varijable petlje (brojac=1), postaviti uvjet (brojac<=20) i
zadati prirast (brojac++). Naredba koja se izvodi konačan broj puta je ispis trenutne vrijednosti
varijable brojac. Zbog preglednosti ispisa nakon svakog broja ispisuje se jedno prazno mjesto. Na
kraju ispisa kazalo prelazi na početak novog reda.

#include<iostream.h>
int main()
{
int brojac;
cout<<"Ispis brojeva od 1 do 20:"<<endl;
for (brojac=1;brojac<=20;brojac++)
{
cout<<brojac<<" ";
}
cout<<endl;
System(pause);
return 0;
}

Zadatak 2: Potrebno je dopuniti prethodni primjer tako da se ispisuju brojevi iz raspona od M do N


(raspon bira korisnik). Ispis neka bude oblika:
Ispis pocinje od broja:
Ispis zavrsava brojem:
Ispis brojeva od ... do ...:
... ... ... ...... ...
Razlika u odnosu na prethodni primjer je odabir granica raspona brojeva koji će biti ispisani.
Početna vrijednost kontrolne varijable brojac je ovisna o unesenoj početnoj vrijednosti raspona (M),
a uvjet o unesenoj završnoj vrijednosti raspona (N). Izraz prirasta (brojac++) se ne mijenja.

#include<iostream.h>
int main()
{
int brojac,m,n;
cout<<"ispis pocinje od broja:";
cin>>m;
cout<<"ispis zavrsava brojem:";
cin>>n;
55
for (brojac=m;brojac<=n;brojac++)
{
cout<<brojac<<" ";
}
cout<<endl;
System(pause);
return 0;
}

Zadatak 3: Potrebno je zbrojiti prvih 100 prir.brojeva. Ispis neka bude oblika:
Zbroj prvih 100 prirodnih brojeva je ....
Treba zadati početnu vrijednost kontrolne varijable petlje (brojac=1), postaviti uvjet (brojac<=100)
i zadati prirast (brojac++). Prije ulaska u petlju treba deklarirati varijablu (npr. zbroj) u koju će se
pribrajati trenutne vrijednosti kontrolne varijable petlje pri svakom prolasku kroz petlju. Naredba u
bloku koja se izvodi konačan broj puta je uvećavanje vrijednosti varijable zbroj (u njoj će na kraju
biti konačan zbroj prvih 100 brojeva) za tekuću vrijednost kontrolne varijable petlje (brojač). Petlja
se ponavlja sve dok je sadržaj varijable brojac manji ili jednak 100.

#include<iostream.h>
int main()
{
int brojac,zbroj;
zbroj=0;
cout<<"Zbroj prvih 100 prirodnih brojeva je:";
for (brojac=1;brojac<=100;brojac++)
{
zbroj=zbroj+brojac;
}
cout<<zbroj<<endl;
System(pause);
return 0;
}

56
Zadatak 4: Treba ispisati tablicu množenja odabranog broja sa brojevima od 1 do 10. Broj bira
korisnik. Ispis neka bude oblika:
Upisi broj sa kojim zelis mnoziti:
... * 1 = ...
... * 2 = ...
.
.
.
... * 10 = ...

#include<iostream.h>
int main()
{
int b, brojac;
cout<<"Upisi broj sa kojim zelis mnoziti:";
cin>>b;
for (brojac=1;brojac<=10;brojac++)
cout<<b<<" * "<<brojac<<" = "<<b*brojac<<endl;
System(pause);
return 0;
}

57
8.3 Beskonačna petlja

Može se dogoditi da je uvjet uvijek ispunjen. Petlja se tada izvodi neograničen broj puta. Ako se
dogodi da se pokrene program u kome je beskonačna petlja program se može prekinuti zatvaranjem
prozora u kom se izvršava program ili restartanjem računala (za računala koja nemaju višezadaćni
operacijski sustav).

Beskonačna petlja je npr.: for(b=3;b<10;)


cout<<“beskonacna petlja”;
Vrijednost varijable b je uvijek manja od 10 pa će se petlja ponavljati neograničen broj puta.

Da bi se izbjegla beskonačna petlja treba:


• zadati uvjet koji jamči konačan broj ponavljanja petlje,
• navesti sva tri izraza u zagradi naredbe for,
• izbjegavati promjenu vrijednosti kontrolne varijable unutar bloka naredbi for petlje.

Zadatak 5: Treba ispisati parne brojeve u rasponu od 50 do 100. Ispis neka bude oblika:
Parni brojevi iz intervala od 50 do 100 su:
50 52 54 56 .......... 98 100
Pošto je razlika dva susjedna parna broja 2, problem je moguće riješiti tako da se vrijednost
kontrolne varijable petlje mijenja za 2 (prirast 2).
brojac=brojac+2 ili brojac+=2
(neće trebati provjeravati parnost )

#include<iostream.h>
int main()
{
int brojac;
cout<<"Parni brojevi iz intervala od 50 do 100 su:"<<endl;
for (brojac=50;brojac<=100;brojac+=2)
{
cout<<brojac<<" ";
}
58
cout<<endl;
System(pause);
return 0;
}

Zadatak 6: Treba ispisati parne brojeve u rasponu od 100 do 50. Ispis neka bude oblika:
Parni brojevi iz intervala od 100 do 50 su:
100 98 96 94 .......... 52 50
Prirast može biti i negativan pa se tada vrijednost kontrolne varijable petlje smanjuje. U ovome
slučaju početna vrijednost kontrolne varijable petlje mora biti veća od završne. Npr. prirast može
biti:
brojac=brojac-2 (brojac-=2)

Zadatak 7: Treba potražiti pa ispisati brojeve djeljive sa 7 unutar raspona od 200 do 300. Ispis neka
bude oblika:

Brojevi djeljivi sa 7 iz raspona od 200 do 300 su:


... ... ... ... ...

Blok naredbi u petlji se izvršava za svaki broj iz zadanog raspona. Ispisuju se samo brojevi djeljivi s
brojem 7. Djeljivost brojeva se provjerava operatorom modulo (%).

#include<iostream.h>
int main()
{
int brojac;
cout<<"Brojevi djeljivi sa 7 iz raspona od 200 do 300 su:"<<endl;
for (brojac=200;brojac<=300;brojac++)
{
if(brojac%7==0)
cout<<brojac<<" ";
}
cout<<endl;
59
System(pause);
return 0;
}

Zadatak 8: Treba provjeriti djeljivost brojeva unutar odabranog raspona sa zadanim brojem. Ispis
neka bude oblika:
Pocetna vrijednost raspona:
Zavrsna vrijednost raspona:
Provjerava se djeljivost sa brojem:
Brojevi djeljivi sa ... iz raspona od ... do ... su:
... ... ... ... ...

#include<iostream.h>
int main()
{
int brojac,m,n,b;
cout<<"Pocetna vrijednost raspona:";
cin>>m;
cout<<"Zavrsna vrijednost rapona:";
cin>>n;
cout<<"Provjerava se djeljivost sa brojem:";
cin>>b;
cout<<"Brojevi djeljivi sa "<<b<<" iz raspona od "
<<m<<" do "<<n<<" su:"<<endl;
for (brojac=m;brojac<=n;brojac++)
{
if(brojac%b==0)
cout<<brojac<<" ";
}
cout<<endl;
System(pause);
return 0;
}

60
8.4 Ugniježđene for petlje

for petlje mogu biti ugniježđene jedna


unutar druge. Pri ulazu u vanjsku petlju,
njena se kontrolna varijabla postavi na
početnu vrijednost. Sa tom se
vrijednošću ulazi u unutarnju petlju.

Pri ulazu u unutarnju petlju, kontrolna


varijabla unutarnje petlje se postavi na
početnu vrijednost i sve dok je uvjet
zadovoljen, izvršava se blok naredbi
unutarnje petlje. Po završenoj unutarnjoj
petlji, kontrolna varijabla vanjske petlje
se mijenja za vrijednost prirasta i
provjerava se uvjet vanjske petlje. Za
svaku vrijednost kontrolne varijable
vanjske petlje izvodi se cjelokupna
unutarnja petlja.

61
Zadatak 9: Vrijednost kontrolne varijable vanjske petlje mijenja se od 1 do 3, a unutarnje od 1 do
5. U programu se ispisuju trenutne vrijednosti kontrolnih varijabli vanjske i unutarnje petlje. (Treba
uočiti da se za svaku vrijednost kontrolne varijable vanjske petlje (i) izvrši cjelokupna unutarnja
petlja (j od 1 do 5).)

Vanjska petlja omogućit će :


• ispis teksta: Vanjska petlja:,
• ispis trenutne vrijednosti kontrolne varijable vanjske petlje (i).
• Ispis teksta: Unutarnja petlja:

Unutarnja petlja :
• ispisuje trenutne vrijednosti kontrolne varijable unutarnje petlje (j, od 1 do 5).
• Po ispisu svakoga od redaka, kazalo se prebacuje na početak novog redka i postupak se
ponavlja.

#include <iostream.h>
int main()
{
int i, j;
for ( i = 1; i <= 3; i++ )
{
cout<<endl<<"Vanjska petlja: i="<<i<<endl;
cout<<"Unutarnja petlja: ";
for ( j = 1; j <= 5; j++ )
{
cout<<" j="<<j;
}
cout<<endl;
}
System(pause);
return 0;
}

62
Zadatak 10: Treba ispisati tablicu množenja za brojeve od 1 do 10. Ispis neka bude prikazan u
stupcima.
Vanjska petlja omogućit će stvaranje 10 redaka. Unutarnja petlja će u svakome redku stvoriti 10
stupaca. Naredba koja se izvršava u unutarnjoj petlji je ispis umnoška trenutnih vrijednosti
kontrolnih varijabli vanjske i unutarnje petlje. Po ispisu svakoga od redaka, kazalo se prebacuje na
početak novog redka.

#include<iostream.h>
int main()
{
int stup,red;
for(red=1;red<=10;red++)
{
for(stup=1;stup<=10;stup++)
{
cout<<red*stup<<" ";
}
cout<<endl;
}
System(pause);
return 0;
}

Ispis se može oblikovati manipulatorima (operatorima za rukovanje ispisom). Da bi ispis bio u


pravilnim stupcima, koristi se manipulator setw(int) koji određuje koliki će se prostor predvidjeti za
ispis podatka koji slijedi u izlaznom toku. Svi su manipulatori definirani u biblioteci iomanip, koju
treba uključiti naredbom include.

#include<iostream.h>
#include<iomanip.h>
int main()
{
int stup,red;
for(red=1;red<=10;red++)
{
for(stup=1;stup<=10;stup++)
{
cout<<setw(7)<<red*stup;
}
cout<<endl;
63
}
System(pause);
return 0;
}

8.5 while petlja

while petlja se najčešće koristi ako broj ponavljanja bloka naredbi u petlji nije unaprijed poznat.
Izvršava se sve dok je ispunjen zadani uvjet. Osnovni oblik while petlje:

while (uvjet)
{
blok naredbi
}

Prije ulaska u while petlju potrebno je zadati početnu


vrijednost varijabli koja se koristi u uvjetu. Zatim se
provjerava vrijednost uvjeta (rezultat je tipa bool). Ako je
vrijednost uvjeta logička istina (1) izvodi se blok naredbi
iz petlje. Ako je vrijednost uvjeta logička neistina (0),
blok naredbi iz petlje se preskače i program se nastavlja
od prve naredbe nakon petlje.
Dijagram toka while petlje

Zadatak 11 (while petlja može zamijeniti for petlju): Uporabom while petlje potrebno je ispisati
brojeve od 1 do 20. Ispis neka bude oblika:
Ispis brojeva od 1 do 20:
1 2 3 4 5 6 7 8 9 ...................20

Petlja while može zamijeniti for petlju. Za rješenje ovog problema potrebno je, prije ulaska u petlju,
zadati početnu vrijednost varijable koja se koristi u uvjetu (brojac=1), zadati uvjet (brojac<=20), a u
bloku naredbi u petlji uz ostalo zadati i prirast (brojac++).
64
#include<iostream.h>
int main()
{
int brojac;
brojac=1;
cout<<"Ispis brojeva od 1 do 20:"<<endl;
while(brojac<=20)
{
cout<<brojac<<" ";
brojac=brojac+1;
}
cout<<endl;
System(pause);
return 0;
}

Zadatak 12: Treba unijeti N realnih brojeva pa izračunati njihovu srednju vrijednost. Unos brojeva
traje sve dok korisnik ne upiše 0. Ispis neka bude oblika:
Nakon posljednjeg broja unesi nulu.
Unesi broj:
Unesi broj:
...
Uneseno je ... brojeva. Srednja vrijednost je ....

Problem se lako rješava while petljom (broj brojeva koje treba unijeti nije unaprijed poznat). Prije
ulaska u petlju potrebno je zadati početnu vrijednost varijable koja se koristi u uvjetu. U ovome
slučaju potrebno je unijeti prvi broj (N). Uvjet će biti uspoređivanje sadržaja varijable u koju se
pohranjuje uneseni broj sa 0 (N==0).
Ako je uvjet ispunjen, izvršit će se blok naredbi u petlji. U bloku je potrebno:
• uneseni broj pribrojiti varijabli zbroj (zbrajanje),
• varijablu broj uvećati za jedan (prebrojavanje),
• unijeti sljedeći broj.
• Unos se nastavlja sve dok je uvjet ispunjen, tj. dok se ne unese 0.
Kada korisnik unese 0, uvjet više nije ispunjen, program se nastavlja od prve naredbe nakon petlje.
Nakon petlje treba izračunati i ispisati srednju vrijednost unesenih brojeva.
65
#include<iostream.h>
int main()
{
cout<<"U programu se unosi N brojeva, a zatim se \
racuna srednja vrijednost unesenih brojeva."<<endl;
float N,broj,zbroj;
broj=0;
zbroj=0;
cout<<"Nakon posljednjeg broja unesi nulu."<<endl;
cout<<"Unesi broj:";
cin>>N;

while(N!=0)
{ broj=broj+1;
zbroj=zbroj+N;
cout<<"Unesi broj:";
cin>>N;
}
cout<<"Uneseno je "<<broj<<" brojeva. \
Srednja vrijednost je "<<zbroj/broj<<endl;
System(pause);
return 0;
}

66
8.6 do-while petlja

do-while petlja se također koristi ako broj


ponavljanja bloka naredbi u petlji nije unaprijed
poznat. Njena specifičnost je u tome što uvjet
ispituje nakon izvođenja bloka naredbi u petlji.
Osnovni oblik do-while petlje:

do
{
blok naredbi
}
while (uvjet);
Dijagram toka:

Oblik ove petlje je takav da se blok naredbi u petlji izvodi bar jednom bez obzira da li je uvjet
ispunjen ili ne. U tome je i osnovna razlika ove petlje u odnosu na petlje for i while kod kojih je
moguće da se blok naredbi u petlji ne izvede niti jednom ako uvjet petlje nije ispunjen.

Zadatak 13: Prethodni primjer riješiti do-while petljom (treba unijeti N realnih brojeva pa
izračunati njihovu srednju vrijednost). Ispis neka bude oblika:
Nakon posljednjeg broja unesi nulu.
Unesi broj:
Unesi broj:
...
Uneseno je ... brojeva. Srednja vrijednost je ....

Kada se koristi do-while petlja nije potrebno unijeti prvi broj prije početka petlje jer se uvjet
ispituje tek nakon izvođenja naredbi iz bloka. U bloku je potrebno:
• unijeti broj,
• uneseni broj pribrojiti varijabli zbroj,
• varijablu broj uvećati za jedan.
Uvjet se ispituje nakon bloka naredbi u petlji. Pošto će na ovaj način biti prebrojena i pribrojena 0
kao uneseni broj, po izlasku iz petlje varijablu broj treba umanjiti za jedan.

#include<iostream.h>
int main(){
cout<<"U programu se unosi N brojeva, a zatim se racuna \
srednja vrijednost unesenih brojeva."<<endl;
float N,broj,zbroj;
broj=0;
zbroj=0;
cout<<"Nakon posljednjeg broja unesi nulu."<<endl;

do {
cout<<"Unesi broj:";
cin>>N;
broj=broj+1;
zbroj=zbroj+N;
}
while(N!=0);
broj=broj-1;
cout<<"Uneseno je "<<broj<<" brojeva.Srednja vrijednost je "
<<zbroj/broj<<endl;
System ("pause");
return 0;

67
8.7 Naredba break

Naredba break se rabi kada treba prekinuti izvođenje nekog bloka naredbi unutar petlje. Nakon
naredbe break program prelazi na prvu naredbu iza programske petlje. (Break je i sastavni dio
switch–case naredbe.)

Zadatak 14: Treba ispisati brojeve od 10 prema 1. Ispis se prekida nakon broja 3. Ispis neka bude
oblika:

Ispis brojeva:
10, 9, 8, 7, 6, 5, 4, 3, prekinuto brojenje unatrag.

#include <iostream.h>
int main ()
{
int n;
for (n=10; n>0; n--)
{
cout << n << ", ";
if (n==3)
{
cout<<" prekinuto brojenje unatrag."<<endl;
break;
}
}
System(pause);
return 0;
68
}

8.8 Naredba continue

Ponekad je potrebno preskočiti dio bloka naredbi do kraja programske petlje, pa nakon toga petlju
nastaviti. U tu se svrhu koristi naredba continue. (Bolje je, umjesto naredbe continue koristiti
naredbu grananja if jer nepažljiva uporaba naredbe continue može izazvati beskonačnu petlju.)

Zadatak 15: Treba ispisati brojeve od 10 prema 1. Trojka se preskače, a nakon toga se nastavlja
ispis. Ispis neka bude oblika:
Ispis brojeva:
10, 9, 8, 7, 6, 5, 4, trojka se preskace 2, 1,

#include <iostream.h>
int main ()
{
int n;
cout<<"Ispis brojeva:"<<endl;
for (n=10; n>0; n--)
{
if (n==3)
{
cout<<" trojka se preskace, ";
continue;
}
cout << n << ", ";
}
System(pause);
return 0; }

69
70
9. Zaključak
U ovoj maturalnoj radnji opisano je sve algoritam, programski jezici, nastanak programa, C++
podaci, osnovna struktura programa, operatori, grananje, naredba continue, i petlje. Uz sve
teorijsko isprobao sam više zadataka iz svake cjelinei vizualno pokazao kako bi izvršenje svakog od
zadataka izgledalo Borland C++ - u.

71
10. Literatura
- RAČUNALSTVO-udžbenik za 1. i 2. razred četverogodišnjih strukovnih škola.
-Darko Grundler
-Sandra Šutalo

- DEMISTIFICIRANI C++
-Julijan Štribar
-Bons Motik

- C++ NAUČITE ZA 21 DAN


-Jesse Liberty

- C++ - ANALIZA I PRIMJENA


-Željko Kovačević

- ZBIRKA RIJEŠENIH ZADATAKA IZ C-a


-Rajko Vulin
-Sanja Grabusin
-Ljiljana Miletić

- ZABILJEŠKE S PREDAVANJA ŠKOLSKE GODINE 2007/8

- PRIPREME ZA NASTAVU NA WEB STRANICI ŠKOLE


- www.ss-strukovna-vvlatkovica-zd.skole.hr

72