C++ 1. Programski
jezici...........................................................................................................................................2
1.1. Proceduralno i objektno orjentisano
programiranje...............................................................................2
1.2.
Program.................................................................................................................................................3
2. Razvojno okruenje Borland turbo
C++........................................................................................................5
2.1. Koritenje razvojnog okruenja Borland
C++.........................................................................................5
2.2. Prvi
program...........................................................................................................................................6
3. Struktura
programa.......................................................................................................................................8
3.1.
Komentari...............................................................................................................................................8
3.2. Deklaracija
promjenljivih.........................................................................................................................8
3.3. Funkcija
main.........................................................................................................................................9
3.4. Dodjela vrijednosti
promjenljivim............................................................................................................9
3.5. Naredbe cout i
cin..................................................................................................................................9
Vjebe..........................................................................................................................................................9
4. Standarni
ulaz/izlaz.....................................................................................................................................11
4.1.
cout......................................................................................................................................................11
4.2.
cin.........................................................................................................................................................13
Vjebe:.......................................................................................................................................................13
5. Deklaracija
promjenljivih.............................................................................................................................16
5.1. Imenovanje
promjenljivih......................................................................................................................16
5.2. Tipovi
podataka....................................................................................................................................16
5.2.1.
Brojevi............................................................................................................................................17
Vjebe........................................................................................................................................................18
5.2.2.
Znakovi..........................................................................................................................................22
5.2.3. Logiki tip
podataka.......................................................................................................................22
5.2.4. Pobrojani
tip...................................................................................................................................22
5.2.5.
Konstante......................................................................................................................................23
6.
Operatori.....................................................................................................................................................24
6.1. Aritmetiki operatori
............................................................................................................................24
6.1.1. Unarni
operatori.............................................................................................................................24
6.1.2. Binarni
operatori............................................................................................................................25
6.1.3. Mijeanje tipova promjenljivih u brojnim
izrazima..........................................................................26
6.1.4. Operator dodjele tipa
....................................................................................................................27
6.1.5. Problem
prekoraenja....................................................................................................................27
6.2. Logiki
operatori..................................................................................................................................28
6.3. Pogodbeni (relacioni) operatori
...........................................................................................................28
6.4. Hijerarhija i redoslijed izvoenja operatora
..........................................................................................29
7. Naredbe za kontrolu toka programa
...........................................................................................................30
7.1. Grananje toka naredbom if
..................................................................................................................30
7.2. Uslovni operator ? :
.............................................................................................................................36
7.3. Grananje toka naredbom
switch...........................................................................................................36
8. Iskazi
ponavljanja.......................................................................................................................................41
8.1. Iskaz
WHILE........................................................................................................................................41
8.2. Iskaz
DO..............................................................................................................................................41
8.3. Iskaz
FOR............................................................................................................................................41
8.4. Iskaz
CONTINUE.................................................................................................................................42
8.5. Iskaz
BREAK........................................................................................................................................43
8.6. Iskaz GOTO
.......................................................................................................................................43
8.7. Iskaz
RETURN.....................................................................................................................................44
8.8.
Vjebe:.................................................................................................................................................44
1
C++
1. PROGRAMSKI JEZICIPrvi raunari bila su vrlo sloeni za
koritenje. Njih su koristili iskljuivo strunjaci koji su bili
osposobljeni za komunikaciju s raunarom. Ta komunikacija se
sastojala od dva osnovna koraka: davanje instrukcija raunaru i
itanje rezultata obrade. I dok se itanje rezultata vrlo brzo uinilo
koliko-toliko snoljivim uvoenjem tampaa na kojima su se rezultati
ispisivali, unoenje instrukcija - programiranje - se sastojalo od
mukotrpnog unosa niza nula i jedinica. Ti nizovi su davali raunaru
upute kao to su: "saberi dva broja", "premjesti podatak s neke
memorijske lokacije na drugu", "skoi na neku instrukciju izvan
normalnog slijeda instrukcija" i slino. Programski jezici koji su
omoguavali ovu komunikaciju nazivaju se mainski programski jezici.
Kako je takve programe bilo vrlo sloeno pisati, a jo sloenije itati
i ispravljati, ubrzo su se pojavili prvi programerski alati nazvani
asembleri (engl. assemblers). U asemblerskom jeziku svaka mainska
instrukcija predstavljena je mnemonikom koji je razumljiv ljudima
koji itaju program. Tako se sabiranje npr. obavlja mnemonikom ADD,
dok se premjetanje podataka obavlja mnemonikom MOV. Time se
postigla bolja itljivost programa, no i dalje je bilo vrlo sloeno
pisati programe i ispravljati ih jer je bilo potrebno davati sve,
pa i najmanje instrukcije raunaru za svaku pojedinu operaciju.
Javlja se problem koji e kasnije, nakon niza godina, dovesti i do
pojave C++ programskog jezika: potrebno je razviti programerski
alat koji e osloboditi programera rutinskih poslova te mu dopustiti
da se usredotoi na problem koji rjeava. Zbog toga se pojavljuje niz
viih programska jezika, koji preuzimaju na sebe neke "dosadne"
programerske poslove. Tako je FORTRAN bio posebno pogodan za
matematike proraune, zatim BASIC koji se vrlo brzo uio, te COBOL
koji je bio u pravilu namijenjen upravljanju bazama podataka. Oko
1972. se pojavljuje jezik C, koji je direktna pretea dananjeg
jezika C++. To je bio prvi jezik opte namjene te je postigao nevien
uspjeh. Vie je razloga tome: jezik je bio jednostavan za uenje,
omoguavao je modularno pisanje programa, sadravao je samo naredbe
koje se mogu jednostavno prevesti u mainski jezik, davao je brzi
kd. Jezik je omoguavao vrlo dobru kontrolu mainskih resursa te je
na taj nain omoguio programerima da optimiziraju svoj kd. Do
unatrag nekoliko godina, 99% komercijalnih programa bili su pisani
u C-u, ponegdje dopunjeni odsjecima u mainskom jeziku kako bi se
kritini dijelovi uinili dovoljno brzima. No kako je razvoj
programske podrke napredovao, stvari su se i na podruju programskih
jezika poele mijenjati. Sloeni projekti od nekoliko stotina
hiljada, pa i vie redova vie nisu rijetkost, pa je zbog toga bilo
potrebno uvesti dodatne mehanizme kojima bi se takvi programi
uinili jednostavnijima za izradu i odravanje, te kojima bi se
omoguilo da se jednom napisani kd iskoristi u vie razliitih
projekata.
1.1.
Proceduralno i objektno orjentisano programiranje
Proceduralno programiranje se zasniva na posmatranju programa
kao niza jednostavnih programskih cjelina: procedura. Svaka
procedura je konstruisana tako da obavlja jedan manji zadatak, a
cijeli se program sastoji od niza procedura koje meusobno sudjeluju
u rjeavanju zadatka. Princip kojim bismo mogli obiljeiti
proceduralno strukturirani model jest podijeli-pa-vladaj:
cjelokupni program je presloen da bi ga se moglo razumjeti pa se
zbog toga on rastavlja na niz manjih zadataka procedura - koje su
dovoljno jednostavne da bi se mogle izraziti pomou naredbi
programskog jezika. Pri tome, pojedina procedura takoer ne mora
biti rijeena monolitno: ona moe svoj posao obaviti kombinirajui rad
niza drugih procedura. Npr. pretpostavimo da treba napisati program
za nalaenje korijena kvadratne jednaine. Ovaj problem mogli bismo
rijeiti u slijedeim koracima: 1. Unesi vrijednosti a,b,c 2.
Izraunaj diskriminantu 3. U ovisnosti o vrijednosti diskriminante,
izracunaj korijene 4. Odtampaj korijene
2
C++ Ovakav programski pristup je bio vrlo uspjean do kasnih
osamdesetih, kada su njegovi nedostaci postajali sve oitiji.
Pokazalo se sloenim istodobno razmiljati o problemu i odmah
strukturirati rjeenje. Umjesto rjeavanja problema, programeri su
mnogo vremena provodili pronalazei naine da programe usklade sa
zadanom strukturom. Takoer, dananji programi se pokreu pomou mia,
prozora, menija i dijaloga. Programiranje je voeno dogaajima (engl.
event-driven) za razliku od starog, sekvencijalnog naina.
Proceduralni programi su korisniku u pojedinom trenutku prikazivali
niz ekrana nudei mu pojedine opcije u odreenom redoslijedu. No
voeno dogaajima znai da se program ne odvija po unaprijed odreenom
slijedu, ve se programom upravlja pomou niza dogaaja. Dogaaja ima
raznih: pomicanje mia, pritisak na tipku, izbor stavke iz menija i
slino. Sada su sve opcije dostupne istovremeno, a program postaje
interaktivan, to znai da promptno odgovara na korisnikove zahtjeve
i odmah (ovo ipak treba uvjetno shvatiti) prikazuje rezultat svoje
akcije na monitoru raunara. Kako bi se takvi zahtjevi jednostavnije
proveli u praksi, razvijen je objektni pristup programiranju.
Osnovna ideja je razbiti program u niz zatvorenih cjelina koje
zatim meusobno sarauju u rjeavanju problema. Umjesto
specijaliziranih procedura koje barataju podacima, radimo s
objektima koji objedinjavaju i operacije i podatke. Pri tome je
vano ta objekt radi, a ne kako on to radi. Jedan objekt se moe
izbaciti i zamijeniti drugim, boljim, ako oba rade istu stvar.
1.2.
Program
Sam raunar, ak i kada se ukljui u struju, nije kadar uiniti nita
korisno. Ono to vam nedostaje jest pamet neophodna za koristan rad
raunara: programi. Pod programom podrazumijevamo niz naredbi u
mainskom jeziku koje procesor u vaem raunaru izvodi i shodno njima
obrauje podatke, provodi matematike proraune, ispisuje tekstove,
iscrtava krivulje, itd. Pokretanjem programa s diska, diskete ili
CD-ROM-a, program se uitava u radnu memoriju raunara i procesor
poinje s mukotrpnim postupkom njegova izvoenja. Programi koje
pokreete na raunaru su u izvrnom obliku (engl. executable),
razumljivom samo procesoru vaeg (i njemu slinih) raunara. U sutini
se mainski kd sastoji od nizova binarnih cifara: nula i jedinica.
Budui da su dananji programi tipino duine nekoliko megabajta,
nasluujete da ih autori nisu pisali izravno u mainskom kdu. Gotovo
svi dananji programi se piu u nekom od viih programskih jezika
(FORTRAN, BASIC, Pascal, C) koji su donekle razumljivi i ljudima.
Naredbe u tim jezicima se sastoje od mnemonika. Kombinovanjme tih
naredbi programer slae izvorni kd (engl. source code) programa,
koji se pomou posebnih programa kompajlera (engl. compiler) i
povezivaa (engl. linker) prevodi u izvrni kd. Prema tome, pisanje
programa u uem smislu podrazumijeva pisanje izvornog kda. Meutim,
kako pisanje kda nije samo sebi svrhom, pod pisanjem programa u
irem smislu podrazumijeva se i prevoenje, odnosno povezivanje
programa u izvr[ni kd. Stoga moemo govoriti o etiri faze izrade
programa: 1. pisanje izvornog kda 2. prevoenje izvornog kda, 3.
povezivanje u izvrni kd te 4. testiranje programa. Prva faza
programa je pisanje izvornog kda. U principu se izvorni kd moe
pisati u bilo kojem programu za ureivanje teksta (engl. text
editor), meutim velika veina dananjih kompajlera i povezivaa se
isporuuje kao cjelina zajedno s ugraenim programom za upis i
ispravljanje izvornog kda. Te programske cjeline poznatije su pod
nazivom integrisane razvojne okoline (engl. integrated development
environment, IDE). Nakon to je pisanje izvornog kda zavreno, on se
pohrani u datoteku izvornog kda na disku. Toj datoteci se obino
daje nekakvo smisleno ime, pri emu se ono za kdove pisane u
programskom jeziku C+ + obino proiruje nastavkom .cpp, .cp ili samo
.c, na primjer pero.cpp. Nastavak je potreban samo zato da bismo
izvorni kd kasnije mogli lake pronai. Slijedi prevoenje izvornog
kda. U integrisanim razvojnim okolinama program za prevoenje se
pokree pritiskom na neku tipku na ekranu, pritiskom odgovarajue
tipke na tastaturi ili iz nekog od menija (engl. menu) - ako
kompajler nije integrsan, poziv je neto sloeniji. Kompajler tokom
prevoenja provjerava sintaksu napisanog izvornog kda i u sluaju
uoenih ili nasluenih greaka ispisuje odgovarajue poruke o grekama,
odnosno upozorenja. Greke koje prijavi kompajler nazivaju se
grekama pri prevoenju (engl. 3
C++ compile-time errors). Nakon toga programer e pokuati
ispraviti sve navedene greke i ponovo prevesti izvorni kd - sve dok
prevoenje kda ne bude uspjeno okonano, nee se moi pristupiti
povezivanju kda. Prevoenjem izvornog dobiva se datoteka objektnog
kda (engl. object code), koja se lako moe prepoznati po tome to
obino ima nastavak .o ili .obj (u naem primjeru bi to bio
pero.obj). Nakon to su ispravljene sve greke uoene prilikom
prevoenja i kd ispravno preveden, pristupa se povezivanju objektnih
kdova izvrni kod. U veini sluajeva objektni kd dobiven prevoenjem
programerovog izvornog kda treba povezati s postojeim bibliotekama
(engl. libraries). Biblioteke su datoteke u kojima se nalaze ve
prevedene gotove funkcije ili podaci. One se isporuuju zajedno s
kompajlerem, mogu se zasebno kupiti ili ih programer moe tokom rada
sam razvijati. Bibliotekama se izbjegava ponovno pisanje vrlo esto
koritenih operacija. Tipian primjer za to je biblioteka matematikih
funkcija koja se redovno isporuuje uz kompajlere, a u kojoj su
definisane sve funkcije poput trigonometrijskih, hiperbolnih,
eksponencijalnih i sl. Prilikom povezivanja provjerava se mogu li
se svi pozivi kdova realizovati u izvrnom kdu. Uoi li poveziva neku
nepravilnost tokom povezivanja, ispisat e poruku o greci i
onemoguiti generisanje izvornog kda. Ove greke nazivaju se grekama
pri povezivanju (engl. link-time errors) - sada programer mora
prionuti ispravljanju greaka koje su nastale pri povezivanju. Nakon
to se isprave sve greke, kd treba ponovno prevesti i povezati.
Uspjenim povezivanjem dobiva se izvrni kd. Meutim, takav izvrni kd
jo uvijek ne garantuje da e program raditi ono to ste zamislili. Na
primjer, moe se dogoditi da program radi pravilno za neke podatke,
ali da se za druge podatke ponaa nepredvidivo. U tom se sluaju radi
o grekama pri izvoenju (engl. run-time errors). Da bi program bio
potpuno korektan, programer treba istestirati program da bi uoio i
ispravio te greke, to znai ponavljanje cijelog postupka u lancu
ispravljanje izvornog kda-prevoenje-povezivanje-testiranje'. Za
ispravljanje greaka pri izvoenju, programeru na raspolaganju stoje
programi za otkrivanje greaka (engl. debugger). Radi se o
programima koji omoguavaju prekid izvoenja izvedbenog kda programa
koji testiramo na unaprijed zadanim naredbama, izvoenje programa
naredbu po naredbu, ispis i promjene trenutnih vrijednosti
pojedinih podataka u programu. Najjednostavniji programi za
otkrivanje greaka ispisuju izvrni kd u obliku mainskih naredbi.
Meutim, veina dananjih naprednih programa za otkrivanje greaka su
simboliki (engl. symbolic debugger) - iako se izvodi prevedeni,
mainski kd, izvoenje programa se prati preko izvornog kda pisanog u
viem programskom jeziku. To omoguava vrlo lagano lociranje i
ispravljanje greaka u programu. Osim greaka, kompajler i linker
redovno javljaju i upozorenja. Ona ne onemoguavaju nastavak
prevoenja, odnosno povezivanja kda, ali predstavljaju potencijalnu
opasnost. Upozorenja se mogu podijeliti u dvije grupe. Prvu grupu
ine upozorenja koja javljaju da kd nije potpuno korektan. Kompajler
ili poveziva e zanemariti nau pogreku i prema svom nahoenju
izgenerisati kd. Drugu grupu ine poruke koje upozoravaju da "nisu
sigurni je li ono to smo napisali upravo ono to smo eljeli
napisati", tj. radi se o dobronamjernim upozorenjima na zamke koje
mogu proizii iz naina na koji smo program napisali. Iako e, unato
upozorenjima, program biti preveden i povezan (moda ak i korektno),
pedantan programer nee ta upozorenja nikada zanemariti - ona esto
upuuju na uzrok greaka pri izvoenju gotovog programa. Za precizno
tumaenje poruka o grekama i upozorenja neophodna je dokumentacija
koja se isporuuje uz kompajler i poveziva.
u
4
C++
2. RAZVOJNO OKRUENJE BORLAND TURBO C++2.1. Koritenje razvojnog
okruenja Borland C++
Razvojno okruenje koje e biti koriteno u ovom kursu jeste
Borland Turbo C++ verzija 4.5.
Razvojno okruenje obuhvata: 1. meni komandi 2. text editor za
unos izvornog koda (prozor c:\win45\zadaci\noname00.cpp), 3. prozor
za ispis poruka o greakama (Message). Nakon unoenja izvornog koda
napisanog u programskom jeziku C++, program je potrebno prevesti
(kompajlirati) pomou komande Project, Compile, iz menija komandi.
Ukoliko je dolo do greaka, u prozoru Message pojavit e se poruke o
grekama prevoenja. Veina integrisanih razvojnih okruenja kao to je
i Borlandov C++ omoguava integrisano prevoenje i povezivanje
programa sa bibliotekama funkcija. Ovo se pokree pomou komande
Project, Build All. Ovom komandom dakle, pozivamo najprije
kompajler, a zatim i linker. Startovanje programa realizuje se
komadom Debug, Run. Nakon toga, pojavit e se novi prozor u kome je
pozvana izvrna verzija programa.
5
C++
C++ izvorni kod moe se snimiti kao i svaka druga datoteka pomou
komadni iz menija File. Datoteka koja sadri izvorni kod automatski
dobije ekstenziju .cpp, objektne datoteke imaju ekstenziju .obj, a
izvrne ekstenziju .exe.
2.2.
Prvi program
U prethodnom poglavlju koriten je jednostavan program koji
ispisuje tekst na ekranu: #include int main() { cout b; // oekuje
drugi broj c = a + b; // rauna njihov zbir // ispisuje rezultat:
cout
