2
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
SADRŽAJ
1. Općenito o programima i programskim jezicima
1.1. Ljudi i računari...................................................................................................................6 1.2. Podjela programskih jezika..................................................................................................7
2. Programski Pristup
2.1. O proceduralnom i neprceduralno programiranju ...............................................................10
2.2. Osnove faze razvoja programiranja ....................... ..................................12
3 .Algoritmi
3.1.Uvod u algoritme ..........................................................................................................13 3.2.Dijagram toka ..................................................................................................................14 3.3.Pravolinijske algoritamske strukture.....................................................................................18
3.4.Grananje..........................................................................................................................19 3.5.Petlje...............................................................................................................................23
4. Pseudo Jezik
4.1.Varijable..........................................................................................................................28
4.2. Operatori........................................................................................................................29 4.3.Funkcije...........................................................................................................................33
5 .Kako započeti?
5.1.MS Visual C++.......................................... ............................... ............34
5.2.Programski paket DEV C++..............................................................................................37 Pitanja za utvrĎivanje ......................................................................................................41
6.Uvod u C++
6.1 Proces kompajliranja. .......................................................................................................42
6.2. Riječi u C++ programskom jeziku ......................................................................................44 6.3.Struktura programa...........................................................................................................45
6.4. Varijable .........................................................................................................................47 6.5. Memorija ........................................................................................................................48
6.6. Ulazno/izlazni usmjerivači toka ..........................................................................................49
6.7. Komentari .....................................................................................................................50
3
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
6.8. Imena (identifikatori) .......................................................................................................51
6.9. Tipovi podataka ...............................................................................................................52
Pitanja za utvrĎivanje .............................................................................................................55
7.Operatori
7.1 Aritmetički operatori .......................................................................................................56 7.2 Relacijski operatori .....................................................................................................58
7.3 Logički operatori .............................................................................................................59 7.4 Bitovni operatori .............................................................................................................59
7.5 Inkrementalni i dekrementalni operatori .............................................................................59 7.6 Operatori pridruţivanja .....................................................................................................60
7.7 Operator razdvajanja (zarez-operator) ...............................................................................61 7.8 typedef imena ................................................................................................................61
7.9 sizeof operator ...............................................................................................................62
7.10 Hijerarhija operatora ......................................................................................................62 Pitanja za utvrĎivanje ............................................................................................................63
8.Naredbe
8.1 Jednostavne i sloţene naredbe ...........................................................................................64
8.2 Naredba if........................................................................................................................66 8.3 Naredba switch-case .........................................................................................................72
8.4 Naredba for .....................................................................................................................75
8.5 Naredba while . ................................................................................................................78
8.6 Naredba do ......................................................................................................................79 Pitanja za utvrĎivanje .............................................................................................................81
9. Funkcije
9.1. Definicija ........................................................................................................................81
9.2. Parametri i argumenti ......................................................................................................84 9.3. Globalne i lokalne varijable ...............................................................................................85
9.4 Rekurzivne funkcije ..........................................................................................................86 Pitanja za utvrĎivanje ..........................................................................................................87
10. Polja (Arrays ),nizovi
10.1. Jednodimenzionalni niz ...................................................................................................87 10.2. Deklaracija niza..............................................................................................................88
10.3.Inicijalizacija niza............................................................................................................89 10.4.Pristup elementima niza...................................................................................................91
10.5.Multidimenzionalna polja(nizovi)........................................................................................94
Pitanja za utvrĎivanje ........................................................................................................96
4
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
11. Pointeri
11.1. Osnovno o pointerima ....................................................................................................97 11.2. Dinamička memorija ......................................................................................................97
11.3. Pointeri i polja ...............................................................................................................99
11.4. Aritmetika sa pointerima .................................................................................................99 11.5. Funkcijski pointeri ........................................................................................................101
Pitanja za utvrĎivanje ........................................................................................................102
12. Datoteke
12.1. Standardna biblioteka fstream .......................................................................................103 12.2. Otvaranje datoteka ......................................................................................................103
12.3. Zatvaranje datoteka .....................................................................................................107 12.4. Pisanje na datoteke ......................................................................................................108
12.5. Čitanje sa datoteka ......................................................................................................110
Pitanja za utvrĎivanje ........................................................................................................113
13.Zbirka zadataka 113
14.Rješenja 123
Literatura 157
5
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
Kratka biografija autora
Dipl.prof.Informatike Smajo(Irfana)Mekić- zv.Smayson- roĎen
01.01.1972.u G.Bukovici Travnik;
Srednju tehničku školu završio u Zenici,Nastavnički fakultet završio na Univerzitetu „Đemal Bijedić“ u Mostaru,nastavio studij na
Panevropskom Univerzitetu „Apeiron“ na FIT-u(Fakultet Informacionih Tehnologija) u Banjaluci smjer nastavnička
informatiku gdje dobiva zvanje Diplomirani profesor
Informatike,Specijalistički studio završio na istom fakultetu,a Diplomski/Specijalistički rad na temu „PoreĎenje Pascala i C++ u
nastavnom procesu“ odbranio pred akademikom dr.Zoran.Ţ.Avramović dipl.ing.elektrotehnike.
Oţenjen, otac četiri sina,trenutno nastanjen na Kalibunaru-Travnik,
uposlen u Mješovitim srednjim školama Busovača i Vitez.
Rječ autora
Autor ove knjige je pokušao na osnovu jako puno literature, dostupne u raznim formatima i na mnogim
jezicima, na temu C++ programiranje , da u skladu sa nastavnim planom i programom za srednje
škole izdvoji i obradi osnovne teme iz ove oblasti.Teme su uraĎene uz poštovanje pedagoških nastavni principa.Cilj ove knjige je lakše shvatanje predviĎenog gradiva ,postupno rješavanja zadataka
,stjecanje rutina,navika,upornosti,preciznosti,analize i sinteze....Ovu knjigu prati projekat u html-u“ C++ programiranje za srednje škole“ na www.mssbusovaca.com.ba. ,takoĎer je u pripremi
muldimedijalni DVD koji prati ovu knjigu. UraĎeni materijal moţe biti od koristi za sve one koji ţele da načine prve korake u programiranju u
programskom jeziku C++.Knjiga predstavlja radnu verziju i podloţna je izmjenama,dopunama te se kao takva koristi interno i nije planirana komercijalizacija i umnoţavanje.Zbirka riješenih zadataka
ima za cilj da motiviše učenike za rad analizu,sintezu,da pokušaju da urade rješenja na drugi način.
Autor je naveo korištene izvore za ovaj projekat,izvore nekih od tema je naveo kroz footnote, tako da je u potpunosti zaštitio autorska prava navedene literature.
Autor zahvaljuje menadţmentima Mješovite srednje škole Busovača, direktoru Admiru Hodţiću i menadţmentu Mješovite srednje škole Vitez direktor Hrustić Seadu na razumjevanju i podršci za ovaj
projekat.
Neke ideje,sugestije i primjedbe koje su ugraĎene u ovu knjigu predloţili su moji dragi prijatelji; Dipl.prof. informatike Almin Halilović,
Prof.informatike i matematike Junuz Junuzović,
Dipl.ing.mašinstva prof.Šabanović Latif, Prof.Haskić Selvedin.
6
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
1.Općenito o programima i programskim jezicima
S programiranjem se danas susrećete posvuda - bilo da programirate snimanje na videorekarderu,
koristite mašinu za pranje veša, vozite neki noviji automobil, koristite mobitel ili jednostavno
programirate na računaru. Zahvaljujući programiranju svijet je danas podesiv i prilagodljiv.I zato je
dobro znati programirati. U ovom kratkom pregledu nećemo odmah uskočiti u programiranje sistema
za nadzor svemirske letjelice, ali ćete razumjeti na čemu se programiranje zasniva i kako funkcionira.
1.1.Ljudi i računari
Prosječni računar baš i nije pametna naprava . Ono nema mogućnost samostalnog odlučivanja,
zaključivanja , nema ono po čemu se ljudi razlikuju od svih ostalih - pamet i iskustvo.Da bismo
natjerali računar da radi ono što mi ţelimo, moramo ga tome naučiti. Budući da računari ne znaju
samostalno misliti , programeri moraju u njih ugraditi upustva koji im govore što trebaju raditi.U
situaciji sličnoj programerovoj nalazi se roditelj kada svoje dijete ţeli naučiti jesti kašikom.Dijete je u
ovom slučaju, slično kao i računar , "prazna ploča" - treba ga nučiti i najsitnijim detaljima. Dijete prvo
mora podići kašiku (ali da ne prospe njen sadrţaj), prinijeti je ustima, paziti da u kašici juha nije
prevruća , otvoriti usta, staviti kašiku u usta (a ne pored usta), progutati sadrţaj kašike (ali ne i
kašiku). Zapravo, ovo uopće nije jednostavan postupak.Tako je i s računarima. Njih takoĎer treba
naučiti da rade ono što bismo mi ţeljeli. No ovdje je problem malo veći nego s djetetom jer računari
komuniciraju na razne načine - koriste, tj. razumiju različite računarske jezike.
Računari oko nas
Danas se računar nalazi u svakom novijem automobilu,u svakom mobitelu, čak i u najobičnijem
televizoru ili videorekorderu. Svi ti ureĎaji u sebi sadrţe računar koji ima je potrebno naloţiti što da
rade. Tako će se televizor sam isključiti nakon nekog vremena,ako mu vi tako zadate, videorekorder će
u 20:15 snimiti utakmicu na drugom programu u trajanju od 120 minuta, mašina za pranje rublja će
uključiti program za pranje osjetljivog rublja,a automobil će upotrijebiti neki od ugraĎenih sistema za
sprječavanje zanošenja na cesti. Spomenimo i obične lične računare. Oni su sposobnI obavljati mnogo
kompliciraniji skup radnji nego računari ugraĎenI u npr. kućanske ureĎaje. Unatoč tome, svi računari
imaju jednu zajedničku činjenicu - ne mogu samostalno zaključivati i donositi odluke. Zato im
programer treba reći šta da rade. Programer to čini koristeći poseban programski jezik i posebne
naredbe pomoću kojih komunicira s računarom i opisuje mu što i kako treba raditi .Računarski program
je skup naredbi koji govori računaru na koji način da obavi određeni zadatak. Tekst programa koji je
čitljiv programeru i korisniku zove se izvorni kod programa, dok je izvršna verzija programa binarna, i
moţe je čitati i izvoditi samo računar. Programski jezik je skup leksičkih, sintaksnih i semantičkih
pravila koja uobličuju strogu strukturu pisanja izvornog koda. Svaki program sastoji se od naredbi.
Naredbe se sastoje, u ovisnosti o programskom jeziku, od izraza, konstanti, identifikatora i
poziva.Općenito postoji više nivoa programskih jezika, i podijeljeni su u generacije jezika. Do danas
postoje jezici od prve do pete generacije, no to nije jedina podjela programskih jezika, oni se takoĎer
razlikuju po namjeni, načinu izvršavanja, strukturiranosti i proceduralnosti.1
1.2.Podjela programskih jezika
1 Preuzeto i obrađeno iz knjige Informatika i računarstvo
7
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
Podjela programskih jezika po namjeni:
Programski jezici za numeričke probleme Programski jezici za poslovne probleme
Programski jezici temeljeni na listama i nizovima
Višenamjenski jezici (u ovu skupinu spadaju .NET jezici)
Podje la po načinu izvoĎenja:
Imperativni – postiţu funkcionalnost pridruţivanjem vrijednosti i njihovim ispitivanjem, te skokovima (Ada, C, FORTRAN, Pascal)
Funkcionalni jezici – ne postoji pridruţivanje, temelje se na funkcijama i listama (Lisp, ML, LOGO)
Ciljno orijentirani jezici – temelje se na izvršavanju upita, dok način na koji se on izvršava ostaje sakriven (Sql, Prolog)
Objektno orijentirani jezici – temelje se na manipulaciji objektima (VB 6.0) Hibridni jezici – u ovu grupu spadaju .NET jezici i C++
Po strukturiranosti jezici mogu bit i strukturirani i nestrukturirani .
Po proceduralnosti mogu bit i proceduralni i neproceduralni .
Podjela programskih jezika po generacijama generacijsku podjelu danas smatraju najbitnijom.
Jezici prve generacije temelje se na mašinskom jeziku, tj. kodovima naredbi koje izvodi direktno sam procesor. Programi su napisani u binarnim kodovima, i vrlo su nečitljivi. Kasnije su dodani
simbolični nazivi naredbama, no skokovi su bili izvedeni prema hardverskim adresama koje su zadane brojem.
Primjer programa u mašinskom kodu:
8
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
Zanimljivo je što se i danas svaki program na kraju svodi na ovaj nivo, jer to je jedini oblik programa koji računar razumije. Za prevoĎenje jezika višeg nivoa jezike niţeg nivoa koriste se programi zvani
prevodioci ili compileri. Drugu generaciju programskih jezika predstavljaju simbolički programski jezici ili Assembli. Od
jezika prve generacije razlikuje se u tome što su uvedena simbolička imena adresa (labeli) i jednostavniji pristup adresiranjima putem mnemoničkih kodova pojedinih naredbi. Mnenonik ili
mnemonički kod je simbolički prikaz binarne naredbe, npr. Naredba 001011 predstavlja se mnemonikom MOV.
Primjer programa pisanog u jeziku druge generacije:
Programski jezici treće generacije temelje se na proceduralnoj paradigmi, tj. program se izvodi putem pozivanja procedura, osim samo jednostavnog dodjeljivanja vrijednosti i njihovog ispitivanja.
Ovakvi jezici prevode se u jezike niţih nivoa da bi se mogli izvoditi, i često jedna naredba jezika ovog nivoa predstavlja mnogo naredbi jezika niţeg nivoa. Uneseno je razrješivanje izraza i prevodioc vrši niz
analiza koje olakšavaju pisanje programa i ispravljanja grešaka. U ovu grupu pripadaju jezici C, Pascal i drugi.
Primjer jezika pisanog u jeziku treće generaci:
9
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
Jezici četvrte generacije temelje se uglavnom na objektno orijentiranoj paradigmi, te raznim
generatorima koda i korisničkim interfejsom. Ovi jezici su obično kombinacija raznih alata, tako da je
većina napornih i dugotrajnih postupaka automatizirana i pojednostavljena. U ovu grupu pripadaju .NET jezici, Java, Delphi itd. Program napisan u jeziku četvrte generacije predstavlja alat za brzu i
jednostavnu izradu svih vrsta aplikacija.
Primjer aplikacije u jeziku 4. generacije:
Jezici pete generacije su uglavnom usko specijalizirani jezici koji često kreiraju cijele aplikacije
potpuno automatski putem raznih Wizarda i slično. Razvoj ovakvih jezika je u početnoj fazi.
2. Programski pristup
10
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
2.1. O proceduralnom programiranju
Za bilo koji problem vjerovatno postoji jednako puno načina da se isti analizira i riješi . Tako se sa programerskog aspekta, na primjer, problem moţe podijeliti (dekompozirati) algoritamski ili
proceduralno, tj. u odnosu na sekvencu ili proceduru dogaĎaja koji se moraju desiti. Alternativno, problem se moţe riješiti pomoću "objektno-orijentisanog"pristupa, posmatrajući razne cjeline koje
utjeću jedne na druge i uzimajući u obzir njihovo meĎusobno djelovanje. Ova dva pristupa u dekompoziranju problema– algoritamski i objektno-orijentisani – su dva pristupa koji programeri
najčešće koriste. Pristupi su figurativno prikazani na Sl.2.1. Algoritamski pristup počinje opštim zadatkom koji treba izvršiti (kao što je "omogućiti korisniku da
izvrši opšte bankarske funkcije"), zatim dijeli opšti zadatak na naredne nivoe specificiranijih
podzadataka (kao što je "proces podizanja novca", te "proces stavljanja depozita"), te na dalje nivoe još specifičnijih zadataka (kao što su "upitaj korisnika na vrijednost depozita" ili "verifikuj unesenu
vrijednost kao vaţeću").
Slika 2.1: Dva pristupa u dekompoziranju problema
11
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
Slika 2.2: Algoritamska dekompozicija problema
Kada se zadatak prikaţe u obliku dijagrama, najopštiji zadatak je obićno na vrhu, a najspecifićniji
zadaci se granaju prema dnu. Razni pravougaonici u takvom "stablu" odgovaraju raznim procedurama i podprocedurama koje treba programirati, kao što je prikazano na Sl.2.2.
Algoritamske ili proceduralne metode u dizajniranju softvera su razvijene u kasnim 60tim kako bi se ukazalo na probleme u kojem se u to vrijeme nalazilo opšte stanje u razvijanju softvera. Pošto su novi
pristupi omogućili strukturni pristup programiranju (u odnosu na haotični "hack and run" pristup, koji su koristili neki programeri), moţe se naići i na podatak da se algoritamski ili proceduralni pristup
programiranju zove "strukturno programiranje". S obzirom da ovaj pristup počinje na vrhu (opšti
zadatak koji treba izvršiti) i dijeli najviši zadatak na naredne nivoe specifičnijih podzadataka prema dnu,ovaj pristup se ponekad naziva i "top-down" pristup. Neki autori ga zovu i proceduralni pristup,
imajući u vidu da se algoritamski pristup fokusira na procedure koje izvršavaju zadatak. Dakle, ovaj pristup dizajniranju softvera ima različite nazive, i to:
Funkcionalna dekompozicija Algoritamska dekompozicija
Strukturno programiranje "top-down" programiranje
proceduralno programiranje
Bez obzira na naziv, ovaj pristup se fokusira na funkcionalnost programa,počinjući sa vrha (najopštija funkcija), i idući prema dnu ka najspecifičnijim funkcijama. Mnogi programeri i danas koriste ovaj
pristup, a još uvijek je koristan za izradu kvalitetnih softvera , naročito za manje programe ili softverske module. Bez obzira na činjenicu da je C++ u osnovi OOP jezik, ovaj tekst se bavi osnovama
C++ sintakse u oblasti proceduralnog programiranja, kao uvod u OOP paradigmu.
Neproceduralno programiranje
Ovaj pristup programiranju temelji se na slijednom izvoĎenju nekog programa. Uglavnom se sastoji od
jednostavnog niza naredbi gdje je izvedeno grananje putem goto ili slične naredbe. Ne postoje pozivi metoda i funkcija. Ovi jezici su zastarjeli i nedovoljno razvijeni za današnje potrebe.
Modularno programiranje
12
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
Modularno programiranje omogućava fragmentaciju koda na module koji mogu biti pisani u različitim
datotekama, i tako pojednostavljuje programe i povećava njihovu čitljivost. Unesen je pojam dijeljenja
koda izmeĎu aplikacija.
2.2.Osnove faze razvoja programiranja
Analiza problema
Postavljanje modela Izrada algoritma
Izrada dijagrama toka Kodiranje programa
Prevođenje programa Testiranje programa
Dokumentiranje programa Eksploatacija programa
Svrha programa je rješavanje problema, najčešći način rješavanja je pomoću tri modela
model podataka model procesa i
model resursa. Model podataka sadrţi definiciju podataka (nazive, vrste, dimenzije, ograničenja vrijednosti...) te
strukture podataka (nizovi, skupovi, datoteke, tablice...). Model procesa moţe biti prikazan različitim tehnikama (dijagram toka, dijagram strukture procesa,
dijagrami akcija....), ali svi oni, na svoj način, prikazuju slijed odvijanja procesa. Model resursa sadrţi definiciju računarskih resursa i njihovih svojstva (operativni sistem, vrsta
programskog prevodioca, svojstva jedinica računara...) koje su potrebne da bi program uredno radio.
Šema riješavanja problema
MODEL
RESURSA
MODEL
PODATAKA
MODEL
PROCESA
13
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
3.Algoritmi
3.1.Uvod u algoritam
Priču o algoritmima započeti ćemo onako kako počinju sve klasične priče.Nekada davno ţivio je u
Bagdadu pisac, matematičar, astronom i geograf po imenu Muhammed ibn Musa al Khowarizmi
.Vjerojatno nije niti sanjao tamo daleke 852. godine kada je pisao knjigu Kitab al jabr w'al-muqubala
da će od toga nastati čak dva uzroka glavobolje učenicima deset-jedanaest vijekova nakon toga.
Njegov al jabr je postala algebra. Isto tako pravila rješavanja iz početka prvenstveno matematički
problema su iskrivljavanjem imena al Khowarizmi nazivana algoritmi. No, tu greškama nije kraj. Prema
korijenu riječi bilo bi pravilno umjesto algoritmi koristiti algorizmi. Ali kako jezik nije nauka nego skup
dogovora, izgleda da je dogovoreno da najčešće greške postaju jezička pravila.Tako mi danas imamo
algoritme, a oni su niz preciznih uputa koje nas korak po korak vode do rješenja nekog problema.To su
zapravo toliko precizne upute da za njihovo izvršavanje nije potrebna inteligencija.Zašto bi se mi bavili
stvarima za koje ne treba nimalo pameti?Zato što izrada algoritma u programiranju prethodi samom
pisanju programa. Pri pisanju programa prvo nam mora biti jasno što se zapravo od programa
očekuje.Kao i kod rješavanja zadataka u bilo kom području prvo moramo znati postaviti problem.Drugi
korak je gruba skica rješenja.Treći korak je izrada algoritma. Ako smo dobro napravili algoritam, tada
pisanje programa nije ništa drugo negoli prepisivanje algoritma u neki programski jezik.Kada smo to
učinili dobili smo program, a program "tjera" računar da radi ono što mi zapravo ţelimo.Neko je rekao
da je računar idiot velike brzine. To je ustvari bit priče o algoritmima. Mi put do rješenja moramo toliko
rascjepkati i detaljno napisati da bi ga mogao razumjeti i taj "idiot velike brzine".Drugim riječima,
upute moraju biti jednostavne i precizne tako da ih moţe izvršavati i mašina. Pokušajte se sjetiti gdje
ste zadnji put pročitali neko detaljno uputstvo. Moţda vam je i bilo u rukama,ali niste čitali jer to već
znate napamet, kao npr.Dopuniti račun mobitela putem bona.Ili moţda da probamo obrnuto. Da li ste
se nedavno našli u situaciji da niste nešto znali napraviti jer su upute bile toliko loše i nerazumljive ili
uopće niste imali upute? U svakodnevnom ţivotu smo zapravo stalno u doticaju s algoritmima, a često i
postupamo po algoritmima da toga nismo niti svjesni. Znati "algoritamski" razmišljati dobro je bez
obzira bavili se vi poslije programiranjem ili ne.
Pojam algoritama (dijagram toka) je jedan od najstarijih i najvaţnijih pojomova u matematici. Teško je
da se precizno definiše algoritma, jer pripada grupi osnovnih pojmova kao što su skup ili tačka. U
početku algoritmom se nazivaju samo pravila računanja s brojevima, kasnije i pravila obavljanja ostalih zadataka u matematici, u XX vjeku, pojavom računara, pojam se proširuje na informatiku, a zatim i na
druga područja. Precizan opis svih pravila i postupaka potrebnih za postizanje ţeljenog rezultata. Evo nekih definicija koje bliţe opisuju algoritam.
Definicija 1. Algoritam je tačan opšte razumljiv propis koji definiše proces transformacije početnih podataka u
traţeni rezultat. Definicija 2.
Algoritam je tačan propis o tome koje operacije nad kojim brojevima i u kom redosljedu treba izvršiti
da bi se rješili svi zadaci nekog zadatog tipa.
Definicija 3.
14
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
Algoritam je precizan,ureĎeni i nedvosmisleni niz koraka koji u konačnom vremenu vodi do rješavanja
problema ako problem ima rješenje,odnosno u konačnom vremenu kaţe da nema rješenja ako problem
nema rješenja.
Definicija 4. Algoritam je konačni skup pravila koja daju redosljed operacija za rješavanje specifičnog problema.
Najbitnije osobine algoritma su: Određenost- je osobina algoritma da za iste početne podatke daje uvjek iste rezultate.
Razumljivost. -algoritam treba da bude razumljiv ovo je relativni pojam i zavisi od nivoa obrazovanja korisnika.
Masovnost- je osobina algoritma da se mogu rješavati svi zadaci istog tipa.
Rezultativnost- je osobina algoritma da on mora da vodi ka rješenju zadatka ako su početni podaci iz skupa mogućih podataka.
Konačnost- je osobina algoritma da se algoritam realizuje sa konačno mnogo koraka. Pri tome ta konačnost treba da je ostvarljiva, tj. da moţe da se realizuje za neko razumno vrijeme.
Primjer algoritma
Bilo koji problem se moţe riješiti izvršavanjem serije akcija u odreĎenom redosljedu. Akcije koje će se
izvršiti i redosljed u kojem će se to odvijati nazivamo algoritam. Iskustvo pokazuje da je najteţi dio riješavanja programerskog problema na računaru upravo razvijanje algoritma za riješenje. Jednom kad
je odreĎen ispravan algoritam, razvoj programa za sam alorgitam je poprilično jednostavan. Sljedeći primjer pokazuje korektan i nekorektan sljed dogaĎaja za algoritam kojim ţelimo opisati
pokretanje automobila:
KOREKTAN SLIJED:
√ otključavanje automobila
√ sjedanje u automobil √ paljenje motora
√ otpuštanje ručne kočnice √ pokretanje automobila
√ zaustavljanje
NEKOREKTAN SLIJED:
otključavanje automobila
sjedanje u automobil
paljenje motora
pokretanje automobila
zaustavljanje
otpuštanje ručne kočnice
3.2.Dijagram toka (flowchart)
Dijagram toka je sredstvo za vizualnu prezentaciju toka podataka, operacija koje se izvode, te slijeda
(sekvenca) kojim se navedene operacije izvode u informacijskom sistemu. Crtanje dijagrama toka je jedna od faza rješavanja problema i uvelike olakšava pisanje programskog koda. Pri crtanju dijagrama
toka potrebno je slijediti odreĎena upustva, te koristiti standardne simbole koje je propisao American National Standard Institute.
Značaj dijagrama toka
15
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
Dijagram toka je reprezentacija kojom ilustrirate sekvencu operacija koje je potrebno izvršiti kako bi se
došlo do rješenja problema. Dijagram toka se crta u ranoj fazi formuliranja kompjuterskog rješenja.
Dijagram toka olakšava komunikaciju izmeĎu programera i poslovnih ljudi. TakoĎe,dijagram toka igra značajnu ulogu u procesu programiranja jer olakšava razumijevanje logike kompliciranih i opseţnih
problema. Jednom kad ste nacrtali dijagram toka postaje jednostavno napisati program u bilo kojem programskom jeziku. Vrlo često je nemoguće objasniti logiku programa bez dijagrama toka. Osim
toga,dijagram toka je neizostavan dio dokumentacije bilo kojeg programa. Smjernice za crtanje dijagrama toka
Za crtanje dijagrama toka koriste se standardni simboli. Neke od često korištenih simbola moţete pogledati u sljedećoj tabeli:
16
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
Za unos i ispis podataka vrlo često se koristi paralelogram
Pravila za crtanje dijagrama toka: Da bi ste nacrtali korektan dijagram toka, potrebno je napraviti popis svih zahtijeva.Dijagram toka
treba biti pregledan i jednostavna za pratiti.Dijagram toka treba biti jednoznačan (ne smije kod osobe koja ga gleda izazivati višeznačne konotacije).
Uobičajen smjer toka je s lijeva na desno ili odozgo prema dolje.U dijagramu toka kad je u pitanju simbol za procesiranje moţe postojati samo jedan izlaz
Podataka
Kad je u pitanju simbol odluke moţe postojati samo jedan ulaz podataka, ali mogu postojati dva ili tri
izlaza podataka (jedan za svaki mogući odgovor).
17
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
Terminalni simbol (start, kraj) takoder moţe imati samo jedan ulazno, odnosno jedan izlazni tok
podataka.
Ukoliko ţelite jasnije opisati podatke ili korake koristite simbol za napomene/komentare (annotation symbol).
Ukoliko je dijagram toka kompleksan bolje je koristiti simbole konektora kako bi ste reducirati broj linija toka. Izbjegavajte presijecanje (kriţanje) linija.
Vodite računa da vam dijagram toka ima logičan početak i kraj. Prednosti
Prednosti dijagrama toka su: • Komunikacija(Dijagram toka olakšava komunikaciju svih koji su zainteresirani za rješavanje
problema).
• Efektivna analiza(Uz pomoć dijagrama toka problem se moţe efektivnije analizirati). • Odgovarajuća dokumentacija( Dijagram toka je dio obavezne programske dokumentacije, koja moţe
sluţiti u različite svrhe). • Efikasno kodiranje( Korektan dijagram toka olakšava pisanje programa (bez obzira u kojem
programskom jeziku). • Otklanjanje grešaka( Dijagram toka olakšava pronalaţenje grešaka).
• Efikasno održavanje programa( Olakšava odrţavanje programa).
Ograničenja
• Kompleksnost Ponekad je problem kompleksan, pa je i dijagram toka kojim ga pokušavate predstaviti kompleksan i „nezgrapan“.
• Alternative i održavanje( U slučaju potrebe za alternativnim rješenjima vrlo često je neophodno dijagram toka nacrtati ponovno (iz početka).
3.3.Pravolinijska algoritamska struktura
18
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
Iz osnovne škole sjećamo se da je brzina nekog tijela zapravo prijeĎeni put u jedinici vremena.
Matematički bismo to zapisali kao V = s / t, gdje je V brzina, s prijeĎeni put i t vrijeme. To je tako
jednostavno da nam nije potrebna nikakva priprema i gruba skica rješenja. Moţemo odmah raditi algoritam.
Za vježbu: Pokušajmo prema ovom primjeru nacrtati dijagram toka za izračunavanje površine pravougaonika, a zatim dijagram za izračunavanje obima pravougaonika.
Evo još jednog primjera za izračunavanje obima i površinu kruga. Kako na tastaturi nemamo na raspolaganju grčka slova, našu formulu za izračunavanje obima pisati ćemo kao
O = 2 * r * Pi.
Isto tako za sada još ne znamo funkciju za kvadriranje pa ćemo formulu za površinu kruga pisati
ovako:
P = r * r * Pi gdje je r * r zapravo r2.
19
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
Za vježbu: Po uzoru na obim i površinu kruga, pokušajte algoritme za izračunavanje obima i površine pravougaonika spojiti tako da u jednom algoritmu bude i obim i površina pravougaonika.
3.4.Grananje
Na ţalost, u stvarnom ţivotu zbivanja ne teku tako jednostavno kao što su to pravolinijski algoritmi. Ponekad treba stati, razmisliti, usporediti neke stvari i donijeti odluku kako dalje. Takovo mjesto u
algoritmu zove se grananje.
Simbol za grananje je romb. Obično se u gornji vrh upiše upitnik i u sredini se postavi logički uvjet. Grananje uvijek ima jedan ulaz i najmanje dva izlaza. Ako
su samo dva izlaza tada je riječ o jednostrukom grananju, a odgovori na postavljeni logički uvjet mogu biti DA i NE, odnosno T i F (true i false). Ako je
moguće više odgovora tada je to višestruko grananje.
Primjer 1
Sjetimo se zadataka iz prethodne lekcije za izračunvanje brzine ako su poznati put i vrijeme:
V = s / t. Ako se na računaru dogodi situacija da dijelimo s nulom program će nam izbaciti grešku. Da bismo
spriječili "ispadanje" programa, prije izračunavanja brzine provjeriti ćemo da li je upisano vrijeme veće od 0.
20
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
Prepravite dijagram toka iz gornjeg primjera tako da ako upisano vrijeme t nije veće od nula da se na
grani NE ispisuje poruka 'Vrijeme mora biti veće od nula' i tek tada odlazi na kraj. Pojedine znakove ili nizove znakova kao što je ova poruka u dijagramu toka pišemo unutar navodnika koji ovisno o
programskom jeziku koji ćemo poslije koristiti mogu biti jednostruki ili dvostruki.
Primjer 2
Idemo riješiti još jedan zadatak. Prisjetimo se zadatka obima i površine pravougaonika iz prethodnih
vjeţbi koji ćemo još malo proširiti. Preko tastature upisuju se stranice pravouganika a i b. Treba izračunati obim i površinu pravougaonika te ispisati poruku o tome da li je upisani lik pravouganik ili
kvadrat.
21
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
Da objasnimo:
Nakon što smo upisali stranice a i b,
izračunali smo obim O i površinu P
pravougaonika. Dobivene rezultate moţemo odmah
ispisati.Kako ćemo utvrditi da li moţda upisane stranice pripadaju kvadratu?
Ako su stranice a i b jednake tada je to kvadrat.
Ispisujemo poruke i odlazimo na kraj. Kraj.
Primjer 3
Treba upisati cijeli broj a i ispisati poruku da li je upisani broj paran il i neparan.
Obratite paţnju na konstrukciju ispisa. Pogledati ćemo lijevu granu koja se izvršava ako je odgovor na logički uvjet NE. Imamo dio poruke u navodnicima 'Broj ' pa zatim odvojeno zarezom varijablu a i
22
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
nakon toga opet iza zareza drugi dio poruke u navodnicima 'je neparan.' Ako je upisan npr. broj 9 tada
će naredba za ispis 'Broj ',a,' je neparan' rezultirati porukom koja izgleda kao rečenica u komadu: Broj
9 je neparan.
Primjer 4
Treba upisati dva broja a i b i ispisati poruku o tome koji je veći.
Stvar je zapravo vrlo jednostavna. Ali pokušajte sada zamisliti da neko upiše dva ista broja, npr. 7 i 7.
U uvjetu ćemo imati pitanje da li je 7 veće od 7. Odgovor je NE. Izvršiti će se lijeva grana i kao rezultat dobiti ćemo poruku:
Broj 7 je veći od broja 7.
Ova poruka baš i nema logike i dokaz je da naš računar od milja zvani „idiot“ velike brzine i ne razmišlja baš puno. Zato ljudi koji rade na razvoju informacijskih sistema moraju predvidjeti puno više
situacija, pa i onih najekstremnijih koje bi se pri radu programa mogle dogoditi. Kaţu da dobra kontrola podataka pri unosu sprječava čak 90% grešaka koje bi se naknadno u radu programa mogle dogoditi.
Zato ćemo mi rješenje našeg zadatka malo promijeniti:
3.5.Petlje
23
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
Naslov ove lekcije govori da sve ovo što smo do sada radili nije dovoljno zapetljano, pa ćemo stvari još
malo dodatno zapetljati.
Nekada su nastavnici imali običaj nestašne učenike kaţnjavati tako da su im zadali 100 puta napisati u biljeţnicu: "Neću nikada više brbljati na času informatike!". Zamislite da je nama neko dao
takvu kaznu. Mi ćemo se probati izvući tako da to računar odradi umjesto nas. Treba mu samo zadati da 100 puta ispiše jednu te istu poruku. Ništa jednostavnije. Evo rješenja:
Hm, već nakon treće upute računaru da ispiše
poruku sam odustao jer mi je dosadilo. Morate priznati da ovo rješenje baš i nije nešto s čime bi
se mogli pohvaliti.
Pokušajmotoodraditina drugačiji način:
Nakon što se i 100-ti puta izvrše naredba grananja i naredbe ispod grananja i će postati 101. Tada je
odgovor na pitanje u grananju da li je i veći od 100 konačno DA i tada bi program trebao završiti s radom. Dio programa, niz istih naredbi koje se ponavljaju dok je neki uvjet zadovoljen ili dok ne
24
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
postane zadovoljen, naziva se petlja. U našem se primjeru ispis poruke i povećanje varijable i za jedan
ponavljaju dok i nije postao veći od 100. Varijabla i je u našem primjeru brojač jer svakim prolaskom
kroz petlju i postaje i više 1.
Neki ljudi tvrde da napredak moţemo zahvaliti samo ljudskoj lijenosti. Naime, ljudi će svašta izmisliti samo da ne moraju raditi. Tako je neko izmislio još jednostavnije rješenje za naš primjer s
ispisom 100 poruka.
Pravougaonik ispod simbola za početak je naredba for koja je sama po sebi petlja. Brojač i kao i uvjet
već su sadrţani u naredbi pa ne moramo mi voditi brigu oko odbrojavanja. Taj red u algoritmu čitali
bismo kao: "Za i koji ide od 1 do 100 učini slijedeće:". Broj ponavljanja u petlji za rješenje odreĎenih problema se zna unaprijed, prije početka
ponavljanja, a za neke se ne zna unaprijed, već ovisi o izvršavanju niza naredbi koje se ponavljaju. Za sada ćemo se samo baviti petljama u kojima unaprijed znamo broj ponavljanja, dakle petljom for.
Koliko vremena vam treba da saberete sve brojeve od 1 do 100? Prava sitnica.
Za naš zbir svih brojeva do 100 koristiti ćemo varijablu zbir koju na početku algoritma moramo
postaviti na vrijednost 0.
Za i koji ide od 1 do 100 treba učiniti slijedeće:
Varijabli zbir dodati vrijednost varijable i koja je
u našem primjeru brojač.
Svakim prolaskom kroz petlju i se povećava za 1 i njegova vrijednost pridodaje sadrţaju varijable zbir.
U prvom prolazu kroz petlju zbir je 0, a i je 1, pa prema tome zbir postaje 1. U drugom prolazu zbir
je 1, a i je 2. Zbir postaje 1+2, dakle sada je 3. I tako 100 puta.
Idemo još malo zapetljati nešto što znamo računati još od petog osnovne, a to je prosjek ocjena. Prosjek je zbir svih ocjena podijeljen s brojem predmeta.
25
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
Varijablu zbir koristiti ćemo za zbir svih ocjena i moramo ju na početku postaviti na
vrijednost 0.
Neka u prvom razredu imamo 15
predmeta. Varijablu i postavili smo na početnu vrijednost 1.
U prvom prolazu kroz petlju upisujemo
prvu ocjenu iz imenika, a to je bosanski jezik. Ocjena se upisuje u varijablu
ocjena. Sadrţaj varijable ocjena se dodaje u varijablu zbir.
U drugom prolazu upisujemo ocjenu iz drugog predmeta, u trećem iz trećeg i tako 15 puta. Po izlazu iz petlje izračunavamo prosjek i ispisujemo ga.
Ovo je bilo prejednostavno da bi bilo stvarno. U stvarnom ţivotu desiti će se da je neko npr. osloboĎen nastave tjelesnog i zdravstvenog odgoja pa ima 14 predmeta. Neko moţda ima 16 predmeta
jer je izabrao i fakultativnu nastavu. Isto tako u drugom, trećem ili četvrtom razredu sigurno nećete imati 15 predmeta. Već smo napomenuli da se programi pišu čim općenitije tako da bi se mogli
primjenjivati za rješavanje čim više sličnih problema. Zato ćemo naš algoritam prepraviti tako što ćemo
umjesto 15 uvesti varijablu brpred koja će predstavljati naš broj predmeta.
26
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
Nakon što smo varijablu zbir postavili na početnu vrijednost 0 treba preko tastature
unijeti broj predmeta koji se smješta u varijablu brpred.
Brojač i u petlji sada broji od 1 do brpred pa je primjenjivo za sve učenike i razrede s
različitim brojem predmeta.
Da bismo dobili prosjek treba po izlasku iz petlje zbir ocjena podijeliti s brojem
predmeta brpred.
Za vježbu: Pokušajte po uzoru na prosjek ocjena za jednog učenika napraviti dijagram toka za
izračunavanje prosječne ocjene razreda.
Još nekoliko primjera petlji
Nakon postavljanja varijable zbir na
početnu vrijednost 0 treba u upisati početni broj n i završni broj m od kojeg do kojeg
ţelimo ispisati i sabrati neparne brojeve.
Brojač u petlji for sada broji od n do m
Da li je i neparan broj znati ćemo ako ga podijelimo s 2 koristeći operator mod i
dobijemo rezultat 1.
Ako ostatak je 1 tada ispisujemo i i
dodajemo njegovu vrijednost varijabli zbir.
Što će se dogoditi ako neko upiše za n veći broj nego za m?
Prepravite gornji algoritam tako da izračunava i zbir neparnih i zbir parnih brojeva od n do m.
27
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
Učenici su na satu fizike naučili Ohmov zakon po kojem otpor u istosmjernom strujnom kola moţete
izračunati tako da podijelite napon sa jakošću struje:
R = U / I gdje je otpor R, napon U i jakost struje I. Naučeno su odmah provjerili mjereći veličine u strujnom
kolu, ako su mjerili napon i jakost mogli su po gornjoj formuli izračunati otpor, ako su mjerili otpor i napon mogli su izračunati jakost struje I = U / R, a ako su mjerili otpor i jakost struje mogli su
izračunati napon U = I * R. Treba napraviti algoritam po kome je moguće za odreĎeni broj mjerenja na temelju dvije izmjerene veličine izračunati treću. Za broj mjerenja ćemo koristiti varijablu brmjer.
Uvest ćemo još jednu varijablu koju ćemo zvati izbor i dogovoriti ćemo se da u nju upišemo 1 ako ţelimo računati otpor, 2 ako ţelimo računati napon i 3 ako ţelimo računati jakost struje. Ako upisani
broj ne bude 1, 2 ili 3 ne treba poduzimati ništa. Pošto slovo I koristimo kao varijablu za jakost struje,
u petlji for ćemo ovaj puta kao brojač upotrijebiti slovo k.
Ovaj primjer moţe se daleko elegantnije riješiti višestrukim grananjem.
Izrada algoritama zahtjeva puno vjeţbe. Algoritmi se ne mogu naštrebati. Potrebno je riješiti puno primjera, od jednostavnijih do sve sloţenijih.
Dijagram toka crtamo običnom olovkom s gumicom pri ruci. Stvari se rješavaju u hodu, mijenjaju, popravljaju i prepravljaju. Uočavaju se stvari koje se mogu pojednostavniti. Prednost
dijagrama toka je što je pregledan, lako se test primjerima moţe "pješice" provjeriti. Zanimljivo je i to da više ljudi moţe napraviti na isti zadatak više različitih algoritama i da su svi dobri. Sloţeni algoritmi
mogu se rastaviti na manje, tako rastavljeni riješiti do detalja i onda prikazati kao rješenje u
28
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
blokovima. Problemi se mogu lako analizirati, lako se uočavaju sličnosti i razlike izmeĎu više rješenja i
odabire najbolje.
Moţda nakon ovih vjeţbi vidite dijagrame toka i tamo gdje ih do sada niste uočavali - različiti shematski prikazi nekih postupaka, hodogrami nekih aktivnosti...
I na kraju što je bio cilj naše izrade algoritama - pisanje programa. Kada je jednom algoritam gotov pisanje programa u nekom programskom jeziku je prepisivanje simbola iz dijagrama toka u
naredbe programskog jezika. Obično svaki simbol u dijagramu toka predstavlja jednu naredbu u programu. Dijagram toka bi trebao biti dio svake dobre programske dokumentacije.
Učenicima je crtanje dijagrama toka ponekad nerazumljivo, a sve što je nerazumljivo je i dosadno. Oni bi najradije sjeli za računar i odmah pisali program. Kod jednostavnih problema to i
moţemo napraviti. Ali kod sloţenijih... Jednom sam sreo svog bivšeg učenika koji se u svom poslu
intenzivno bavi programiranjem. Ţalio mi se da nekad nekoliko sati provede za računarom pokušavajući riješiti neki problem, ali ne ide i gotovo. Pitao sam ga što tada učini. Odgovorio je: "Pa
uzmem olovku i papir i nacrtam algoritam..."
4.Pseudo jezik
Pseudokod je neoficijelan jezik koji pomaţe programerima u razvijanju algoritama.
Pseudokod nije programerski jezik. Njegova svrha je riješiti program prije pisanja u programerskom jeziku kao što je C++.
Pseudokod se sastoji jedino od izvršnih naredbi – onih koje se izvršavaju kada program iz
pseudokoda pretvorimo u C++ i pokrenemo.
Ne postoji opće prihvaćena norma načina pisanja pseudo jezika već svaki autor moţe u načelu koristiti svoj način pisanja.
4.1.Varijable
Mjesto u memoriji rezervisano za pohranu podatka naziva se varijabla. Svaka varijabla ima ime koje ju
jednoznačno odreĎuje kako bi se razlikovala od ostalih varijabli. Ime varijable se u pseudo jeziku moţe
zadati proizvoljno, npr. x, a, TX, B_Pod, AmPe. Vrijednost varijable
Varijabli se vrijednost pridruţuje uz pomoć operatora pridruţivanja. Operator pridruţivanja koji se koristi u ovoj verziji pseudo jezika je znak (:=). Tim se operatorom varijabli pridruţuje ili u varijablu
upisuje vrijednost.Npr. izraz x:=3 se može čitati "varijabli x se pridružuje broj 3".
Kraj naredbe Algoritam zapisan pseudo jezikom sastoji se od niza naredbi. Svaka naredba ove verzija pseudo jezika
završava znakom tačka-zarez (;).
4.2.Operatori
29
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
Operatori su simboli koji predstavljaju (zamjenjuju) odreĎene funkcije. Operatori se mogu svrstati u
grupe prema vrsti funkcije koju prestavljaju, npr.:
aritmetički operatori,
logički operatori,
operatori usporeĎivanja (relacijski operatori).
Za ispravno zapisivanje algoritma pseudo jezikom izmeĎu ostalog treba poznavati i značenje pojedinih
operatora. Pri tom moţe zbunjivati sličnost izgleda operatora pseudo jezika i operatora kojima se koristimo u matematici (ponekad izgledaju isto a imaju različita značenja).
Aritmetički operatori
Opis Pseudo jezik Pascal C/C++
Sabiranje + + +
Oduzimanje - - -
Množenje * * *
Dijeljenje / / /
Cjelobrojno dijeljenje DIV DIV /
Ostatak cjelobrojnog
dijeljenja
MOD MOD %
Operatori sabiranja, oduzimanja i mnoţenja se u pseudo jeziku koriste na uobičajen način.
Kod početnika zabunu mogu stvoriti tri različita operatora dijeljenja. Osim operatora dijeljenja (/) koji kao rezultat vraća vrijednost količnika u obliku realnog broja tu su i operatori DIV i MOD.
Operator DIV vraća cjelobrojni dio dijeljenja dva cijela broja.
Operator MOD vraća cjelobrojni ostatak dijeljenja dva cijela broja.
Primjer upotrebe operatora dijeljenja:
x:= 5; y:=2;
a:=x/y; b:=x DIV y;
c:=x MOD y;
Rezultat će biti:
a=2,5 ;b=2;c=1 (5:2=2 cijela i 1 ostatak). Logički operatori
Logički podaci su podaci koji mogu poprimiti samo jednu od dvije moguće vrijednosti. To su na primjer
true/false, da/ne, istina/laţ, 1/0. Varijabla u koju se pohranjuju podaci ove vrste moţe poprimiti vrijednosti true (1) ili false (0). Za rad s logičkim podacima, postoje logičke funkcije. Logičke se
funkcije zapisuju logičkim operatorima. Rezultat rada logičkih operatora je podatak logičkog tipa.
30
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
Opis Pseudo jezik Pascal C/C++
Logički I I AND &&
Logički ILI ILI OR ||
Logički NE NE NOT !
Tablica stanja operatora Tablica stanja operatora Tablica stanja operatora
I ILI NE
Primjer upotrebe logičkih operatora:
Rezultati logičkih operacija će biti:
e=0
f=1 g=1.
Operatori poreĎenja (relacijski operatori)
Dva se podatka mogu usporeĎivati. Ako je napisani izraz istinit, rezultat poreĎenja će biti 1 (true), a ako nije, rezultat će biti 0 (false). UsporeĎuje se upotrebom operatora poreĎenja.
31
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
Opis Pseudo jezik Pascal C/C++
Manje < < <
Manje ili jednako <= <= <=
Veće > > >
Veće ili jednako >= >= >=
Jednako = = =
Različito <> <> !=
Primjer upotrebe operatora poreĎenja:
Rezultati usporedbe će biti:
a=1
b=1
c=0
d=0.
Kod početnika zabunu moţe stvoriti operator jednakosti (=). Operator jednakosti NE pridruţuje
vrijednost varijabli već samo provjerava da li je vrijednost njegove lijeve i desne strane jednaka. Npr. Izraz
x=3 se moţe čitati: "da li je vrijednost varijable x jednaka 3?". Tim izrazom se vrijednost varijable ne mijenja i ostaje kakva je bila i prije izraza. Operator jednakosti
ne mijenja vrijednost varijable.
Operator pridruţivanja (:=) mijenja vrijednost varijable. Npr.:
Rezultat na kraju će biti:
x=3;a=0.
Redoslijed izvršavanja operatora
Pri zapisivanju sloţenih izraza pseudo jezikom vaţno je imati na umu redoslijed izvršavanja operatora
(prioritet).
Redosljed izražavanja Operatori
32
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
1 ()
2 NE
3 */ DIV MOD I
4 + - ILI
5 <,<=,>=,<>,=
1.Primjer redoslijeda izvršavanja operatora:
Svi su operatori ravnopravni, izraz se izvršava s lijeva u desno ovim redoslijedom:
1. 22 DIV 5 = 4 2. 4 * 11 = 44
3. 44 MOD 3 = 2 (ostatak dijeljenja 44/3) 4. x=2
2.Primjer redoslijeda izvršavanja operatora:
Zagrade poništavaju prioritete operatora pa se izvršava ovim redoslijedom:
1. 22 DIV 5 = 4 2. 11 MOD 3= 2
3. 4 * 2 = 8 4. x = 8
3. Primjer redoslijeda izvršavanja operatora:
S obzirom na prioritete, operacije se izvršavaju ovim redoslijedom:
1. 55 MOD 6 = 1 2. 3 * 4 = 12
3. 6 / 3= 2 4. 12 + 2 - 1 = 13
5. x = 13
4.3.Funkcije
33
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
Izdvojeni nizovi naredbi koji čine logičke cjeline a obavljaju tačno utvrĎene zadatke nazivaju se
funkcije. Moguće je stvoriti vlastite funkcije pa ih zatim koristiti u svom programu ili koristiti već
postojeće i za upotrebu pripremljene funkcije. U ovoj verziji pseudo jezika od učenika se očekuje poznavanje nekoliko pripremljenih matematičkih funkcija.
Opis Pseudo jezik Pascal C/C++
Apsolutna vrijednost
realnog broja
Abs(x) Abs(x) abs(x)
Drugi korijen realnog broja
Sqrt(x) Sqrt(x) sqrt(x)
Zaokruživanje ralnog
brojana najbliži cijeli
broj
Round(x) Round(x) round(x)
Najveći broj manji ili jednak od x
Trunc(x) Trunc(x) ceil(x)
5.Kako započeti?
34
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
Da bismo napravili program koji treba da obavi neki zadatak, neophodna su nam dva specijalizirana
programa: jedan koji koristimo da napišemo izvornu datoteku (editor), i drugi sa kojim dobijemo
izvršnu datoteku (kompajler). Ova dva programa se najčešće kombiniraju u jedinstven paket - tzv. razvojno okruţenje. Danas,
najpoznatije C++ okruţenje predstavlja Microsoftov proizvod Visual C++ .NET. MeĎutim, ovaj, kao i većina ovakvih programa, je komercijalan i nije dostupan svim korisnicima. Ipak, moguće je naći veliki
broj besplatnih C++ okruţenja. Jedno od takvih okruţenja je i Dev-C++ .
5.1.MS Visual C++
Nakon pokretanja MS Visual C++ razvojnog okruţenja otvorit će se prozor programa. Ovisno o
podešenosti programa raspored i sadrţaj cjelina unutar prozora programa moţe biti i drugačiji.
Slika 5.1.
Novi projekt se pokreće naredbom File/New.Nakon odabira naredbe File/New otvara se prozor New u kojem treba na kartici Projects odabrati vrstu projekta te zadati osnovne podatke za projekt.
35
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
Slika 5.2.
U popisu projekata treba birati Win32 Console Application. Projektu treba dati ime (engl. Project name) i mjesto pohrane (engl. Location). Nakon unosa potrebnih podataka otvara se prozor Win32 Console
Application – Step 1 of 1.
Slika5.3.
Odabirom An empty project i klikom na dugmić Finish stvoren je i pohranjen novi projekt obiljeţja
prikazanih u prozoru New Project Information.
Slika5.4.
Sada u stvorenom projektu (okviru za izradu programa) treba otvoriti novu datoteku izvornog kôda. Potrebno je kliknuti na karticu FileView, a potom označiti mapu Source Files koja se nalazi pod
nazivom projekta. Na kraju birati naredbu File/New.
36
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
Slika 5.5
Otvorit će se prozor New u kojem treba na kartici Files izabrati vrstu datoteke. Bira se vrsta datoteke
C++ Source File.
Slika 5.6.
37
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
Na kraju treba zadati ime datoteci (engl. File name). Izvorni kôd programa C++ sprema se u datoteku
izabranog imena i nastavka cpp.
5.2.Programski paket Dev-C++
Najnoviju verziju programa moguće je naći na web stranici firme BloodshedSoftware
(http://bloodshed.net/download.html). Instalacija Dev-C++ programa ni u čemu se ne razlikuje od korištenja većine instalacionih datoteka u Windows okruţenjima. Dovoljno je dvostrukim klikom
pokrenuti instalacionu datoteku (npr. devcpp-4.9.9.2 setup.exe) i pratiti poruke na ekranu. Nakon završetka ovog postupka, u traci sa alatima pojavljuje se ikona za pokretanje
programa Dev-C++ . Korak po korak” prvi program u Dev C++”
Slika 5.7. Korak 1-pokretanje Dev C++
Slika 5.8. korak 2-kreiranje novog projekta
38
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
Slika 5.9.korak 3- biranje praznog projekta
Slika 5.10.korak 4 spremanje projekta
39
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
Slika 5.11.korak 5 mjesto za pisanje programskog koda
Slika 5.12. korak 6-pisanje programskog koda
40
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
Slika 5.13.korak7 proces kompajliranja
Slika 5.14. korak8-pokretanje izvršne datoteke Pitanja za utvrđivanje:
41
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
1. Definiši Algoritam?
2. Kako se još naziva proceduralno programiranje i zbog čega? 3. Koje su najbitnije osobine algoritma?
4. Nabroj nekoliko programskih paketa koji omogućavaju pisanje i kompajliranje programa napisanih u C++ ?
5. Programski jezik C++ pripada ........... jezicima. 6. Šta je osnovna karakteristika proceduralnog programiranja?
7. Šta je pseudo jezik?
6.Uvod u C++
C++ je viši programski jezik opće namjene. Ovo je kratka rečenica sa dosta nerazumljivih ojmova.Prvi od njih je programski jezik. Ljudi u svakodnevnom ţivotu koriste govorne jezike, i bilo bi idealno kada
bi mogli na našem maternjem jeziku kazati računaru da nam nešto uradi, npr. “Molim te naĎi mi rješenja kvadratne jednačine
x2 +5x+6=0!”.
To bi nam itekako olakšalo ţivot iz matematike, ali naţalost stvari sa računarima nisu još uvijek tako jednostavne, iako bi jednog dana mogle biti upravo takve. Govorni jezici ne koriste se za komuniciranje
sa računarom jer su preobimni, dvosmisleni i neprecizni. Tako npr. na ulazu u jedan ribnjak stoji natpis “Gostima zabranjeno hraniti ribe!”. Svima je jasno da se
misli na to da posjetioci ribnjaka ne smiju bacati hranu ribama, ali se rečenica moţe tumačiti i na način da se ribe ne smiju hraniti sa gostima! Takva rečenica je sigurno dvosmislena.Primjer nepreciznosti se
moţe vidjeti u rečenici: “Odi u prodavnicu i kupi mlijeko!”. Na koju prodavnicu se misli? Koju masnoću mlijeka? Od kojeg proizvoĎača?
Primjer preobimnosti jezika moţemo naći u bilo kojem knjiţevnom djelu, gdje je ljepota izraţavanja
poţeljna, ali u informatici je to nepotrebno ako nema u sebi nekih korisnih informacija.Dakle programski jezik je precizan i nedvosmislen jezik razvijen za komuniciranje i kontrolu nad
računarom.Kaţe se da je C++ jezik opće namjene, što znači da nije specijaliziran u npr. matematičke ili neke druge svrhe.
C++ je viši programski jezik, ali to nema nikakve veze sa visinom, jer jezici nemaju visinu, niti duţinu.Ovo viši (eng. highlevel) stoji uz C++ jer postoje jezici i niţeg nivoa (eng. lowlevel).Ako je jezik
višeg nivoa to ne znači da je automatski bolji od jezika niţeg nivoa. To znači samo veći nivo apstrakcije od mašinskog jezika, koji je jedini jezik koji procesor razumije bez prevoĎenja. On se sastoji od nula i
jedinica i moţe se reći da je za ljudska bića gotovo nerazumljiv i neupotrebljiv. Veći nivo apstrakcije
znači jednostavniji rad ali i manju kontrolu nad računarom.
42
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
C++ je programski jezik za koji se slobodno moţe reći da je C programski jezik sa dodatim klasama i
svim ostalim osobinama modernih jezika. Dokaz za to je i prvo ime ovog jezika koje je glasilo “C sa
klasama”! Tvorac C programskog jezika je Dennis Ritchie, koji je tad radio u AT&T Bell Laboratories. C je nastao da bi zamijenio jezik B(postojao je i jezik A, a početkom 2007 je izdat i jezik D) čiji tvorac je
otac Unix operativnog sistema Ken Thompson i prvenstvena mu je namjena bila odrţavanje Unix operativnog sistema. C je čudan jezik koji ima osobine i viših i niţih programskih jezika, pa kao takav
ima sve prednosti i mane takvih jezika. Da bi prevazišao mane i iskoristio prednosti C jezika, Bjarne Stroustrup zaposlenik AT&T Bell Laboratories je razvio C++ programski jezik. Da li je u tome uspio ili je
samo još doprinio zbrci oko u suštini vrlo snaţnog programskog jezika je rasprava koja se često vodi u programerskim krugovima.
6.1. Proces kompajliranja
Da bi se napisani program izvršio na računaru(da bi ga koristili), potrebno ga je iz izvornog koda
(programa) prevesti u oblik koji procesor razumije tj. mašinski jezik. Prevedeni oblik se najčešće naziva izvršni ili objektni kod(program). Kada radite sa nekim programom na računaru npr. sa Firefoxom
radite sa objektnim programom. Objektni program se zna nazivati i kompajlirani program, jer se program iz izvornog oblika prevodi u objektni putem posebnih programa koji se nazivaju kompajleri ili
prevodioci. Pored kompajlera, da bi pravili vlastite programe potrebni su nam još dvije vrste programa: tekst editori i debuggeri. Tekst editor je program sa kojim pišemo izvorni program, kao npr. Notepad ili
Vim. Kako programe pišu ljudi, a oni su po svojoj prirodi skloni greškama, često su nam potrebni i
programi koji nam pomaţu da takve greške otkrijemo i uklonimo. Takvi programi se nazivaju debuggeri, a naziv im potiče od engleskog naziva bug za grešku u programu, dok je proces uklanjanja
grešaka debugging. Dakle, za pisanje izvornog koda nam treba editor. Za prevoĎenje tog izvornog koda u izvršni kod nam
treba kompajler, a da bi otkrili eventualne greške u svojim programima, često nam zatrebaju debuggeri.
Kako ovo znači da prilikom pisanja svoga programa trebamo koristiti tri različite vrste programa, neko se dosjetio da ta tri programa “ujedini u jedan program”. Takvi programi se nazivaju integrirana
razvojna okruţenja ili IDE(Integrated Development Environment), a mi ćemo koristiti Blodshed
DevC++ IDE.
43
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
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
Izvršni oblik
Programi se mogu izvršiti na računaru 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 prevodioc (engl. compiler) i povezivač (engl. linker). Program prevodioc prevodi izvorni
kod iz višeg programskog jezika u mašinski 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 direktno izvršiti na računaru. Objektni kod je meĎukorak do izvršnog
koda i uz ostalo omogućava uključivanje gotovih dijelova programa iz drugih datoteka.
Biblioteke
Datoteke koje sadrţavaju gotove dijelove programa nazivaju se biblioteke (engl. libraries). Takvi se
gotovi dijelovi programa mogu koristitit u drugim programima. Kada se koriste biblioteke više nije
potrebno uvijek iznova zapisivati radnje (funkcije) koje se često koriste. 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 koristiti drugi programi.
Povezivač
Program koji povezuje objektnu datoteku s bibliotekama i drugim potrebnim
datotekama naziva se povezivač (engl. linker). Ako se pri povezivanju pojavi
greška (engl. link-time error), bit će ispisana poruka o tome.Greš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, prevodioca, povezivača itd.
6.2.Riječi u C++ programskom jeziku
44
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
Programski jezici koriste imena kako bi se označile različite cjeline koje čine program. Osim imena
varijabli, ovdje spadaju i imena funkcija, tipova, te makroa. C++ postavlja sljedeća pravila za pravilno
kreiranje imena (ili identifikatora). Ime traba da se sastoji od jednog ili više karaktera, od kojih bilo koji moţe biti slovo (tj, slova engleske abecede a-z i A-Z), broj (0-9) i znak "_", pričemu na prvom
mjestu ne moţe da bude broj. Uz to, velika i mala slova se razlikuju, tako da se, na primjer, varijable zarada i Zarada razlikuju.
C++ ne postavlja nikakvo ograničenje na broj karaktera u nekom identifikatoru. MeĎutim, večina implementacija ima ovo ograničenje, ali je ono toliko veliko da ne predstavlja nikakav problem (npr. i
do 255 karaktera). Treba imati na umu da postoje odreĎene riječi u C++ koje su rezervisane, tako da identifikatori ne mogu uzimati njihova imena.
Te riječi se nazivaju rezervisane ili ključne riječi i date su u tabeli:
Tabela 1: Ključne (rezervisane) riječi u C++
6.3.Struktura programa
//program koji ispisuje pozdravnu poruku komentar
#include<iostream> // zaglavlje standardne biblioteke using namespace std;
int main() // zaglavlje funkcije
{ cout<<“Sretan pocetak“; // naredba tijelo funkcije funkcija
system(„Pause“); return 0;
} Objašnjenje
Znak // označava komentar, kompajler potupuno ignoriše sve od pojave znaka // pa do kraja reda,svrha komentara je objašnjenje korisnicima koji pokušavaju razumjeti šta program radi,komentar
je obično kratak,komentari su vrlo vaţni kod velikih programa gdje komentar treba da objasni o čemu
se radi u pojedinim dijelovima programa. #include <iostrem> prestavlja predprocesorsku direktivu kojom se označava da kompajler treba da
očita tzv.heder datoteku u kojoj se nalazi definicije, deklaracije funkcija i objekata za unos i ispis sa standardnog ulaza odnosno izlaza.
using namespace std;ovom linijom koda definiramo područje za imenovanje objekata.Naravno poznato nam je da u jednom programu dva objekta ne mogu imati isto ime odnosno isti identifikator
jer će doći do kolizije i program neće raditi. int main() je zaglavlje funkcije,svaki program u C++ mora imati najmanje jednu funkciju main glavna
funkcija.Funkcija koja če se prva izvršiti kada program počne sa radom.U programskim jezicima
funkcija je potprogram koja vraća neki rezultat u navedenom primjeru funkcija int main vraća cijelobrojni rezultat . Nakon zaglavlja funkcije dolazi tijelo funkcije koje počinje otvorenom vitičastom
zagradom {, a završava zatvorenom vitičastom zagradom }.Vitičaste zagrade koristimo kada imamo
45
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
skupinu naredbi koje čine jednu cjelinu.Tijelo funkcije sačinjavaju naredbe svaka naredba završava
tačka-zarezom; Naredbe su niz instrukcija koje govore računaru šta treba da radi.
Cout je skračenica od consol out predstavlja objekat tzv. izlaznog toka podataka output stream koji je povezan sa standardnim ureĎajima za ispis tpično ekran. '<<' prestavlja znak redirekcije odnosno
umetanja koji pojednostavljeno moţemo čitati kao šalji Sretan pocetak na ekran― to ustvari predstavlja niz znakova koje šaljemo na ekran, takav niz znakova nazivamo string. System("PAUSE");
zaustavlja izvršenje programa, kako bismo mogli vidjeti rezultat njegovog rada. Bez ove linije program bi se nakon pokretanja izvršio, a konzola bi se zatvorila veoma brzo, tako da bismo imali osjećaj kao da
program nije ništa ni uradio. Return 0 znači da naša funkcija vraća cijelobrojnu vrijednost 0. } zatvrena vitčasta zagrada zatvara
tijelo funkcije.
Primjer2;
1 #include <iostream> 2 using namespace std;
3 int main() 4 {
5 cout << " Sretan pocetak u C++ zeli Vam prof Smajo \n"; 6 system("PAUSE");
7 return 0; 8 }
Naredba u datom primjeru šalje string1 " Sretan pocetak u C++ zeli Vam prof Smajo " na tok
cout(output stream). Posljednji karakter u datom stringu (n) je karakter koji označava
novi red .Za istu svrhu moţe se koristiti i funkcija endl, odnosno: cout << " Sretan pocetak u C++ zeli Vam prof Smajo " << endl;
Tok (stream) je objekat koji izvršava ulazne i izlazne naredbe. Tok cout je standardni izlazni tok (obićno ekran) u C++ . Simbol << je izlazni operator (usmjerivač toka) kojem je lijevi operand izlazni
tok, a desni izraz. Ovaj operator upućuje desni operand na lijevi. Dakle, u ovom slučaju string "Sretan pocetak u C++ zeli Vam prof Smajo /n" se šalje na cout, tj. uzrokuje njegov ispis na ekranu i
pomjeranje usljedeći red.
Slika 6.1. Izgled programskog koda i izvršne datoteke
Kompajliranje C++ programa obuhvata nekoliko koraka, koji su večinom nevidljivi za korisnika:
46
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
Prvi korak, C++ predprocesor ide kroz program i izvodi instrukcije koje su specificirane
predprocesorskim direktivama (npr. #include). Rezultat ovoga je modificirani tekst programa koji više
ne sadrži nikakve direktive. Drugi korak, C++ kompajler prevodi programski kod. Kompajler može biti pravi C++ kompajler, koji
pravi osnovni (asemblerski ili mašinski) kod,ili samo prevodilac, koji kod prevodi u C jezik. U drugom slučaju, rezultujući C kod se zatim prevodi kroz C kompajler kako bi se napravio osnovni kod. U oba
slučaja, rezultat može biti nepotpun zbog toga što program poziva podprogramske biblioteke koje nisu definisane u samom programu.
Treći korak, linker završava objektni kod njegovim povezivanjem sa objektnim kodom bilo kojeg modula biblioteka, koji program može pozvati.
Konačan rezultat je izvršna datoteka.
6.4.Varijable
Varijabla je simboličko ime za memorijsku lokaciju u koju se mogu pohraniti podaci, koji se naknadno mogu pozvati. Varijable se koriste za čuvanje vrijednosti podataka tako da se iste mogu koristiti u
raznim proračunima u programu. Sve varijable imaju dvije važne osobine: Tip, koji se postavlja kada se varijabla definiše (npr. cijeli broj, realni broj, karakter, ...). Kada
se jednom definiše, tip varijable u C++ se ne moţe promijeniti. Vrijednost, koja se moţe promijeniti davanjem nove vrijednosti varijabli.
Vrsta vrijednosti koja se može pridružiti nekoj varijabli zavisi od njenog tipa. Na primjer, cjelobrojna
varijabla (int) može uzeti samo vrijednosti cijelih brojeva (npr. -5, 13, ...). Kada se varijabla definiše, njena vrijednost je nedefinisana sve dok joj se ne pridruži neka.
Pridruživanje vrijednosti nekoj varijabli po prvi put naziva se inicijalizacija. Neophodno je da se svaka varijabla inicijalizira prije nego se koristi. C++ podržava dvije vrste inicijalizacije: (i) inicijalizaciju
kopiranjem (eng. copy-initialisation) i (ii) direktna inicijalizacija (eng. directinitialisation). Inicijalizacija kopiranjem koristi znak jednakosti, =, dok se direktna inicijalizacija izvodi pomoću malih
zagrada, (), kao u sljedećim primjerima:
int broj(10); // direktna inicijalizacija
int broj = 10; // inicijalizacija kopiranjem
U oba slučaja varijabla broj je inicijalizirana na vrijednost 10. Treba napomenuti da inicijalizacija ne predstavlja pridruživanje (iako se u inicijalizaciji kopiranjem koristi znak jednakosti), nego se dešava
onda kada se varijabla definiše i kada joj se da početna vrijednost. S druge strane, pridruživanje predstavlja poništavanje trenutne vrijednosti varijable i zamjene novom.
Također je moguće da se varijabla definiše i inicijalizira u isto vrijeme,što je vrlo praktično. Naredni primjer pokazuje razlicite načine definisanja i inicijaliziranja varijabli.
1 #include <iostream> 2 using namespace std;
3 main() 4 {
5 int a,b,c; 6 float x = 4.32;
7 int e,f,g; 8 char ime;
9 e = 4;
10 f = g = 12; 11 ime = ’C’
12 }
Da objasnimo
Linije 5, 7 i 8 pokazuju primjere definisanja varijabli a, b, c, zatim e, f, g i ime, respektivno. Varijable
e, f i g su inicijalizirane linijama 9 i 10, a varijabla ime u liniji 11. Istovremeno definisanje i
47
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
inicijalizacija data je u liniji 6 za varijablu x. Na kraju, treba napomenuti da većina autora proces
definisanja varijabli poistovječuje sa procesom deklarisanja. MeĎutim, neki autori prave razliku izmeĎu
ovih pojmova. Naime, zbog situacija u kojima se u više datoteka jednog te istog programa pristupa
istoj varijabli, C++ razlikuje pojmove definisanja i deklarisanja. Tako, definisanje varijable predstavlja
alociranje prostora za nju, te moguću inicijalizaciju. U jednom programu moţe biti samo jedna
definicija varijable. S druge strane, deklaracija ’upoznaje’ program sa tipom i imenom varijable.
Definicija je time i deklaracija. Deklarisanje se izvršava na taj način da se ispred tipa doda ključna riječ
extern. Sljedeći primjer pokazuje razliku izmeĎu definisanja i deklarisanja neke varijable:
extern int broj; // deklarise ali ne i definise broj
int broj; // deklarise i definise broj
Osnovna razlika je u tome da se sa extern, odnosno procesom deklaracije,ne alocira prostor za datu
varijablu, nego samo upućuje na to da je varijabla definisana negdje u programu.
6.5.Memorija
Za pohranjivanje izvršnog koda kao i podataka sa kojima program manipulira,kompjuter ima na
raspolaganju RAM memoriju (eng. Random AccessMemory). Pri tome, memorija se moţe zamisliti kao
neprekidan niz bita, od kojih svaki moţe da pohrani binarni broj (0 ili 1). Memorija se obično dijeli na
grupe od 8 uzastopnih bita (ovo predstavlja bajt). Bajtovi su uzastopno adresirani, tako da je svaki bajt
jedinstveno predstavljen svojom adresom .C++ kompajler generiše izvršni kod, koji mapira ulazne
veličine na memorijske lokacije. Na primjer, definicija varijable
int zarada = 500;
navodi kompajler da alocira nekoliko bajta kako bi predstavio varijablu zarada.
Slika 2.5.1.Organizacija memorije u kompjuteru
Tačan broj bajta koji je alociran i metoda koja se koristi za binarnu reprezentaciju cijelog broja zavisi
od specificnosti C++ implementacije. Pretpostavimo,na primjer, da se radi o 2 bajta. Kompajler koristi
adresu prvog bajta na koju se alocira zarada kako bi označio varijablu. Prethodna jednakost uzrokuje
da se vrijednost 500 pohrani u ova dva bajta koja su alocirana (Sl.2.5.2)
48
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
Slika 2.5.2: Reprezentacija cijelog broja u memoriji
6.6.Ulazno-izlazni tokovi
Treba napomenuti da je organizacija memorije i korištenje adresa koji se odnose na podatke veoma
vaţno za programera, dok tačna binarna reprezentacija podataka koje on koristi to nije.Da bi program
bio koristan, mora komunicirati s ulazno/izlaznim ureĎajima (tastaturom, monitorom, diskom i sl.).
Komunikacija s ulazno/izlaznim ureĎajima se u programu C++ ostvaruje ulazno-izlaznim tokovima
(engl. input and output streams).
Svaki program prima podatke posredstvom ulazno-izlaznih tokova i rezultat predaje okolini
posredstvom ulazno-izlaznih tokova. S gledišta programa sasvim je svejedno o kojem je ulaznom ili
izlaznom ureĎaju riječ pa se svi podaci u program unose i iz programa predaju okolini na isti
način.Ulazno-izlaznim tokovima se rukuje funkcijama biblioteka iostream.
Biblioteka iostream
iostream je biblioteka koja sadrţi niz ulazno-izlaznih funkcija koje omogućavaju rukovanje ulazno-
izlaznim tokovima. Dvije funkcije koje su najčešće u upotrebi su cout i cin.
Cin ulazni tok
Funkcija cin usmjerava podatke s tastature na ulazni tok. Podaci se u ulazni tok umeću operatorom
unosa (>>).
Primjena funkcije cin
cin>>x; Program očekuje unos podataka s tastature koji
će biti pohranjen u varijablu x.
cin>>a>>b; Program očekuje unos sa tastaturekoji će bit pohranjen u varijablu a i b
cout<<34<<“moguć je i ispis niza znakova“; Moguće je ulančavanje operatora unosa koji se izvodi s lijeva na desno.
Posljedica funkcije unosa cin je prekid izvršenja programa sve dok se ne unese podatak i pritisne tipka
Enter (program "čeka" da korisnik upiše podatak). Više ulaznih podataka moţe se upisati u istome
redu, odvojeni prazninama (tek na kraju treba pritisnuti tipku Enter).
49
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
Cout izlazni tok
Funkcija cout usmjerava podatke s izlaznog toka na ekrana monitora. Ispis podataka se ostvaruje
operatorom ispisa (<<).
Primjena funkcije cout
cout<<17; Ispisat će broj 17
cout<<“Moguć je ispis znakova“; S desne strane operatora ispis može biti bilo koji tip podataka.U primjeru će se ispisati tekst unutar
navodnika.
cout<<15<<a<<“Moguć je i ispis niza znakova“; Moguće je ulančavanje operatora unosa koji se izvodi s lijeva na desno.Ispisat će se redom jedno
iza drugog;15,vrijednost varijable a,i tekst naveden unutar navodnih znakova.
endl
U prethodnom bi se primjeru svi podaci ispisali u istome redu. Ako korisnik ţeli pregledniji ispis, tj.
nakon završenog ispisa jednog podatka pokazivač prebaciti na početak sljedećeg reda treba koristiti
konstantu endl (takoĎer pohranjenu u biblioteci iostream).
Upotreba konstante endl
cout<<34<<endl;
cout<<a<<endl;
cout<<“Moguć je i ispis niza znakova“<<endl;
Cout<<34<<endl<<a<<endl<<“Moguć je ispis niza znakova“;
U oba primjera rezultat(ispis) će biti isti:
34
a
Moguć je ispis znakova
6.7.Komentari
Komentar je dio opisnog teksta koji objašnjava neke aspekte programa. Kompajler u potpunosti
ignoriše komentare u programu, tako da je jedina svrha koju komentar ima, da pomogne onome koji
ce čitati program. C++ daje dvije mogućnosti pisanja komentara:
bilo šta napisano nakon //, pa do kraja date linije smatra se komentarom3,
i
bilo šta napisano izmeĎu /* i */ smatra se komentarom.
Sljedeći primjer pokazuje upotrebu oba načina pisanja komentara.
#include <iostream>
50
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
2 using namespace std;
3
4 /* Ovaj program racuna ukupnu platu radnika,
5 koja se zasniva na ukupnom broju radnih sati i satnici. */
6
7 int main (void)
8 {
9 int radniDani = 22; // Broj radnih dana u mjesecu
float radniSati = 7.5; // Broj radnih sati u danu
11 float satnica = 33.50; // Satnica
12 float plata; // Ukupna mjesecna plata
13
14 // Racunanje i ispis plate
15
16 plata = radniDani * radniSati * satnica;
17 cout << "Plata = " << plata << ’\n’;
18 }
Prvi način se moţe koristiti za komentar jedne i samo jedne linije (ili dijela jedne linije), kao što je to
demonstrirano u linijama 14 (cijeli red), te linijama 9-12 (dio reda). Drugim načinom se (koristeći /* i
*/), pak, moţe komentarisati tekst upisan u više linija (linije 4-5).
6.8.Imena (identifikatori)
Programski jezici koriste imena kako bi se označile različite cjeline koje čine program. Osim imena
varijabli, ovdje spadaju i imena funkcija, tipova, te makroa. C++ postavlja sljedeća pravila za pravilno
kreiranje imena (identifikatora):
ime treba da se sastoji od jednog ili više karaktera, od kojih bilo koji moţe biti slovo (tj, slova
engleske abecede a-z i A-Z), broj (0-9) i znak " ", pri čemu na prvom mjestu ne moţe da bude
broj.
velika i mala slova se razlikuju (zarada nije isto što i Zarada).C++ ne postavlja nikakvo
ograničenje na broj karaktera u nekom identifikatoru.
MeĎutim, većina implementacija ima ovo ograničenje, ali je ono toliko veliko da ne predstavlja nikakav
problem (npr. i do 255 karaktera). Ipak, treba imati na umu da postoje odreĎene riječi u C++ koje su
rezervisane, tako da identifikatori ne mogu uzimati njihova imena. Te riječi se nazivaju rezervisane ili ključne rijeći i neke od njih su date u Tabela 1: Ključne (rezervisane) riječi u C++.
Pored navedenih pravila o davanju imena varijablama, postoji i veliki broj prihvačenih konvencija, koje se uglavnom koriste radi lakšeg pračenja programa.
Neke od vaţnijih su: imena varijabli se obično pišu malim slovima
51
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
za davanje imena se obično koriste mnemonička imena, tj. imena koja pobliţe opisuju varijablu ime moţe da ima i više riječi, koje su obično razdvojene donjom crtom,ili su direktno povezane
sa početnim velikim slovom riječi koja se dodaje imenu. No, bez obzira na konvencije, opšte je pravilo da se jedna odreĎena konvencija konstantno koristi.
6.9.Tipovi podataka2
6.9.1.Organizacija numeričkih brojeva u računarskoj memoriji
Brojni sistemi
Da bi shvatilli tipove podataka neophodne za učenje programskog jezika,potrebno je osvrnuti se na
organizaciju numeričkih podataka u računarskoj memoriji.
Prvi pojam koji je potrebno savladati je brojni sistem.
Postavimo pitanje:Šta predstavlja broj 342,i po čemu se on razlikuje od brojeva 423 i 234 koji su
sastavljeni od istih cifara? Poznato je da svaka cifra unutar broja ima odreĎenu "teţinu" (ovisno o
poziciji unutar broja) ,te moţemo reći da je broj 342 skraćeni zapis sljedećeg broja:
Ako o razmislimo zašto je baza 10, shvati čemo da ovakav izbor nema posebnog argumenta. Jedini
razlog je zapravo historijski zbog činjenice da čovjek ima 10 prstiju i da je shvatio da za brojeve veće
od deset ne moţe više računati na prste,nego mora izmisliti neki način zapisa većih brojeva.
Brojni sistem s bazom 10 naziva se decimalni ili dekadski brojni sistem.
Baza je mogla biti bilo koji broj,jer se lako moţe dokazati da se pozitivan broj moţe zapisati u obliku.
U digitalnim elektronskim sklopovima(u koje spadaju i računari) brojni sistem sa bazom 10 se pokazao
nepogodnim za praktičnu realizaciju.Baza 2 je,s druge strane,bila mnogo "lakša" za implementaciju;
jer se dvije znamenke-0 i 1-mogu predstaviti kao "odsustvo" i prisustvo"nečega(npr.ima struje-nema
struje ).
Ovaj brojni sistem od svega dvije znameke naziva se binarni.
Pokušajmo predstaviti neki broj u binarnom brojnom sistemu(po bazi 2).
npr.142=128+14=128+8+6=27 +23 +21 =(10001110)2
Dakle, 142 se u binarnom brojevnom sistemu piše kao 1001110.Gore opisana metoda pretvorbe
brojeva iz dekadskog u binarni brojni sistem nije pogodna za pretvaranje većih brojeva.
2 Preuzeto i obrađeno Diplomski rad“ Poređenje Pascala i C++ u nastavi Smajo Mekic“
52
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
Standardna metoda za pretvaranje,zasniva se na uzastopnom dijeljenju broja sa 2 ispisivanjem
ostataka, sve dok se ne doĎe do količnika 0,ostaci dijeljenja,pročitani redom odozdo na gore,
predstavljaju traţeni binarni broj.
142 0
71 1
35 1
17 1
8 0
4 0
2 0
1 1
0
U C++ su ugraĎeni prosti i sloţeni tipovi podataka,ovdje ćemo objasniti proste tipove podataka.
6.9.2.Brojevi
U C++ su ugraĎena dva osnovna tipa brojeva, i to: cijeli i realni brojevi. Cijeli brojevi
Cijeli broj (engl. integer) se moţe definisati pomoću tipova short, int i long. Jedina razlika je u tome što int koristi više ili barem isto bajta kao short, a long koristi više ili barem
isto bajta kao int . Ovo zavisi od kompjutera na kojem se radi.Konvencija je da cjelobrojne varijable
uzimaju u obzir i pozitivne i negativne brojeve (tada se kaţe da su oni tipa signed). MeĎutim, u slučaju kada se koriste samo pozitivne vrijednosti, uključujući i 0, koriste se sa predznakom unsigned.Ovo
vrijedi i za realne brojeve. Najčešće se pri definisanju cijelih brojeva koristi tip int, koji u kompjuteru obično zauzima 4 bajta
(mada kod nekih starijih kompjutera zauzima 2 bajta). S obzirom da 4 bajta predstavlja 4*8 = 32 bita, i da prvi bit odreĎuje predznak broja, preostaje nam
31 bit da pohranimo vrijednost nekog broja. Na taj način se tipom int mogu pohraniti svi brojevi veći od najmanjeg negativnog broja
-231 = -2147483648
i manji od največeg mogućeg pozitivnog broja -231 ¡ 1 = 2147483647
Treba napomenuti da se cjelobrojne veličine u izvornom kodu mogu prikazati u jednom od tri brojna sistema, i to: dekadskom, oktalnom i heksadecimalnom.
Pri tome, naravno, dekadski brojni sistem je sistem brojeva od 0-9,oktalni 0-7, i heksadecimalni (0-9, A-F).
U jeziku C++ oktalne vrijednosti se pišu tako da se ispred prve cifre broja napiše broj 0, nakon čega slijedi oktalni zapis broja, kao npr.
int broj = 010; // broj 8 u dekadskom zapisu U slučaju heksadecimalnog zapisa u C++ , ispred broja se piše 0x ili 0X,tj.
int broj = 0x0C; // broj 12 u dekadskom zapisu Ipak, bez obzira koji od prikaza koristimo pri pridruţivanju neke vrijednosti,na ekranu se ispisuje broj u
dekadskom brojnom sistemu. Tako u sljedećem primjeru za svaki slučaj ispis je jednak broju 32:
int broj = 32; // broj 32 u dekadskom zapisu
cout << broj; // ispis 32
int broj = 040; // broj 32 u oktalnom zapisu cout << broj; // ispis 32
53
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
int broj = 0x20; // broj 32 u heksadecimalnom zapisu
cout << broj; // ispis 32
Realni brojevi
Da bismo operisali sa realnim, tj. decimalnim, brojevima moţemo koristiti varijable tipa float i double. Tip double koristi više bajta i time omogućuje veći opseg i veću tačnost pri predstavljanju realnih
brojeva. Naredni primjeri pokazuju upotrebu tipa float (analogno je za ostale tipove koji predstavljaju realne
brojeve): float pi = 3.1415926;
float brzinaSvjetlosti = 2.997925e8;
float naboj = -1.6E-19;
U prvom slučaju koristi se klasični način prikaza broja sa decimalnim zarezom,dok je u drugom i trećem slučaju korišteno naučno označavanje (eng.scientific). Pri tome, u naučnom označavanju je
moguće koristiti i malo i veliko slovo "e", ali ne smije biti nikakvih praznina unutar broja (izmeĎu cifri i slova e, te iza predznaka).
U slučaju da nam tačnost na sedam decimala nije dovoljna, koristimo brojeve sa dvostrukom tačnošću, tj. brojeve tipa double. U principu, za prikaz decimalnih brojeva najbolje je uvijek koristiti tip double,
jer je brzina obavljanja operacija sa ovim tipovima na današnjim kompjuterima podjednako velika
kao i sa tipom float. Ograničenja brojevnih tipova
Kao što je pokazano u dijelu o cijelim brojevima, na osnovu veličine memorije koju neki brojevni tip
zauzima, moguće je odrediti maksimalan i minimalan broj koji se sa njim moţe prikazati. O tome kako se odreĎuje veličina memorije koju zauzima neki objekat ili tip.
Ipak, korištenjem datoteka climits(Datoteka mora biti pozvana naredbom #include), za cjelobrojne, i cfloat, za decimalne brojeve, moguće je naći ove vrijednosti. Na primjer, konstante INT_MIN i
INT_MAX daju najmanju i najveću vrijednost brojeva tipa int. Slične konstante postoje i za ostale
tipove, a sljedeći dio programa daje njihovu primjenu:
cout << "Najmanji int: " << INT_MIN << endl; cout << "Najveci int: " << INT_MAX << endl;
cout << "Najmanji long: " << LONG_MIN << endl; cout << "Najveci int: " << LONG_MAX << endl;
cout << "Najveci float: " << FLT_MAX << endl; cout << "Najmanji double:" << DBL_MIN << endl;
Simboličke konstante
Prethodni brojevni tipovi se koriste za definisanje varijabli koje mijenjaju svoju vrijednost u toku izvršavanja programa. MeĎutim, u C++ je moguće definisatii konstante, tj. veličine koje ne treba da
mijenjaju svoju vrijednost u toku izvršenja programa. Takve su na primjer, vrijednost π brzina
svjetlosti, naboj elektrona, itd.Osnovni razlog zbog korištenja simboličkih konstanti je osiguranje od
promjene njihove vrijednosti. Naime, moţe se desiti da u toku pisanja programa napišemo naredbu
koja mijenja vrijednost konstante (npr. broja π) i na taj način napravimo veliku grešku u daljem
proračunu.
Kako bismo izbjegli ovakve probleme, na raspolaganju nam je kvalifikator const, koji nam govori da se radi o varijabli koja ne mijenja svoju vrijednost.
Ovaj kvalifikator se koristi na taj način da se postavlja ispred tipa varijable, kao u primjeru: const float pi = 3.1415926;
Ako bismo pokušali promijeniti vrijednost varijable pi (na primjer sa pi = 2*pi;) kompajler bi prijavio grešku.
Drugi način definisanja neke konstante je pomoću predprocesorske naredbe #define, kao u:
#define PI 3.1415926
54
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
Jedina razlika u korištenju ova dva pristupa je u tome što varijanta sa const omogućuje i simboličko
lociranje pogrešaka pri debagiranju, dok to nije moguće sa drugom varijantom.
TakoĎer, bitno je napomenuti da se sve simboličke konstante moraju i inicijalizirati prilikom definisanja, tj. pogrešno je napisati:
const float pi; // greška!!!
Logički tipovi Logički tipovi su vrlo kasno uvedeni u standardni jezik C++ . Prije nego se uveo tip za ovu vrstu
podataka, bool (od engleske riječi boolean, po matematičaru Booleu), u ovu svrhu su se koristili cijeli brojevi 0 i 1 (mada se umjesto 1 mogao koristiti bilo koji broj različit od 0).
Osnovna karakteristika logičkih tipova je da mogu imati dvije vrijednosti,i to: tačno i netačno (eng.
true i false). Primjer definisanja logičkih varijablije: bool jaSamUcenik = true;
bool autoLeti = false; Prilikom manipulisanja sa logičkim varijablama (ispis, aritmetičke operacije,i sl.), oni se predstavljaju
cjelobrojnim tipom int, i to: true se pretvara u 1,a false u 0. No, logičkim varijablama se mogu pridružiti i aritmetički tipovi,tako da se svim brojevima različitim od nule pridružuje true, a jednakim
nuli false.
Karakteri (znakovi)
Varijabla karakter (znak) se definiše tipom char (od engleske riječi character -karakter, znak) i uglavnom se piše kao samo jedan znak upisan izmeĎu jednostrukih znaka navoda ’. Ona obuhvata
jedan jedini bajt koji sadrţi kod datog karaktera. Ovaj broj je numerička vrijednost i zavisi od sistema kodiranja karaktera koji se koristi (to je zavisno od kompjutera). Najčešći sistem je ACSII
(eng. American Standard Code for Information Interchange). Na primjer,karakter A ima ASCII kod 65, a karakter a 97.
Kao i cijeli broj i karakter moţe da bude signed i unsigned. Tako, signed karakter moţe da sadrţi
numeričke vrijednosti izmeĎu -128 i 127, a unsigned 0do 255. Sljedeći primjer pokazuje upotrebu tipa char za jednoznakovne varijable:
Pri pokretanju, ovaj program se nastavlja ako se unese bilo koji drugi karakter osim k ili K. Ako se, pak, unese k ili K, program se zaustavlja. Problem nastaje ako korisnik programa pritisne samo tipku
ENTER. U tom slučaju objekat cin očekuje da se unese neka vrijednost, pa tek onda pritisne ENTER.
#include <iostream> 2 using namespace std;
3 main() 4 {
5 char ch; 6 do
7 {
8 cout << "Pritisnite K ili k za kraj, 9 a bilo koju tipku za nastavak \n";
10 cin >> ch; 11
12 if (ch != ’K’ && ch != ’k’) 13 cout << "Zelite nastaviti?\n";
14 else 15 cout << "Kraj programa";
16 }while (ch != ’K’ && ch != ’k’);
17 }
55
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
Osim klasičnih karaktera (slova i sl.), postoje i karakteri koji imaju posebnu namjenu (ne predstavljaju
karaktere koji se ispisuju). Oni se predstavljaju pomoću tzv. escape-sekvenci, kao npr:
\n - novi red \t - novi tabulator
\v - novi vertikalni tabulator \b - backspace
\’ - znak navoda (apostrof) \" - dvostruki znak navoda
\\ - backslash (/) \a - zvučni signal
Znakovne varijable se, ipak, najčešće koriste kao nizovi karaktera (eng. string)za ispis tekstova.
Pitanja za utvrĎivanje: 1. Da li je moguće definisati više varijabli jednom naredbom? Ako jeste,
dati primjer. 2. Koja je razlika između tipova podataka unsigned int i int?
3. Koja je uloga include direktive? 4. Koliko main funkcija može biti u programu?
5. Šta predstavlja varijabla?
6. Šta radi kompajler? 7. Šta radi linker?
8. Šta radi predprocesor? 9.Šta je od navedenog ispravna definicija varijable:
a. int n=-100; b. unsigned int i =-100;
c. signed int = 2.9; d. long m=2,p=4;
10.Koje od navedenih riječi predstavljaju pravilne nazive varijabli:
a. identifier b. dva 15
c. ukupna-plata d. ukupna_plata
e) default f) proc.program
11. Definiši varijable koje predstavljaju sljedeće veličine: a. visina neke osobe
b. zarada neke osobe
c. broj rijeci u rječniku d. slovo u abecedi
12. Dati primjer starog (jedan red) i novog načina pisanja komentara. 13. Koju datoteku (header file) moramo pozvati u izvornoj datoteci da bi se koristile cout i cin?
14. Napisati naredbu koja dobiva numeričku vrijednost sa tastature i pridružuje je varijabli temp. 15. Kako se definišu brojevi u C++ ?
16. Kako se definišu znakovi u C++ ? 17. Kako se u C++ definišu logičke varijable?
7.Operatori
56
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
C++ nudi operatore za izvršavanje aritmetičkih, relacijskih, logičkih,bitovnih i uslovnih izraza.
TakoĎer, tu su i veoma korisne "popratne pojave" (eng. side-effect) kao što su pridruţivanje,
inkrement i dekrement.
7.1.Aritmetički operatori
C++ nudi pet osnovnih operatora, koji su sumirani u Tabeli.
Osim ostatka pri dijeljenju (%) svi aritmetički operatori prihvataju miješanje cijelih i realnih brojeva. Općenito, ako su oba operanda cijeli brojevi,i rezultat je cijeli broj. MeĎutim, ako je jedan od
operanada realan, onda je i rezultat realan (na primjer, tipa double; Ovakav način konverzije u C++ naziva se implicitna konverzija).
Kada su oba operanda pri dijeljenju cijeli brojevi, rezultat je takoĎer cijeli broj (tzv. cjelobrojno dijeljenje). U tom slučaju rezultat se zaokruţuje na donju vrijednost, tj..
9/2 daje 4, a ne 4.5!
-9/2 daje -5, a ne -4.5!
Čak i u slučaju kada je rezultat dijeljenja definisan kao realan broj, kao u sljedećem primjeru
int cijena = 100; int volumen = 80;
double jedinicnaCijena = cijena/volumen; // daje 1
rezultat dijeljenja je cjelobrojan, s obzirom da dijeljenje ima veći prioritet od pridruţivanja. Cjelobrojno dijeljenje predstavlja jednu od najčešćih greški u programiranju, pa je neophodno upoznati
načine na koje se moţe zaobići. Ovo se moţe ostvariti pomoću tzv. eksplicitne konverzije, ili dodjele
tipa (eng. cast). U tu svrhu se mogu koristiti sljedeći operatori (eng. cast operators): static_cast,dynamic_cast, const_cast i reinterpret_cast,
ali je za naš slučaj vaţan operator static_cast (koristi se u slučajevima kada se manjem aritmetičkom
tipu pridruţuje veći; na primjer tipu int pridruţuje tip double). Sljedeći primjer pokazuje njegovu primjenu:
int cijena = 100;
int volumen = 80;
double jedinicnaCijena = static_cast<double>(cijena)/volumen; //daje 1.25 Operator static_cast moţe se koristiti i na varijabli volumen, ali i na obje varijable u količniku.
Prije nego se počeo koristiti ovaj C++ način pisanja, u upotrebi je bio stari način (eng. old-style cast), koji se daje ili u tzv. funkcijskom obliku (varijabla meĎu zagradama):
double jedinicnaCijena = double(cijena)/volumen; // daje 1.25
ili u tzv. starom načinu pisanja u jeziku C (sa tipom me�u zagradama): double jedinicnaCijena = (double)cijena/volumen; // daje 1.25
57
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
Ipak, stari način pisanja se ne preporučuje u pisanju programa koji će se kompajlirati na C++
kompajlerima.
Operator % daje ostatak pri dijeljenju dva cijela broja (oba operanda moraju biti cijeli brojevi!!!), npr. 13%3 daje 1.
Prilikom korištenja aritmetičkih operatora veoma vaţno mjesto zauzima pojam preljeva. Naime, u slučaju da zbir brojeva prelazi maksimalno dozvoljenu vrijednost, dobivena vrijednost moţe biti
negativna. Ovaj fenomen se lako moţe pokazati na slici ako se za tip int pretpostavi da ima 2 bajta, tj. 16 bita (to znači da je maksimalan pozitivan broj jednak 215 = 32767).
Dakle, ukoliko neku varijablu koja ima vrijednost 32767 uvečamo za samo 1, vrijednost koju dobivamo
je -32768 (!!!), odnosno za jedan veća od najveće moguće u smjeru kazaljke na satu na slici.
7.2.Relacijski operatori
C++ nudi šest relacijskih operatora za računanje brojnih veličina.
Pri tome, treba zapamtiti da se operatori <= i >= mogu koristiti samo u tom obliku, a da =< i => ne znače ništa u ovom kontekstu.
Operandi nekog relacijskog operatora moraju biti brojevi. No, i karakteri su ispravni operandi pošto predstavljaju brojnu vrijednost .
Relacijski operatori se ne smiju korisiti za poreĎenje stringova, pošto se u tom slučaju porede njihove
adrese, a ne sadrţaj. U tom slučaju, rezultat je neodreĎen. Ipak, postoje funkcije koje mogu porediti i leksikografsku razliku dva stringa.
58
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
7.3.Logički operatori
Za kombinovanje logičkih izraza C++ nudi tri logička operatora.
Slično relacijskim operatorima, rezultat pri korištenju logičkih operatora je 0 (false) ili 1 (true).
Za razliku od logičkog i i logičkog ili operatora, koji su binarni operatori, logička negacija je unarni
operator, tj. ima samo jedan operand kojem daje negaciju vrijednosti koju posjeduje.
7.4.Bitovni operatori
C++ obezbijeĎuje šest bitovnih (eng. bitwise) operatora koji se koriste za manipulisanje pojedinačnim
bitovima cjelobrojnih podataka. Bitovni operatori su definisani samo za cjelobrojne (int, long int) operand i tretiraju ih kao sekvence
bita. Tako, binarna negacija (˜ - tilda) predstavlja unarni operator koji mijenja stanje bita operanda, tj. svi bitovi koji su jednaki 0 postavlja u 1, a sve bitove koji su jednaki 1 u 0. Binarno i uporeĎuje
odgovarajuće bitove svojih operanada i kao rezultat daje 1 ako su oba bita 1, a 0 u ostalim slučajevima. Binarno isključivo ili uporeĎuje odgovarajuće bitove svojih operanada i kao rezultat daje 1
ako su oba bita različita, a 0 u ostalim slučajevima.
59
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
Operatori pomaknuti lijevo i pomaknuti desno kao lijevi operand uzimaju sekvencu bitova, a kao desni
neki cijeli broj n. Prvi operator daje kao rezultat sekvencu bita koja je jednaka lijevom operandu, ali
koja je pomjerena n bitovnih pozicija ulijevo. Drugi operator ima istu funkciju, s tom razlikom što pomjera sekvencu bita za n pozicija udesno.
7.5.Inkrementalni i dekrementalni operatori
Takozvani auto inkrementalni (++) i auto dekrementalni (¡¡) operatori obezbijeĎuju prigodan način za
povečavanje, odnosno smanjivanje brojne varijable za 1. Upotreba ovih operatora je sumirana u Tabeli, pri čemu se pretpostavlja da je
int k = 5;
Kao što se vidi, oba operatora se mogu koristiti u prefiksnom i postfiksnom obliku. Razlika je velika, jer
kada se operator koristi u prefiksnom obliku prvo se primjenjuje operator, a onda se u izrazu koristi rezultat. Kada se koristi u postfiksnom obliku, prvo se računa izraz, a onda se primjenjuje operator.
Oba operatora se mogu primijeniti kako na cjelobrojne, tako i na realne brojeve, iako se ova karakteristika veoma rijetko koristi na realnim brojevima.
7.6.Operatori pridruživanja
Operator pridruţivanja (=) se koristi za pohranjivanje vrijednosti na neku memorijsku lokaciju (koja je
obično pridruţena nekoj varijabli). Lijevi operand operatora treba biti neka vrijednost, npr. lijevaVrijednost, dok desni operand moţe biti proizvoljni izraz. Desni operand se izračuna i pridruţi
lijevoj strani. Pri tome lijevaVrijednost predstavlja bilo šta što zauzima neku memorijsku lokaciju na koju se moţe
pohraniti neka veličina; moţe biti varijabla, te zasnovana na pointerima i referencama. Operator pridruţivanja moţe imati mnogo varijanti, koje se dobivaju njegovim kombinovanjem sa
aritmetičkim operatorima (moguća je kombinacija i sa bitovnim operatorima).
Kako operator pridruţivanja sam po sebi predstavlja izraz čija se vrijednost pohranjuje u lijevi operand,
on se moţe koristiti kao desni operand za narednu operaciju pridruţivanja, odnosno moţe se napisati:
60
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
int m, n, p; m = n = p = 5; // isto kao: m = (n = (p = 100));
m =(n= p = 100) + 2; // isto kao: m = (n = (p = 5)) + 2;
ili m = 100; m += n = p = 5; // isto kao: m = m + (n = p = 5);}
7.7.Operator razdvajanja (zarez-operator)
Operator razdvajanja, ili zarez-operator (eng. comma operator) koristimo kada mnogostruke izraze ţelimo kombinovati u jedan izraz. Ovaj operator ima dva operanda, pri čemu prvo izračunava lijevi
operand, a zatim desni, pa tek nakon toga vraća vrijednost posljednjeg kao konačan rezultat. Na primjer:
int m, n, min; int mBroji =0, nBroji=0;
...... min = (m < n ? mBroji++, m : nBroji++, n);
U ovom primjeru, kada je m < n, izračunava se mBroji++, a zatim se vrijednost m pohranjuje u min. U
suprotnom, izračunava se nBroji++, a zatim se vrijednost n pohranjuje u min.
7.8.typedef imena
Ključna riječ typedef omogućava definisanje novih imena (sinonima) za postojeće tipove podataka. Opšta formula ima oblik:
typedef tip novo_ime_tipa;
Dakle, typedef definicija počinje ključnom riječi typedef, nakon čega se ispisuje tip podatka i
identifikator. Pri tome, identifikator ne uvodi novi tip podatka, nego samo sinonim (nadimak) za postojeći tip. Ovaj identifikator se moţe koristiti bilo gdje u programu u kojem bi se mogao koristiti i
sam tip. Na primjer, sljedeći primjer pokazuje korištenje sinonima prirodni, za prirodne, tj. nenegativne cijele
brojeve. typedef unsigned int prirodni;
Ukoliko bismo ţeljeli definisati prirodni broj N korištenjem imena prirodni, pišemo: prirodni N;
Treba napomenuti da se u posljednjem primjeru identifikator prirodni moţe koristiti kao tip u nekoj
drugoj typedef deklaraciji. Inače, typedef imena se koriste kako bi se smanjila kompleksnost ispisivanja pojedinih tipova, kao što su kompleksne deklaracije imenika, pointera na funkcije, te pointera na
funkcijske članove klasa.
7.9.sizeof operator
Sizeof operator sluţi za računanje veličine bilo kojeg podatka ili tipa. To je unarni operator, koji za operand moţe imati tip (npr. int, char, . . . ) ili izraz, a kao rezultat daje broj bajtova koji operand
zauzima u memoriji računara.
Ovaj rezultat je u potpunosti zavisan od računara na kojem se radi. Naredni primjer ilustruje korištenje ovog operatora za računanje veličine osnovnih tipova podataka.
#include <iostream>
2 using namespace std; 3
4 int main (void) 5 {
61
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
6 cout << "char size = " << sizeof(char) << " bytes\n";
7 cout << "short size = " << sizeof(short) << " bytes\n";
8 cout << "int size = " << sizeof(int) << " bytes\n"; 9 cout << "long size = " << sizeof(long) << " bytes\n";
10 cout << "float size = " << sizeof(float) << " bytes\n"; 11 cout << "double size =" << sizeof(double) << " bytes\n";
12 cout << "HELLO size = " << sizeof("HELLO") << " bytes\n"; 13 system("pause");
14 }
7.10.Hijerarhija operatora
Slično pravilima u matematici o redoslijedu izvoĎenja pojedinih računskih operacija,i redoslijed
korištenja pojedinih operatora u nekom izrazu u C++ je veoma bitan. Stoga se operatori dijele na različite hijerarhijske nivoe, pri čemu operatori na višim nivoima imaju prednost nad onim koji su niţe.
daje prikaz hijerarhije nekih od operatora operatora u C++ , od onih sa najvecim prema onim sa najmanjim prioritetom. Pri tome su operatori sa istim prioritetom smješteni u isti blok
(odvojen horizontalnim linijama).
Na primjer, u izrazu
62
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
a=b+c*d;
prvo se računa c*d, jer znak mnoţenja * ima veći prioritet od znaka sabiranja + i znaka pridruţivanja
=. Rezultat mnoţenja se zatim dodaje varijabli b, jer operacija sabiranja ima veći prioritet od operacije pridruţivanja.
Ovakav način definisanja hijerarhije je neophodan, jer se pojedini operatori koriste za više namjena. Takav primjer je znak plus, +, koji se moţe koristiti kao binarni operator za sabiranje, unarni operator
za promjenu znaka nekog broja, ali i kao operator za uvečavanje (postfiks i prefiks inkrement). Ako, na primjer, ţelimo sabrati dva broja, pri čemu je drugi broj prethodno uvećan za
jedan, imamo izraz: c=a+ ++b;
No, moţe se desiti da umjesto prethodnog izraza napišemo:
c=a+++b; što bi, imajući na umu hijerarhiju operatora, kompajler razumio kao:
c=a++ +b; U ovom slučaju, prvo se izvršava sabiranje brojeva a i b, a zatim se broj a poveća za jedan, što
naravno nismo ţeljeli uraditi. Treba napomenuti da u slučaju dvoumljenja oko prioriteta operatora, najbolje je koristiti zagrade, i na
taj način zaobići ugraĎenu hijerarhiju. Tako bi ranije primjere mogli napisati u obliku: a=b+(c*d);
odnosno
c=a+(++b);
Pitanja za utvrđivanje: 1. Koji od logičkih operatora su unarni, a koji su binarni?
2. Šta radi inkrement operator? 3. Šta radi dekrement operator?
4. Objasni šta radi sljedeća naredba: cout >> --broj!
5.Dodati zagrade sljedećim izrazima tako da se pokaže kojim redom se izračunavaju
pojedini operatori: a) (n <= p + q && n >= p - q || n == 0)
b) (++n * q– / ++p - q) c) (n | p & q ˆ p « 2 + q)
d) (p < q ? n < p ? q * n - 2 : q / n + 1 : q - n) 6. Šta će biti vrijednost sljedećih varijabli nakon inicijalizacije:
a) double d = 2 * int(3.14); b) long k = 3.14 - 3;
c) char c = ’a’ + 2;
d) char c = ’p’ + ’A’ - ’a’; 7. Tačno ili netačno: u naredbi pridruživanja, vrijednost sa lijeve strane od znaka jednako je uvijek
jednako vrijednosti na desnoj strani. 8. Tačno ili netačno: potpuno je normalno koristiti različite tipove podataka
u istom aritmetičkom izrazu. 9. Objasniti pojam preljeva?
10. Napisati naredbu koja pomoću operatora pridruživanja povećava vrijednost varijable temp za 23. Napisati istu naredbu bez operatora pridruživanja.
11. Relacijski operator;
a) Pridružuje jedan operator drugom b) Daje Boolean rezultat
c) Poredi dva operanda d) Logički kombinuje dva operanda
12. Napisati izraz koji koristi relacijski operator koji ima vrijednost true ako varijabla var1 nije jednaka varijabli var2.
13. Operatori && i ||: a) Porede dvije numeričke vrijednosti
63
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
b) Kombinuju dvije numeričke vrijednosti
c) Porede dvije Boolean vrijednosti
d) Kombinuju dvije Boolean vrijednosti 14. Provjeriti šta je rezultat sljedeće upotrebe uslovnog operatora, ako je
m=5.1, n=7.2: int min = (m < n ? m++ : n++);
8.Naredbe
Ovim naslovom opisat ćemo razne oblike C++ naredbi koje sluţe za pisanje programa.
Kao i večina ostalih programskih jezika, C++ nudi različite vrste naredbi koje se koriste u različite svrhe. Tako se deklaracione naredbe koriste za definisanje varijabli, naredbe pridruţivanja za
jednostavne proračune, itd.
8.1.Jednostavne i složene naredbe3
Jednostavna naredba je svaka naredba koja završava tačka-zarezom (;). Definicije varijabli i izrazi koji završavaju sa tačka-zarezom su samo neki od primjera, kao u sljedećim slučajevima:
int i; // deklaraciona naredba
++i; // naredba sa popratnom pojavom double d = 10.5; // deklaraciona naredba
d + 5; // beskorisna naredba Najjednostavniji oblik naredbe je linija koja sadrţi samo tačka-zarez, tzv.null-naredba. No, i ovakva
naredba ponekad ima smisla. Mnogostruke naredbe se mogu kombinovati u sloţene naredbe kada se grupišu izmeĎu velikih zagrada
({}), kao na primjer:
{ int min, i = 10, j = 20;
min = (i < j ? i : j); cout << min << ’\n’;
} Ovakve naredbe su korisne iz dva razloga:
a) omogućuju da se mnogostruka naredba postavi tamo gdje bi inače mogla da se postavi samo jedna, b) omogućuju da se u program uvede područje definisanosti varijable (eng. scope).
Područje varijable predstavlja dio programa unutar kojeg varijabla ostaje definisana. Izvan tog područja ona to više nije.
3 Preuzeto i obrađeno by Uvod u programiranja u C++ -predavanja na FIT Mostar;
64
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
8.2.Naredba if
Ponekad je poţeljno da se izvrši odreĎena naredba koja zavisi od ispunjenja nekog uslova. Upravo tu mogućnost pruţa if naredba, čiji je opšti oblik:
if (izraz) naredba;
Prvo se izvršava izraz, i ako je rezultat različit od nule izvršava se naredba. U suprotnom, ništa se ne
dešava.
Uvjet je logički izraz, zapisuje se unutar para okruglih zagrada. Na kraju naredbe if ne stavlja se znak tačka zarez ;
Primjer 1 Ako ţelimo provjeriti da li je pri dijeljenju djelilac različit od nule i izvršiti dijeljenje, upotreba naredbe if
ima oblik:
if (djelilac != 0) Kolicnik=djelitelj/djelilac;
U slučaju da ţelimo izvršiti više naredbi koje ovise o nekom istom uslovu,koristimo sloţenu naredbu, tj. sve naredbe stavljamo izmeĎu velikih zagrada.
Varijanta if naredbe koja omogućuje da se specificiraju dvije alternativne naredbe, jedna koja se izvršava kada je uslov ispunjen i druga kada nije, naziva se if-else naredba i ima oblik:
if (izraz) naredba1;
else
naredba2; Ovdje se najprije izvršava izraz, i ako je rezultat različit od nule, izvršava se naredba1. U suprotnom,
izvršava se naredba2, što pokazuje i primjer provjere da li je broj paran ili ne:
1 #include <iostream> 2 using namespace std;
3
4 main() 5 {
6 int x; 7 cout << "Unesite neki broj";
8 cin >> x; 9 if (x % 2 == 0)
10 cout << "Broj je paran" << endl; 11 else
12 cout << "Broj je neparan" << endl;
13 system(“Pauase“);return 0; }
65
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
Pored prethodno navedenih varijanti, postoji i ugnijeţdena if naredba, u kojoj se javlja više od dvije
alternative. Primjer takve varijante je, recimo, izračunavanje cijene telefonskog računa:
if (vrijemePoziva > 7 && vrijemePoziva < 19) { if (duzinaPoziva <= 60)
cijena = duzinaPoziva * tarifa1; else
cijena = 60 * tarifa + (duzinaPoziva - 60) * tarifa2; } else
cijena = osnovnaCijena;
Kao što se vidi unutar prve if naredbe, koja provjerava uslov da li je poziv izvršen u periodu 7.00-19.00 sati, nalazi se još jedna if naredba. Ova naredba ima za cilj da provjerava duţinu poziva, i na osnovu
toga formira cijenu istog. U slučaju da je poziv izvršen izvan perioda 7.00-19.00, cijena se formira na osnovu osnovne cijene
poziva. Primjer 2
Treba unijeti cijeli broj različit od 0 pa provjeriti da li je negativan ili pozitivan. U oba slučaja ispisati apsolutnu vrijednost broja.
Ako je (a<0) izvršit će se prvi blok naredbi.
Ako uvjet nije zadovoljen, prvi blok naredbi se preskače i izvoĎenje se programa nastavlja od prve naredbe iza bloka, a to je provjera drugog uvjeta (a>0).
Ako nije ispunjan niti drugi uvjet (za a=0), drugi blok naredbi se preskače i izvoĎenje se nastavlja od
naredbe return 0. Naredba if else
Za dvostruko uvjetno grananje koristi se naredba if - else.
66
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
Ako je vrijednost uvjeta logička istina izvodi se prvi blok. Nakon njegova završetka izvoĎenje se
nastavlja od prve naredbe iza drugog bloka. Ako je vrijednost uvjeta logička neistina, preskače se prvi blok i izvodi se drugi blok (iza naredbe else).
Nakon njegova završetka izvoĎenje se nastavlja od prve naredbe iza drugog bloka.
Primjer3. Primjer je riješen uz pomoć if – else naredbe.
Ako je (a<0) izvršit će se prvi blok naredbi. Ako je (a>0), preskače se prvi blok i izvodi se drugi blok naredbi.
Što ako korisnik ne pročita uputu paţljivo, pa unese broj 0? Rezultat neće biti ispravan:
67
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
Uneseni broj treba provjeriti. Ako je unesena 0, korisnika valja upozoriti, a potom korisnik mora unijeti
novi broj koji je različit od 0. Da bi to bilo moguće, potrebna je naredba koja omogućava nastavak odvijanja programa od odabrane
naredbe. Naredba goto
Naredba goto omogućava nastavak odvijanja programa od odabrane naredbe. Naredba na koju se ţeli skočiti, od koje se ţeli nastaviti odvijanje programa, moţe biti bilo gdje u
programu.
Opći oblik naredbe: goto oznaka_naredbe;
Naredbu od koje se ţeli nastaviti odvijanje programa treba označiti oznakom iza koje dolazi znak
dvotačke. oznaka_naredbe:naredba;
…… ……
goto oznaka_naredbe; ¸
Čestom upotrebom naredbe goto teško je slijediti tok odvijanja programa što oteţava otkrivanje pogrešaka.
Naredbu goto stoga treba izbjegavati i nastojati zadatak rješiti na drugi način, pomoću petlji koje će biti objašnjene kasnije.
Nredba if-else if-else
68
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
Za višestruko uvjetno grananje koristi se naredba if – else if - else.Broj pustavljenih uvjeta nije
ograničen.
Ako je vrijednost prvog uvjeta logička istina, izvodi se prvi blok naredbi. Nakon njegova završetka
izvoĎenje se nastavlja od prve naredbe iza zadnjeg bloka naredbi. Ako je vrijednost prvog uvjeta logička neistina, provjerava se drugi uvjet.
Ako je on logička istina, izvodi se drugi blok naredbi, a potom prva naredba iza zadnjeg bloka naredbi. Ako je vrijednost drugog uvjeta logička neistina, provjerava se treći uvjet, i td.
Provjere se tako redom nastavljaju sve do naredbe else.
Ako do tada niti jedan od uvjeta nije imao vrijednost logičke istine, izvršit će se zadnji blok naredbi koji se nalazi iza naredbe else.
Primjer4
69
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
Treba upisati prirodni broj pa provjeriti da li je veći ili manji od 100, te da li je paran ili neparan.
Višestrukim uvjetnim grananjem provjerava se da li je broj veći, manji ili jednak 100. Dvostrukim uvjetnim grananjem (neovisno o tome da li je broj veći ili manji od 100) provjerava se
parnost broja. Parnost se provjerava operatorom modulo (ostatak dijeljenja s 2 se usporeĎuje s 0).
8.3.Naredba switch
Naredba switch-case omogućava jednostruko grananje koje ovisi o vrijednosti postavljenog uvjeta.
Za razliku od višestrukog grananja naredbom if u kojoj su uvjeti logički izrazi, u naredbi switch-case
uvjet je cjelobrojan izraz ili cjelobrojna varijabla.Grananje swich-case.
70
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
Opšti oblik switch naredbe je: switch (izraz)
{ case konstanta_1:
naredbe; break;
... case konstanta_n:
naredbe;
break; default:
naredbe; }
Prvo se računa izraz (switch tag), a zatim se rezultat poredi sa svakom od numeričkih konstanti (labele), po redu kako se javljaju, dok se ne poklopi sa jednom od komponenti. Nakon toga se
izvršavaju naredbe koje slijede.
Izvršavanje se izvodi sve dok se ne naiĎe na naredbu break ili dok se ne izvrše sve naknadne naredbe. Posljednji slučaj (default) moţe, a i ne mora da se koristi, i pokreće se ako nijedna od prethodnih
konstanti nije zadovoljena. Korištenje ove naredbe dat je u sljedećem primjeru, koji odreĎuje opseg osvojenih bodova na ispitu na
osnovu dobijene ocjene.
71
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
#include <iostream>
using namespace std;
main() {
int ocj; cout << "Unesite ocjenu: ";
cin >> ocj; switch (ocj)
{ case 5:
cout << "Imate 90 – 100 bodova" << endl;
break; case 4:
cout << "Imate 80 – 89 bodova" << endl; break;
case 3: cout << "Imate 70 – 79 bodova" << endl;
break; case 2:
cout << "Imate 60 – 69 bodova" << endl;
break; default:
cout << "Imate ispod 60 bodova" << endl; system(“Pause“);return 0;
} }
Primjer 5
Treba izračunati ukupni otpor za otpore R1 i R2, ovisno o tome da li su spojeni serijski ili paralelno. Za odabir serijskog spoja korisnik upisuje 1, a za paralelnog 2.
Valja načiniti dvije grane (serijski spoj-1, paralelni-2). Ovisno o tome što korisnik upiše (broj 1 ili broj 2) izvršit će se jedna od dvije grane.
U slučaju da korisnik unese vrijednost koja nije 1 ili 2, ispisat će se upozorenje.
72
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
Rezultat programskog koda.
Ako se ne upiše broj 1 ili 2 ispisat će se poruka o grešci.
8.4.Naredba for
73
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
For petlja se najčešće koristi ako se dijelovi programa trebaju ponoviti unaprijed poznati broj puta.
Svaka for petlja ima svoju kontrolnu varijablu.Njena se vrijednost svakim prolaskom kroz petlju
mijenja ovisno o vrijednosti prirasta. Kontrolnu varijablu petlje potrebno je prije ulaska u petlju deklarirati. U petlji se najprije zadaje vrijednost početnog stanja kontrolne varijable petlje (početno
stanje). Po zadavanju početnog stanja kontrolne varijable petlje zapisuje se uvjet. Rezultat uvjeta je podatak 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.
Naredba for (for petlja) je slična naredbi while, ali ima dvije dodatne komponente: (i) izraz koji se izračunava samo jednom prije nekog proračuna koji se ponavlja, i (ii) izraz koji se
izračunava jednom na kraju svake iteracije. Opšti oblik naredbe for je:
for (izraz1; izraz2; izraz3) naredba;
Prvo se izračunava izraz1. Svakim prolaskom kroz petlju se izračunava izraz2. Ako je rezultat različit od nule izračunava se izraz3. U suprotnom petlja se zaustavlja. Oblik while
petlje koja je ekvivalentna do petlji je: izraz1;
while (izraz2) { naredba;
izraz3;
} Naredba for se najčešće koristi u situacijama kada se neka varijabla povečava ili smanjuje za neku
veličinu u svakoj iteraciji, odnosno kada je broj iteracija unaprijed poznat. Sljedeći primjer računa zbir svih brojeva od 1 do n:
sum = 0;
for (int i = 1; i <= n; ++i) sum += i;
Prvo se vrijednost zbira inicijalizira na vrijednost nula (sum=0;). Prvi izraz u petlji for predstavlja početnu vrijednost brojača i, koja je jednaka 1. Nakon toga, provjerava se uslov i <= n. Ako je uslov
ispunjen, izračunava se naredba. U ovom slučaju, radi se o jednostavnoj naredbi (sum += i;), tako da nema potrebe za korištenjem
velikih zagrada. Nakon izvršenja naredbe, izračunavase treći izraz, ++i, i postupak nastavlja sve dok se ne ispuni uslov i <= n.
Treba naglasiti da se umjesto prefiks inkrementa, kao treći izraz mogao staviti i postfiks inkrement (i++).
Bilo koja od komponenti u petlji moţe biti prazna. Na primjer, ako se uklone prvi i treći izraz, onda je
do petlja for (; i != 0;)
bilo-sta; ekvivalentna sa while petljom
. while (i != 0) bilo-sta;
Uklanjanje svih izraza u petlji daje beskonačnu petlju:
for (;;) // beskonačna petlja
bilo-sta;
Pošto petlje predstavljaju naredbe, mogu se pojaviti unutar drugih petlji (tzv. ugnijeţdene petlje). Klasični primjer je korištenje dvostruke petlje pri ispisu tablice mnoţenja brojeva do 10:
for (int i = 1; i <= 10; ++i){ for (int j = 1; j <= 10; ++j)
cout << setw(5)<< i*j; cout << endl;
74
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
}
U liniji sa ispisom (cout << setw(5)<< i*j;) korišten je operator za manipulisanje setw(), koji se koristi
za formatirano ispisivanje. Naime, brojka unutar zagrada (u gornjem primjeru to je broj 5) predstavlja najmanji prostor predviĎen za ispis podataka u izlaznom toku.
Primjer 1: Ispiši prvih 20 prirodnih brojeva, svaki u svom redu.
Na kraju ispiši i vrijednost varijable i nakon izvoĎenja petlje.
Rješenje:
Primjer 2: Ispiši parne brojeve od 20 do 450.
Rješenje:
75
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
Primjer 3: Ispiši sve prirodne brojeve izmeĎu 1 i N, koji su djeljivi sa 3.
Rješenje:
76
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
8.5.Naredba while
Naredba while (naziva se i while petlja) omogućuje ponavljanje neke naredbe sve dok je ispunjen neki uslov. Opšti oblik ove naredbe je:
while (izraz) naredba;
Prvo se izračunava izraz (naziva se i uslov petlje). Ako je rezultat različit od nule tada se izvršava naredba (naziva se i tijelo petlje) i cijeli proces se ponavlja.
U suprotnom, proces se zaustavlja.
Na primjer, ako ţelimo izračunati zbir svih brojeva od 1 do n, upotreba while naredbe ima oblik: i = 1;
sum = 0; while (i <= n)
sum += i++; \\ili {sum = sum + i; i = i + 1;} Tijelo petlje while moţe biti prazno, tj. sa null-naredbom, ali to nije uobičajeno.
Ipak, sljedeći primjer, problem nalaţenja največeg neparnog faktora nekog broja, pokazuje i jedan takav slučaj.
while (n % 2 == 0 && n /= 2)
Ovdje uslov petlje izvršava sve neophodne kalkulacije, tako da nema potrebe za tijelom.
Primjer:Za niz od 5 različitih brojeva ispiši zbir.
77
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
8.6.Naredba do
Naredba do (naziva se i do petlja) je slična naredbi while, osim što se prvo izvršava tijelo petlje, a
zatim se provjerava uslov. Opšti oblik naredbe je:
do naredba;
while (izraz); Prvo se izvršava naredba, a zatim provjerava izraz. Ako je izraz različit od nule cijeli proces se
ponavlja. U suprotnom, petlja se zaustavlja. Naredba do se manje koristi nego while petlja. Obično se koristi kada se tijelo petlje mora izvršiti
najmanje jedanput bez obzira na ispunjenje uslova. Takav primjer je, recimo, ponovljeno unošenje nekog broja u primjeru izračunavanja njegovog kvadrata sve dok se ne unese broj 0:
do {
cin >> n; cout << "Kvadrat broja " << n << " je" << n * n << "\n";
} while (n != 0); Za razliku od while petlje, do petlja se nikada ne koristi sa praznim tijelom prvenstveno zbog jasnoće.
Primjer:Za niz prirodnih brojeva od 1-N ispiši sumu (zbir) neparnih.
78
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
Pitanja za utvrĎivanje: 1. Koja od petlji (for, while, do) se izvršava barem jednom?
2. Koja od petlji je najbolji izbor kada je broj iteracija poznat? 3. Napiši naredbe za sljedeće:
a) provjera da li je broj neparan,
b) provjera da li je broj neparan i negativan, c) dati apsolutnu vrijednost nekog broja.
4. Pretpostavljajući da je n = 20, šta će biti rezultat sljedećeg koda: if (n >= 0)
if (n < 10) cout << "n je malo\n";
else cout << "n je negativno\n";
5. Opiši svrhu tri naredbe unutar for petlje.
6. Tačno ili netačno: inkrementalni izraz unutar for petlje moţe smanjiti varijablu petlje. 7. Blok nekog koda je odvojen .....
8. Koliko puta se izvršava tijelo do petlje? 9. Dati sintaksu naredbe switch!
79
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
9.Funkcije
Funkcije obezbijeĎuju prikladan način pakovanja nekog numeričkog "recepta", koji se moţe koristiti koliko god je to puta potrebno, i predstavljaju okosnicu tehnike proceduralnog programiranja.
Na primjer «Ja ću vam dati jedan broj. Vi trebate tom broju dodati 2 i proizvod pomnoţiti sa datim
brojem» . Slične instrukcije moţete dati i kompjuteru izraţene na nekom programskom jeziku. Tada očekujete
da broj x unesete, da mašina izračuna x + 2, zatim (x + 2) * x. Za dati ulaz x mašina će proizvesti jedinstven izlaz
broj ((x + 2) * x). U matematici, proces koji, za dati ulaz (odreĎenog tipa), proizvodi jedinstven izlaz naziva se funkcija.
Efekt procesa obrade na računaru moţe se posmatrati kao evaluacija funkcija. Zato su funkcije najvaţnija matematička tema u oblasti kompjuterske obrade.
9.1.Definicija
Definicija funkcije se sastoji od dva glavna dijela:
1.zaglavlja ili interfejsa, i 2.tijela funkcije.
Interfejs definiše kako se funkcija moţe koristiti. On se sastoji od tri dijela: Imena. Ovo je, u stvari, jedinstveni identifikator funkcije.
Parametara (ili potpisa). Ovo je niz od nula ili više identifikatora nekog tipa koji se koriste za prosljeĎivanje vrijednosti u i iz funkcije.
Tipa. Ovo specificira tip vrijednosti koji funkcija vraća. Funkcija koja ne vraća nijednu vrijednost
bi trebala da ima tip void. Tijelo funkcije sadrţi računske korake (naredbe) koji čine samu funkciju.Korištenje funkcije se izvodi
njenim pozivanjem. Poziv funkcije se sastoji od imena funkcije, pračenim zagradama za pozivanje (). Unutar ovih zagrada se pojavljuje nula ili više argumenata koji se odvajaju zarezom. Broj argumenata
treba odgovarati broju parametara funkcije. Svaki argument je izraz čiji tip treba odgovarati tipu odgovarajućeg parametra u interfejsu funkcije.
Kada se izvršava poziv funkcije, prvo se računaju argumenti i njihove rezultujuće vrijednosti se pridruţuju odgovarajućim parametrima. Nakon toga se izvršava tijelo funkcije. Na kraju, funkcija vraća
vrijednost poziva (ako isti postoji).
Sljedeći primjer ilustrativno pokazuje definiciju jednostavne funkcije koja izračunava vrijednost stepena cijelog broja na neki cijeli broj.
1 int Stepen (int baza, unsigned int eksponent)
2 { 3 int rezultat = 1;
4 for (int i = 0; i < eksponent; ++i)
5 rezultat *= baza; 6 return rezultat;
7 }
Linija 1 definiše interfejs funkcije. Ona počinje tipom funkcije koji se vraća;u ovom slučaju radi se o cjelobrojnoj vrijednosti, int . Nakon toga je dato ime funkcije, Stepen, a zatim lista njenih parametara.
Funkcija Stepen ima dva parametra (baza i eksponent) koji su tipa int. Pri tome, uzeto je da varijabla eksponent ima samo pozitivne vrijednosti (unsigned int), jer je i funkcija Stepen cjelobrojnog tipa int1.
Sintaksa parametara je slična sintaksi definisanja varijabli, tj. nakon tipa daje se ime parametra, osim
što se parametri ne odvajaju zarezom, kao u:
80
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
int Stepen (int baza, eksponent) // Ovo je pogrešno!
Zagrada { u liniji 2 predstavlja početak tijela funkcije. U liniji 3 definisana je lokalna varijablu rezultat. Stepen varijable baza na varijablu eksponent pomoću for petlje se računa u linijama 4 i 5. Rezultat se
pohranjuje u varijablu rezultat (linija 5). U liniji 6 vraća se vrijednost rezultat kao rezultat funkcije. Zagrada } u liniji 7 predstavlja
kraj tijela funkcije. Naredni primjer pokazuje kako se funkcija poziva (bez definicije funkcije).
Posljedica poziva funkcije je da se vrijednosti argumenata 2 i 8 pridruţuju parametrima baza i eksponent, respektivno, a zatim se računa tijelo funkcije.
1 #include <iostream>
2 using namespace std; 3
4 main(void){ 5 cout << "2 ^ 8= " << Stepen(2,8) << ’\n’;
6 }
Kada se program pokrene daje sljedeći izlaz:
2 ^ 8 = 256
Definisanje gore pomenute funkcije moţe se izvršiti na više načina, kao što ćemo pokazati u narednim primjerima.
Primjer 1. 1 #include <iostream>
2 using namespace std; 3
4 double Stepen (int baza, int eksponent) 5 {
6 double rezultat = 1;
7 8 for (int i = 0; i < eksponent; ++i)
9 rezultat *= baza; 10 return rezultat;
11 } 12
13 main () 14 {
15 int a,b;
16 cout << "Unesi bazu:"; 17 cin >> a;
18 cout << "\nUnesi eksponent:"; 19 cin >> b;
20 cout << a<<"^" <<b<<" = " << Stepen(a,b) << ’\n’; 21 system("PAUSE");
22 }
Vidi se da je funkcija Stepen definisana prije glavnog programa (sve funkcije,koje se koriste u nekom
programu, moraju se definisati prije glavnog programa, dakle prije funkcije main). U ovom slučaju, funkcija ima tip double, tako da moţe da "pokrije" više mogućnosti (veće rezultate, decimalne brojeve
kao rezultat). Poziv funkcije, linija 20, vrši se pomoću Stepen(a,b), pri čemu tipovi oba argumenta a i b, odgovaraju tipovima parametara funkcije baza i eksponent, respektivno.
Primjer 2. Treba napomenuti da se definicija funkcije sastoji od njenog prototipa, tako da je za definisanje
dovoljno ispisati samo njen prototip. Na taj način, kompletna definicija funkcije se moţe dati kasnije,
81
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
kao što je pokazano u narednom primjeru. TakoĎer je moguće izostaviti nazive parametara u definiciji,
ali to
nije preporučljivo.
1 #include <iostream>
2 using namespace std; 3
4 double Stepen (int baza, int eksponent);
5 // deklarisanje funkcije 6
7 /* moguce je funkciju daklarisati i na sljedeci način 8 double Stepen (int, int);
9 */ 10
11 main () 12 {
13 int a,b;
14 cout << "Unesi bazu:"; 15 cin >> a;
16 cout << "\nUnesi eksponent:"; 17 cin >> b;
18 cout << a<<"^" <<b<<" = " << Stepen(a,b) << ’\n’; 19 system("PAUSE");
20 } 21
22 double Stepen (int baza, int eksponent)
23 { 24 double rezultat = 1;
25 26 for (int i = 0; i < eksponent; ++i)
27 rezultat *= baza; 28 return rezultat;
29 }
Dakle, funkcija je definisana u liniji 4, koristeći njen potpis. Vaţno je napomenuti da je u ovom slučaju
neophodno staviti tačka-zarez (;) nakon definisanja, jer linija 4 predstavlja naredbu. Sjetimo se da se nakon definisanja funkcije ne stavlja tačka-zarez nakon zagrade }, koja zatvara tijelo funkcije.
čitava definicija funkcije data je linijama 22-29.
Primjer 3. Radi preglednosti veoma je korisno sakupiti sve funkcije u posebne datoteke, i umjesto njihovog
definisanja u sklopu izvršne datoteke, treba samo pročitati tu datoteku. Na primjer, ako je definicija funkcije Stepen data u datoteci
StepenInt.h,tj.
\\ sadrzaj datoteke StepenInt.h int Stepen (int baza, int eksponent)
{ int rezultat = 1;
for (int i = 0; i < eksponent; ++i) rezultat *= baza;
82
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
return rezultat;
}
onda prethodni program ima oblik:
#include <iostream> #include “StepenInt.h”
using namespace std; main ()
{
int a,b; cout << "Unesi bazu:";
cin >> a; cout << "\nUnesi eksponent:";
cin >> b; cout << a<<"^" <<b<<" = " << Stepen(a,b) << ’\n’;
system("PAUSE"); }
Ovdje treba paziti gdje se datoteka StepenInt.h nalazi. U primjeru koji je dat, ona se nalazi u istom
direktoriju kao i izvršna datoteka. U suprotnom, treba dati tačnu lokaciju iste (eng. path).
9.2.Parametri i argumenti
C++ podrţava dva oblika parametara: vrijednost i referencu. Parametar po vrijednosti prima kopiju vrijednosti argumenata koja im se prenosi. Kao posljedica toga, ako funkcija napravi bilo kakvu
promjenu na parametrima, ovo neće promijeniti vrijednosti argumenata. Na primjer, u programu: #include <iostream>
using namespace std;
void Funkcija (int broj) {
broj = 0; cout << "broj = " << broj << ’\n’;
} int main ()
{ int x = 10;
Funkcija(x);
cout << "x = " << x << ’\n’; system("PAUSE");
return 0; }
kao lokalna varijabla u funkciji. Kada se funkcija pozove i vrijednost x se prenese, varijabla broj primi kopiju vrijednosti varijable x. Kao rezultat toga, iako varijabla broj u funkciji
mijenja vrijednost na 0, to nece utjecati na varijablu x. Program će dati sljedeći izlaz: broj = 0;
x = 10;
Za razliku od parametra po vrijednosti, parametar po referenci prima argumentkoji se prenosi i sve obavlja direktno na njemu. Bilo koja promjena parametra po referenci u samoj funkciji,direktno se
odnosi i na argument, tj. i on se mijenja. Da bismo definisali parametar po referenci, potrebno je dodati simbol & (ampersand) ispred varijable koja je parametar u interfejsu funkcije, tj. u prethodnom
primjeru interfejs funkcije. Funkcija ima oblik:
void Funkcija (int &broj)
83
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
Moguće je simbol & staviti i iza tipa varijable broj, kao u void Funkcija (int& broj),i na programeru je da
odabere način koji mu više odgovara. U principu, vaţno se uvijek drţati istog pravila, ako ni zbog cega
drugog onda zbog preglednosti programa. U kontekstu pozivanja funkcija, a na osnovu prethodno iznesenog, razlikujemo dvije vrste
pridruţivanja: pridruţivanje prema vrijednosti i pridruţivanje prema referenci. U praksi (u pogledu funkcija) se mnogo više koristi pridruţivanje prema vrijednosti.
9.3.Globalne i lokalne varijable
Za sve što se definiše izvan programskog područja (scope) se kaţe da ima globalni karakter. Tako, sve funkcije koje smo do sada koristili predstavljaju globalne funkcije. No, i varijable se mogu definisati u
globalnom području, tj.izvan svih funkcija koje se koriste u programu, uključujući i funkciju main.
Na primjer: int godina = 1994; // globalna varijabla
int Maksimum (int,int); // globalna funkcija int main (void){ // globalna funkcija
//... }
Treba zapamtiti da su globalne varijable automatski inicijalizirane na vrijednost nula. Pošto su globalni entiteti "vidljivi" na svim programskim nivoima, oni moraju biti jedinstveni na nivou
programa. To znači da se globalne varijable ili funkcije na globalnom području ne mogu definisati više
nego jedanput, iako se ime funkcije moţe definisati više puta sve dok su im parametri (njen potpis) jedinstveni . Globalni entiteti su općenito pristupačni bilo gdje u programu.Svaki blok u programu
definiše lokalno područje. Na taj način, tijelo funkcije predstavlja lokalno područje. Parametri funkcije imaju isto područje kao i tijelo funkcije. Varijable koje su definisane unutar lokalnog područja su
vidljive samo u tom području. Lokalno područje moţe da bude ugnijeţdeno, pri cemu unutrašnje područje
poništava vanjsko. Na primjer:
int xyz; // xyz je globalna varijabla void Funkc (int xyz) // xyz je lokalna varijabla
// u tijelu funkcije Funkc {
if (xyz > 0) { double xyz; // xyz je lokalna varijabla u ovom bloku
//... }
}
imamo tri različita područja, od kojih svaki ima različitu varijablu xyz.Općenito, ţivotni vijek varijable je
ograničen na područje iste. Tako, na primjer, globalne varijable traju svo vrijeme izvršenja programa, dok se lokalne varijable kreiraju kada se uĎe u njihovo područje, a uništavaju kada se iz njega
izaĎe. Memorijski prostor za lokalne varijable je rezervisan prije izvršenja programa, dok je memorijski prostor za lokalne varijable alociran "u hodu" u toku izvršenja programa.
Pošto lokalno područje poništava globalno, to lokalne varijable sa istim imenom kao globalne varijable onemogućavaju pristup globalnim varijablama unutar lokalnog područja.
Na primjer, u
int greska; \\globalna varijabla void Greska (int greska) { \\lokalna varijabla
//... }
globalna varijabla greška je, kao što se i očekuje, nepristupačna unutar funkcije. Greska, pošto je poništena lokalnim parametrom greška.Ovaj problem se moţe prevazići korištenjem
unarnog operatora područja (unary scope operator), koji globalni entitet uzima kao argument, kao u primjeru
84
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
int greska; void Greska (int greska) {
//... if (::greska != 0) // odnosi se na globalnu varijablu
// greska //...
}
9.4.Rekurzivne funkcije
Za funkciju koja poziva samu sebe kaţemo da je rekurzivna. Rekurzija je opšta programska metoda
koja se primjenjuje na probleme koji se definišu u odnosu na same sebe. Na primjer, problem računanja faktorijela je primjer rekurzivne funkcije.
Faktorijel je definisan sa: Faktorijel od 0 je 1.
Faktorijel pozitivnog broja n je n puta faktorijel od n-1, tj. n!=n(n-1)! Posljednji dio definicije jasno pokazuje da je faktorijel definisan u odnosu na samog sebe, te se stoga
moţe predstaviti rekurzivnom funkcijom, npr.
int Faktorijel (unsigned int n) { return n == 0 ? 1 : n * Faktorijel(n-1);
} U principu, sve rekurzivne funkcije se mogu napisati koristeći iteracije. Naime, treba imati u vidu da u
slučaju velikog broja poziva funkcija (u primjeru faktorijela je to veliki broj n), dolazi do zauzimanja velikog memorijskog prostora (tzv. runtime stack ), pa je upotreba iteracija bolje rješenje. No, u nekim
slučajevima elegantno i jednostavno rekurzivno rješenje moţe da bude bolja opcija. U slučaju faktorijela, na primjer, iterativna opcija je bolja, pa bi funkcija imala oblik:
int Faktorijel (unsigned int n) {
int rezultat = 1; while (n > 0) rezultat *= n--;
return rezultat; }
Pitanja za utvrĎivanje:
1. Da li funkcija moţe imati više od jednog argumenta? 2. Da li funkcija mora imati return vrijednost?
3. Da li funkcija moţe imati više od jedne return vrijednosti? 4. Da li je moguće da funkcija nema ni argumente ni return vrijednost?
5. Da li funkcija moţe imati i argumente i return vrijednosti? 6. Nakon imena funkcije slijedi .....
7. Tijelo funkcije je odvojeno .... 8. Skup naredbi koji obavlja radnje neke funkcije predstavlja ..... funkcije.
9. Opis funkcije dat jednom naredbom, koja započinje definiciju funkcije,
naziva se .... 10. Tačno ili netačno: kada se argumenti funkcije prenose po vrijednosti,funkcija radi sa originalnim
argumentima iz programa koji poziva funkciju. 11. Varijabla definisana unutar bloka je ’vidljiva’:
a) od tačke definisanja nadalje u programu, b) od tačke definisanja nadalje u funkciji,
c) od tačke definisanja nadalje u bloku, d) u cijeloj funkciji.
85
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
12. Šta znači kada se koriste prazne zagrade () u definiciji funkcije?
13. Koliko vrijednosti se moţe vratiti iz funkcije?
14. Tačno ili netačno: kada funkcija vraća vrijednost, cijeli poziv funkcije se moţe pojaviti na desnoj strani znaka jednakosti i pridruţiti drugoj varijabli.
15. Gdje se specificira tip vrijednosti koji se vraća nekom funkcijom? 16. Kada se argument prenosi po referenci:
a) kreira se varijabla u funkciji da pohrani vrijednost argumenta, b) funkcija ne moţe pristupiti vrijednosti argumenta,
c) kreira se privremena varijabla u programu koji poziva funkciju da pohrani vrijednost argumenta, d) funkcija pristupa originalnoj vrijednosti argumenta u programu koji je poziva.
10.Polja (Arrays)ili nizovi
10.1.Jednodimenzionalni niz
Polje se sastoji od niza objekata (nazivaju se i elementi polja), koji su istog tipa i zauzimaju neprekidan
memorijski prostor. Općenito, samo polje ima simboličko ime, a ne njegovi elementi. Svaki element je
identificiran njegovim indeksom, koji pokazuje poloţaj nekog elementa u polju. Broj elemenata u polju naziva se dimenzija polja.Dimenzija polja je fiksirana i prethodno odreĎena, i ne moţe se promijeniti u
toku izvršenja programa. Polja su pogodna za predstavljanje podataka koji se sastoje od mnogo sličnih, individualnih objekata.
Primjeri za to su lista imena, tabela gradova i njihovih sezonskih temperatura, i slično. Tipovi poput „int“, „double“ i sl.dozvoljavaju predstavljanje samo pojedinačnih vrijednosti.
Često pri rješavanju problema iz stvarnog svijeta trebamo predstaviti skupinu vrijednosti koje su sve istog tipa, na primjer:
Prosječne količine padavina za svaki mjesec
Ocjene svih učenika u razredu
Stanje prodaje za svaki dan u sedmici, itd
U jeziku C++ takve skupine vrijednosti predstavljamo pomoću nizova.Niz je struktura podataka koja omogućava pohranu niza vrijednosti. Vrijednosti su pohranjene u kontinuirani blok memorije. Nizovi
omogućavaju brz (random access) pristup pojedinim elementima.
Kao i varijable, niz moramo deklarirati prije nego ga upotrijebimo. Sintaksa deklaracije niza izgleda ovako:
tip ime_niza [broj_elemenata];
tip moţe biti bilo koji validni tip podatka u C++(npr. int, float...) ime niza je bilo koji validan identifikator u C++
u uglatim zagradama[] se nalazi broj elemenata niza tj. veličina niza (obavezno neka
konstantna vrijednost).
Na primjer: int rezultati [9];
niz rezultati koji se sastoji od 5 elemenata tipa int moţemo grafički predstaviti ovako:
86
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
Svaki element niza je varijabla , odreĎena svojim indeksom. Bilo koja operacija koja se moţe vršiti nad
varijablama običnog tipa, moţe se vršiti i nad individualnim elementima niza.
Indeks se navodi nakon imena niza, u uglatim zagradama: Na primjer:
rezultati [5]= 21; cout<<rezultati [5];
10.2.Deklaracija nizova4
Prilikom deklaracije nizova, unutar uglastih zagrada mora se nalaziti nešto čija je vrijednost
konstantna, poput broja ili konstante deklarirane sa „const“. Tako, ako je „n“ varijabla,deklaracija poput double prosjek[n]; nije dozvoljena, dok je ista deklaracija dozvoljena u slučaju da je „n“
konstanta. S druge strane, kada pristupamo elementima niza, indeks u zagradi moţe biti proizvoljan cjelobrojni aritmetički izraz, tako da je uz pretpostavku da je „n“ cjelobrojna varijabla, sljedeći izraz
potpuno legalan: prosjek [2*n-3] = 13.7;
Nizovi su sloţeni tipovi (non-scalar types) podataka. Kod nizova isključivo pristupamo pojedinačnim elementima, a nikad nizu kao cjelini. Ne moţemo jednom naredbom ispisati čitav niz na ekran, niti
jednom naredbom unijeti cijeli niz sa tastature.
Indeksi niza koji ima n elemenata se kreću od 0 do n-1. Procesiranje bilo kojeg polja obićno uključuje korištenje petlje, koja ide kroz polje od elementa do
elementa. Sljedeći primjer pokazuje funkciju koja računa srednju vrijednost elemenata nekog polja od tri cjelobrojna elementa:
const int velicina = 3; double Srednja (int broj[velicina]) {
double srednja = 0; for (int i = 0; i < velicina; ++i)
srednja += broj[i];
return srednja/velicina; }
10.3.Inicijalizacija niza
Kad deklariramo niz lokalno (npr u funkciji), kao i kod običnih varijabli, elementi niza nemaju nikakvu
precizno odreĎenu vrijednost sve dok se eksplicitno ne izvrši dodjela, bilo pomoću operatora dodjele „=“, bilo pomoću unosa sa tastature.
MeĎutim, kod globalno deklariranih nizova članovi niza se automatski inicijaliziraju nulama.
U oba slučaja ( i lokalno i globalno) pri deklaraciji niza imamo mogućnost dodijeliti inicijalne vrijednsti svakom elementu niza.
Na primjer:
int rezultat [9] = { 16, 2, 77, 40, 1207, 18, 103, 22, 49 };
Još jedan primjer u kojem se dimenzija polja moţe izostaviti je kada je neko polje parametar u nekoj funkciji. Na primjer, funkcija Srednja se moţe napisati na bolji način, ako se postavi da dimenzija polja
nije fiksirana na neku konstantnu vrijednost, nego se doda još jedan parametar, tj. double Srednja (int broj[], int velicina) {
double srednja = 0; for (int i = 0; i < velicina; ++i)
srednja += broj[i]; return srednja/velicina;
}
4 Preuzeto i prilagođeno by Motik, B. and Šribar, J. Demistificirani C++. Element, Zagreb, 2. izdanje
edition, 2001.
87
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
Vidi se da se pomoću definicije int broj[] omogućava veća fleksibilnost dimenzije polja, pa je kompletan
program u tom slučaju:
Sljedeći program predstavlja primjer pomoću kojeg se unosi, sortira i ispisuje neki niz. Pri tome, sortiranje je izvedeno od najvećeg prema najmanjem elementu niza.
1#include <iostream>
2 using namespace std;
3 int main () 4 {
5 // DEFINISANJE 6 int x[10];
7 int y[10]; 8 int i, j, n;
9 // UNOSENJE 10 cout << "Unesite broj clanova polja (<10): ";
11 cin >> n;
12 for (i = 0; i < n; i++) 13 {
14 cout << "Unesite clan br. " << i << ": "; 15 cin >> x[i];
16 y[i] = x[i]; 17 }
18 // SORTIRANJE 19 for (i = 0; i < n-1; i++)
88
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
20 {
21 for (j = i+1; j < n; j++)
22 { 23 if (y[i] < y[j]) swap(y[i],y[j]);
24 } 25 }
26 // STAMPANJE 27 cout << "x:" << ’\t’ << "y:" << endl;
28 for (i = 0; i < n; i++) 29 {
30 cout << x[i] << ’\t’ << y[i] << endl;
31 } 32 }
U ovom primjeru je za zamjenu vrijednosti varijabli korištena funkcija swap (linija 23), mada
programer sam moţe definisati sličnu funkciju. Kao što je ranije rečeno, za pohranjivanje testova se koriste znakovna polja (eng. string). To su, u
stvari, polja čiji elementi imaju tip char. Prilikom inicijalizacije ovakvih polja, sadrţaj se stavlja izmeĎu znaka dvostrukih navoda
. Na primjer:
"char str[] = "VOZDRA";
definiše varijablu str kao niz od sedam (7) karaktera: šest slova i jedan prazan karakter (null-karakter). Završni prazan karakter postavlja kompajler. Zarazliku od toga,
char str[] = {’V’, ’O’, ’Z’, ’D’, ’R’, ’A’}; definiše varijablu str kao niz od 6 elemenata. Treba naglasiti da prethodni primjer nije ispravan, jer
svaki pravilno inicijalizirani niz karaktera mora obavezno da završi null-karakterom. TakoĎer, ovakav način inicijaliziranja je neefikasan u odnosu na prvi.
Osim ovakvog predstavljanja riječi, tj. znakovnih polja, u C++ je ugraĎen i tip string, koji manipuliše
sa znakovnim poljima. S obzirom da se radi o specijalnoj klasi u C++ , što pripada objektno-orijentisanoj paradigmi, ovdje o tome neće biti riječi.
Broj elemenata navednih u vitičastim zagradama mora biti jednak broju elemenata koje smo naveli u uglatim zagradama.
C++ dozvoljava i sljedeće: ukoliko pri inicijalizaciji ostavite uglate zagrade prazne kompjaler će pretpostaviti da je veličina niza jednaka broju vrijednosti navedenih u vitičastim zagradama.
int rezultat [ ] = { 16, 2, 77, 40, 1207, 18, 103, 22, 49 }; Kao i kod ostalih varijabli, vrijednosti elemenata polja se mogu inicijalizirati.U tu svrhu koriste se
zagrade {}, izmeĎu kojih se specificira lista početnih vrijednosti elemenata polja koje su odvojene zarezom. Na primjer,
int broj[3] = {5, 10, 15};
definiše polje broj, i inicijalizira tri elementa ovog polja na vrijednosti 5, 10, 15, respektivno. Ovo je tzv. eksplicitno inicijaliziranje. Kada je broj vrijednosti u inicijalizatoru manji od dimenzije polja, ostali
elementi su inicijalizirani na nulu, kao u slučaju: int broj[3] = {5, 10}; // broj[2] je inicijaliziran na 0
89
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
Kada se koristi potpuni inicijalizator (broj početnih vrijednosti odgovara dimenziji polja), dimenzija
polja postaje suvišna i moţe se izostaviti, tj. broj elemenata je implicitan u inicijalizatoru – implicitna
inicijalizacija. U ovom slučaju inicijalizacija polja broj se moţe izvršiti i na sljedeći način: int broj[] = {5, 10, 15}; // dimenzija nije potrebna
10.4.Pristup elementima niza
Moguće je pristupiti bilo kojem pojedinačnom elementu niza (kao bilo kojoj običnoj varijabli)
jednostavnim navoĎenjem imena niza i indeksa ţeljenog elementa: ime [indeks]
Na primjer, ako ţelite pohraniti vrijednost 75 kao treći elment niza billy moţete napisati sljedeće: rezultati[2] = 77;
a ako ţelite dodijeliti vrijednost trećeg elementa niza varijabli a, moţete pisati: a = rezultati[2];
Primjećujete da je treći elment niza rezultati specificiran sa rezultati[2]. Zašto indeks trećeg elementa ima vrijednost 2?
Prvi element niza ima vrijednost indeksa . Dakle, polje ili niz je najjednostavnija struktura podataka . Niz je uredeni skup koji sadţi odreĎeni
broj elemenata istoga tipa T. S nizom se moţe manipulisati kao sa cjelinom, ali se takoĎer moţe i
pristupati pojedinim njegovim elementima. Nekom se elementu niza pristupa navoĎenjem njegovoga indeksa; pritom vrijeme pristupa
ne ovisi o vrijednosti indeksa. U jezicima C i C++ za pristup i_tom elementu niza a pišemo a[i]. Vaţno je upamtiti da prvi element niza koji sadrţi n elemenata ima indeks 0, a posljednji indeks n-1.
Elementi niza se u memoriji računala pohranjuju u n uzastopno smještenih varijabli odreñenoga tipa T. U znanstvenim i tehničkim primjenama često se pojavljuju velike količine podataka (naprimjer
rezultata raznih mjerenja) koje treba srediti i klasificirati. Najčešće su to nizovi podataka istog tipa (realni ili cijeli brojevi), pa su nizovi prikladne strukture za njihov prikaz.
Vidjeli smo osnovne karakteristike jednodimenzionalnog niza.
Sada ćemo objasniti osnovne elemente upotrebe niza kao parametra funkcije: Navedimo nekoliko primjera:
1. Trebamo naći element niza koji ima maksimalnu vrijednost 2. Neka se bitna svojstva niza statističkih podataka mogu izraziti pomoću nekoliko statističkih
parametara: a) za dani se niz podataka n-1
90
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
Za izračunavanje ćemo koristiti funkcije:
1. za član niza sa maksimalnom vridjenošću funkciju double max(double x[], int velicina) 2. a) za izračunavanje aritmetičke sredine napisati ćemo funkciju koju ćemo nazvati double:
double mean(double x[], int velicina). Navedemo li, pri pozivu funkcije, kao argument naziv neke varijable, njezina se vrijednost pridruţuje
parametru funkcija (barata sa kopijom vanjske varijable). Znamo da se takvo prenošenje argumenta u funkciju naziva poziv po vrijednosti.
Medutim ako bi tako radili sa nizom kao parametrom funkcije trebali bi u funkciju iskopirati
vrijednosti svih njegovih elemenata (kopiranje u novi privremeni niz) što bi nepotrebno produljilo vrijeme izvoñenja programa i gubitak memorijskoga prostora.
Radi toga niz u funkciju prenosimo referencom ali ne kristimo operator adrese & kao kod varijabli. U C i C++ programskom jeziku ime niza „sadrţava“ adresu prvog (sa indeksom 0) člana.
Dakle, parametri funkcije su ime niza i veličina niza. Funkcija za zadatak 1 je:
int max(int x[], int velicina) {
int imax=0;
for (int i=1; i<velicina; i++) if (x[i]>x[imax]) imax=i;
return(imax); }
Poziv funkcije iz glavnog programa biće imax(x, velicina), s time da je int n poznat (definiran kao konstanta).
91
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
10.5.Multidimenzionalna polja(nizovi)
92
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
Polje moţe da ima i više nego jednu dimenziju (dvije, tri, i više). Ipak, organizacija polja u memoriji je
ista kao i prije, tj. neprekidna sekvenca elemenata,pa je percepcija programera nešto drugacija od one
koja se nameće na prvi pogled (kao multidimenzionalna). Na primjer, pretpostavimo da je srednja vrijednost temperatura po godišnjim dobima za tri bosanskohercegovačka grada data tabelom:
Ovo se moţe predstaviti dvodimenzionalnim poljem cijelih brojeva:
int godDobTemp[3][4];
Ovo je u memoriji predstavljeno kao neprekidan niz od 12 elemenata tipa int . Programer, meĎutim, moţe to zamisliti kao tri reda od po 4 elementa u svakom,kao na slici.
Kao i kod jednodimenzionalnih polja (nizova), i ovdje se elementima pristupa preko indeksa. No, neophodan je dodatni indeks za svaku dimenziju.
Na primjer, srednja temperatura u Zenici u toku ljeta, data je elementom godDobTemp[2][1].
Inicijalizacija polja se moţe obaviti pomocu ugnijeţdenog inicijalizatora, kao u:
int godDobTemp[3][4] = { {10, 20, 10, 1},
{13, 21, 12, 3}, {14, 23, 11, 4}
};
Pošto se ovo dvodimenzionalno polje mapira kao jednodimenzionalni niz od 12 elemenata, moguće je koristiti i sljedeći način:
int godDobTemp[3][4] = { 10, 20, 10, 1, 13, 21, 12, 3, 14, 23, 11, 4
};
Ipak, bolja opcija je korištenje ugnijeţdenog inicijalizatora, pošto ne samo da je pregledniji, nego daje i dodatne mogućnosti. Na primjer, ako je samo prvi element svakog reda različit od nule, a ostali su
jednaki nuli, moţemo koristiti:
int godDobTemp[3][4] = {{26}, {24}, {28}};
Također je moguće izostaviti prvu dimenziju (implicitna inicijalizacija), kao u: int godDobTemp[][4] = {
93
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
{10, 20, 10, 1},
{13, 21, 12, 3},
{14, 23, 11, 4} };
Procesiranje multidimenzionalnih polja je slično jednodimenzionalnim, s tim da se moraju koristiti
ugnijeţdene petlje. Sljedeći primjer pokazuje pronalaţenje maksimalnog elementa u dvodimenzionalnom polju iz prethodnih primjera.
#include <iostream> using namespace std;
const int redovi = 3; const int kolone = 4;
int godDobTemp[redovi][kolone] = { {72, 20, 10, 11},
{13, 21, 66, 3}, {14, 56, 11, 4}
};
int najTemp (int temp[redovi][kolone]) {
int najveca = temp[0][0]; for (int i = 0; i < redovi; ++i)
for (int j = 0; j < kolone; ++j) if (temp[i][j] > najveca)
najveca = temp[i][j]; return najveca;
}
main () {
cout << najTemp(godDobTemp) << "\n"; system("PAUSE");
} Napomena: Treba paziti kako se inicijalizira vrijednost kontrolne varijable najveća u prethodnom
primjeru; pravilno je postaviti na prvi član polja,umjesto pretpostaviti neku konačnu vrijednost (na primjer 0).
Primjer 1: Unesi N članova niza X pomoću for petlje te ih zatim ispiši na ekranu računara, takoĎer
petljom for
94
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
#include <cstdlib>
#include <iostream>
using namespace std;
int main()
{
int i,N;
int X[10]; /*deklaracija niza od 10 cijelih brojeva*/
cout<<"Zadaj 0<N<10 = "; /*broj N mora biti manji od 10 jer je
deklariran niz od maksimalno 10 članova*/
cin >>N;
for (i=0;i<N;i++) /*upis članova niza*/
{
cin>>X[i]; /*upis i-tog člana niza*/
}
for (i=0;i<N;i++) /*ispis članova niza for petljom*/
{
cout << X[i]; /*ispis i- tog člana niza*/
cout <<endl; /*ispis praznog retka (end line)*/
}
system ("PAUSE");
return 0;
}
Pitanja za utvrĎivanje 1. Da li neko polje moţe sadrţavati i cijele brojeve, realne brojeve i karaktere?
2. Koji je indeks prvog elementa u nizu?
3. Koji je indeks posljednjeg elementa u nizu? 4. Koja je razlika izmeĎu inicijalizacije i pridruţivanja?
5. Koja su dva načina inicijalizacije polja?
11.Pointeri(Pokazivači)
11.1.Osnovno o pointerima5
5 Preuzeto i obrađeno by Osnove programiranja u C++ -Aleksandar Karač;
95
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
Pointeri (pokazivači) predstavljaju adresu neke memorijske lokacije i omogućuju indirektni način
pristupa podacima u memoriji. Pointer varijabla se definiše pokazivanjem na podatak odreĎenog tipa.
Na primjer,
int *ptr1; // pointer cijelog broja char *prt2; // pointer karaktera
Vrijednost pointera varijable je adresa na koju pokazuje. Na primjer, ako se uzme da je: int num;
možemo pisati: ptr1 = #
Simbol & (ampersand, znak i) je adresni operator; on uzima varijablu kao argument i vraća
memorijsku adresu te varijable. Efekt prethodnog pridruţivanja je da je adresa varijable num pridruţena pointeru ptr1. Na taj način, kaţemo da ptr1 pokazuje na num. Dijagramski prikaz ovog
pridruţivanja datje na slici
Uzimajući da ptr1 pokazuje na num. Izraz: *ptr1
dereferencira ptr1 da bi se dobilo ono na šta on pokazuje, pa je time ekvivalentan num. Simbol * je
operator dereferenciranja; on uzima pointer kao argument i vraća sadrţaj memorijske lokacije na koju pokazuje.
Općenito, tip pointera mora odgovarati tipu podatka na koji taj pointer pokazuje. MeĎutim, pointer tipa
void odgovara bilo kojem tipu. Ovo je veoma korisno pri definisanju pointera koji mogu pokazivati na podatke različitih tipova, ili one podatke kojima tip u početku nije poznat.
Pointer se moţe konvertovati (pomoću cast) u neki drugi tip. Na primjer,
ptr2 = (char*) ptr1; konvertuje ptr1 u pointer karaktera prije nego se pridruţi pointeru ptr2.
Bez obzira na tip, pointeru se moţe pridruţiti vrijednost 0. Ovakav pointer se naziva null-pointer. Null-pointer se koristi za inicijalizaciju pointera, i za obiljeţavanje kraja struktura sa podacima koji se
zasnivaju na pointerima (na primjer, linkovane liste i sl.).
11.2.Dinamička memorija
Pored programskog stoga (eng. stack ), koji se koristi za pohranjivanje globalnih varijabli, te blokova
stogova za pozivanje funkcija, na raspolaganju je i drugi vid memorije, koji se naziva hrpa (eng. heap). Ova memorija se koristi za dinamičko alociranje memorijskih blokova u toku izvršenja programa.
Zbog toga se ova memorija često naziva i dinamička memorija. S druge strane, programski stog se često naziva statička memorija.
Za alociranje i dealociranje memorijskih blokova u hrpi (još se naziva i javna memorija) koriste se dva
operatora. Operator new kao argument uzima tip i alocira memorijski prostor za objekat tog tipa. On vraća pointer na alocirani prostor. Na primjer,
int *ptr = new int; char *str = new char[10];
alociraju prostor za jedan cijeli broj i prostor koji je dovoljno velik da pohrani niz od deset karaktera, respektivno.
Memorija koja se alocira iz hrpe ne ispunjava ista pravila područja definisanosti (eng. scope rules) kao normalne varijable. Na primjer, kada funkcija
Funkcija
96
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
void Funkcija (void) {
char *str = new char[10];
//... }
vraća vrijednost, lokalna varijabla str je uništena, ali memorijski prostor koji pokazuje na str nije. Ovo
posljednje ostaje alocirano sve dok ga programer eksplicitno ne oslobodi. Operator delete se koristi za oslobaĎanje memorijskog prostora koji se alocira pomoću new. On uzima
pointer kao argument i oslobaĎa memorijski prostor na koji taj pointer pokazuje. Na primjer,
delete ptr; // briše neki objekat
delete [] str; // briše niz objekata Ukoliko bi se na niz podataka, koristio prvi pristup, oslobaĎa se prostor samo jednog elementa niza,
tako da je u slučaju nizova uvijek neophodno dodati zagrade [ ], koje treba da to i pokaţu. Ako se operator delete treba primijeniti na pointer koji pokazuje ni na šta drugo no dinamički alocirani objekat
(na primjer varijabla u stogu), moţe doći do ozbiljne greške (tipa runtime). S druge strane, potpuno je
bezazleno primijeniti ovaj operator na null-pointer. Dinamički objekti su veoma korisni za kreiranje podataka koji traju duţe od poziva funkcija koje ih kreiraju. Sljedeći primjer pokazuje jedan takav
slučaj,
gdje se koristi funkcija koja uzima string parametar i vraća kopiju stringa.
1 #include <string> 2 char* CopyOf (const char *str)
3 { 4 char *copy = new char[strlen(str) + 1];
5 strcpy(copy, str); 6 return copy;
7 }
U linija 1, kao što je već poznato, poziva se standardna biblioteka string koja definiše mnoštvo funkcija
za manipulisanje sa stringovima. Funkcija strlen (definisana u string), u liniji 4, daje broj karaktera njenog argumenta (koji je tipa string) do posljednjeg null-karaktera, koji nije uzet u obzir. Kako
nullkarakter nije uključen u brojanje, treba dodati još jedan karakter i alocirati niz karaktera te velicine (sa tim brojem karaktera). Funkcija strcpy, koja je takoĎer definisana u string, kopira drugi argument
na prvi, karakter po karakter, uključujući i posljednji null-karakter. Zbog ograničenih memorijskih resursa, uvijek postoji mogućnost da se dinamička memorija "potroši" u
toku izvršenja programa, naročito ako se alocira veliki prostor, ali se i ne oslobodi. U slučaju da
operator new ne moţe da alocira prostor potrebne veličine, vratiće vrijednost nula. Na programeru je da sebavi ovakvim problemima. Jedna od osnovnih karakteristika jezika C++ , rad
sa iznimkama, daje praktičan primjer šta i kako raditi sa ovim problemima.
11.3.Pointeri i polja
Pointeri i polja su u jeziku C++ povezani. Naime, članovima polja se pristupa preko pointera. Tako na
primjer, naredbom
int cijeliBroj[10]; definišemo jednodimenzionalno polje cijelih brojeva tipa int sa deset članova.Ime varijable cijeliBroj
ima smisao pointera na prvi elemenat polja cijeliBroj[0]. Prilikom pristupa elementima polja, kompajler vrijednost indeksa dodaje pointeru na prvi elemenat, tako da se naredba
int broj = cijeliBroj[3]; prevodi kao
int broj = *(cijeliBroj+3);
97
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
Posljednja naredba se moţe shvatiti kao: uzmi adresu prvog elementa polja,povečaj je za 3, pogledaj
šta se nalazi na toj adresi, te pridruţi tu vrijednost varijabli broj. Dakle, ako imamo definisano polje
int cijeliBroj[] = {1,2,3}; onda imamo sljedeća značenja:
cout << cijeliBroj << endl;
// adresa pocetnog elementa cout << *cijeliBroj << endl;
// vrijednost pocetnog elementa polja cout << &(cijeliBroj[1]) << endl;
// adresa elementa cijeliBroj[1]
cout << (cijeliBroj + 1) << endl; // adresa elementa cijeliBroj[1]
Stoga se elementima polja moţe pristupati i preko pointera i preko indeksa, i na programeru je koji će
pristup koristiti. Ipak, treba naglasiti da se definicijom int cijeliBroj[10];
ne stvara pointer na varijablu cijeliBroj koji pokazuje na polje, nego je cijeliBroj samo sinonim za pointer na prvi elemenat polja. Vrlo slična diskusija se moţe primijeniti i na višedimenzionalna polja, s
obzirom da su u memoriji računara ista predstavljena jednodimenzionalnim poljima.
11.4.Aritmetika sa pointerima
U C++ je moguće neku cjelobrojnu vrijednost dodati i oduzeti od pointera.Programeri često koriste ovu
mogućnost, koja se još naziva i aritmetika sa pointerima. Ova aritmetika, pak, nije ista kao ona sa
cjelobrojnim vrijednostima, jer rezultat zavisi od veličine objekta na koji se pokazuje.
Na primjer,
pretpostavimo da je int predstavljen sa 4 bajta. Ako se uzme da je
char *str = "VOZDRA";
int broj[] = {10, 20, 30, 40};
int *ptr =&broj[0];
str++ će "napredovati" str za jedan karakter char, tj. za jedan bajt, tako da pokazuje na drugi karakter
niza karaktera "VOZDRA", dok će ptr++ "napredovati"ptr za jedan int, tj. 4 bajta, tako da pokazuje na
drugi elemenat niza.
Na osnovu prethodno rečenog slijedi da se elementi niza "VOZDRA" mogu predstaviti i sa *str,
*(str+1), *(str+2), itd.. Na sličan način, elementi niza broj se mogu predstaviti sa
*ptr, *(ptr+1), *(ptr+2) i *(ptr+3).
Još jedan vid aritmetike sa pointerima koji je dozvoljen u C++ je oduzimanje pointera istog tipa.
Na primjer,
int *ptr1 = &broj[1];
int *ptr2 = &broj[3];
int n = ptr2 - ptr1; // n postaje 2
Aritmetika sa pointerima je veoma korisna kada se pristupa elementima nekog niza. Sljedeći primjer
pokazuje funkciju za kopiranje riječi sličnu funkciji strcpy.
98
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
1 void CopyString (char *dest, char *src)
2 {
3 while (*dest++ = *src++) 4 ;
5 }
U liniji 3, uslov petlje pridruţuje sadrţaj src sadrţaju dest, a zatim inkrementalno povecava oba
pointera. Ovaj uslov postaje jednak nuli kada je posljednji null-karakter pointera src kopiran u dest.
Pokazuje se da je varijabla koja predstavlja niz, kao što je to slučaj sa broj sama po sebi adresa prvog
elementa niza koji predstavlja. Stoga se elementima varijable broj moţe pristupiti i preko aritmetike sa
pointerima na broj, tj. broj[i] je ekvivalentno *(broj+i). Razlika izmeĎu broj i ptr je u tome što je broj
konstanta, tako da ne moţe pokazivati ni na šta, dok je ptr varijabla i moţe se iskoristiti da pokazuje
na bilo koji drugi cijeli broj.Sljedeći primjer pokazuje kako funkcija najTemp, koja je pokazana u
prethodnom poglavlju moţe da se poboljša korištenjem aritmetike sa pointerima.
1 int najTemp (const int *temp, const int redovi,
2 const int kolone)
3 { 4 int najveca = 0;
5 for (int i = 0; i < redovi; ++i) 6 for (int j = 0; j < kolone; ++j)
7 if (*(temp + i * kolone + j) > najveca) 8 najveca = *(temp + i * kolone + j);
9 return najveca; 10 }
U ovom slučaju, umjesto da se na funkciju prenosi niz (linija 1), prenosi se int pointer i dva dodatna
parametra koja specificiraju dimenzije niza. Na ovaj način, funkcija nije ograničena na niz odreĎene
duţine. Izraz *(temp+i * kolone+ j) u liniji 8, je ekvivalentan izrazu temp[i][j] koji je korišten u
prethodnom poglavlju.
Funkcija najTemp se moţe dalje pojednostaviti, ako se temp tretira kao jednodimenzionalni niz od
redovi*kolone cijelih brojeva. Ovo je pokazano u sljedećem primjeru.
1 int najTemp (const int *temp, const int redovi,
2 const int kolone) 3 {
4 int najveca = 0; 5 for (int i = 0; i < redovi * kolone; ++i)
6 if (*(temp + i) > najveca)
7 najveca = *(temp + i); 8 return najveca;
9 }
11.5.Funkcijski pointeri6
Pored svega do sada rečenog o pointerima, moguće je uzeti i adresu funkcije i pohraniti je kao pointer
funkcije. Tada se pointer moţe koristiti da indirektno pozove funkciju.
Na primjer,
int (*Uporedi)(const char*, const char*);
6 Preuzeto i obrađeno by Osnove programiranja u C++ -Aleksandar Karač;
99
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
definiše pointer funkciju koja se naziva Uporedi koja moţe zadrţati adresu bilo koje funkcije koja kao
argumente uzima dva konstantna pointera tipa char i vraća cjelobrojnu vrijednost. Takva je, na
primjer, funkcija strcmp, koja sluţi za uporeĎivanje stringova.
Na taj način imamo:
Uporedi = &strcmp; // funkcija Uporedi pokazuje na strcmp
// funkciju
Operator & nije neophodan i moţe se izostaviti:
Uporedi = strcmp; // funkcija Uporedi pokazuje na strcmp
// funkciju
Kao alternativa, moguće je definisati i inicijalizirati pointer odjednom, kao
int (*Uporedi)(const char*, const char*) = strcmp;
Kada se adresa funkcije pridruţuje pointeru funkcije, dva tipa se moraju poklapati. Prethodna definicija
je ispravna jer se prototip funkcije strcmp poklapa
int strcmp(const char*, const char*);
Sa definicijom funkcije Uporedi datom prethodno, strcmp se moţe koristiti direktno, ili indirektno preko
Uporedi. Sljedeća tri poziva su ekvivalentna:
strcmp("Suljo","Mujo"); // direktni poziv
(*Uporedi)("Suljo","Mujo"); // indirektni poziv
Uporedi("Suljo","Mujo"); // indirektni poziv (skraceno)
čest slučaj korištenja pointer funkcije je da se prenese kao argument nekoj drugoj funkciji; obično zbog
toga što posljednja traţi različite oblike prve u različitim okolnostima. Dobar primjer je binarna
pretraţivačka funkcija koja pretraţuje kroz ureĎeni niz stringova. Ova funkcija moţe koristiti funkciju
uporeĎivanja (kao što je strcmp) radi uporeĎivanja stringa koji se traţi i niza stringova. No, ovo ne
mora da bude prigodno za sve slučajeve. Na primjer,strcmp razlikuje mala i velika slova. Ako bismo
ţeljeli da izvršimo pretraţivanje bez razlikovanja malih i velikih slova, onda bismo trebali koristiti drugu
funkciju za uporeĎivanje.
Kao što je pokazano u sljedećem primjeru, postavljajući funkciju uporeĎivanja kao parametar funkcije
pretraţivanja, imamo mogućnost da ih postavimo nezavisno jednu od druge.
1 int BinTrazi (char *podatak, char *tabela[], int n, 2 int (*Uporedi)(const char*, const char*))
3 { 4 int dole = 0;
5 int gore = n - 1; 6 int sred, cmp;
7 while (dole <= gore) { 8 sred = (dole + gore) / 2;
9 if ((cmp = Uporedi(podatak,tabela[sred])) == 0)
10 return sred; // return item index 11 else if (cmp < 0)
12 gore = sred - 1; // pretrazi donji dio 13 else
14 dole = sred + 1; // pretrazi gornji dio 15 }
16 return -1; // nije pronadjeno 17 }
100
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
Linije 1 i 2 predstavljaju potpis funkcije BinTrazi, koja predstavlja poznati algoritam za traţenje kroz
sortiranu listu podataka. Lista traţenja je, u ovom slučaju, tabela koja predstavlja polje stringova sa
dimenzijom n. Podatak koji se traţi je pod imenom podatak. Linija 2 predstavlja pointer funkciju koja
treba da se koristi za uporeĎivanje podatka podatak sa elementima polja.
Algoritam za pretraţivanje započinje u liniji 7 koristeći while petlju, i u svakom koraku opseg
pretraţivanja polovi. Postupak se zaustavlja kada se granice opsega, označene sa dole i gore, poklope,
ili dok se podatak ne naĎe.
Podatak se poredi sa srednjim elementom polja (linija 9), i ako se sa njim poklapa, vraća se indeks
istog (linija 10). Ako je, pak, podatak manji od srednjeg podatka, pretraţivanje se ograničava na donju
polovinu polja (linija 11-12). U suprotnom, pretraţivanje se ograničava na gornju polovinu polja
(linija 13-14).
U slučaju da nije pronaĎen podatak koji se poklapa sa traţenim, funkcija vraća vrijednost ¡1.
Sljedeći primjer pokazuje kako se funkcija BinTrazi moţe pozvati sa strcmp,koji se prenosi kao funkcija
za uporeĎivanje.
char *gradovi[] = {"Doboj","Kakanj","Sarajevo","Zenica"}
cout << BinTrazi("Zenica", gradovi, 4, strcmp) << endl;
Rezultat posljednje naredbe bio bi, naravno, 3.
Pitanja za utvrĎivanje
1. Šta su pointeri ili pokazivači? 2. Koja je razlika u definisanju cjelobrojne varijable i cjelobrojne pointer varijable?
3. Koje je značenje tipa podatka u definiciji pointera? 4. Šta je to null-pointer?
5. Koji operator se koristi da bi se pointer pridruţio adresi neke druge varijable ili konstante? 6. Da li pointer moţe pokazivati na različitu memorijsku lokaciju u različitim vremenskim periodima u
programu?
7. Da li na istu memorijsku lokaciju moţe da pokazuje više od jednog pointera? 8. Šta je rezultat inkrementiranja pointer varijable?
9. Šta je to dinamička memorija? 10. Koja je veza pointera i polja?
11. Šta predstavljaju aritmetičke operacije sa pointerima? 12. Objasni pojam funkcijskih pointera?
12.Datoteke
Ovo poglavlje pokazuje kako se podaci dobiveni pokretanjem nekog programa mogu sačuvati
(pohraniti) na neku datoteku. S obzirom da čuvanje podataka nema svrhu ako tim podacima ne
moţemo da pristupamo, biće objašnjeno i kako pročitati podatke sa neke datoteke.
Datoteka, pri tome, predstavlja skup podataka koji su snimljeni na neku formu trajne memorije (hard
disk, CD-ROM, floppy disk, itd.). Datoteci se pristupa preko njenog imena (filename), u čijem sastavu
se obićno nalazi ekstenzija (dio imena iza tačke), koja označava tip podataka u datoteci (npr. .doc
za Microsoft Word, .xls Microsoft Excel, .cpp za C++ izvornu datoteku, itd.).
101
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
U osnovi, postoje dvije vrste datoteka: tekstualne i binarne. Tekstualne datoteke sadrţe tekst, dok
binarne mogu sadrţavati i kompleksnije vrste podataka, kao što su slike, izvršni programi, baze
podataka, itd. Tekstualnim datotekama je nešto jednostavnije pristupiti, pisati podatke u njih, te čitati
sa
njih. Upravo to je i razlog zbog čega ce se primjeri u ovom poglavlju odnositi samo na njih.
12.1.Standardna biblioteka fstream
U ranijim poglavljima koristili smo standardnu biblioteku iostream (io se odnosi na input/output), koja
pored ostalog, daje mogućnost ispisivanja na standardni izlaz (ekran, monitor) pomoću cout, te čitanje
sa standardnog upisa (tastatura) pomoću cin. MeĎutim, ova datoteka nam ne omogućava da podatke
trajno sačuvamo. U tu svrhu se koristi standardna biblioteka fstream (f se odnosi na datoteku, tj. file),
koja omogućava pisanje na i čitanje sa datoteka. Ovo se postiţe pozivanjem sadrţaja datoteke fstream
sa:
#include <fstream>
Biblioteka fstream definiše tri nova tipa podataka:
ofstream. Ovaj tip podataka predstavlja tok za izlazne datoteke (o se odnosi na output). Pravac
izlaza je sa programa na datoteku. Ovaj tip podataka se koristi za kreiranje datoteka i pisanje
informacija na njih. Ne može se koristiti za čitanje datoteka.
ifstream. Ovaj tip podataka predstavlja tok za ulazne datoteke (i se odnosi na input). Pravac
ulaza je sa datoteke prema programu. Ovaj tip podataka se koristi za čitanje informacija sa datoteka.
Ne može se koristiti za kreiranje datoteka i pisanje na njih.
fstream. Ovaj tip podataka predstavlja općenito tok za datoteke, ima karakteristike i ofstream i
ifstream objekata. Pomoću ovog tipa, datoteke se mogu kreirati, može se pisati na njih ali i čitati sa
njih.
"Životni" ciklus pristupa datotekama
Kada program pristupa datotekama, bez obzira da li ih čita, ili na njih piše,ili čini oboje, on prolazi kroz
sljedeće korake:
Datoteka prvo mora da se otvori. Ovo otvara put u komunikaciji između datoteke i objekta toka
u programu (fstream, ifstream, ofstream), koji se koristi u pristupu datoteci.
Nakon otvaranja, program čita sa datoteke, piše na nju, ili čini oboje.
Na kraju, program zatvara datoteku. Ovo je bitan korak, pošto održavanje komunikacije između
datoteke i objekta toka zahtijeva resurse, tako da zatvaranje datoteke oslobađa ove resurse kada više
nisu potrebni. Uz to,postoji mogućnost da se kasnije u programu ne može pristupiti datoteci ako
prethodno nije zatvorena.
12.2.Otvaranje datoteka
Bez obzira da li se sadržaj datoteke treba pročitati ili se na datoteku trebaju ispisati neki podaci,
datoteka prvo treba da se otvori. Naredna poglavlja pokazuju kako se to obavlja.
Otvaranje datoteke za pisanje
Datoteke za pisanje se mogu otvoriti pomoću fstream i ofstream objekata na dva načina:
(i) pomoću metode open, ili (ii) pomoću konstruktora (constructor1).
Otvaranje pomoću funkcije open Ovaj način otvaranja datoteke postižemo na sljedeći način:
1 ofstream izlaz; 2 izlaz.open("ucenici.txt");
Prvom linijom je kreiran objekat izlaz tipa ofstream, dok se u drugoj liniji kreira datoteka ucenici.txt.
Kao što se vidi, argument funkcije open je ime i lokacija datoteke koja se treba otvoriti. MeĎutim,
102
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
moguće je dodati i drugi argument zavisno od toga da li je funkcija open član objekta fstream ili
ofstream,
ili se ţeli neki drugi modul od onog koji se daje .
Datoteka u koju ţelimo pisati podatke ne mora postojati. U slučaju da ne postoji, ona će se automatski
kreirati pod imenom i na lokaciji koju smo upisali.
Lokacija se moţe dati kao relativna (relative path) ili apsolutna (absolute path). Pri tome, relativni put
predstavlja lokaciju u odnosu na lokaciju programa, tj.direktorij u kojem se nalazi izvorna datoteka.
Za razliku od relativnog puta, apsolutni put predstavlja lokaciju koja započinje slovom drajva,
sadrţavajući sve direktorije i poddirektorije, dok se ne doĎe do datoteke. Na primjer, ako je datoteka
ucenici.txt u direktoriju Srednja, a ovaj je poddirektorij direktorija Mssbusovaca, a sve se nalazi na
tvrdom disku sa slovom C, onda bi se datoteka otvorila na sljedeći način:
ofstream izlaz;
izlaz.open("C:\\MFZE\\Busovaca\\ucenici.txt");
Vidimo da se u tom slučaju koriste po dva znaka n, jer samo jedan između navodnika predstavlja
escape-sekvencu.
Bez obzira da li koristimo relativni ili apsolutni put, argument za funkciju open ne mora da bude neko
ime (riječ), nego i (string) varijabla, kao što je to u sljedećem primjeru:
ofstream izlaz;
char imeDatoteke[80];
cout << "Unesite ime datoteke: ";
cin >> imeDatoteke;
izlaz.open(imeDatoteke);
Vaţno je zapamtiti da je korištenje relativnog puta bolja opcija, jer se moţe desiti da neki direktorij u
apsolutnom putu ne postoji, naročito ako se program koristi na nekom drugom kompjuteru (sa
drugačijim rasporedom direktorija).
Korištenje drugog argumenta u funkciji open definiše modul u kojem se datoteka treba otvoriti. Neke
od opcija (tzv. file mode flag), koje se mogu koristiti date su u Tabeli:
Ako, na primjer, ţelimo da konstantno dodajemo neke podatke u datoteku
log, koristimo opciju ios::app, tj.
ofstream izlaz;
izlaz.open("log", ios::app);
Kada za otvaranje datoteke koristimo ofstream objekat, onda ne moramo koristiti dodatne argumente,
ali treba zapamtiti da u tom slučaju moţemo samo upisivati informaciju na datoteku, ali ne i čitati sa
nje.
103
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
MeĎutim, ako se za otvaranje datoteke za pisanje koristi fstream objekat, treba dodati još jedan
argument, tj. opcija za pisanje ios::out. U ovom slučaju imamo:
fstream izlaz;
izlaz.open("ucenici.txt", ios::out);
Otvaranje pomoću konstruktor
Konstruktori su funkcije koje se automatski pozivaju kada se pokušava kreirati primjerak (eng.
instance) nekog objekta (primjerak je prema objektu isto što i varijabla prema tipu podatka). Oni mogu
biti opterečeni (eng. overloaded), tako da isti objekat moţe imati konstruktor sa nijednim, jednim, dva,
ili više argumenata. U prethodnim primjerima (npr. fstream izlaz;) korištene su naredbe sa
konstruktorima bez argumenata.
Naredni primjeri pokazuju upotrebu konstruktora sa jednim i dva argumenta, respektivno:
ofstream izlaz("ucenici.txt");
fstream izlaz("ucenicii.txt",ios::out);
Prvi slučaj zamijenjuje izraz:
ofstream izlaz;
izlaz.open("ucenici.txt");
a drugi
fstream izlaz;
izlaz.open("ucenici.txt", ios::out);
Primjena konstruktora, u stvari, omogućava definisanje i inicijalizaciju primjerka nekog objekta. Kao i u
slučaju definisanja (deklarisanja) i inicijalizacije varijabli, korištenje jednog od načina otvaranja
datoteke zavisi od samog programa i naših potreba.
Otvaranje datoteka za čitanje
Sve što je rečeno u prethodnom poglavlju moţe se primijeniti i na otvaranje datoteka za čitanje. Jedina
razlika je što se, uz korištenje objekta fstream, umjesto objekta ofstream koristi ifstream objekat. Uz
to, datoteka sa koje se čita mora postojati, jer se pokretanjem jednog od prethodnih objekata datoteka
ne kreira.
Analogno diskusiji o otvaranju datoteka za pisanje, otvaranje datoteke za čitanje se moţe otvoriti na
jedan od sljedećih načina:
1) pomoću ifstream objekta
ifstream ulaz;
ulaz.open("ucenici.txt");
2) pomoću fstream objekta
fstream ulaz;
ulaz.open("ucenici.txt", ios::in); //obavezno dodati argument ios::in
3) pomoću konstruktora
ifstream ulaz("ucenici.txt");
fstream ulaz("ucenici.txt", ios::in);
Otvaranje datoteka za čitanje i pisanje
Kao što je ranije rečeno, objekat fstream se moţe koristiti za otvaranje datoteka i za pisanje i za
čitanje. U tu svrhu koristi se sljedeća sintaksa:
fstream izlazUlaz;
izlazUlaz.open("ucenici.txt", ios::in | ios::out);
ili pomoću konstruktora:
104
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
fstream izlazUlaz("ucenici.txt", ios::in | ios::out);
U oba primjera korišten je bitovni operator i, |,
Provjera da li je datoteka otvorena.
Prije nego počnemo čitati podatke sa neke datoteke, korisno je znati da li ona uopšte postoji. Provjera
se moţe izvršiti na dva načina. Ako se datoteka ne moţe otvoriti za čitanje, onda je:
(i) vrijednost ifstream objekta jednaka NULL (nula),
(ii) vrijednost funkcije fail objekta ifstream je true(1). Sljedeći primjer ilustruje korištenje oba načina.
#include <fstream>
#include <iostream> using namespace std;
int main (){ ifstream ulaz;
ulaz.open("ucenici.txt"); cout << "(ulaz) = " << ulaz << endl;
cout << "(ulaz.fail()) = " << ulaz.fail() << endl; return 0;
}
Ako datoteka ucenici.txt ne postoji nakon izvršenja programa dobijamo:
(ulaz) = 0
(ulaz.fail()) = 1
U slučaju da postoji, izlaz je, na primjer:
(ulaz) = 0x22fed4
(ulaz.fail()) = 0
pri čemu 0x22fed4 predstavlja memorijsku lokaciju (adresu) ifstream varijable ulaz.
105
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
Za razliku od ifstream objekta, ofstream objekat koji pokušava otvoriti datoteku koja ne još postoji nije
NULL, a njegova fail funkcija ima vrijednost false(0). To je zbog toga što operativni sistem kreira
datoteku, ako ona ne postoji. Ipak, i u ovom slučaju je korisno provjeriti da li datoteka postoji.
Naime, ako datoteka postoji, ali ima osobinu read-only2, dobićemo negativan odgovor o njenom
postojanju (vrijednost iostream objekta je NULL, a funkcije fail je true, tj. 1).
12.3.Zatvaranje datoteka
Svaka otvorena datoteka se treba zatvoriti prije nego se napusti program. To je zbog toga što svaka
otvorena datoteka zahtijeva sistemske resurse. Osim toga, neki operativni sistemi imaju ograničenje
na broj otvorenih datoteka sa kojima se ne "manipuliše".
Zatvranje datoteka se vrši pomoću funkcije close. Sljedeći primjeri pokazuju njenu upotrebu pri
zatvaranju datoteka za pisanje i čitanje:
ofstream izlaz;
izlaz.open("ucenici.txt");
// skup naredbi
outfile.close();
106
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
ifstream ulaz;
ulaz.open("ucenici.txt");
// skup naredbi
ulaz.close();
12.4.Pisanje na datoteke
Pisanje podataka na datoteku se izvodi pomoću operatora za ispisivanje (<<),
kao što je to bio slučaj sa ispisivanjem na ekran (cout<<). Jedina razlika je utome što se ovdje koristi
fstream ili ofstrem objekat, a ne cout objekat.
Sljedeći program pokazuje primjer upisivanja podataka na datoteku ucenici.txt:
1 #include <fstream> 2 #include <iostream>
3 using namespace std; 4
5 int main (){
6 char podaci[80]; 7 ofstream izlaz;
8 izlaz.open("ucenici.txt"); 9 cout << "Zapisivanje u datoteku" << endl;
10 cout << "=======================" << endl; 11 cout << "Upisite razred: ";
12 cin.getline(podaci, 80); 13 izlaz << podaci << endl;
14 cout << "Unesite broj ucenika: ";
15 cin >> podaci; 16 cin.ignore();
17 izlaz << podaci << endl; 18 izlaz.close();
19 return 0; 20 }
107
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
U ovom primjeru upis teksta sa tastature je obavljen pomoću funkcijskog člana objekta cin getline()
(linija 12), koji kao prvi argument uzima znakovni niz, a kao drugi duţinu istog. Ovim se tekst koji je
upisan preko tastature,pridruţuje varijabli podaci, koja je data kao niz od 80 elemenata. U liniji
16 korištena je funkcija ignore() (i ovo je funkcijski član klase iostream), koja u ovom obliku (bez
argumenata) ima za cilj da pročita sljedeći karakter pri upisu, ali ga ne pridruţi nijednoj varijabli. To je
zbog toga što nema potrebe za pridruţivanjem karaktera, koji označava novu liniju, koji je ostao pri
čitanju u ulaznom me�uspremniku (eng. input buffer) nekoj varijabli.
Upotrebom drugog argumenta pri otvaranju datoteke za pisanje (ios::app)
moţemo dodavati sadrţaj na postojeću datoteku kao što to pokazuje sljedeći primjer. U ovom primjeru
zapisivanje se prekida nakon unosa znakova ***.
#include <iostream>
108
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
#include <string>
#include <fstream>
using namespace std; int main ()
{ char x[100];
ofstream izlaz; izlaz.open("podaci.txt", ios::app);
while (x != "***") {
cout << "Unesite neki tekst
(za kraj unesite ***):" << endl; cin >> x;
izlaz << x << endl; }
izlaz.close(); }
12.5.Čitanje sa datoteka
Analogno prethodnom poglavlju, čitanje podataka sa datoteka obavlja se pomoću operatora za čitanje
(>>) kao što je to slučaj sa ispisivanjem sa tastature (cin>>). Sljedeći primjer nadopunjava onaj iz
prethodnog dijela, tj. nakon što korisnik upiše informacije na datoteku, program čita iste podatke sa
datoteke i ispisuje ih na ekran.
1 #include <fstream>
2 #include <iostream> 3 using namespace std;
4 5 int main (){
6 char podaci[100];
7 ofstream izlaz; 8 izlaz.open("ucenici.txt");
9 cout << "Upisivanje u datoteku" << endl; 10 cout << "=====================" << endl;
11 cout << "Unesite razred: "; 12 getline(cin,podaci);
13 izlaz << podaci << endl; 14 cout << "Unesite broj ucenika: ";
15 cin >> podaci;
16 cin.ignore(); 17 izlaz << podaci << endl;
18 izlaz.close(); 19
20 ifstream ulaz; 21 cout << "Citanje sa datoteke" << endl;
22 cout << "===================" << endl; 23 ulaz.open("ucenici.txt");
24 getline(ulaz,podaci);
25 cout << podaci << endl; 26 getline(ulaz,podaci);
27 cout << podaci << endl; 28 ulaz.close();
29 return 0;
109
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
30 }
Slično primjeru iz prethodnog dijela, podaci se unose pomoću funkcije getline (linija 13) sa nešto
drugačijom sintaksom. Ovdje pomenuta funkcija (definisana je kao funkcija, a ne funkcijski član) ima
dva argumenta:
prvi tipa iostream (cin), a drugi varijabla podaci. Na sličan način se pomoću iste funkcije podaci čitaju
sa datoteke (linije 23 i 25), pri čemu je prvi član objekat ulaz tipa ifstream.
Prethodni primjer se moţe napisati i na programerski adekvatniji način upotrebom funkcija za čitanje i
pisanje na datoteku.
#include <fstream>
#include <iostream> #include <string>
using namespace std; bool upisiDatoteku (ofstream&, char*);
bool citajDatoteku (ifstream&, char*);
int main (){ char podaci[100];
bool status; ofstream izlaz;
status = upisiDatoteku(izlaz, "ucenici.txt"); if (!status)
{ cout << "Datoteka za ispisivanje se ne moze otvoriti\n";
cout << "Program se zavrsava\n";
system("PAUSE"); return 0;
} else
{ cout << "Pisanje u datoteku" << endl;
cout << "==================" << endl; cout << "Upisite razred: ";
getline(cin, podaci);
izlaz << podaci<< endl; cout << "Unesite broj ucenika: ";
cin >> podaci; cin.ignore();
izlaz << podaci<< endl; izlaz.close();
} ifstream ulaz;
status = citajDatoteku(ulaz, "ucenici.txt");
if (!status) {
cout << "Datoteka za citanje se ne moze otvoriti\n";
cout << "Program se zavrsava\n"; system("PAUSE");
return 0; }
else
{ cout << "Citanje se datoteke" << endl;
110
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
cout << "===================" << endl;
getline(ulaz, podaci);
while(!ulaz.fail()) { cout << podaci << endl;
getline(ulaz, podaci); }
ulaz.close(); }
system("PAUSE"); return 0;
}
bool upisiDatoteku (ofstream& datoteka, char* strDatoteka) {
datoteka.open(strDatoteka); if (datoteka.fail())
return false; else return true;
} bool citajDatoteku (ifstream& datoteka, char* strDatoteka)
{
datoteka.open(strDatoteka); if (datoteka.fail())
return false; else return true;
}
Iz ovog primjera se vidi da se ifstream i ofstream objekti u funkcijama upisiDatoteku i citajDatoteku
prosljeĎuju po referenci, iako nije dna od ovih funkcija ne mijenja sadrţaj datoteke. Razlog leţi u
činjenici da unutrašnje stanje objekta toka moţe promijeniti korištenjem open funkcije, iako se sadrţaj
ne mijenja.
Sukcesivno čitanje
Često puta je potrebno pročitati sve podatke sa neke datoteke, pri čemu unaprijed ne poznajemo
konačan broj informacija (na primjer, proizvoljan broj vrijednosti neke varijable). U tu svrhu se koristi
funkcija eof (od engleske riječi end of file), koja je tačna ukoliko se proĎe posljednja linija u kojoj
postoji
neka informacija. Sljedeći primjer pokazuje upotrebu ove funkcije u problemu čitanja nizova karaktera
(riječi).
#include <iostream>
#include <fstream>
using namespace std; int main ()
{ char podaci[80];
ifstream saDat; saDat.open("podaci.txt");
while(!saDat.eof()) { saDat >> podaci;
cout << podaci << endl;
} saDat.close();
system("PAUSE");
111
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
}
Linije petlja while, omogućavaju sukcesivno čitanje podataka sa datoteke podaci.txt. Kada se doĎe do
posljednje linije sa nekom informacijom, funkcija eof vraća vrijednost true i automatski se izlazi iz
petlje. Na analogan način se mogu čitati podaci rasporeĎeni u kolone.
Pitanja za utvrĎivanje
1. Nabrojati formate datoteka u kojima se mogu pohraniti podaci!
2. Koja standardna datoteka treba da se pozove kada program piše na datoteku ili čita sa nje? 3. Koji od tri objekta iostream, ifstream, fstream, moţe sluţiti i za upis i za ispis na datoteke?
4. U čemu se suština zatvaranja datoteke? 5. Šta je konstruktor?
6. Da li se stream objekti trebaju proslijediti po vrijednosti ili referenci, i zašto?
13.Zbirka Zadataka
13.1.Zadaci pravolinijska struktura
Zadatak 1
Potrebno je izračunati srednju vrijednost po volji izabrana četiri realna broja. Ispis neka bude oblika:
Unesi cetiri realna broja:
Srednja vrijednost brojeva ...., ...., .... i .... je ......
Zadatak 2
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 ....
Zadatak 3
Potrebno je unijeti broj i pridruţiti ga varijabli A. Sadrţaj varijable prvo treba uvećati za 5, pa umanjiti
za 8, na kraju pomnoţiti s 3. Zadatak riješiti upotrebom operatora 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 s 3. Sada A iznosi: ....
Zadatak 4
Zadatak je primjer svoĎenja rezultata na zajednički tip s operandima. Treba izračunati kolicnik dvaju
cijelih brojeva i spremiti ga u realnu varijablu. Ispis neka bude oblika:
Unesi prvi broj:
Unesi drugi broj:
Kolicnik iznosi: ....
Zadatak 5
Zadatak je primjer svoĎenja operanada na zajednički tip. Treba izračunati kolicnik dva broja od kojih je
jedan cijeli, a drugi realan. Rezultat spremiti u cjelobrojnu varijablu kolicnikt. Ispis neka bude oblika:
Unesi prvi broj:
Unesi drugi broj:
Vrijednost izraza a/b= ....
112
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
Sadrzaj varijable kolicnik iznosi: ....
Zadatak 6
Treba unijeti godinu roĎenja neke osobe i tekuću godinu. Računaju se godine starosti osobe. Ispis neka
bude oblika:
Upisi godinu svog rodjenja:
Koja je godina sada?
Sada imas .... godina.
Zadatak 7
Treba izračunati otpor bakrene ţice ako je zadana duzina u metrima i poluprecnik u milimetrima. Ispis
neka bude oblika:
Upisi poluprecnik zice (u mm):
Upisi duzinu zice (u m):
Bakrena zica duzine ... m i presjeka ... mm2 ima otpor ... oma.
Zadatak 8
Tijelu mase m kilograma promijeni se za t sekundi brzina s v1 na v2 m/s. Treba izračunati silu koja je
djelovala na tijelo. Ispis neka bude oblika:
Upisi masu tijela (u kg):
Upisi vrijeme (u s):
Upisi pocetnu brzinu (u m/s):
Upisi konacnu brzinu (u m/s):
Na tijelo je djelovala sila od ... N.
Zadatak 9
Treba unijeti vrijeme u sekundama a zatim izračunati koliko je to sati, minuta i sekundi. Ispis neka
bude oblika:
Upisi vrijeme u sekundama:
... sekundi je ... sati, ... minuta i ... sekundi.
Zadatak 10
Tijelo mase m kilograma pada s visine h metara brzinom v m/s. Kolika je ukupna energija tijela. Ispis
neka bude oblika:
Upisi masu tijela (u kg):
Upisi visinu (u m):
Upisi brzinu (u m/s):
Tijelo ima ... J kineticke energije i ... J potencijalne energije, sto daje ukupnu energiju od ... J.
Zadatak 11
Treba unijeti trocifreni broj a zatim ispisati vrijednost cifre desetice. Ispis neka bude oblika:
Upisi trocifreni broj:
U trocifrenom broju ... na mjestu desetice je cifra ...
Zadatak 12
Na izvor napona U su priključena tri serijski spojena otpornika: R1, R2 i R3. Potrebno je izračunati
ukupni otpor R,snagu struje I i pojedine padove napona na otporima: U1, U2 i U3. Ispis neka bude
oblika:
U (V)=
R1 (om)=
R2 (om)=
R3 (om)=
113
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
Ukupni otpor R iznosi ... oma.
Snaga struje I iznosi ... A.
Pad napona U1 je ... V.
Pad napona U2 je ... V.
Pad napona U3 je ... V.
Zadatak 13
Jedan voz kreće iz mjesta A prema mjestu B brzinom v1 km/h, a drugi, istodobno, u obrnutom smjeru
brzinom v2 km/h. Mjesta A i B su meĎusobno udaljena s kilometara. Izračunati udaljenost od mjesta A
na kome će se vlakovi susresti i trenutak kad će se to dogoditi. Ispis neka bude oblika:
Upisi brzinu prvog voza (u km/h):
Upisi brzinu drugog voz (u km/h):
Upisi udaljenost izmedju dva mjesta (u km):
Susret ce se dogoditi nakon .... km. Preostali dio puta je .... km (vrijedi za prvi voz, za drugi su iznosi
obrnuti).
Vozovi ce se susresti nakon .... sati.
Zadatak 14
Na stolici mase Ms kilograma sjedi čovjek mase Mc kilograma. Koliki je pritisak na tlo ako stolica ima
četiri noge. Presjek svake od noga je kvadrat sa stranicama X centimetara. Ispis neka bude oblika:
Upisi masu stolice u kg:
Upisi masu covjeka u kg:
Unesi vrijednost stranice kvadrata u cm:
Pritisak kojim covjek mase ... kg, koji sjedi na stolici mase ... kg, djeluje na tlo je ... paskala.
Zadatak 15
Poluprečnik Zemlje je 6370 km. Za koje će vrijeme avion obletjeti Zemlju ako leti na visini od h
kilometara brzinom v km/h. Ispis neka bude oblika:
Upisi visinu na kojoj leti avion (u km):
Upisi brzinu kojom leti avion (u km/h):
Avion koji leti brzinom ... km/s, na visini od ... km obletjet ce Zemlju za ... sati.
Zadatak 16
Treba izračunati snagu P koju mora imati električno kuhalo koje za t minuta moţe vodu mase m grama
zagrijati od temperature temp1 do temperature temp2 (temperatura je izraţena u °C). Ispis neka bude
oblika:
Upisi vrijeme (u min):
Upisi masu vode (u gr):
Upisi pocetnu temperaturu (u °C):
Upisi konacnu temperaturu (u °C):
Elektricno kuhalo koje za ... min moze ... grama vode zagrijati sa ...°C na ...°C ima snagu od ... vata.
Zadatak 17
Treba izračunati koliko bi vremena bilo potrebno zvuku da preĎe razmak izmeĎu dva mjesta ako taj isti
razmak svjetlost preĎe za t sekundi. Ispis neka bude oblika:
Upisi vrijeme (u sek):
Svjetlost preĎe razmak izmedju dva mjesta za ... s, a zvuk je sporiji pa mu za isti razmak treba ... s.
13.2.Zadaci struktura grananja
Zadatak 1
Treba unijeti cijeli broj pa provjeriti da li je >=0. Ako nije, treba izračunati apsolutnu vrijednost
unesenog broja. Potom treba provjeriti da li je broj paran. Ako je paran treba izračunati i ispisati
njegovu treću potenciju, a ako nije treba ispisati: Broj je neparan.
114
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
Unesi broj :
Broj ... je paran, a njegova treca potencija iznosi ...
ili
Broj ... je neparan.
Zadatak 2
Treba unijeti dva realna broja pa izračunati i ispisati njihov cjelobrojni kolicnik i ostatak dijeljenja.
Potrebno je načiniti i provjeru. Ako je djelitelj 0 treba ispisati odgovarajuću poruku. Ispis neka bude
oblika:
Upisi djeljenik :
Upisi djelitelj :
... / ... = ... cijelih i ... ostatka.
Provjera: ... * ... + ... = ...
ili
Ne moze se dijeliti sa 0.
Zadatak 3
Treba unijeti koeficijente kvadratne jednačine, pa zavisno o njihovim vrijednostima izračunati i ispisati
rješenja.
Vaţno je provjeriti vrijednost koeficijenta a, ako je a=0, jednačine nije kvadratna.
Treba provjeriti predznak diskriminante jer on odreĎuje hoće li rješenja kvadratne jednačine bit realni
ili kompleksni brojevi. Ispis neka bude oblika:
Upisi koeficijent a:
Upisi koeficijent b:
Upisi koeficijent c:
Rjesenja su realni brojevi:
x1=... i x2=...
ili
Rjesenja su kompleksni brojevi:
z1=...+...i, z2=...-...i
ili
Ako je koeficijent a=0, jednačina nije kvadratna.
Zadatak 4
U pravougli je trouglu poznat ugao alfa (izraţen u stepenima) i kateta a (u cm).Treba izračunati
vrijednost hipotenuze c.
Unesi vrijednost ugla alfa u stepenima:
115
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
Unesi vrijednost katete a:
Ako je vrijednost ugla alfa ... stepeni, a vrijednost katete
a= ... cm, hipotenuza ima vrijednost c= ... cm.
Zadatak 5
Čamac vozi brzinom vc okomito na tok rijeke koja teče brzinom vr. Kojom se brzinom krece čamac u
odnosu na obalu? Za koji ugao će čamac skrenuti sa svoje putanje?
Unesi brzinu camca u m/s:
Unesi brzinu rijeke u m/s:
Ako je brzina rijeke ... m/s a brzina camca ... m/s, camac se u odnosu na obalu krece brzinom ...
m/s.
Camac je skrenuo sa svoje putanje za ... stepeni.
Zadatak 6
Treba unijeti tri realna broja zatim pronaći i ispisati najmanji. Ispis neka bude oblika:
Upisi prvi broj :
Upisi drugi broj :
Upisi treci broj:
Ako se upisu brojevi: ..., ... i ... najmanji od njih je ...
Zadatak 7
Treba unijeti tri realna broja zatim ih ispisati od najmanjeg ka najvećem. Ispis neka bude oblika:
Upisi prvi broj:
Upisi drugi broj:
Upisi treci broj:
Brojevi: ..., ... i ... poredani od najmanjeg ka najvecem: ..., ..., ...
Zadatak 8
Treba izračunati jačinu struje, napon ili otpor, prema odabiru korisnika. Za računanje jačine struje
treba birati 1, za napon 2, a za otpor 3. Ovisno o tome što se ţeli računati treba unijeti odgovarajuće
podatke. Ispis neka bude oblika:
Ohmov zakon
Za računanje jačine struje upiši 1, za računanje napona upiši 2, a za otpor 3:
NPR:
U (V)=...
R (om)=...
Ako je napon ... V, a otpor ... oma, jačina struje iznosi ... ampera
Zadatak 9
Program na osnovu unesenog rednog broja mjeseca ispisuje koliko taj mjesec ima dana. U slučaju
unosa broja koji nije iz raspona od 1 do 12 treba ispisati upozorenje. Ispis neka bude oblika:
Upisi redni broj mjeseca:
... . mjesec ima 31 dan.
ili
... . mjesec ima 30 dana.
ili
116
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
2. mjesec ima 28 dana (ili 29 ako je godina prestupna).
Zadatak 10
Program na osnovu unesenih vrijednosti stranica trougla računa obim ili površinu, po ţelji korisnika. Za
rezultat obima upisuje se 1, a za površinu 2.
Za rezultat obima upisi 1, a za rezultat povrsine 2:
a=
b=
c=
Obim trougla je O= ....
ili
Povrsina trougla je P= ...
Zadatak 11
Program na osnovu unesenog maksimalnog broja bodova koji se moţe ostvariti na testu oblikuje
bodovnu skalu, a zatim na temelju osvojenog broja bodova na testu, ispisuje odgovarajuću ocjenu.
Upisi maksimalni broj bodova na testu: …
Odlican od 89% do 100%: … - … bodova.
Vrlo dobar od 77% do 88%: … - … bodova.
Dobar od 64% do 76%: … - … bodova.
Dovoljan od 51% do 63%: … - … bodova.
Nedovoljan za manje od 50%: … i manje bodova.
Upisi osvojeni broj bodova na testu: …:
… bodova je … %, ocjena je …
Zadatak 12
Treba unijeti prirodni broj pa ga rastaviti na proste faktore. Ispis neka bude oblika:
Upisi broj veci od 0:
... = 1 * ... * ... * ... * ...
Zadaci struktura petlje
Zadatak 1
Potrebno je ispisati brojeve iz raspona od M do N (raspon bira korisnik). Ispis neka bude oblika:
Ispis pocinje od broja:
Ispis zavrsava brojem:
Ispis brojeva od ... do ...:
... ... ... ...
Zadatak 2
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 = ...
...
117
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
...
...
... * 10 = ...
Zadatak 3
Potrebno je ispisati prvih N neparnih brojeva. Ispis neka bude oblika:
Upisi zeljeni broj neparnih brojeva:
Prvih ... neparnih brojeva su: ... ... ... ....
Zadatak 4
Potrebno je sabrati prvih 100 prirodnih brojeva. Ispis neka bude oblika:
Zbir prvih 100 prirodnih brojeva je ...
Zadatak 5
Treba prebrojiti koliko brojeva unutar raspona od M do N ima cifru jedinice vrijednosti 9. Ispis neka
bude oblika:
Raspon pocinje od broja:
Raspon zavrsava brojem:
U rasponu od ... do... ima ... brojeva sa cifrom jedinice vrijednosti 9.
Zadatak 6
Treba provjeriti djeljivost brojeva iz odabranog raspona od M do N sa zadanim brojem B. Ispis neka
bude oblika:
Pocetna vrijednost raspona:
Zavrsna vrijednost raspona:
Provjerava se djeljivost s brojem:
Brojevi djeljivi sa ... iz raspona od ... do ... su:
... ... ... ... ...
Zadatak 7
Potrebno je sabrati sve prirodne trocifrene brojeve. Ispis neka bude oblika:
Zbir svih prirodnih trocifrenih brojeva je ....
Zadatak 8
Potrebno je sabrati N odabranih cijelih brojeva. Ispis neka bude oblika:
Upisi koliko brojeva zelis sabirati:
Upisi broj:
Upisi broj:
.......
.......
Zbir unesenih brojeva je ...
Zadatak 9
Potrebno je sabrati N članova niza :
(1 + 1/2 + 1/3 + 1/4 + 1/5 +....+ 1/N). Ispis neka bude oblika:
Upisi zeljeni broj clanova niza:
Zbir ... clanova ovog niza iznosi ... .
Zadatak 10
Potrebno je ispisati i sabrati sve prirodne brojeve djeljive s 3 iz raspona od 1 do N. Ispis neka bude
oblika:
Upisi zavrsnu vrijednost raspona:
U intervalu od 1 do ... brojevi djeljivi sa 3 su:
.... ... ...
Zbir brojeva djeljivih s 3 iz intervala od 1 do... je ...
Zadatak 11
118
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
Potrebno je prebrojiti i sabrati sve parne prirodne brojeve iz raspona od 1 do N . Ispis neka bude
oblika:
Upisi gornju granicu raspona:
U intervalu od 1 do ... ima ... brojeva djeljivih sa 2. Njihov zbir je ... .
Zadatak 12
Potrebno je provjeriti da li je odabrani prirodni broj prost (prost broj je djeljiv samo sa 1 i sa samim
sobom). Ispis neka bude oblika:
Upisi prirodni broj:
... je/nije prost.
Zadatak 13
Potrebno je provjeriti da li je odabrani prirodni broj savršen (broj je savršen ako je jednak zbiru svih
svojih djelitelja, osim njega samog). Ispis neka bude oblika:
Upisi prirodni broj:
Broj ... je/nije savrsen.
Zadatak 14
Potrebno je ispisati sve savršene prirodne brojeve iz raspona od 1 do 3000. Ispis neka bude oblika:
Savrseni brojevi iz zadanog raspona su ... ... .... ...
Zadatak 15
Potrebno je ispisati sve četverocifrene brojeve čiji je proizvod cifara 100. Ispis neka bude oblika:
Brojevi ciji je proizvod cifara 100 su:... ... ... ...
Zadatak 16
Potrebno je ispisati sve trocifrenee brojeve koji su djeljivi sa 7, a zadnja im je cifra 7. Ispis neka bude
oblika:
Brojevi koji zadovoljavaju uslov su:
... ... ... ...
Zadatak 17
Potrebno je ispisati dekadske ASCII vrijednosti (od 32 do 255) i njihove odgovarajuće znakove.Da bi
ispis bio u pravilnim stupcima, koristi manipulator setw.
Zadatak 18
Potrebno je ispisati tekst "***" u obliku slova V, kao na slici (koristiti manipulator setw(int):
Zadatak 19
Treba unijeti N realnih brojeva pa izračunati njihovu srednju vrijednost. Unos brojeva traje sve dok
korisnik ne upiše 0. Primjer riješiti do-while petljom. Ispis neka bude oblika:
Nakon posljednjeg broja unesi nulu.
Unesi broj:
Unesi broj:
...
Uneseno je ... brojeva. Srednja vrijednost je ....
Zadatak 20
Potrebno je unesenom prirodnom broju ispisati vrijednosti pojedinih cifara počevši od cifre najmanje
teţinske vrijednosti, jednu ispod druge. Ispis neka bude oblika:
Upisi prirodni broj:
Njegove cifre su:
...
119
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
...
...
Zadatak 21
Potrebno je unesenom prirodnom broju sabrati vrijednosti njegovih cifara. Ispis neka bude oblika:
Upisi prirodni broj:
Zbir cifara broja ... je ... .
Zadatak 22
Korisnik unosi prirodne brojeve. Nakon posljednjeg broja unosi 0. Program ispisuje najveći uneseni
broj. Ispis neka bude oblika:
Upisi prirodni broj:
Upisi prirodni broj:
...
Najveci broj je ...
Zadatak 23
Program računa ukupni otpor N otpora spojenih u paralelu. Nakon posljednje vrijednosti otpora unosi
se 0. Ispis neka bude oblika:
Upisi vrijednost otpora u omima:
Upisi vrijednost otpora u omima:
...
Ukupni otpor ... otpora spojenih u paralelu je ... oma.
Zadatak 24
Program računa srednju ocjenu uspjeha učenika. Nakon posljednje ocjene treba unijeti 0. U slučaju da
je bilo koja od ocjena 1, ispisuje se poruka: Negativan uspjeh. Ako se unese vrijednost koja nije iz
raspona od 1-5, ispisat će se poruka: Pogrešan unos. Ispis neka bude oblika:
Srednja ocjena uspjeha je ...
Zadatak 25
Potrebno je ispisati N članova Fibonaccijevog niza. Fibonaccijev niz je niz u kome su prva dva člana
jednaka jedan, a svaki sljedeći član je zbir prethodna dva člana niza (1, 1, 2, 3, 5, 8, 13, 21, 34,
......). Ispis neka bude oblika:
Upisi koliko clanova niza zelis:
Članovi niza: 1, 1, ..., ..., ..., .....
Zadatak 26
Potrebno je izračunati najveću zajedničku mjeru dva prirodna broja. Najveća zajednička mjera dva
broja je najveći prirodni broj kojim su djeljiva oba broja. Ispis neka bude oblika:
Unesi prvi broj:
Unesi drugi broj:
Najveca mjera brojeva ... i ... je ...
Zadatak 27
Potrebno je unijeti odabrani broj cifara počevši od cifre najveće teţinske vrijednosti, pa od njih sastaviti
i ispisati prirodni broj. Unos cifara se prekida kada se unese broj manji od 0 ili veći od 9. Ispis neka
bude oblika:
Upisi cifru:
Upisi cifru:
120
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
Upisi cifru:
...
Broj sastavljen od zadanih cifara je ...
14.Rješenja
Pravolinijska struktura – Rješenje1 #include<iostream>
using namespace std;
int main()
{
float a,b,c,d,srvr;
cout<<"Unesi cetiri realna broja"<<endl;
cin>>a>>b>>c>>d;
srvr=(a+b+c+d)/4;
cout<<endl<<"Srednja vrijednost brojeva:";
cout<<endl<<a<<", "<<b<<", "<<c<<" i "<<d<<" je "<<srvr<<endl;
system("PAUSE");return 0;
}
Pravolinijska struktura – Rješenje 2 #include<iostream>
using namespace std;
int main()
121
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
{
int a;
cout<<"Unesi broj:";
cin>>a;
cout<<endl<<"Kada se broju "<<a<<" promijeni predznak, on postaje
"<<-a<<endl;
system("PAUSE"); return 0;
}
Pravolinijska struktura - Rješenje3 #include<iostream>
using namespace std;
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;}
Pravolinijska struktura - Rješenje4 #include<iostream>
using namespace std;
int main()
{
int a,b;
float kolicnik;
cout<<"Unesi prvi broj:";
cin>>a;
cout<<"unesi drugi broj:";
cin>>b;
kolicnik=a/b;
cout<<"kolicnik iznosi:"<<kolicnik<<endl;
system("PAUSE");return 0;
}
Pravolinijska struktura - Rješenje5 #include<iostream>
using namespace std;
int main()
{
int a,kolicnik;
float b;
122
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
cout<<"Unesi prvi broj:";
cin>>a;
cout<<"unesi drugi broj:";
cin>>b;
kolicnik=a/b;
cout<<"Vrijednost izraza a/b= "<<a/b<<endl;
cout<<"Sadrzaj varijable kolicnik iznosi:"<<kolicnik<<endl;
system("PAUSE");return 0;
}
Pravolinijska struktura - Rješenje6 #include<iostream>
using namespace std;
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;
}
Pravolinijska struktura - Rješenje7 #include<iostream>
using namespace std;
int main()
{
float precnik,l,r,s,otpor;
const double PI=3.14;
const double ro=0.0175;
cout<<"Upisi precnik zice (u mm):";
cin>>precnik;
cout<<endl<<"Upisi duzinu zice (u m):";
cin>>l;
r=precnik/2;
s=r*r*PI;
otpor=ro*l/s;
cout<<endl<<"Bakrena zica duzine "<<l<<" m i presjeka " <<s<<" mm2
ima otpor";
cout<<otpor<<" oma."<<endl;
system("PAUSE");return 0;
}
123
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
Pravolinijska struktura - Rješenje8 #include<iostream>
using namespace std;
int main()
{
float m,t,v1,v2,a,F;
cout<<"Upisi masu tijela (u kg):";
cin>>m;
cout<<"Upisi vrijeme (u s):";
cin>>t;
cout<<"Upisi pocetnu brzinu (u m/s):";
cin>>v1;
cout<<"Upisi konacnu brzinu (u m/s):";
cin>>v2;
a=(v2-v1)/t;
F=m*a;
cout<<endl<<"Na tijelo je djelovala sila od "<<F<<" N."<<endl;
system("PAUSE");return 0;
}
Pravolinijska struktura - Rješenje9 #include<iostream>
using namespace std;
int main()
{
int s, sek, min, sat, ostatak;
cout<<"Upisi vrijeme u sekundama:";
cin>>s;
sat=s/3600;
ostatak=s%3600;
min=ostatak/60;
sek=ostatak%60;
cout<<s<<" sekundi je "<<sat<<" sati, "<<min<<" minuta i "<<sek<<"
sekundi."<<endl; system("PAUSE");
return 0;
}
124
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
Pravolinijska struktura - Zadatak10 #include<iostream>
using namespace std;
int main()
{
const double g=9.81;
float m,h,v,Ep,Ek,Euk;
cout<<"Upisi masu tijela (u kg):";
cin>>m;
cout<<"Upisi visinu (u m):";
cin>>h;
cout<<"Upisi brzinu (u m/s):";
cin>>v;
Ep=m*g*h;
Ek=m*v*v/2;
Euk=Ep+Ek;
cout<<endl<<"Tijelo ima "<<Ek<<" J kineticke energije i "<<Ep;
cout<<" J potencijalne energije,sto daje ukupnu energiju od "<<Euk
<<" J."<<endl;
return 0;
}
Pravolinijska struktura - Rješenje12 #include<iostream>
using namespace std;
int main()
{
float U,R1,R2,R3,R,I;
cout<<"U (V)= ";
cin>>U;
cout<<endl<<"R1 (om)= ";
cin>>R1;
cout<<endl<<"R2 (om)= ";
cin>>R2;
cout<<endl<<"R3 (om)= ";
cin>>R3;
R=R1+R2+R3;
I=U/R;
cout<<endl<<"Ukupni otpor R iznosi "<<R<<" oma."<<endl;
cout<<endl<<"Jakost struje I iznosi "<<I<<" A."<<endl;
cout<<endl<<"Pad napona U1 je "<<I*R1<<" V."<<endl;
cout<<"Pad napona U2 je "<<I*R2<<"V."<<endl;
cout<<"Pad napona U3 je "<<I*R3<<"V."<<endl;
return 0;
}
Pravolinijska struktura - Rješenje13
125
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
#include<iostream>
using namespace std;
int main()
{
float v1, v2, udaljenost;
float put1, put2, vrijeme;
cout<<"Upisi brzinu prvog voza (u km/h):";
cin>>v1;
cout<<"Upisi brzinu drugog voza (u km/h):";
cin>>v2;
cout<<"Upisi udaljenost izmedju dva mjesta (u km):";
cin>>udaljenost; //put1/brzina1=put2/brzina2
//udaljenost=put1+put2
put1=udaljenost*v1/(v1+v2);
put2=udaljenost-put1;
vrijeme=put1/v1;
cout<<"Susret ce se dogoditi nakon "<<put1;
cout<<" km. Preostali dio puta je "<<put2;
cout<<" km (vrijedi za prvi voz, za drugi su iznosi
obrnuti)."<<endl;
cout<<"Vozovi ce se susresti nakon "<<vrijeme<<" sati."<<endl;
system("PAUSE");return 0;}
Pravolinijska struktura - Rješenje14 #include<iostream>
using namespace std;
int main()
{
float Mc,Ms,Gs,Gc,X,F,S,s1,p;
const double g=9.81;
cout<<"Upisi masu stolice u kg:";
cin>>Ms;
cout<<"Upisi masu covjeka u kg:";
cin>>Mc;
cout<<"Unesi iznos stranice kvadrata u cm:";
cin>>X;
Gs=Ms*g;
Gc=Mc*g; //ukupna sila koja djeluje na pod
F=Gs+Gc; //povrsina presjeka jedne noge stolice
s1=X*X; //ukupna povrsina na koju djeluje sila
S=4*s1;
S=S/10000; //pretvaranje cm2 u m2
p=F/S; //pritisak u paskalima
cout<<"Pritisak kojim covjek mase "<<Mc<<" kg, koji sjedi na stolici
mase "<<Ms;
cout<<" kg, djeluje na pod je "<<p<<"paskala";
system("PAUSE");return 0;
}
126
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
Pravolinijska struktura - Rješenje15 #include<iostream>
using namespace std;
int main()
{
float h,v, Ruk,O,vrijeme;
const double R=6370; //konstanta je izrazena u km
const double PI=3.14;
cout<<"Upisi visinu na kojoj leti avion (u km):";
cin>>h;
cout<<"Upisi brzinu kojom leti avion(u km/h):";
cin>>v; //Zbir poluprecnika zemlje i visine
Ruk=R+h; //Racunanje puta (obim kruga)
O=2*Ruk*PI; //t=s/v, jednoliko gibanje
vrijeme=O/v;
cout<<"Avion koji leti brzinom "<<v<<"km/h, na visini od "<<h;
cout<<" km obletjet ce Zemlju za"<<vrijeme<<" sati."<<endl;
system("PAUSE");return 0;
}
127
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
Pravolinijska struktura - Rješenje16 #include<iostream>
using namespace std;
int main()
{
float tmin,m,temp1,temp2,ts,DT,M,Q,P;
const double c=4186;
//konstanta je izrazena u J/(kg*K)
cout<<"Upisi vrijeme (u min):";
cin>>tmin;
cout<<"Upisi masu vode (u gr):";
cin>>m;
cout<<"Upisi pocetnu temperaturu (u °C):";
cin>>temp1;
cout<<"Upisi konacnu temperaturu (u °C):";
cin>>temp2;
DT=temp2-temp1; //vrijeme treba pretvoriti u sekunde
ts=tmin*60; //masu treba pretvoriti u kg
M=m/1000; //racuna se toplotna energija
Q=M*c*DT; //racuna se snaga
P=Q/ts;
cout<<"Elektricno kuhalo koje za "<<tmin<<" min moze "<<m;
cout<<" grama vode zagrijati sa "<<temp1<<"stepeni C na "<<temp2;
cout<<"stepeni C ima snagu od "<<P<<" vata."<<endl;
system("PAUSE");return 0;
}
Pravolinijska struktura - Rješenje17 #include<iostream>
using namespace std;
int main()
{
float t,s,tz;
const double c=3e+8;
const double v=340;
cout<<"Upisi vrijeme (u sek):";
cin>>t; //racunanje puta
s=c*t;
tz=s/v;
cout<<"Svjetlost prevali razmak izmedju dva mjesta za "<<t;
cout<<" s, a zvuk je sporiji pa mu za isti razmak treba "<<tz<<"
sekundi."<<endl; system("PAUSE");
return 0;
}
Struktura grananja - Rješenje1
128
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
#include <iostream>
#include <cmath>
using namespace std;
int main ()
{
int i,rez;
cout<<"Unesi broj:";
cin>>i;
if (i<0)
{
i=abs(i);
}
if (i%2==0)
{
rez=pow(i,3);
cout<<"Broj "<<i<<" je paran, a njegova treca potencija
iznosi"<<rez<<endl;
}
else
{
cout<<"Broj "<<i<<" je neparan."<<endl;
} system("PAUSE");
return 0;
}
Struktura grananja - Rješenje2 #include<iostream>
#include<cmath >
using namespace std;
int main()
{
float a,b,ost,rez;
cout<<"Upisi djeljenik:";
cin>>a;
cout<<"Upisi djelitelj:";
cin>>b;
if (b==0)
cout<<"Ne moze se dijeliti sa 0. ";
else
{
rez=a/b;
rez=floor(rez);
ost=fmod(a,b);
cout<<endl<<a<<"/"<<b<<"="<<rez<<" cijelih i " <<ost<<"
ostatka.";
cout<<endl<<"Provjera: "<<rez<<"*"<<b<<"+"<<ost
<<"="<<rez*b+ost<<endl;
} system("PAUSE");
129
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
return 0;
}
Struktura grananja - Rjeešenje3 #include<iostream>
#include<cmath>
using namespace std;
int main()
{
float a,b,c,x1,x2,pom1,xR,xi;
cout<<"Upisi koeficijent a:";
cin>>a;
cout<<"Upisi koeficijent b:";
cin>>b;
cout<<"Upisi koeficijent c:";
cin>>c;
if (a!=0)
{
pom1=b*b-4*a*c;
if (pom1>=0)
{
x1=(-b+sqrt(pom1))/(2*a);
x2=(-b-sqrt(pom1))/(2*a);
cout<<"Rjesenja su realni brojevi x1= "<<x1<<" i
x2="<<x2<<endl;
}
else
{
xR=-b/(2*a);
xi=sqrt(-pom1)/(2*a);
cout<<"Rjesenja su kompleksni brojevi:";
cout<<endl<<"z1="<<xR<<"+"<<xi<<"i, z2= "<<xR<<"-
"<<xi<<"i"<<endl;
}
}
else
{
cout<<"Ako je koeficijent a=0,jednadzba nije
kvadratna"<<endl;
} system("PAUSE");
return 0;
}
Struktura grananja - Rješenje4
#include<iostream>
130
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
#include<cmath>
using namespace std;
int main()
{
float ugaoalfa,a,c,ugaoalfa1;
const float PI=3.14;
cout<<"Unesi vrijednost ugla alfa u stepenima: ";
cin>>ugaoalfa;
cout<<"Unesi vrijednost katete a: ";
cin>>a;
ugaoalfa1=ugaoalfa*PI/180;
c=a/sin(ugaoalfa1);
cout<<endl<<"Ako je vrijednost ugla alfa " <<ugaoalfa;
cout<<" stepeni, a vrijednost katete a="<<a;
cout<<" cm, hipotenuza ima vrijednost c="<<c<<" cm."<<endl;
system("PAUSE");return 0;
}
Struktura grananja - Rješenje5 #include<iostream>
#include<cmath>
using namespace std;
int main()
{
float vc,vr,v,ugao;
const double PI=3.14159265;
cout<<"Unesi brzinu camca u m/s: ";
cin>>vc;
cout<<"Unesi brzinu rijeke u m/s: ";
cin>>vr;
v=sqrt(pow(vc,2)+pow(vr,2));
ugao=atan(vr/vc);
ugao=ugao*180/PI;
cout<<endl<<"Ako je brzina rijeke "<<vr<<" m/s, a brzina camca
"<<vc;
cout<<" m/s camac se u odnosu na obalu giba brzinom "<<v<<"
m/s."<<endl;
131
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
cout<<endl<<"Camac je skrenuo sa svoje putanje za "<<ugao<<"
Stepeni."<<endl; system("PAUSE");
return 0;
}
Struktura grananja - Rješenje6 #include<iostream>
using namespace std;
int main()
{
float a,b,c,min;
cout<<"Upisi prvi broj:";
cin>>a;
cout<<"Upisi drugi broj:";
cin>>b;
cout<<"Upisi treci broj:";
cin>>c;
min=a;
if (b<min)
{
min=b;
}
if (c<min)
{
min=c;
}
cout<<"Ako se upisu brojevi: "<<a<<", " <<b<<" i "<<c<<" najmanji
od njih je "<<min; system("PAUSE");
return 0;
}
Struktura grananja Rješenje 7 #include<iostream>
using namespace std;
int main()
{
132
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
float a,b,c,min,mid,max;
cout<<"Upisi prvi broj:";
cin>>a;
cout<<"Upisi drugi broj:";
cin>>b;
cout<<"Upisi treci broj:";
cin>>c;
min=a;
if (b<min)
{
min=b;
}
if (c<min)
{
min=c;
}
max=a;
if (b>max)
{
max=b;
}
if (c>max)
{
max=c;
}
mid=a;
if ((b!=max)&&(b!=min))
{
mid=b;
}
if ((c!=max)&&(c!=min))
{
mid=c;
}
cout<<"Brojevi: "<<a<<", "<<b<<" i "<<c<<" poredani od
najmanjeg ka najvecem:";
cout<<endl<<min<<", "<<mid<<", "<<max<<endl;
133
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
system("PAUSE");return 0;
}
Struktura grananja - Rješenje8
#include <iostream>
using namespace std;
int main ()
{
cout<<"Omov zakon"<<endl;
cout<<"Za racunanje jacine struje upisi 1, za racunanje napona upisi
2, a za otpor 3: ";
int i;
float U,I,R;
cin>>i;
switch (i)
{
case 1:
cout<<"U (V)=";
cin>>U;
cout<<"R (om)=";
cin>>R;
I=U/R;
cout<<"Ako je napon "<<U<<" V, a otpor "<<R<<" oma, jacina
struje iznosi ";
cout<<I<<" A."<<endl;
break;
case 2:
cout<<"I (A)=";
cin>>I;
cout<<"R (om)=";
cin>>R;
U=I*R;
cout<<"Ako je jacina struje "<<I<<" A, a otpor "<<R<<"
oma, napon iznosi ";
cout<<U<<" V."<<endl;
break;
case 3:
134
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
cout<<"U (V)=";
cin>>U;
cout<<"I (A)=";
cin>>I;
R=U/I;
cout<<"Ako je napon "<<U<<" V, a jacina struje iznosi ";
cout<<I<<" A, otpor iznosi "<<R<<" oma."<<endl;
break;
default:
cout<<"Pogresan unos. Treba upisati 1, 2 ili 3.";
}
system("PAUSE");return 0;
}
Struktura grananja - Rješenje9 #include<iostream>
using namespace std;
int main()
{
int i;
cout<<" Program na osnovu unesenog rednog broja mjeseca
ispisuje";
cout<<" koliko taj mjesec ima dana"<<endl;
cout<<"Upisi redni broj mjeseca: ";
cin>>i;
switch (i)
{
case 4:
case 6:
case 9:
case 11:
cout<<i<<". mjesec ima 30 dana."<<endl;
break;
case 1:
case 3:
case 5:
case 7:
135
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
case 8:
case 10:
case 12:
cout<<i<<". mjesec ima 31 dan."<<endl;
break;
case 2:
cout<<i<<". mjesec ima 28 dana (ili 29 ako
je godina prestupna).";
break;
default:
cout<<"Pogresan unos.";
cout<<" Redni broj mjeseca moze biti iz raspona
od 1 do 12.";
} system("PAUSE");
return 0;
}
Struktura grananja - Rješenje10
#include<iostream>
#include<cmath>
using namespace std;
int main()
{
cout<<"Program na osnovu unesenih vrijednosti stranica
trougla racuna ";
cout<<" obim ili povrsinu, ovisno o zelji korisnika"<<endl;
float a,b,c,o,p,p1,pov;
int i;
cout<<"Za racunanje obima upisi 1, a za povrsinu 2:";
cin>>i;
cout<<"a = ";
cin>>a;
cout<<"b = ";
cin>>b;
cout<<"c = ";
cin>>c;
if((a<=0)||(b<=0)||(c<=0))
136
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
{
cout<<"Vrijednost stranice trougla ne moze biti
<=0 " <<endl;
goto kraj;
}
if((a+b<=c)||(b+c<=a)||(c+a<=b))
{
cout<<" Unesene vrijednosti nisu stranice
trougla." <<endl;
goto kraj;
}
switch(i)
{
case 1:
o=a+b+c;
cout<<"Obim trougla je O= "<<o<<endl;
break;
case 2:
cout<<"Povrsina se racuna po Heronovoj formuli";
p=(a+b+c)/2;
p1=p*((p-a)*(p-b)*(p-c));
pov=sqrt(p1);
cout<<" Povrsina trougla je P= "<<pov<<endl;
break;
default:
cout<<" Pogresan unos. Valja unijeti 1 ili 2! "
<<endl;
} system("PAUSE");
kraj:return 0;
}
Struktura grananja - Rješenje11 #include<iostream>
#include<iomanip>
#include<cmath>
using namespace std;
int main()
137
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
{
float p,i,b, po;
cout<<"Program na osnovu osvojenog broja bodova na testu,
ispisuje ";
cout<<" odgovarajucu ocjenu."<<endl;
upis:cout<<"Upisi maksimalni broj bodova na testu: ";
cin>>i;
if (i<=0)
goto upis;
p=i/100;
cout<<endl<<setw(35)<<"Odlican od 89% do 100%: ";
cout<<floor(89*p)<<" - "<<i<<" bodova."<<endl;
cout<<setw(35)<<"Vrlo dobar od 77% do 88%: ";
cout<<floor(77*p)<<" - "<<floor(88*p)<<" bodova."<<endl;
cout<<setw(35)<<"Dobar od 64% do 76%: ";
cout<<floor(64*p) <<" - "<<floor(76*p)<<" bodova."<<endl;
cout<<setw(35)<<"Dovoljan od 51% do 63%: ";
cout<<floor(51*p)<<" - "<<floor(63*p)<<" bodova."<<endl;
cout<<setw(35)<<"Nedovoljan za manje od 50%: ";
cout<<floor(50*p)<<" i manje bodova."<<endl;
upis2:cout<<endl<<endl<<"Upisi osvojeni broj bodova na testu: ";
cin>>b;
if (b<0 || b>i)
{
cout<<"Neispravan unos, ponovi.";
goto upis2;
}
po=b/p;
if (po>=0 && po<=50)
cout<<b<<" bodova je "<<po<<" %, ocjena
nedovoljan." <<endl;
else if (po<=63)
cout<<b<<" bodova je "<<po<<" %, ocjena
138
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
dovoljan." <<endl;
else if (po<=76)
cout<<b<<" bodova je "<<po<<" %, ocjena dobar."
<<endl;
else if (po<=88)
cout<<b<<" bodova je "<<po<<" %, ocjena vrlo
dobar. " <<endl;
else
cout<<b<<" bodova je "<<po<<" %, ocjena odlican.
" <<endl; system("PAUSE");
return 0;
}
Struktura grananja - Rješenje12 #include<iostream>
#include <iostream>
using namespace std;
int main()
{
int br, prbr;
cout<<"Rastavljanje broja na proste faktore";
unos:cout<<"Upisi broj veci od 0:";
cin>>br;
if(br<=0)
{
cout<<"Treba unijeti broj veci od 0" <<endl;
goto unos;
}
else
{
prbr=2;
cout<<br<<" = 1";
dj2:if(br==1)
139
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
{
goto kraj;
}
else
{
dj1:if(br%prbr==0)
{
cout<<" * "<<prbr;
br=br/prbr;
goto dj2;
}
else
{
prbr=prbr+1;
goto dj1;
}
}
}
kraj:cout<<endl; system("PAUSE");
return 0;
}
Struktura petlje - Rješenje1
#include<iostream>
using namespace std;
int main()
{ int brojac,m,n;
cout<<"ispis pocinje od broja:";
cin>>m;
cout<<"ispis zavrsava brojem:";
140
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
cin>>n;
for (brojac=m;brojac<=n;brojac++)
{
cout<<brojac<<" ";
}
cout<<endl;
system("PAUSE"); return 0;
}
Struktura petlje - Rješenje2
#include<iostream>
using namespace std;
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;
}
Struktura petlje - Rješenje3
#include<iostream>
#include<cmath>
using namespace std;
int main()
{
float a,b,c,x1,x2,pom1,xR,xi;
cout<<"Upisi koeficijent a:";
cin>>a;
cout<<"Upisi koeficijent b:";
cin>>b;
cout<<"Upisi koeficijent c:";
cin>>c;
if (a!=0)
{
pom1=b*b-4*a*c;
if (pom1>=0)
{
x1=(-b+sqrt(pom1))/(2*a);
141
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
x2=(-b-sqrt(pom1))/(2*a);
cout<<"Rjesenja su realni brojevi x1= "<<x1<<" i x2="<<x2<<endl;
}
else
{
xR=-b/(2*a);
xi=sqrt(-pom1)/(2*a);
cout<<"Rjesenja su kompleksni brojevi:";
cout<<endl<<"z1="<<xR<<"+"<<xi<<"i, z2= "<<xR<<"-"<<xi<<"i"<<endl;
}
}
else
{
cout<<"Ako je koeficijent a=0,jednadzba nije kvadratna"<<endl;
} system("PAUSE"); return 0;}
Struktura petlje - Rješenje4
#include<iostream>
using namespace std;
int main()
{
int brojac,zbrir;
zbir=0;
cout<<"Zbir prvih 100 prirodnih brojeva je:";
for (brojac=1;brojac<=100;brojac++)
{
zbir=zbir+brojac;
}
cout<<zbir<<endl;
system(“Pause“);
return 0;
}
142
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
Struktura petlje - Rješenje5
#include<iostream>
#include<cmath>
using namespace std;
int main()
{
float vc,vr,v,ugao;
const double PI=3.14159265;
cout<<"Unesi brzinu camca u m/s: ";
cin>>vc;
cout<<"Unesi brzinu rijeke u m/s: ";
cin>>vr;
v=sqrt(pow(vc,2)+pow(vr,2));
ugao=atan(vr/vc);
ugao=ugao*180/PI;
cout<<endl<<"Ako je brzina rijeke "<<vr<<" m/s, a brzina camca "<<vc;
cout<<" m/s camac se u odnosu na obalu kreće brzinom "<<v<<" m/s."<<endl;
cout<<endl<<"Camac je skrenuo sa svoje putanje za "<<ugao<<" stepeni."<<endl;
system("PAUSE"); return 0;
}
Struktura petlje - Rješenje6
#include<iostream>
using namespace std;
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;
cout<<" do "<<n<<" su:"<<endl;
for (brojac=m;brojac<=n;brojac++)
{
if(brojac%b==0)
cout<<brojac<<" ";
}
cout<<endl; system("PAUSE");
143
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
return 0;
}
Struktura petlje - Rješenje7
#include<iostream>
using namespace std;
int main()
{
int brojac,zbir;
cout<<"Program sabira sve prirodne trocifrene brojeve."<<endl;
zbir=0;
for(brojac=100;brojac<=999;brojac++)
{
zbir=zbir+brojac;
}
cout<<"Zbir svih prirodnih trocifreni brojeva je "<<zbir<<endl; system("PAUSE");
return 0;
}
Struktura petlje - Rješenje8
#include<iostream>
using namespace std;
int main()
{
int broj,brojac,zbir,N;
zbir=0;
cout<<"Upisi koliko brojeva zelis sabirati: ";
cin>>N;
for (brojac=1;brojac<=N;brojac++)
{
cout<<"Upisi broj: ";
cin>>broj;
zbir=zbir+broj;
}
cout<<"Zbir unesenih brojeva je "<<zbir<<endl; system("PAUSE");
return 0;
}
Struktura petlje - Rješenje9
#include <iostream>
using namespace std;
int main()
{
float zbir,brojac,N;
144
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
cout<<endl<<"Upisi zeljeni broj clanova niza: ";
cin>>N;
zbir=0;
for(brojac=1;brojac<=N;brojac++)
{
zbir=zbir+1/brojac;
}
cout<<"Zbir "<<N<<" clanova ovog niza iznosi " <<zbir <<endl;
system("PAUSE"); return 0;
}
Struktura petlje - Rješenje10
#include<iostream>
using namespace std;
int main()
{
int N,zbir,brojac;
cout<<"Upisi zavrsnu vrijednost raspona:";
cin>>N;
zbir=0;
cout<<"U intervalu od 1 do "<<N<<" brojevi djeljivi sa 3 su: " <<endl;
for(brojac=1;brojac<=N;brojac++)
{
if(brojac%3==0)
{
zbir=zbir+brojac;
cout<<brojac<<" ";
}
}
cout<<"Zbir brojeva djeljivih sa 3 iz \ intervala od 1 do "<<N<<" je"<<zbir;
system("PAUSE"); return 0;
}
Struktura petlje - Rješenje11
#include<iostream>
using namespace std;
int main()
{
int broj,brojac,N;
broj=0;
cout<<"Upisi gornju granicu raspona: ";
cin>>N;
for(brojac=1;brojac<=N;brojac++)
{
if(brojac%2==0)
broj=broj+1;
145
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
}
cout<<"U intervalu od 1 do "<<N<<" ima "<<broj<<" parnih brojeva "<<endl;
system("PAUSE");return 0;
}
Struktura petlje - Rješenje12 #include<iostream>
using namespace std;
int main()
{
int brojac,N;
cout<<"Upisi prirodni broj: ";
cin>>N;
for (brojac=2;brojac<=(N-1);brojac++)
{
if(N%brojac==0)
{
cout<<"Broj "<<N<<" nije prost."<<endl;
goto kraj;
}
}
cout<<"Broj "<<N<<" je prost."<<endl;
kraj:return 0;
}
Struktura petlje - Rješenje13
#include<iostream>
using namespace std;
int main()
{
int brojac,zbir,N;
cout<<"Upisi prirodni broj: ";
cin>>N;
zbir=0;
for (brojac=1;brojac<=(N-1);brojac++)
{
if(N%brojac==0)
{
zbir=zbir+brojac;
}
}
if(zbir==N)
cout<<"Broj "<<N<<" je savrsen."<<endl;
else
cout<<"Broj "<<N<<" nije savrsen."<<endl; system("PAUSE");
return 0;
146
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
}
Struktura petlje - Rješenje14
#include<iostream>
using namespace std;
int main()
{
int br,brojac,zbir;
cout<<"Savrseni brojevi su: ";
for(br=1;br<=3000;br++)
{
zbir=0;
for (brojac=1;brojac<=(br-1);brojac++)
{
if(br%brojac==0)
zbir=zbir+brojac;
}
if(zbir==br)
cout<<br<<" ";
} system("PAUSE");
return 0;
}
Struktura petlje - Zadatak15
#include<iostream>
using namespace std;
int main()
{
int i,pom,j,d,s,t;
cout<<"Brojevi ciji je proizvod cifara 100 su: ";
for(i=1000;i<=9999;i++)
{
pom=i;
j=pom%10;
d=(pom/10)%10;
s=(pom/100)%10;
t=(pom/1000)%10;
if(j*d*s*t==100)
cout<<endl<<i;
} system("PAUSE");
return 0;
}
Struktura petlje - Rješenje16
#include<iostream>
147
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
using namespace std;
int main()
{
int i;
cout<<"Brojevi koji zadovoljavaju uslov su: ";
for(i=100;i<=999;i++)
{
if((i%10==7)&&(i%7==0))
{
cout<<endl<<i;
}
} system("PAUSE");
return 0;
}
Struktura petlje - Rješenje17
#include<iostream>
#include<iomanip>
using namespace std;
int main()
{
int znak,red,stupac;
znak=32;
for(red=1;red<=45;red++)
{
for(stupac=1;stupac<=5;stupac++)
{
cout<<setw(10)<<znak<<" = "<<char(znak);
znak=znak+1;
}
cout<<endl;
} system("PAUSE");
return 0;
}
Struktura petlje - Rješenje18
#include<iostream>
#include<iomanip>
using namespace std;
int main()
{
int i,s,p;
s=10;
p=40;
for(i=1;i<=10;i++)
{
148
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
cout<<setw(s)<<"***"<<setw(p)<<"***"<<endl;
s=s+2;
p=p-4;
} system("PAUSE");
return 0;
}
Struktura petlje - Rješenje19
#include<iostream>
using namespace std;
int main()
{
int br,b;
cout<<"Upisi prirodni broj: ";
cin>>b;
br=0;
do
{
b=b/10;
br=br+1;
}
while(b>0);
cout<<"Broj cifara: "<<br<<endl; system("PAUSE");
return 0;
}
Struktura petlje - Rješenje20
#include<iostream>
using namespace std;
int main()
{
int b,i;
upis:cout<<"Upisi prirodni broj: ";
cin>>b;
if (b<=0)
goto upis;
while(b>0)
{
i=b%10;
cout<<endl<<i;
b=b/10;
}
cout<<endl; system("PAUSE");
return 0;
}
149
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
Struktura petlje - Rješenje21
#include<iostream>
using namespace std;
int main()
{
int b,i,s,br;
s=0;
cout<<"Upisi prirodni broj: ";
upis:cin>>b;
if(b<0)
{
cout<<"Upisi prirodni broj"<<endl;
goto upis;
}
br=b;
while(b>0)
{
i=b%10;
s=s+i;
b=b/10;
}
cout<<"Zbir cifara broja "<<br<<" je "<<s<<endl; system("PAUSE");
return 0;
}
Struktura petlje - Rješenje22
#include<iostream>
using namespace std;
int main()
{
int b,max;
upis:cout<<endl<<"Upisi prirodni broj: ";
cin>>b;
if (b<=0)
goto upis;
max=b;
while(b>0)
{
if(b>max)
{
max=b;
}
cout<<"Upisi prirodni broj: ";
150
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
cin>>b;
}
cout<<endl<<"Najveci broj je: "<<max<<endl; system("PAUSE");
return 0;
}
Struktura petlje - Rješenje23
#include<iostream>
using namespace std;
int main()
{
float R,br,Ruk1,Ruk;
cout<<"Nakon posljednje vrijednosti otpora unijeti 0" <<endl;
br=0;
Ruk1=0;
upis:cout<<"Upisi vrijednost otpora u omima: ";
cin>>R;
if(R<0)
{
cout<<"Vrijednost otpora mora biti >0."<<endl;
goto upis;
}
while(R>0)
{
br=br+1;
Ruk1=Ruk1+1/R;
cout<<"Upisi vrijednost otpora u omima: ";
cin>>R;
}
Ruk=1/Ruk1;
cout<<"Ukupni otpor "<<br<<" otpora spojenih u paralelu je "<<Ruk<<" oma.";
system("PAUSE");
return 0;
}
Struktura petlje - Rješenje24
#include<iostream>
using namespace std;
int main()
{
cout<<"Program racuna srednju ocjenu uspjeha ucenika."<<endl;
cout<<"Nakon posljednje ocjene unosi se 0."<<endl;
float b,suma,br;
suma=0;
151
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
br=0;
do
{
cout<<"Unesi ocjenu: ";
cin>>b;
if(b==1)
{
cout<<"Negativan uspjeh."<<endl;
goto kraj;
}
else if(b<0)
{
cout<<"Pogresan unos."<<endl;
goto kraj;
}
else
{
suma=suma+b;
br=br+1;
}
}
while(b>0);
br=br-1;
cout<<"Srednja ocjena uspjeha je " <<suma/br<<endl; system("PAUSE");
kraj:return 0;
}
Struktura petlje - Rješenje25
#include<iostream>
using namespace std;
int main()
{
int prvi,drugi,treci,brojac,N;
cout<<"Program ispisuje N clanova Fibonaccijevog niza."<<endl;
prvi=1;
drugi=1;
upis:cout<<"Upisi koliko clanova niza zelis: ";
cin>>N;
if(N<2)
{
cout<<"Broj clanova niza mora biti veci ili jednak 2"<<endl;
goto upis;
}
cout<<prvi<<" "<<drugi;
for(brojac=3;brojac<=N;brojac++)
{
152
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
treci=prvi+drugi;
cout<<" "<<treci;
prvi=drugi;
drugi=treci;
}
cout<<endl; system("PAUSE");
return 0;
}
Struktura petlje - Rješenje26
#include<iostream>
using namespace std;
int main()
{
int A,B,manji,br,mjera;
unos:cout<<"Unesi prvi broj: ";
cin>>A;
cout<<"Unesi drugi broj:";
cin>>B;
if((A<=0)||(B<=0))
{
cout<<"Treba unijeti brojeve vece od 0"<<endl;
goto unos;
}
mjera=1;
if(A<B)
{
manji=A;
}
manji=B;
for(br=2;br<=manji;br++)
{
if((A%br==0)&&(B%br==0))
mjera=br;
}
cout<<"Najveca mjera brojeva "<<A<<" i "<<B<<" je "<<mjera<<endl; system("PAUSE");
return 0;
}
Struktura petlje - Rješenje27
#include<iostream>
using namespace std;
int main()
{
cout<<"Program na osnovu unesenih cifara Sastavlja i ispisuje prirodni broj."; <
int ci,br;
153
C+
+ p
rogra
mir
an
je z
a s
red
nje
šk
ole
pro
f.S
ma
jo M
ek
ić
br=0;
cout<<endl<<"Upisi cifru: ";
cin>>ci;
while((ci>=0)&&(ci<=9))
{
br=br*10+ci;
cout<<"Upisi cifru: ";
cin>>ci;
}
cout<<"Broj sastavljen od zadanih cifara je " <<br<<endl; system("PAUSE");
return 0;
}
LITERATURA
Efikasno programiranje na jeziku C++/Praktični primjeri/-Andrew Koenig,Barbara E.Moo,
Predavanja sa FIT-a Mostar/Uvod u programiranje/Programiranje 1 i 2,
Osnove programiranja u C++ -Aleksandar Karač;
Uvod u programiranje dr.Senad Rahimić;
C++ za apsolutene početnike
Motik, B. and Šribar, J. Demistificirani C++. Element, Zagreb, 2. izdanje
edition, 2001.
Stroustrup, B. The C++ Programming Language. Addison-Wesley, 3.izdanje edition, 2000.
Hekmat, S. C++ Programming. Pragmatix Software Pty. Ltd., 2005.
Recommended
