S v e u i l i t e u Z a g r e b u

Fakultet strojarstva i brodogradnje

Katedra za osnove konstruiranja

N. Pavkovi, D. Marjanovi, N. Bojeti

PROGRAMIRANJE I ALGORITMI

Skripta, drugi dio

Zagreb, 2005.
Sadraj

Potprogrami i funkcije (elementi modularizacije programa) .........................................3

Razmjena podataka izmeu potprograma ............................................................................................4
Vrste potprograma ...............................................................................................................................4
Vrste procedura u Visual Basic-u ........................................................................................................5
Deklariranje procedura ........................................................................................................................5
Deklariranje funkcija ...........................................................................................................................5
Rekurzija..............................................................................................................................................6
STRUKTURE PODATAKA .................................................................................. 7
Polje.............................................................................................................................8
Slog..............................................................................................................................8
Povezana lista .............................................................................................................9
Stog ...........................................................................................................................11
Red ............................................................................................................................12
Struktura stabla..........................................................................................................13
Binarno stablo pretraivanja (eng. binary search tree).......................................................................15
Gomila (eng. heap) ............................................................................................................................15
Graf............................................................................................................................15
Matrini prikaz grafova.................................................................................................................................. 16
ALGORITMI ....................................................................................................... 16
Iteracija ......................................................................................................................17
Primjer uporabe strukture stoga u algoritmu evaluacije aritmetikog izraza..............19
Algoritmi sortiranja .....................................................................................................20
"Bubble" sort .....................................................................................................................................21
Sortiranje umetanjem.........................................................................................................................22
Selection sort..................................................................................................................................22
"Heap" sortiranje................................................................................................................................22
"Shell" sort.........................................................................................................................................22
"Mergesort" (uparivanje i sortiranje) .................................................................................................23
"Quicksort" ........................................................................................................................................23
Indirektno sortiranje...........................................................................................................................23
Algoritmi pretraivanja ...............................................................................................23
Slijepo pretraivanje ..........................................................................................................................24
Pretraivanje liste (niza) ................................................................................................................................ 24
Pretraivanje stabla ........................................................................................................................................ 24
Usmjereno pretraivanje ....................................................................................................................25
Primjeri usmjerenog pretraivanja u inenjerskoj praksi ............................................................................... 25
PROGRAMSKI JEZICI....................................................................................... 26
Podjela programskih jezika........................................................................................27
Metodologije (paradigme) programiranja...................................................................27
Imperativno (proceduralno) programiranje........................................................................................27
Programi pokretani dogaajima ..................................................................................................................... 28
Funkcijsko programiranje ..................................................................................................................29
Deklarativno (logiko) programiranje ...............................................................................................30
Objektno orijentirana paradigma programiranja................................................................................30
Usporedba proceduralnog i objektnog programiranja .................................................................................... 31
OBJEKTNO ORIJENTIRANO PROGRAMIRANJE........................................... 32
Koncept objekta .................................................................................................................................33
Koncept klase.....................................................................................................................................34
Osnovni elementi objektnog modela .................................................................................................36
Uahurenje (enkapsulacija)............................................................................................................................ 36
Nasljeivanje ................................................................................................................................................. 37
Primjer nasljeivanja metoda......................................................................................................................... 39
Vieoblije (polimorfizam) ............................................................................................................................ 39
Osnove rada s objektima u .NET Visual Basic-u...............................................................................41
Sloeni objektno orijentirani programski sustavi...............................................................................42
Koncipiranje sloenih objektnih sustava........................................................................................................ 42
Razvoj metoda modeliranja objektno orijentiranih programskih sustava....................................................... 42
Unified Modeling Language (UML).............................................................................................................. 43
Potprogrami i funkcije (elementi modularizacije programa)
Sloeni programski problemi mogu se pojednostavniti dekompozicijom programa u manje
cjeline. Takve manje cjeline obino nazivamo modulima. Moduli mogu sadravati jednu ili vie
komponenti programskih procedura. Vrste procedura razlikuju se u programskim jezicima, a
obino se dijele na potprograme i funkcije. Mogunost razbijanja problema na manje cjeline
vano je svojstvo svakog programskog jezika na taj nain olakava se razvoj, testiranje,
odravanje i praenje programa. Manje logike cjeline lake je testirati zasebno, odnosno
nezavisno od ostalih dijelova programa. Nakon otklanjanja svih greaka u svakoj manjoj cjelini,
one se "sklapaju" u cjelovito programsko rjeenje. Na slijedeoj slici prikazan je primjer
dekompozicije sloenijeg problema shematski je prikazana hijerarhija poziva modula iz
glavnog programa.

GLAVNI PROGRAM ZA PRORACUN

ROTORA ELEKTROMOTORA

UCITAVANJE ULAZNIH IZRACUN TEINE ITERACIJA ODREIVANJE

STATICKI PROGIB
PODATAKA I PRIPREMA ROTORA PROGIB MAGN. SILA IZLAZNIH PODATAKA
PRORACUNA

POCETNA KRUTOST I KRUTOST

EKSCENTRICITET LEAJEVA PROVJERA
ODREIVANJE PODJELA VRATILA IZRACUN MAKS.
NAPREZANJA, VIJEKA
POJEDINIH NA SEGMENTE I TRAJANJA
FAKTORA POLJA PROGIBA I
NAGIBA LEAJA
METODA DINAMICKI
PRIJENOSNIH PROGIB
MATRICA

METODA
METODA PRIJENOSNIH
PRIJENOSNIH MATRICA
MATRICA

Slika 1: Primjer dekompozicije sloenog programskog sustava na manje module i potprograme

Postoje brojni razlozi i prednosti koritenja potprograma:
Smanjiti ponavljanja (redundancije) istih ili slinih sekvenci programskog koda.
Omoguiti ponovnu uporabu dijelova programskog koda u razliitim programima.
Dekompozicija sloenih problema u manje i jednostavnije cjeline.
Poboljanje "itljivosti" i preglednosti programa.
Repliciranje rjeenja za matematike funkcije.
Sakrivanje informacija i nevanih detalja unutar pojedinih dijelova programa.
Smanjenje rizika od greaka, lake odravanje i nadogradnja velikih sustava.
Osnovna je funkcija potprograma "sakrivanje" nevanih detalja programskog rjeenja. Koritenje
potprograma omoguuje bolji uvid u tok programa, tako da je panju lake posvetiti problemu
"to radi" za razliku od "kako to radi". Openito, da bi se ostvarila uporaba potprograma, koristi
se odreene forma naredbe poziva (eng. call). U trenutku izvoenja naredbe poziva potprograma,
slijed (kontrola) izvoenja naredbi predaje se pozvanoj cjelini, odnosno prelazi se na izvravanje
naredbi potprograma. Nakon to se izvedu sve naredbe pozvanog potprograma, kontrola se vraa
"pozivau" i izvravaju se dalje njegove naredbe. Potprogrami mogu biti pozvani iz glavnog
programa, ali i sami potprogrami mogu pozivati druge potprograme.
U principima implementacije potprograma meu programskim jezicima male su razlike u:
nainu prevoenja (mogunost nezavisnog prevoenje i testiranja potprograma kao to to
omoguuje Fortran, za razliku od npr. Pascala gdje se potprogrami deklariraju unutar
glavnog programa);
nainu prijenosa argumenata (po vrijednosti, ili po adresi);
 po vrsti:
o procedure-potprogrami iji poziv je zasebna naredba unutar neke programske
cjeline
o funkcije - koje su dio nekog izraza i njihovo referenciranje vraa vrijednost
Osnovne karakteristike potprograma koje razmatramo:
imaju jednu ulaznu toku
pozivajua procedura (program) se zaustavlja u toku izvravanja pozvanog potprograma,
samo jedan potprogram se izvrava u danom vremenu
kontrola se uvijek vraa pozivajuoj proceduri po zavretku izvravanja potprograma
Postupak pozivanja u nekim situacijama drugaiji je u programiranju pokretanom dogaajima,
jer je korisnik programa taj koji u veini sluajeva zapravo bira i poziva procedure, tj. elementi
suelja (odnosno korisnik) direktno sudjeluju u usmjeravanju tijeka izvoenja programa.
Meutim dijelovi programa koji se pokreu dogaajima mogu biti sastavljeni od vie
potprograma i funkcija, a osim mogunosti poziva procedure preko suelja, postoje i procedure
koje se pozivaju naredbama unutar programskog koda.

Razmjena podataka izmeu potprograma

Potprogrami su zasebne programske jedinice koje stoga alociraju i razliite (nepovezane)
dijelove memorije za svoje varijable. Jedan potprogram "ne zna" za varijable drugoga, odnosno
nema direktnog pristupa do adresa memorijskih lokacija na kojima su varijable drugih
potprograma. Drugim rijeima, potprogrami i "ne znaju" za postojanje drugih potprograma.
Stoga pri pozivu potprograma ili funkcije pozvanoj cjelini treba "prenijeti" ulazne podatke, a pri
zavretku pozvana cjelina treba "vratiti" rezultate programu koji ga je pozvao.
Postoji nekoliko naina prijenosa (razmjene) podataka izmeu potprograma:
Globalne varijable:
o U ovom nainu varijable kojima treba pristupati vie programskih cjelina
deklariraju se "izvan" svake od njih, u posebnom "zajednikom" dijelu memorije
kojem imaju pristup sve programske cjeline. Uobiajeno je rei da su globalne
varijable "vidljive" u svim potprogramima.
Prenose se vrijednosti varijabli (call by value):
o Kopira se vrijednost lokalne varijable iz pozivajue procedure u lokalnu varijablu
pozvane procedure. Ako pozvana procedura promijeni vrijednost varijable, to
utjee samo na lokalnu kopiju u pozvanoj proceduri.
Prenose se adrese varijabli (call by reference):
o Pozvana procedura dobiva pristup lokalnim varijablama iz pozivajue procedure.
Pozvana procedura moe trajno promijeniti vrijednost varijablama ije su adrese
prenesene.
Ako nije drukije navedeno, u Visual Basic-u se podrazumijeva call by reference.
Pojmovi dosega i trajanja varijabli vani su za razumijevanje prijenosa podataka (vrijednosti
varijabli) izmeu potprograma. Ova tematika detaljno je objanjena u poglavlju o varijablama.
Trajanje varijable je vano ako elimo zadrati vrijednost lokalne varijable pri ponovnom pozivu
potprograma u tom sluaju lokalnu varijablu treba deklarirati kao "statiku", ali tu mogunost
nemaju svi programski jezici.

Vrste potprograma
Uobiajena je podjela potprograma na dvije osnovne vrste:
Funkcije, (function) koje imaju od nula do vie ulaznih argumenata i vraaju jedan
rezultat. Funkcije se pozivaju kao dio izraza, npr. A = fun(B). Pojam "vraanja"
vrijednosti zapravo je izraunavanje vrijednosti funkcije koja se dalje tretira kao i ostale
varijable u izrazu.

4
 Openite potprograme (subroutine) koji imaju od nula do vie ulaznih argumenata i vie
izlaznih rezultata koje predaju argumentima. Pozivaju se najee posebnom naredbom
iza koje slijedi ime potprograma i lista ulaznih i izlaznih argumenata.
Navoenje pojedinanih podvrsta i naina implementacija potprograma u pojedinim jezicima
zahtijevalo bi previe vremena i prostora. Takoer postoje i razlike u terminologiji neki jezici
koriste termin "subroutine" kojeg prevodimo kao "potprogram" dok drugi jezici zapravo za isti
pojam koriste termin "procedure" koji prevodimo kao "procedura". Za funkcije se takoer koriste
i termini "funkcijski potprogram" ili "funkcijska procedura". Bez obzira na razlike u
terminologiji, osnovna razlika izmeu dvije vrste programskih jedinica je u nainu poziva i broju
izlaznih argumenata. U daljnjem tekstu obraditi e se vrste potprograma samo za programski
jezik Visual Basic.

Vrste procedura u Visual Basic-u

Zajedniki naziv svih vrsta potprograma u Visual Basic-u je "procedura" (eng. procedure).
Postoje tri vrste procedura:
procedure vezane uz dogaaje (event procedures) pozivaju se aktiviranjem nekog
dogaaja (npr. "klik" miem na neki objekt na formi)
ope procedure (general procedures) pozivaju se naredbom Call
funkcijske procedure (function procedures) pozivaju se kao dio izraza

Deklariranje procedura
Ope procedure kao i procedure vezane uz dogaaje deklariraju se sa rezerviranom rijei "Sub"
iza koje slijedi naziv procedure i lista argumenata.

[Public | Private] Sub name [(arglist)]

[statements]
[Exit Sub]
[statements]
End Sub
arglist:
[ByVal | ByRef] varname[( )]

Dvije su vrste procedura vezanih uz dogaaje:

Dogaaj vezan uz kontrolu na formi:
Private Sub controlname_eventname (arguments )
statements
End Sub
Dogaaj vezan uz formu:
Private Sub Form_eventname (arguments)
statements
End Sub

Deklariranje funkcija
Funkcijske procedure deklariraju se sa rezerviranom rijei "Function" iza koje slijedi naziv
procedure i lista argumenata. Barem jedanput prije naredbe "Exit Function" ili "End Function"
mora se pojaviti naredba oblika ime funkcije = izraz, jer se tom naredbom dodjeljuje vrijednost
koju funkcija "vraa" u pozivajuu proceduru.

5
 [Public | Private] Function name [(arglist)]
[statements]
[name = expression]
[Exit Function]
[statements]
[name = expression]
End Function
arglist:
[ByVal | ByRef] varname[( )]

Rekurzija
Rekurzija je vaan koncept u raunalnoj znanosti jer se mnogi algoritmi mogu pomou nje
najbolje prikazati. Rekurzija je zapravo i jedan nain implementacije potprograma u nekim
jezicima potprogram moe pozvati samog sebe uzrokujui zaustavljanje svojeg procesa
izvravanja za vrijeme dok traje drugi "ugnjeeni" proces izvravanja istog potprograma.
Kao primjer za bolje razumijevanje rekurzije razmotrimo definiciju predaka odreene osobe:
roditelji neke osobe su njeni preci (osnovni sluaj)
roditelji bilo kojeg pretka su takoer preci osobe koju razmatramo (korak rekurzije)
Rekurzivna procedura dakle poziva samu sebe ili sadri poziv neke druge procedure koja bi
mogla rezultirati pozivom originalne procedure. Da bi se izbjeglo beskonano izvoenje
programa:
mora postojati odreeni kriterij (temeljni kriterij) za koji procedura ne poziva samu sebe
svaki put kad procedura pozove samu sebe (direktno ili indirektno) mora biti blie
temeljnom kriteriju
Neki jezici (npr. FORTRAN) ne podravaju rekurziju. Rekurzivni programi su krai, ali
izvoenje programa je dulje. Za pohranjivanje rezultata i povratak iz rekurzije koristi se struktura
podataka stog.
Primjer rekurzivno definirane funkcije je slijedea definicija funkcije faktorijela:
f(0) = 1
f(n) = n * f(n 1) za svaki cijeli broj n > 0
Prema danoj definiciji f(3) rauna se kako slijedi:
f(3) = 3 * f(3 1)
= 3 * f(2)
= 3 * 2 * f(2 1)
= 3 * 2 * f(1)
= 3 * 2 * 1 * f(1 1)
= 3 * 2 * 1 * f(0)
= 3 * 2 * 1 * 1
= 6
Slijedei primjer rekurzivne funkcije u programskom jeziku C takoer izraunava faktorijel
cijelog broja n:
int fakt(int n){
if (n <= 1) {
return 1;
} else {
return n * fakt(n-1);
}
}

6
STRUKTURE PODATAKA
U raunalnoj znanosti pojam "struktura podataka" oznaava nain pohrane podataka u raunalu
koji omoguava efikasnu uporabu tih podataka. Vrlo esto dobar odabir strukture podataka
omoguuje i uporabu efikasnijeg algoritma obrade. Razliite vrste struktura podataka odgovaraju
razliitim vrstama programskih problema, dapae neke strukture su visokospecijalizirane samo
za odreene zadatke. U razvoju sloenih programskih sustava, izbor struktura podataka koje e
se primjeniti jedan je od najvanijih koraka. Iskustva razvoja velikih programskih sustava
pokazala su da kvaliteta i performanse konanih rjeenja u mnogome ovise o izboru
najpogodnijih struktura podataka. Nakon to su odabrane strukture podataka, esto je odmah s
time odreen i algoritam kojeg treba upotrijebiti.
Ukratko, moemo rei da je struktura podataka logiki ili matematiki model odreene
organizacije podataka.
Slijedee strukture podataka i operacije na njima temelji su raunalne znanosti jer su osnovni
elementi brojnih algoritama:
Polje (eng. array) sekvencijalni niz podataka istog tipa koje imaju zajedniko ime
Slog (eng. record) - skup podataka koji mogu biti razliitog tipa, niz slogova obino je
dio datoteke ili tablice
Lista, povezana lista (eng. linked list) niz elemenata koji sadre podatke i pokazivae
na slijedei element
Stog (eng. stack) niz elemenata u kojem se dodavanje i brisanje mogu obavljati samo
na jednom kraju niza
Red (eng. queue) niz elemenata u kojem je dodavanje mogue samo na jednom kraju a
brisanje samo na drugom kraju
Stablo, binarno stablo (eng. binary tree) hijerarhijska struktura u kojoj svaki element
moe imati samo jednog prethodnika
Graf (eng. graph) openita struktura u kojoj svaki element moe biti povezan sa vie
drugih elemenata
Navedimo etiri osnovne operacije na strukturama podataka koje se primjenjuju na svim vrstama
struktura:
pristup i obrada preko svih podataka (eng. traversing):
o pristup svakom elementu strukture tono jedanput, da bi se odreeni podatak
obradio (procesirao) primjer uitavanje polja ili matrice
pretraivanje (eng. searching):
o pronalaenje lokacije elementa strukture koji sadri eljenu vrijednost, ili
pronalaenje svih elemenata strukture koji ispunjavaju jedan ili vie uvjeta
dodavanje novog elementa u strukturu
brisanje odreenog elementa iz strukture

Strukture podataka dijele se na linearne i nelinearne. Struktura je linearna ako njeni elementi
tvore niz, odnosno slijed linearnu listu. Dva su osnovna naina prikaza linearnih struktura u
memoriji raunala:
linearna veza izmeu elemenata ostvarena slijedom memorijskih lokacija to je
karakteristino za polja
linearna veza izmeu elemenata ostvarena pokazivaima karakteristino za povezane
liste
Nelinearne strukture su stabla i grafovi.
Pored ve navedenih operacija pristupa i obrade, pretraivanja, dodavanja i brisanja, na linearne
strukture se primjenjuju i operacije sortiranja (eng. sorting) po odreenom redoslijedu i spajanja
(eng. merging) kombiniranja dvije liste u jednu. Izbor odreene vrste linearne strukture za
danu situaciju ovisi o relativnoj uestalosti primjene pojedine od navedenih operacija.

7
Polje
Struktura polja (eng. array) vrlo se esto upotrebljava. Na poljima se jednostavno primjenjuju
operacije prolaza, pretraivanja i sortiranja, stoga se polja koriste za pohranu relativno
permanentnih (statinih) skupova podataka. S druge strane, u situacijama gdje se veliina
strukture ili sami podaci konstantno mijenjaju, povezane liste su pogodnije strukture od polja.
Osnovni prikaz i objanjenje strukture polja ve je dan ranije, stoga ga ovdje neemo ponavljati.
Polje zauzima sekvencijalni niz memorijskih lokacija, a elementima polja pristupa se preko
indeksa, dakle fiziki redoslijed memorijskih lokacija odreuje povezanost elemenata polja.
Osnovni nedostaci polja su slijedei:
teko je dodavati i brisati elemente nakon to se elementima pridrue vrijednosti
u veini jezika problematino je poveati alokaciju memorije za elemente polja
Zbog navedenih nedostataka polja se smatraju statikim strukturama podataka.
Algoritam "pristupa i obrade" (eng. traversing) svih elemenata polja vrlo esto se koristi npr. kod
uitavanja ili ispisa elemenata polja ili kao dio drugih algoritama:
1. postavi broja na poetnu vrijednost jednaku indeksu poetnog elementa polja
2. ponavljaj korake 3 i 4 tako dugo dok je broja manji od indeksa krajnjeg elementa
polja
3. pristupi elementu polja i primjeni eljenu obradu na njemu
4. poveaj vrijednost brojaa za 1

Slog
Slog (eng. record) je skup meusobno povezanih (ali heterogenih) podataka koje obino
nazivamo polja ili atributi. Zapisi nekih vrsta datoteka su zapravo skupovi slogova, odnosno
takve datoteke su linearne liste slogova. Vano je naglasiti osnovne razlike izmeu sloga i polja:
elementi sloga mogu biti nehomogeni podaci (razliitih tipova)
ne mora postojati "prirodni" redoslijed elemenata sloga, elementi se oznaavaju
imenima atributa
Skup slogova moemo promatrati i kao tablicu u kojoj svaki stupac ima svoje ime i odgovara
pojedinom polju (atributu) sloga. Takva struktura ini osnovu tzv. relacijskih baza podataka.
Pojedini atribut sloga mora imati isti tip u svim slogovima. Jedan od moguih naina pohrane i
manipulacije sa slogovima je koritenje vie paralelnih polja pri emu svakom atributu sloga
odgovara jedno polje, odnosno elementi razliitih polja sa istom vrijednou indeksa pripadaju
jednom slogu. Drugi nain manipulacije sa slogovima je koritenje razliitih sintaktikih
elemenata specifinih za odreeni jezik neki jezici imaju ugraenu strukturu sloga.
Primjer sloga sa podacima o studentima - prvi redak tablice sadri nazive atributa u slogu, a
prikazan je niz od est slogova:

IME PREZIME MATINI DATUM UPISANA

BROJ ROENJA GODINA
Ime 1 Prezime 1 0038512345 05.04.1984. 1
Ime 4 Prezime 4 0038512766 12.08.1984. 1
Ime 8 Prezime 8 0038576238 30.01.1982. 3
Ime 2 Prezime 2 0038636686 25.10.1983. 2
Ime 3 Prezime 3 0038578798 05.04.1984. 2
Ime 5 Prezime 5 0037987987 09.07.1980. 4

8
Povezana lista
Povezana lista (eng. linked list) je linearna struktura elemenata u kojoj je redoslijed odreen
pokazivaima. Za razliku od polja, svaki element liste sadri pokaziva (eng. pointer) na
slijedei element. Poto pokaziva sadri adresu slijedeeg elementa u listi, sukcesivni elementi
liste ne moraju biti spremljeni u sukcesivnom nizu memorijskih lokacija. Na taj nain fiziki
redoslijed memorijskih lokacija nema nikakav utjecaj na redoslijed elemenata u listi. Za razliku
od polja, vrlo jednostavno je dodavanje i brisanje elemenata iz liste.
Svaki element (vor) povezane liste sastoji se od dva dijela:
1. Podatak
2. Pokaziva koji sadri adresu slijedeeg vora u listi
Zadnji vor sadri tzv. null pokaziva koji oznaava kraj liste.
Lista sadri posebni pokaziva koji sadri adresu prvog vora u listi.

POCETAK

CVOR (ELEMENT LISTE)

POKAZIVAC NA SLIJEDECI
ELEMENT
KRAJ LISTE
PODACI

Slika 2: primjer povezane liste sa 6 vorova

Algoritam operacije pristupa i obrade svih elemenata povezane liste (eng. traversing a linked
list):
1. Postavi pokaziva (PTR) na poetak
2. Ponavljaj korake 3 i 4 dok je PTR razliit od null
3. Pristupi elementu liste i izvri eljenu obradu
4. Postavi pokaziva (PTR) na slijedei element

PTR

Slika 3: postupak pristupa i obrade elemenata povezane liste

Najei nain prikaza povezane liste u memoriji je koritenjem dva paralelna polja i varijablom
(pokazivaem) koja sadri adresu prvog lana liste. Na slici 4 prikazan je primjer sa poljima
"DATA" i " "POINT". Svakom voru liste odgovara po jedan element iz svakog polja, s time da
ti elementi imaju istu vrijednost indeksa. Polje "DATA" sadri podatke svakog vora, a polje
"POINT" sadri lokaciju slijedeeg vora, odnosno podatka u listi. Varijabla "START" sadri
lokaciju poetnog vora u listi. Ako sloimo po redoslijedu elemente liste, dobiti emo tekst
"PRIMJER".

9
 DATA POINT

START 9 3 R 6

4 R 0

6 I 11

7 J 10

9 P 3

10 E 4

11 M 7

12

Slika 4: Prikaz povezane liste u memoriji pomou dva paralelna polja

Na slici 5 shematski je prikazano dodavanje elementa u povezanu listu. Prije dodavanja novog
elementa vor A pokazuje na slijedei vor B. Nakon umetanja novog vora izmeu vorova A i
B, vor A pokazuje na novi vor N, a vor N pokazuje na vor B.
START

Cvor A Cvor B
x

START a) Prije umetanja

Cvor A Cvor B

Cvor N
b) Nakon umetanja

Slika 5: dodavanje elementa u povezanu listu

Na slian nain, mijenjanjem lokacije na koju pokazuje pokaziva realizira se i brisanje elementa
iz povezane liste.
Dvostruko povezane liste (slika 6) mogu se procesirati (obilaziti) u dva smjera od poetka do
kraja i obrnuto. Svaki vor (element) dvostruko povezane liste osim podatka, sadri i dva
pokazivaa na prethodni i na slijedei vor u listi.

pocetak kraj
podatak

pokazivac na prethodni cvor

pokazivac na slijedeci cvor

x x

cvor N

Slika 6: dvostruko povezana lista

10
Stog
Polja i povezane liste dozvoljavaju dodavanje i oduzimanje (brisanje) elemenata na bilo kojem
mjestu poetku, kraju ili izmeu. Postoje odreene situacije u programiranju kada elimo
ograniiti dodavanja i brisanja elemenata samo na kraj ili poetak liste. Linearna struktura u
kojoj se elementi mogu dodavati ili oduzimati samo na jednom kraju zove se stog (eng. stack).
Slika 7 je shematski prikaz takve strukture nije mogue izvaditi ili umetnuti bilo koji element
iz sredine prije nego se "skinu" svi elementi iznad njega. Iz toga slijedi da je zadnji dodani
element ujedno i onaj koji e se prvi izvaditi. Stoga je drugi uobiajeni naziv za strukturu stoga :
LIFO lista (eng. last in first out). Drugim rijeima stog je struktura podataka kod koje se
posljednji pohranjeni podatak prvi uzima u obradu.

Osnovne operacije na stogu su:

dodavanje
oduzimanje
dodavanje (umetanje) elementa
na stog (eng. push)

brisanje (oduzimanje) elementa

iz stoga (eng. pop)

Slika 7: shematski prikaz strukture stoga

Premda se ini da je stog vrlo restriktivna struktura podataka, on ima brojne vrlo vane primjene
u raunalnoj znanosti. Prikaz i manipulacija sa stogom moe se realizirati statikom strukturom
podataka. U jednodimenzionalno polje zadane strukture dodaju se ili briu pojedine stavke po
principu "LastInFirstOut" (LIFO). Pojedina operacija dodaj ili brii zahtijeva jednako vremena
bez obzira na broj pohranjenih podataka. Situacija da je stog pun moe zahtijevati alociranje
dodatne memorije i ponovno izvoenje programa. Prazan stog ne mora znaiti pogreku.

STOG

A B E N

1 2 3 4 5 6 7 8 9 10

VRH 4 MAX 10

Slika 8: prikaz stoga pomou jednodimenzionalnog polja

Na slici 8 prikazan je primjer implementacije strukture stoga pomou jednodimenzionalnog polja
"STOG", te varijable "VRH" koja sadri trenutnu poziciju najvieg (gornjeg) elementa i varijable
"MAX" koja sadri maksimalni broj elemenata u stogu.
Struktura stoga esto se upotrebljava u situacijama kada odreene korake obrade treba odgoditi
do trenutka ispunjenja drugih uvjeta. Primjeri uporabe strukture stoga detaljnije su objanjeni u
poglavlju "Algoritmi".

11
Red
Red (eng. queue) je linearna struktura u kojoj se elementi dodaju iskljuivo na jednom kraju, a
oduzimaju iskljuivo na drugom kraju. Strukturu reda lako je predoiti analogijom sa istim
pojmom u svakodnevnom ivotu npr. redom ispred blagajne u duanu. Svaka nova osoba koja
doe zauzima mjesto na kraju reda, a osoba sa poetka reda plaa svoju robu i odlazi. Drugi
uobiajeni naziv za ovu strukturu je FIFO lista (eng. first in first out).

Slika 9: red osoba

Struktura reda moe se u raunalu implementirati na razliite naine, a najee se koristi jedno
jednodimenzionalno polje i dvije varijable (pokazivaa) koje sadre lokacije poetka i kraja reda,
odnosno lokacije poetnog i krajnjeg elementa u redu. Takav nain implementacije reda prikazan
je na slici 10.

QUEUE
a) pocetak: 1
kraj: 4 AAA BBB CCC DDD

1 2 3 4 5 6 ... N

QUEUE
b) pocetak: 2
kraj: 4
BBB CCC DDD

1 2 3 4 5 6 ... N
QUEUE
c) pocetak: 2
kraj: 6 BBB CCC DDD EEE FFF

1 2 3 4 5 6 ... N
QUEUE
d) pocetak: 3
kraj: 6 CCC DDD EEE FFF

1 2 3 4 5 6 ... N
Slika 10: Implementacija strukture reda pomou polja
Varijabla "poetak" sadri lokaciju prvog elementa na poetku reda, a varijabla "kraj" lokaciju
zadnjeg elementa na kraju reda. Inicijalno red sadri 4 elementa, u drugom koraku brie se prvi
element sa poetka reda, u treem koraku dodaju se dva nova elementa na kraj reda, a u etvrtom
koraku brie se element sa poetka reda. Uoite da se uz ovakav nain brisanja i dodavanja
elemenata stalno "pomiemo u desno", tj. za zapis elemenata reda koristi se zapravo samo jedan
segment polja, a nakon svakog brisanja poveava se poetni dio polja koje ostaje neiskoriteno.
Ovaj problem moe se rijeiti tako da u odreenom trenutku premjestimo krajnji lan reda na
poetak polja, tj. da napravimo tzv. cirkularno polje.

12
 RED (QUEUE) Na slici 11 prikazan je primjer
a) inicijano prazan red: POCETAK: 0
koritenja cirkularnog polja za red koji
KRAJ: 0 moe sadravati maksimalno pet
1 2 3 4 5
lanova.
b) A, B i C ukljuceni: POCETAK: 1
KRAJ: 3
A B C Ako cirkularno polje sadri openito n
lanova, tada polje(1) slijedi iza
c) A iskljucen: POCETAK: 2
B C
polje(n) i na taj nain ponovno se
KRAJ: 3
iskoritava poetni dio polja nakon to
su elementi reda iz njega obrisani.
d) D a zatim i E ukljuceni: POCETAK: 2
B C D E
KRAJ: 5
U oba naina implementacije strukture
e) B i C iskljuceni: POCETAK: 4
D E
reda pomou polja moe doi do tzv.
KRAJ: 5
preljeva (eng. overflow), tj. situacije da
u polju nema vie dovoljno mjesta za
f) F ukljucen: POCETAK: 4
KRAJ: 1
F D E dodavanje novog lana u red.

g) D iskljucen: POCETAK: 5
F E
KRAJ: 1

h) G a zatim i H ukljucen: POCETAK: 5

F G H E
KRAJ: 3

i) E iskljucen: POCETAK: 1
F G H
KRAJ: 3

j) F iskljucen: POCETAK: 2
G H
KRAJ: 3

k) K ukljucen: POCETAK: 2
G H K
KRAJ: 4

l) G i H iskljuceni: POCETAK: 4
K
KRAJ: 4

m) K iskljucen, RED prazan: POCETAK: 0

KRAJ: 0

Slika 11: Implementacija strukture reda pomou tzv. cirkularnog polja

Struktura stabla
Za razliku od prethodno razmatranih linearnih struktura, stablo (eng. tree) je nelinearna struktura
koja se koristi za prikaz hijerarhijskih odnosa izmeu elemenata. Primjer strukture stabla koju
koristimo u svakodnevnom radu je struktura direktorija, odnosno organizacija datotenog sustava
na raunalu. Strukture stabla koje emo ovdje razmatrati sastoje se od vorova (eng. nodes) i
veza izmeu njih koje uobiajeno nazivamo grane. Takva stabla imaju jedan poetni vor na
vrhu hijerarhije, npr. u strukturi direktorija to je tzv. korijenski (osnovni) direktorij (eng. root
directory.)
Jedna od najvanijih vrsta strukture stabla u raunalstvu je tzv. binarno stablo. U binarnom
stablu (eng. binary tree) svaki vor ima ili najvie dva sljedbenika ili samo jednog ili nijednog
sljedbenika. Na slici 12 prikazan je primjer binarnog stabla sa 11 vorova. vorovi A, B i C
imaju dva sljedbenika, vorovi E i J po jednog sljedbenika, a vorovi D, F, G, L i K nemaju
sljedbenika. vorovi bez sljedbenika nazivaju se terminalni vorovi.

13
 A

B C

D E G H

F J K

L
Slika 12: Primjer binarnog stabla
Jedna od primjena strukture binarnog stabla je prikaz aritmetikog izraza koji se koristi u
procesu prevoenja programa u strojni jezik.
Koritenje tri paralelna polja jedan je od naina prikaza binarnog stabla u memoriji (slika 13).
Polje INFO sadri podatak o nazivu pojedinog vora, polje LIJEVO sadri lokaciju lijevog
sljedbenika, a polje DESNO lokaciju desnog sljedbenika pojedinog vora. Varijabla KORIJEN
pokazuje na lokaciju poetnog (korijenskog) vora, a varijabla AVAIL pokazuje na lokaciju
prvog slobodnog indeksa sva tri paralelna polja za upis podataka slijedeeg vora koji bi se
dodao u stablo.

INFO LIJEVO DESNO

KORIJEN
1 K 0 0

A KORIJEN 2 C 3 6
5 3 G 0 0
B C
4 14

AVAIL 5 A 10 2
x D x E x x G x H
8 6 H 17 1

x F x J x x K x 7 L 0 0

8 9
x L x
9 4

10 B 18 13

11 19

12 F 0 0

13 E 12 0

14 15

15 16

16 11

17 J 7 0

18 D 0 0

19 20

20 0

Slika 13: Prikaz binarnog stabla u memoriji pomou tri paralelna polja

14
Binarno stablo pretraivanja (eng. binary search tree)
Binarno stablo pretraivanja jedna je od najvanijih struktura podataka u raunalnoj znanosti
Za svaki vor ove strukture vrijedi:
vrijednost u voru je vea od svih vrijednosti u lijevom podstablu i manja od svih
vrijednosti u desnom podstablu

Slika 14: Primjer binarnog stabla pretraivanja

Gomila (eng. heap)

Gomila je vrsta strukture stabla koja se koristi u jednom od algoritama sortiranja. Struktura
gomile je binarno stablo u kojem za svaki vor vrijedi slijedee: vrijednost u voru je vea ili
jednaka od vrijednosti svih vorova ispod njega (svih sljedbenika).

Slika 15: Primjer strukture gomile

Graf
Struktura grafa (eng. graph) takoer je nelinearna.
Definicija grafa:
Graf G sadri dva konana skupa: skup toaka V, koje nazivamo vorovima, i skup linija
povezivanja E, koje nazivamo bridovima. Pri tome svaki brid povezuje dva vora.
G = (V, E)
Definicija usmjerenog grafa:
Usmjereni graf G = (V, E) je graf u kojem svaki brid e = (i,j) ima smjer od "inicijalne toke"
(vora) do "terminalne toke" (vora). Pod uvjetom da su suprotnih smjerova, u usmjerenom
grafu mogu postojati dva brida koja povezuju iste vorove.
Graf G je povezan ako i samo ako postoji jednostavna putanja izmeu bilo koja dva vora u G.
Ako svakom bridu grafa pripada neki podatak, takav graf se naziva oznaenim. Ako su
bridovima grafa pridruene pozitivne numerike vrijednosti, onda se takav graf naziva teinski ili
graf sa teinskim faktorima.

15
 D
B 1
B F E
2
7
5 4

A A 3
8
F
2
6
C
C E
D
a) graf b) graf sa teinskim faktorima

Slika 16: Primjer prikaza strukture grafa

Matrini prikaz grafova

vorovi grafa obino se oznaavaju s v1, v2, . ili jednostavno brojevima, a bridovi
s e1, e2, . ili s njihove dvije krajnje toke (vora) npr.: e1= (1,4), e2=(1,2)
Brid (vi, vj) je svojstven (upadan, zavisan, eng. "incident") voru vi (vrhu); isto vrijedi za vj.
Broj bridova svojstvenih voru v naziva se stupanj vora v.
Dva vora nazivamo susjednim (eng. "adjacent") vorovima grafa ako su povezani bridom,
odnosno ako ine dvije krajnje toke brida.
Za raunalni prikaz grafova najpogodnije je koristiti matrice, pa slijedi prikaz nekoliko oblika
matrinih prikaza grafova.
Definicija matrice susjedstva (eng. adjacency matrix) grafa G:
[ ]
A = a ij
1 ako G ima brid ( i, j )
aij =
0 ako nema brida
Matrica susjedstva opeg grafa je simetrina.
Element matrice susjedstva usmjerenog grafa, aij = 1, onda kad postoji usmjereni brid (od vora i
prema voru j). Matrica susjedstva usmjerenog grafa nije simetrina.
Definicija matrice incidencije grafa G:
[ ]
A = a jk
+ 1 ako grana k izlazi iz vora j

a jk = 1 ako grana k ulazi u vor j
0 ako grana k ne dira vor j

ALGORITMI
Poznavanje algoritama temelj je uspjenog programiranja, pogotovu u razvoju sloenih
programskih sustava. Predviena satnica predavanja i vjebi doputa izlaganje samo
najjednostavnijih osnovnih algoritama. Granicu izmeu "osnovnih" i "sloenih" algoritama teko
je postaviti. Zadaci na vjebama prezentiraju neke od temeljnih algoritama obrade numerikih
podataka koji se javljaju u inenjerskoj praksi. Najjednostavniji algoritmi pogodni su za poetak
uenja programiranja, pri emu je vrlo bitno izgraditi i usvojiti nain razmiljanja i postupke
rjeavanja problema pri programiranju.
Na vjebama se prvo obrauju algoritmi operacija s nizovima uitavanje niza, sumiranje
lanova niza, pronalaenje minimalnog i/ili maksimalnog elementa niza, sortiranje, traenje i
ispis lanova niza koji zadovoljavaju odreene uvjete. Nakon usvajanja navedenih algoritama na
nizovima isti i slini algoritmi se obrauju i na matricama. Pri tome se za nizove koristi struktura
16
jednodimenzionalnog polja, a za matrice dvodimenzionalna polja. Navedeni algoritmi detaljno
su obrazloeni u podlogama za vjebe, stoga se ovdje nee izlagati.
U ovom poglavlju posebna je panja posveena postupku iteracije, jer se ona vrlo esto javlja
kao dio sloenijih problema u inenjerskoj praksi. Nakon toga dan je jedan primjer uporabe
strukture stoga u algoritmu za odreivanje vrijednosti numerikog izraza., te primjer
najjednostavnijeg algoritma sortiranja niza brojeva. Poglavlje zavrava informativnim pregledom
algoritama sortiranja i pretraivanja. Potrebno je napomenuti da su ovdje izloene samo neke
odabrane klase (vrste) algoritama, a za svako ozbiljnije studiranje algoritama potrebno je prouiti
specijaliziranu literaturu.
Algoritmi se mogu klasificirati na mnogo razliitih naina, a kriteriji pojedinih klasifikacija
predmet su kontinuiranih rasprava u okruju raunalne znanosti.
Jedan nain klasifikacije algoritama je prema metodologiji primjenjenoj u kreiranju algoritma.
Mogue je razluiti odreen broj razliitih metodologija (paradigmi):
"Podijeli i vladaj" ponavlja se postupak reduciranja sloenog problema na vie
jednostavnijih (manjih) cjelina, dok cjeline ne postanu dovoljno male da bi bile lako
rjeive. Reduciranje se obino ponavlja na rekurzivan nain.
"Dinamiko programiranje" pogodno je za probleme u kojima se cjelokupno rjeenje
moe kreirati na nain da se rjeenja istih podproblema upotrijebe za rjeavanje brojnih
razliitih instanci problema. Ovaj pristup nastoji izbjei "rjeavanje ve rijeenog".
"Greedy" metoda slina je dinamikom programiranju, osim to u svim koracima
nemamo rjeenje podproblema, pa se u takvim sluajevima radi "greedy" izbor onoga to
se ini najpogodnijim u tom trenutku.
Linearno programiranje Ovaj nain rjeavanja problema svodi se na kreiranje sustava
linearnih nejednadbi, nakon ega se nastoji maksimizirati ili minimalizirati ulazne
veliine.
Pretraivanje i enumeracija mnogi problemi (npr. igranje aha) mogu se modelirati
pomou grafova. Algoritmi specifikacije pravila za kretanje (pretraivanje) po strukturi
grafa korisni su za ovakve probleme.
Probabilistiki i heuristiki postupci ne odgovaraju u potpunosti definiciji algoritma, jer
generiraju rjeenja na temelju sluajnih odabira.
Genetiki algoritmi nastoje pronai rjeenje oponaanjem biolokih evolucijskih procesa
- ciklusima sluajnih mutacija generiraju se sukcesivne "generacije rjeenja".
Drugi nain klasifikacije algoritama je prema nainu implementacije.
Rekurzivni algoritam poziva (referencira) samog sebe do trenutka ispunjenja odreenog uvjeta, a
takva metoda uobiajena je u tzv. funkcijskom programiranju. Algoritmi se uobiajeno
razmatraju sa pretpostavkom da raunalo izvodi jednu po jednu instrukciju, odnosno
podrazumijeva se jednoprocesorska arhitektura. Takve algoritme zovemo serijski algoritmi za
razliku od paralelnih algoritama koji koriste prednosti vieprocesorskih arhitektura raunala.

Iteracija
Postupak iteracije nastoji rijeiti problem nalaenjem sukcesivnih aproksimacija tonom
rjeenju, polazei od inicijalne pretpostavke. Najee se radi o rjeavanju jednadbe ili sustava
jednadbi, kada ima vie nepoznanica nego jednadbi. Za linearne sustave jednadbi postoje
dvije osnovne vrste iterativnih metoda: stacionarne i openitije Krylove metode podprostora.
Stacionarne iterativne metode rjeavaju sustav linearnih jednadbi sa operatorom koji je
aproksimacija originala i na temelju mjerenja greke formiraju korekcijsku jednadbu za koju se
navedeni proces ponavlja. Stacionarne metode jednostavne su za implementaciju i analizu, ali
konvergencija k tonom rjeenju garantirana je samo za odreene klase matrica.
Iteracija je jedan od najvanijih i vrlo estih postupaka u rjeavanju inenjerskih problema. Kod
sloenijih jednadbi, "runo" raunanje brojnih koraka postaje mukotrpno i vrlo podlono
grekama, pogotovo ako se zahtijeva velika tonost rjeenja. Stoga je daleko lake, bre, tonije i
17
efikasnije takve probleme rjeavati raunalnim programima. U poecima razvoja raunala i
programskih jezika upravo su numeriki problemi bili prevladavajue podruje primjene
raunala.
Sve iterativne metode karakterizira postupak rjeavanja zadataka usmjerenim pokuajima.
Ovisno o pojedinom problemu razlikovati e se naini pribliavanja (konvergiranja) k rjeenju,
odnosno korigiranja poetnih pretpostavki. Da bi mogli osigurati pribliavanje rjeenju, nuno je
poznavati karakter funkcija u odabranom podruju. Moramo naglasiti da bilo koji iterativni
postupak daje uvijek samo priblino rjeenje! Iteracija se primjenjuje se kad jednostavnim
matematikim postupcima nije mogue nai egzaktno rjeenje.
Postupak iteracije moe se saeti na tri osnovna koraka:
1. Pretpostaviti rjeenje
2. Provjeriti da li pretpostavljeno rjeenje zadovoljava uvjete
3. Ako rjeenje zadovoljava uvjete, postupak se prekida i ispisuje se rjeenje
Ako rjeenje ne zadovoljava uvjete, treba korigirati pretpostavke i vratiti se na prethodni
korak.
Drugi i trei korak ponavljaju se tako dugo dok se ne pronae zadovoljavajue rjeenje. Ako na
adekvatan nain ne korigiramo pretpostavljeno rjeenje, moe se dogoditi da nema
konvergencije prema rjeenju i da se iteracija protegne na beskonano ponavljanje drugog i
treeg koraka. Stoga obino treba ukljuiti i kontrolu realiziranog broja koraka, te ako je taj broj
prevelik treba prekinuti postupak. Takve situacije dogaaju se obino ako ne poznajemo
dovoljno dobro ponaanje funkcija u okolini rjeenja, ali moe biti i drugih uzroka izostanka
konvergencije. Treba napomenuti da je programiranje sloenijih iterativnih postupaka vrlo
"osjetljiv" posao za kojeg je potrebno odreeno iskustvo i poznavanje problema numerike
analize. Treba uvijek imati na umu na raunalo radi sa konanim brojem decimala i da kod
odreenih problema moe doi do multiplikacije greke na taj nain da nije mogue doi niti do
priblinog rjeenja.

Na slici 17 prikazani su grafovi dviju funkcija. Presjecite grafova je rjeenje kojeg traimo. Na
ovom primjeru biti e izloena metoda binarnog pretraivanja, tj. rjeenje traimo tako da
kontinuirano smanjujemo interval u kojem bi se trebalo nai rjeenje tako dugo dok sam interval
ne postane manji od zadane tonosti. Funkcija f1 kontinuirano pada na cijelom promatranom
podruju (prije i nakon sjecita), a funkcija f2 kontinuirano raste na cijelom promatranom
podruju. Traimo priblino rjeenje sa tonou , tj. traimo onu vrijednost x za koju e se y1 i
y2 razlikovati za manje od . Za poetnu pretpostavku uzimamo vrijednost x0. Izrauna se
vrijednost y1 = f1(x0) i vrijednost y2 = f2(x0) i nakon toga provjeriti da li pretpostavljeno
rjeenje zadovoljava uvjete. Dakle treba provjeriti da li je apsolutna vrijednost razlike y1 i y2
manja od zahtijevane tonosti : Abs(y1-y2) < . Daljnji postupak pribliavanja rjeenju prikazan
je na slici 18.

y1 = f (X) x, y1=Y2

(Y-, Y+)

y2 = f (X)

Xo

X1

Slika 17: poetni korak iteracije

18
 (X-, X+)

y1 = f (X) x, y1=Y2

(Y-,
Y+)

y2 = f (X)

Xo X2
X1 X1
X1 X2
X2
X1
X1

Slika 18: pribliavanje rjeenju u postupku iteracije

Da bi osigurali konvergenciju postupka, moramo u svakom trenutku, odnosno u svakom koraku
znati s koje strane rjeenja se nalazi naa pretpostavka. To znai i da moramo biti sigurni s koje
strane rjeenja smo krenuli i u kojem smjeru. Npr. da smo pretpostavili x0 > x i nastavili dalje
dodavati korekciju, dalje bi se samo neprestano udaljavali od rjeenja. Stoga dakle na
prikazanom primjeru pretpostavljamo da je x0 sigurno manji od x. Ukoliko je Abs(y1-y2) > ,
treba korigirati poetnu pretpostavku. Ako smo sigurni da se nalazimo lijevo od rjeenja, treba
dakle dodati odreeni iznos (x1) i ponovno izraunati y1 i y2. Nakon svake korekcije treba
ustanoviti da li smo jo uvijek s iste strane rjeenja ili smo preli na drugu stranu. Ako
poznajemo karakter funkcija u promatranom podruju onda moemo zakljuiti gdje se nalazimo
u odnosu na rjeenje na temelju odnosa y1 i y2. Na prikazanom primjeru u podruju od x0 do x
y1 je uvijek vee od y2, a desno od x y2 je vee od y1. Dakle da bi pravilno korigirali
pretpostavku, moramo prvo ustanoviti da li se nalazimo s lijeve ili s desne strane rjeenja. Ako je
pretpostavka s lijeve strane, za korekciju treba dodati odreeni iznos, a ako je pretpostavka s
desne strane rjeenja, pri korekciji potrebno je oduzeti odreeni iznos! Ako bi korekcije radili
tako da dodajemo i oduzimamo uvijek iste iznose, postupak bi "plesao" po istim tokama oko
rjeenja, bez konvergencije. Dakle, nakon to "preemo" s druge strane rjeenja treba oduzeti ili
dodati razliit iznos od korekcije u prethodnom koraku. U ovom primjeru nakon "promjene
strane" iznos nove korekcije jednak je polovini iznosa korekcije u prethodnom koraku. Uoite na
ne moemo uvijek tono znati u kojem koraku e se prei s jedne strane na drugu stranu od
rjeenja, stoga algoritam odreivanja korekcije mora uvijek pripremiti iznos korekcije za
suprotni smjer, tj. za jedan korak unaprijed.

Primjer uporabe strukture stoga u algoritmu evaluacije

aritmetikog izraza
Ovdje e biti izloen pojednostavljeni algoritam evaluacije numerikog izraza kao primjer
jednog od brojnih algoritama u kojima se koristi struktura stoga. Algoritam uitava aritmetiki
izraz kao niz znakova (string), a zadaa mu je izraunati vrijednost tako uitanog aritmetikog
izraza.

19
Radi pojednostavljenja algoritma u ovom primjeru uvedena su slijedea ogranienja:
izraz sadri samo jednoznamenkaste cijele brojeve i operatore zbrajanja, oduzimanja,
mnoenja i dijeljenja,
izraz je ve transformiran u "reverznu poljsku notaciju"
Reverzna poljska notacija zapis je izraza u kome su operatori zapisani iza operanada:
a+b ab+
Algoritam evaluacije izraza:
1. Dodaj ) na kraj izraza da bi se oznaio kraj izraza
2. skeniraj (parsiraj) izraz s lijeva na desno i ponavljaj korake 3 i 4 dok se ne dostigne
) (oznaka kraja izraza)
3. Ako je pronaen operand, stavi ga na stog, tj. na vrh stoga
4. Ako je pronaen operator o:
a. Uzmi dva elementa sa vrha stoga (A je na vrhu, a B ispod njega)
b. Izraunaj B o A
c. Stavi rezultat na vrh stoga
5. Kada se obradi cijeli izraz do oznake kraja, vrijednost izraza jednaka je elementu na vrhu
stoga

"Parsiranje" izraza je postupak kojim se redom obrauje znak po znak iz uitanog niza, tj.
izdvaja se pojedini znak i ustanovljava se da li je to znamenka ili operand. U sluaju
vieznamenkastih brojeva, postupak parsiranja je sloeniji jer treba ustanoviti za svaki broj
poetak i kraj niza znamenki.
U slijedeoj tablici prikazani su svi koraci parsiranja izraza: 5 * ( 6 + 2 ) 12 / 4
koji zapisan u reverznoj poljskoj notaciji glasi: 5 6 2 + * 12 4 / -
U drugom stupcu tablice zapisan je simbol koji se trenutno obrauje, a u treem stupcu vide se
svi podaci u stogu, odnosno trenutno stanje stoga. Pri tome je vrh stoga s lijeve strane, a kraj s
desne strane.

korak simbol stog

1 5 5
2 6 5,6
3 2 5,6,2
4 + 5,8
5 * 40
6 12 40,12
7 4 40,12,4
8 / 40,3
9 - 37
10 )

Algoritmi sortiranja
Algoritam sortiranja postavlja elemente neke liste u odreeni redoslijed. Najee se sortira po
numerikom redoslijedu ili po abecedi (leksikografski redoslijed). Efikasni algoritmi sortiranja
preduvjet su uspjenosti nekih drugih algoritama npr. onih algoritama pretraivanja koji
zahtijevaju sortiranu listu da bi u njoj mogli pronai odreeni lan. Veina algoritama sortiranja

20
zasniva se na metodologiji "podijeli i vladaj" tj. ponavlja se postupak reduciranja sloenog
problema na vie jednostavnijih (manjih) cjelina, odnosno veliki niz se dijeli na vie manjih
nizova koji se zasebno sortiraju. Takvi zasebno sortirani segmenti zatim se spajaju u konano
sortirani niz. Reduciranje niza se obino ponavlja na rekurzivan nain. Algoritmi sortiranja
najvie se razlikuju u operacijama odnosno nainima dijeljenja na podnizove i spajanja u
konano sortirani niz.

"Bubble" sort
Ovo je jedna od najjednostavnijih metoda sortiranja koja efikasno funkcionira samo za relativno
maleni broj elemenata koji se sortiraju. Za vei broj elemenata ova metoda je prespora. Stoga se
ova metoda vrlo rijetko upotrebljava osim za edukacijske svrhe.
Najvei lan u polju postavlja se na kraj polja, a u ostatku polja se na jednak nain trai najvei
lan. Niz kojeg treba sortirati ima n lanova. Osnovna je ideja premjetanje najveeg lana niza
na posljednje mjesto, a zatim se postupak ponavlja za prvih n-1 lanova niza, jer je na n-toj
poziciji ve najvei lan. Postupak premjetanja odreenog lana niza na njegovo mjesto sastoji
se od sukcesivnih usporedbi susjednih lanova niza. Ukoliko je odreeni lan niza manji od onog
koji slijedi iza njega, izvrava se zamjena njihovog redoslijeda. Niz je nuno sortiran kada se
postupak usporeivanja (poevi od prvog lana niza do zadnjeg nesortiranog) ponovi n-1 puta.
Prvi puta nuno je izvriti n-1 usporedbu, da bi najvei lan doao na posljednje mjesto u nizu. U
svakom e sljedeem prolazu kroz niz broj usporedbi biti manji za jedan.

PRIMJER: broj lanova niza: n = 4

lanovi niza: 7, 2, 6, 1

7>2 ! 2, 7, 6, 1 j=1
7>6 ! 2, 6, 7, 1 } 3 usporedbe |
7>1 ! 2, 6, 1, 7 i = 1, n j |
| 3 prolaza kroz podatke
2<6 ! 2, 6, 1, 7 j=2 |
6>1 ! 2, 1, 6, 7 } 2 usporedbe n 1 prolaz
i = 1, n j | prolaz
| j = 1, n - 1
j=3 |
2>1 ! 1, 2, 6, 7 } 1 usporedba |
i = 1, n j

Algoritam "bubble" sort metode u pseudokodu:

1. Uitati broj lanova niza N
2. Uitati niz u jednodimenzionalno polje X
3. Petlja J = 1, N 1
petlja I = 1, N J
ako je X ( I ) > X ( I + 1) onda izvri zamjenu
sadraja dva susjedna lana polja:
Y = X ( I )
X ( I ) = X ( I + 1 )
X ( I + 1 ) = Y
4. Ispisati sortirani niz X.

21
Sortiranje umetanjem
Ova metoda slina je prethodnoj, ali je ipak neto efikasnija. Element niza usporeuje se sa svim
prethodnim elementima dok se ne pronae slijedei manji element. Na taj nain element niza
"umee" se na svoju poziciju u sortiranom dijelu niza. Sortiranje umetanjem daje dobre rezultate
za male liste (do 30 elemenata).
24 4 3 15 9 7
(-) ?
4 24 3 15 9 7
(----) ?
3 4 24 15 9 7
(--------) ?
3 4 15 24 9 7
(-------------) ?
3 4 9 15 24 7
(-----------------) ?
3 4 7 9 15 24

Selection sort
Ova metoda trai najmanji element u nesortiranom dijelu polja i stavlja ga na svoje mjesto.

4 9 3 15 24 7
(------------------------)
3 9 4 15 24 7
(--------------------)
3 4 9 15 24 7
(-----------------)
3 4 7 15 24 9
(-------------)
3 4 7 9 24 15
(---------)
3 4 7 9 15 24

"Heap" sortiranje
"Heap" sortiranje pripada u familiju "selekcijskih" algoritama sortiranja. Takvi algoritmi
sortiranja odreuju prvo najvei (ili najmanji) element u listi te ga postavljaju na kraj (ili
poetak) liste, te na isti nain nastavljaju sa ostatkom liste. "Heapsort" izvrava ovaj zadatak
koritenjem strukture podataka koja se zove gomila (eng. heap). Podsjetimo se da je struktura
gomile binarno stablo u kojem za svaki vor vrijedi da je vrijednost u voru vea ili jednaka od
vrijednosti svih njegovih sljedbenika. Lista se pretvara u gomilu, a korijenski vor je sigurno
najvei element liste. Korijenski vor gomile se izuzima i stavlja se na kraj sortirane liste, tj.
gomila se skrauje za 1 element i ponovno podeava.

"Shell" sort
Donald Shell objavio je ovu metodu 1959. To je zapravo unaprijeena "bubble" metoda i
metoda "umetanja" na nain da se elementi pomiu u redoslijedu za vie pozicija istovremeno.
Implementacija ove metode moe se opisati kao "preslagivanje" liste (niza) u dvodimenzionalno
polje i zatim sortiranje stupaca takvog polja metodom umetanja. I ova metoda nije efikasna za
velike liste, ali je jedna od najbrih za liste reda veliine oko 1000 elemenata. Prednost je ove
metode to ima male zahtjeve za memorijom.

22
"Mergesort" (uparivanje i sortiranje)
Ovaj algoritam koristi strategiju "podijeli pa vladaj". Niz se rekurzivno dijeli u segmente koji se
zasebno sortiraju, a zatim se sortirani segmenti spajaju u konano sortirani niz. U primjeru na
slici 19 niz je podijeljen na dva segmenta koji su nakon sortiranja ponovo spojeni u jedan niz.

Slika 19: Primjer "mergesort" metode

"Quicksort"
"Quicksort" je do sada najbri poznati algoritam za sortiranje. I ovo je rekurzivni algoritam
zasnovan na strategiji "podijeli pa vladaj". Algoritam se sastoji od slijedeih koraka:
1. Odabir jednog lana niza, tzv. "pivot-a".
2. Raspodijeliti lanove niza na taj nain da sve elemente manje od pivot-a stavimo ispred
njega (podniz 1), a sve lanove vee od pivot-a stavimo iza njega (podniz 2). Nakon te
raspodjele "pivot" se nalazi na svojoj konanoj poziciji.
3. Rekurzivno sortirati svaki podniz na isti nain.

Slika 20: raspodjela niza na dva podniza oko odabranog "pivot-a" x

Rekurzija se prekida na nizovima od jednog ili niti jednog elementa, koji su sami po sebi
sortirani. "Quicksort" algoritam u svakoj iteraciji stavlja barem jedan element niza na njegovu
konanu poziciju. Izbor "pivot-a" nije jednoznano odreen, a nije niti jednoznano odreeno to
uiniti s lanovima polja jednakim "pivot-u", pa to postaje pitanje realizacije algoritma.

Indirektno sortiranje
Ako treba sortirati velike strukture, npr. slogove koji sadre vie polja: matini broj studenta,
prezime, ime, adresa, upisani predmeti i ocjene itd., tada nema smisla obavljati mnogo zamjena
velikog broja podataka. Ako se slogovi sortiraju npr. po matinom broju, tada se izdvoje u
posebno polje matini brojevi s pripadnim pokazivaima na ostale podatke. Sortira se (bilo kojim
od postupaka) samo takvo izdvojeno polje.

Algoritmi pretraivanja
U raunalnoj znanosti algoritam pretraivanja u irem kontekstu je algoritam koji daje rjeenje
nekog problema nakon evaluacije skupa moguih rjeenja. Skup svih moguih rjeenja problema
naziva se uobiajeno "prostor pretraivanja". Osnovna podjela algoritama pretraivanja je na tzv.
"slijepe" (eng. blind, uninformed search) i "usmjerene" (engl. directed, informed search).

23
Slijepo pretraivanje
Strategija slijepog pretraivanja ne uzima u obzir specifinu prirodu problema. Na taj nain
"slijepi" algoritmi pretraivanja mogu se poopiti, odnosno na isti nain mogu se primjeniti na
iroko podruje problema. Meutim veina prostora pretraivanja je vrlo velika, te ovakvi
algoritmi nisu efikasni osim za male primjere (veinom za edukacijske svrhe). Slijepo
pretraivanje napreduje sistematski kroz prostor pretraivanja ili po nekom prethodno
definiranom redoslijedu ili birajui redoslijed evaluacije sluajno.

Pretraivanje liste (niza)

Ovo je najjednostavnija vrsta algoritma pretraivanja. Cilj je pronai odreeni element prema
nekom kljuu - element koji ima odreenu vrijednost ili sadri informaciju povezanu sa kljuem.
To je jedan od najeih problema u raunalstvu, pa je sloenost i struktura ovakvih algoritama
temeljito prouena. Najjednostavniji takav algoritam je linearno pretraivanje, koje
jednostavno sekvencijalno ispituje jedan po jedan element iz liste. Vrijeme izvoenja je dugako,
ali ovaj algoritam se moe direktno primjeniti na "neobraenu" listu, za razliku od algoritama
koji npr. zahtijevaju da lista bude sortirana.
Binarno pretraivanje zapoinje na polovici liste i nastavlja se stalnim raspolavljanjem
intervala u kojem bi se mogao nai traeni zapis. Prosjeni broj pretraivanja je log2 n -1, gdje je
n broj elemenata u listi. Za binarno pretraivanje lista mora biti sortirana i mora biti omoguen
direktan pristup svim elementima liste (to je vano kod npr. pretraivanja slogova datoteke).
Za vrlo velike liste efikasniji je algoritam interpolacijskog pretraivanja.

Pretraivanje stabla
Algoritmi pretraivanja strukture stabla ine jezgru tehnika pretraivanja. Pretrauju se vorovi
stabla koji se uzimaju iz strukture podataka te se generiraju njihovi sljedbenici i dodaju u
strukturu. Struktura reda koristi se za uvanje generiranih i jo neistraenih vorova. Redoslijed
kojim se vorovi pohranjuju u red za ispitivanje i uklanjanje odreuje tip pretraivanja.
Postoje dva osnovna naina pretraivanja strukture stabla:
Pretraivanje u irinu (engl. breadth-first search) - ispituju se svi vorovi na odreenoj razini
prije prelaska na slijedeu razinu.
Pretraivanje u dubinu (engl. depth-first search) - pretrauje poniranjem niz stablo to je bre
mogue tako da uvijek generira djecu zadnjeg proirenog vora dok ne doe do rjeenja (ili
dok ne pree zadani limit dubine).
Algoritam pretraivanja u dubinu razlikuje se od onog u irinu po redoslijedu kojim je taj vor
stavljen u red - novostvorena djeca stavljaju se na poetak reda tako da se ona prva ispituju.
A A

B C B C

D D D D

C E F G B E F G C E F G B E F G

A G A G A G A G

Slika 21: Pretraivanje strukture stabla po irini i po dubini

Za pretraivanje strukture grafa takoer postoji nekoliko algoritama, a neki od njih zapravo su
proirenja algoritama za pretraivanje strukture stabla.
24
Usmjereno pretraivanje
Za razliku od slijepog pretraivanja, usmjereno pretraivanje koristi informacije o naravi
problema kao vodilje koje mogu bitno ubrzati pronalaenje rjeenja - to je vie podataka
dostupno postupku pretraivanja to je pretraivanje efikasnije. Takve informacije obino se
nazivaju heuristike temelje se na iskustvenim pravilima i tehnikama prosuivanja koje mogu
pomoi, ali nuno ne osiguravaju pronalaenje rjeenja. Heuristike informacije mogu se
oblikovati u heuristiku evaluacijsku funkciju koja zavisi od pojedinog vora i od cilja koji se
trai. Veina algoritama za usmjereno pretraivanje namijenjena je za strukture stabla, npr.
algoritam "najboljeg prvog" (eng. best-first search) koji zadrava procjene vrijednosti
heuristikih funkcija svih prethodno generiranih vorova i izabire najbolji za nastavak
potrage.

Svi mogui potezi u nekoj igri (npr. ah ili "krii krui") mogu se prikazati strukturom stabla.
Takva struktura prikazuje prostor moguih stanja koja nastupaju tijekom igre. Pretraivanje
takve strukture u svrhu pronalaenja efikasne strategije planiranja slijedeih poteza dodatno je
oteano jer treba razmatrati i sve mogue poteze koje moe povui drugi igra. Raunalni
programi za ovakve namjene pripadaju u domenu umjetne inteligencije, osnovne vrste
algoritama za pretraivanje u ovakvoj vrsti problema su (engleski nazivi): minimax algoritam),
search tree pruning i alpha-beta pruning (pruning kresati, oistiti).
Slika 22 sadri samo mali dio ukupnog prostora moguih stanja u igri "krii krui", tj. na
svakoj razini nakon druge "ekspandiran" je samo jedan vor (prikazani su sljedbenici samo
jednog vora stabla), makar i svi ostali vorovi te razine imaju isti broj sljedbenika.

O O O
O O O
O O O

X X X
O O O XO OX O O O
X X X

O O O
O O O OO OO O O
X X X X X XO X O

Slika 22: Dio prostora stanja igre "krii krui"

U veini slinih prostora stanja izraen je problem tzv. "kombinatorike eksplozije", tj. sa
svakim novim elementom uzetim u obzir, eksponencijalno raste broj moguih kombinacija
odnosno stanja koje treba pretraivati.

Primjeri usmjerenog pretraivanja u inenjerskoj praksi

U inenjerskoj praksi (najee u konstruiranju) vrlo esti su problemi zadovoljenja ogranienja.
Umjesto putanje kroz prostor stanja, rjeenje je ovdje skup vrijednosti koje poprima skup
varijabli.
Proizvod koji se konstruira mora zadovoljiti skup funkcionalnih zahtjeva. Funkcionalni zahtjevi
ispunjavaju se indirektno mijenjanjem jednog ili vie parametara konstrukcije, fizikog oblika i
operativnih uvjeta. Uobiajeno je da se funkcionalni zahtjevi izraavaju kao funkcije parametara
konstrukcije, drugih funkcionalnih zahtjeva i razliitih "internih varijabli" ("prijelaznih ili

25
pomonih" varijabli). Interne varijable i parametri konstrukcije ine vektor nepoznanica
konstrukcije P = [p1, p2, p3, , pn]. Funkcionalni zahtjevi ine vektor F = [F1, F2, F3, , Fn].
Relacije izmeu zahtjeva i nepoznanica mogu se izraziti kao:
fi ( F, P ) = 0 i = 1, k
gj ( F, P ) Gj j = 1, s
Navedene jednadbe i nejednadbe u terminologiji znanosti o konstruiranju nazivaju se
"ogranienja". Pri tome neke od navedenih relacija ne moraju sadravati funkcionalne zahtjeve,
nego samo parametre i "interne varijable". esto je vrlo teko pronai skup vrijednosti varijabli
(nepoznanica konstrukcije) tako da budu jednako kvalitetno zadovoljeni svi funkcionalni
zahtjevi, jer pojedini zahtjevi esto budu u koliziji.
Metode rjeavanja problema ogranienja ukljuuju kombinatoriko pretraivanje i
"backtracking".
U novije vrijeme brojna su istraivanja tzv. genetikih algoritama koji simuliraju procese
bioloke evolucije i koriste ih za pronalaenje puta prema rjeenju problema.

PROGRAMSKI JEZICI
Programski jezik zapravo je skup sintaktikih i semantikih pravila koja definiraju raunalni
program. Jezik omoguuje programeru precizno specificiranje na kojim podacima e raunalo
djelovati, kako e ti podaci biti spremljeni i prikazani, te koje akcije treba poduzeti za razliite
uvjete. Kompleksne raunalne aplikacije danas nalazimo gotovo u svakom aspektu modernog
ivota: medicinski ureaji, elektrane, video igre, sustavi u automobilu itd. Mnoge aplikacije
sadre milione linija koda (naredbi) od kojih se oekuje da rade ispravno u svim situacijama.
Softver openito mora biti izuzetno pouzdan - posljedice greki mogu biti u rangu od nelagode
pa do ivotne opasnosti. to je potrebna vea pouzdanost, to je i razvoj skuplji, pa uvijek treba
traiti kompromis izmeu cijene i pouzdanosti. Navedenim problemima bave se strunjaci iz
podruja softverskog inenjerstva (eng. software engineering). Tehnike softverskog inenjerstva
nastoje unaprijediti funkcionalnost i pouzdanost programa, uz istovremeno poveanje efikasnosti
i olakavanje procesa razvoja softvera. Problemi softverskog inenjerstva ujedno su i ciljevi
daljnjeg razvoja programskih jezika.
Povijesni razvoj programskih jezika, tehnika i metodologija programiranja moe se promatrati
kroz nekoliko osnovnih problema. Poetkom sedamdesetih godina prolog stoljea dolo je do
razvoja prvih izuzetno velikih programskih sustava koji su postavili pitanje kako se moemo
nositi sa veliinom i sloenou modernih raunalnih programa, odnosno kako planirati i
realizirati procese razvoja takvih sustava? Neprestana konkurentska borba na tritu potakla je
razvoj mnogih metoda i alata kojima se nastoji smanjiti vrijeme i cijenu razvoja sloenih
programa. Ono to i danas "najvie boli" svakog korisnika bilo koje aplikacije je kako poveati
pouzdanost, odnosno minimizirati koliinu "bugova" s kojima aplikacija izlazi na trite.
U ovom poglavlju izloen je kratki pregled podjele programskih jezika po razliitim kriterijima,
a zatim slijedi opis etiri metodologije (paradigme) programiranja koje su u svojim osnovama
bitno razliite kao i podruja njihove namjene. Razlike izmeu programskih jezika najbolje je
promatrati upravo kroz vrste metodologije programiranja kojima pripadaju, a ne po detaljima
implementacije ili perfromansi. Nastanak razliitih metodologija uvjetovan je proirenjem sa
poetnog koritenja softvera iskljuivo za numerike probleme na sve aspekte ivota, ali i svim
ranije izloenim problemima kojima se bavi softversko inenjerstvo. Objektno orijentirana
metodologija je danas prevladavajua metodologija programiranja u razvoju velikih i sloenih
programskih sustava za veinu podruja primjene raunala. Stoga je objektno programiranje
izloeno puno opirnije od ostalih metodologija, tj. posveeno mu je cijelo poglavlje koje slijedi
iza ovog poglavlja.

26
Podjela programskih jezika
Mnogo je kriterija po kojima moemo izvriti podjele svih postojeih programskih jezika.
Podjela prema namjeni dosta je relativna - prvi razvijeni jezici bili su za numerike i znanstvene
probleme (FORTRAN, ALGOL) i za poslovne probleme (COBOL). Daljnjim razvojem
podruja namjene su se stalno proirivala, mogli bi se npr. izdvojiti jezici za podruje umjetne
inteligencije (LISP, PROLOG), jezici za manipuliranje sa bazama podataka (SQL) itd. Velik dio
dananjih modernih jezika moe se smatrati vienamjenskima.
Kako je ve navedeno najvee razlike izmeu programskih jezika mogu se razluiti po nainu
rada, odnosno prema metodologiji (paradigmi) programiranja. etiri osnovne (najee koritene
paradigme su imperativna (proceduralna), funkcijska, logika i objektno orijentirana. Svaka od
njih detaljnije je obraena u ovom poglavlju. Neki jezici ne mogu se svrstati iskljuivo u jednu
paradigmu pa ih nazivamo hibridnima. Primjer takvog jezika je C++, koji se uobiajeno smatra
objektnim jezikom, ali nema sva svojstva "istog" objektnog jezika, a s druge strane ima i veinu
karakteristika proceduralnog jezika.
Vaan je kriterij "proceduralnosti" u proceduralnim programskim jezicima slijed naredbi
odreuje KAKO obaviti neki posao, a u neproceduralnim jezicima slijed naredbi odreuje TO
treba uiniti.
Sa aspekta strukturiranosti razlikujemo nestrukturirane i strukturirane programske jezike.
Sa aspekta povijesnog razvoja odnosno generacijske podjele razlikujemo jezike prve, druge,
tree i etvrte generacije. Jezici etvrte generacije bitno olakavaju i ubrzavaju proces razvoja
softvera (npr. SQL jezik koji se koristi za baze podataka).

Metodologije (paradigme) programiranja

Metode koncipiranja, modeliranja i programiranja kompleksnih programskih sustava prole su u
svom razvojnom putu nekoliko faza kroz koje se iskristaliziralo vie razliitih pristupa koji se
obino nazivaju paradigmama (eng. paradigm). U ovom kontekstu rije "paradigm" pogodno bi
bilo prevesti kao "obrazac". Ovdje e biti dani prikazi proceduralnog, funkcijskog, logikog i
objektno orijentiranog programiranja.
Paradigma programiranja odreuje nain koncipiranja programa, ali prvenstveno i nain
izvravanja programa. Na primjer u objektnom programiranju, programer promatra program kao
skup objekata koji meusobno komuniciraju, dok u funkcijskom programiranju program
moemo promatrati kao niz evaluacija funkcija.
Razliiti programski jezici podravaju razliite paradigme programiranja. Veina jezika
podrava samo jednu paradigmu, a ima i jezika koji mogu podrati i vie paradigmi npr. C++,
Common Lisp, Python i Oz. Npr. C++ podrava elemente proceduralnog programiranja,
objektnog programiranja i generikog programiranja. U jeziku C++ mogue je napisati "isto"
proceduralni program, "isto" objektni program ili program koji sadri elemente obje paradigme.

Imperativno (proceduralno) programiranje

Imperativno programiranje opisuje raunalni proces u smislu stanja programa i naredbi koje
mijenjaju stanje, odnosno programi su niz naredbi koje raunalo treba izvesti. Hardverska
implementacija veine raunala je imperativna, tj. veina hardvera konstruirana je da izvrava
strojni jezik napisan u imperativnom stilu. Na toj razini, stanje programa je definirano sadrajem
memorije i naredbama strojnog jezika. Vii imperativni programski jezici upotrebljavaju
varijable i kompleksnije naredbe, ali i oni slijede istu paradigmu. Poto su temeljne ideje
imperativnog programiranja "ugraene" u hardver, veina programskih jezika je imperativna.
Imperativni jezici postiu funkcionalnost dodjeljivanjem vrijednosti varijablama i ispitivanjem
vrijednosti varijabli. Naredba dodjeljivanja vrijednosti zapravo izvodi operaciju na informaciji u
memoriji. Vii programski jezici omoguuju izraunavanje sloenih mjeovitih izraza koji su

27
kombinacija aritmetikih, relacijskih i logikih operatora te poziva funkcija. Nakon
izraunavanja vrijednost izraza dodjeljuje se memorijskoj lokaciji. Petlje ponavljaju niz naredbi
odreeni broj puta ili do promjene odreenog uvjeta. Uvjetno grananje omoguuje izvoenje
bloka naredbi samo pod odreenim uvjetima. Naredbe bezuvjetnog grananja ukljuuju tzv.
bezuvjetni skok i poziv procedure odnosno potprograma.
Imperativno (proceduralno) programiranje najee se upotrebljava za rjeavanje veine
problema u inenjerskoj praksi.
Vano je ovdje napomenuti da se sve to je izloeno u poglavlju "osnovni koncepti programskih
jezika" odnosi na imperativne jezike, jer druge paradigme imaju neke dijelove koncepata rijeene
na bitno drugaiji nain! Zadaci koji se obrauju na vjebama iz kolegija "Programiranje i
algoritmi" napravljeni su imperativnim stilom. Visual Basic .NET hibridni je jezik kao i C++, pa
spomenuti zadaci sadre i neke elemente objektne paradigme.

Programi pokretani dogaajima

Razvoj raunalne grafike potaknu je i razvoj grafikih suelja koja koristimo pri radu sa
programskim sustavima, kao i u procesu razvoja programa. Programe prvih imperativnih jezika
raunala su uitavala pomou buenih kartica. Slijedio je period uporabe alfanumerikih
terminala kada se za unos naredbi i pokretanje programa koristila tipkovnica, uz mogunost
prikaza upisanog teksta i/ili izlaznih podataka na ekranu. U to vrijeme veina programa izvodila
se u slijedeim koracima:
1. pokretanje programa upisivanjem odgovarajue naredbe operativnog sustava,
2. upisivanje ulaznih podataka,
3. program obrauje podatke, ispisuje izlazne podatke i zavrava s radom.
U ovakvom nainu rada program kontrolira redoslijed izvoenja pojedinih dijelova programskog
koda. Izvoenje poinje prvom "izvrnom" naredbom i slijedi unaprijed odreene putanje do
zadnje naredbe kojom se prekida izvravanje.
Pojava mia i grafikih elemenata u suelju operativnog sustava znatno je unaprijedila
mogunosti komunikacije s raunalom. Tada se razvija posebna vrsta upravljanja sa radom
programa programiranje pokretano dogaajima (eng. event driven programming).
U programu upravljanom dogaajima programski kod ne slijedi u cijelosti unaprijed odreene
putanje, ve se izvode razliiti dijelovi programskog koda kao odgovori na dogaaje. Dogaaji
mogu biti pokrenuti akcijom korisnika, porukama sustava ili drugih programa te samog
programa. Redoslijed tih dogaaja odreuje segmente putanje kojom e programski kod biti
izveden. Unutar jedne procedure koja reagira na pojedini dogaaj putanja izvoenja i dalje je
odreena naredbama po imperativnom principu.
Primjer implementacije programiranja pokretanog dogaajima je Visual Basic .NET, i ostale
razvojne okoline s prefiksom "Visual". Dogaaji su preteno akcije korisnika kao to je klik
miem ili odabir stavke iz izbornika, ali mogu biti i rezultat akcije nekog drugog dijela
programskog koda. U toku rada programa poseban dio sustava obrauje dogaaje te poziva
(aktivira) odgovarajue dijelove programskog koda (procedure) slika 23.

dogaaj
(event)
procesiranje dogaaja
(event processor)

programski kod 1 programski kod 2 programski kod 3

(event procedure 1) (event procedure 2) (event procedure 3)

Slika 23: program pokretan dogaajima

28
Budui da se ne moe predvidjeti redoslijed dogaaja (pa niti koji e se dogaaji "dogoditi", a
koji ne), programski kod mora uzeti u obzir neke pretpostavke o "opem stanju" (suelja i
podataka) kada se pone izvoditi npr. sadri li polje za upis podatka neku vrijednost ili ne i sl.
Ovdje je potrebno napomenuti da je vrlo teko grafiki prikazati putanje izvravanja programa u
ovakvim situacijama. Standardni elementi dijagrama toka razvijeni su u doba prije nastanka
tehnike programiranja pokretanog dogaajima i nisu naknadno prilagoavani ovoj tehnici, pa ne
sadre sve elemente potrebne za prikaz situacija koje mogu nastupiti u programima upravljanim
dogaajima.
Proces rada aplikacije upravljane dogaajima moe se opisati slijedeim koracima:
1. Poetak izvoenja aplikacije uitava se i prikazuje suelje (u Visual Basicu se zove
forma) kao poseban "prozor" na ekranu.
2. Forma ili kontrola na formi prima dogaaj. Dogaaj moe biti uzrokovan akcijom
korisnika (npr. "klik" miem), sustavom (npr. mjera vremena), ili posredno
programskim kodom (npr. dogaaj "Load" pri uitavanju forme).
3. Ako postoji programski kod u odgovarajuoj "event proceduri" ona se izvodi.
4. Aplikacija nakon toga eka na idui dogaaj.
Koraci 2, 3 i 4 se ponavljaju, sve dok korisnik ili naredba u programskom kodu ne prekinu
izvoenje aplikacije.
Programiranje pokretano dogaajima nije svojstveno odreenoj paradigmi programiranja, nego
se radi o nainu rada sa programom tijekom njegova izvoenja.

Funkcijsko programiranje
Funkcijsko programiranje vrsta je paradigme koja tretira raunalni proces kao evaluaciju
matematikih funkcija. Za razliku od imperativnog programiranja, funkcijsko programiranje
naglaava evaluaciju funkcijskih izraza umjesto izvoenja niza naredbi. Neki mehanizmi i
operacije karakteristini za imperativno programiranje u funkcijskom programiranju ne postoje
ili su rijeeni na drugi nain. Na primjer u striktnom funkcijskom programiranju nema
eksplicitne alokacije memorije, niti eksplicitnog dodjeljivanja vrijednosti varijablama. Te
operacije izvode se automatski prilikom poziva funkcije, to ima za posljedicu da se eliminira
tzv. popratni efekt poziva funkcije (eng. side effect), karakteristian za imperativne jezike. Na taj
nain eliminiraju se i negativne posljedice popratnih efekata poziva funkcije koje postoje u
imperativnim jezicima. Za odreeni skup parametara, rezultat poziva funkcije u funkcijskom
jeziku biti e uvijek isti bez obzira gdje ili kada je poziv funkcije izvren. Na taj nain osigurava
se tzv. referencijalna transparentnost koja uvelike olakava dokazivanje ispravnosti programa i
omoguuje automatsko odreivanje dijelova programa koji se mogu nezavisno izvravati u
paralelnim procesima. Ponavljanje dijelova programskog koda u smislu petlji ne postoji u
funkcijskim jezicima, nego se takvi procesi rjeavaju rekurzijom. Rekurzija moe poprimiti
mnoge oblike u funkcijskim jezicima i openito se smatra da je efikasnija od mehanizama petlji
u imperativnim jezicima. To je i jedan od razloga da i veina imperativnih jezika podrava
rekurziju (iznimke su npr. FORTRAN 77 i COBOL prije 2002).
Funkcijski jezici specificiraju TO treba napraviti, ostavljajui detalje organizacije podataka i
redoslijeda izvoenja interpreteru, dakle naglasak je na tome to e biti izraunato, a ne kako e
biti izraunato.
Imperativni jezici detaljno opisuju KAKO treba doi do rezultata, i to koritenjem postojee
arhitekture raunala (hardvera).
Predstavnici "istih" funkcijskih jezika su Haskell i ML. Jezik LISP pripada funkcijskoj
paradigmi, ali nije "isti" funkcijski jezik, iako je najraireniji u uporabi.
U tabeli koja slijedi dana je paralelna usporedba imperativnog i funkcijskog programiranja.

29
IMPERATIVNO FUNKCIJSKO
Program: niz naredbi za von Neumann-ovu Program: skup definicija funkcija (neovisan o
arhitekturu raunala strojnom kodu raunala)
Izvrava se niz naredbi Izvravanje evaluacijom izraza
Iteracija Rekurzija
Varijable se mijenjaju tijekom izvravanja Varijablama se samo jednom pridruuje
vrijednost
Primjer: Primjer:

i := 0; sum := 0; func sum(n:int) : int;

while (i < n) do if n = 0
i := i + 1; then 0
sum := sum + i else n + sum(n-1)
end; end;

Deklarativno (logiko) programiranje

Deklarativno programiranje ukljuuje kreiranje skupa relacija koje opisuju prostor rjeenja.
Interpretacija specifinih koraka na putu pronalaenja rjeenja ostavlja se interpreteru. Drugim
rijeima znanje sadrano u skupu relacija interpreter upotrebljava na razliite naine za
rjeavanje razliitih upita. Takve relacije mogu biti injenice i pravila. Kao i funkcijsko,
deklarativno programiranje definira TO treba uiniti, a KAKO e se to uiniti ostavlja se
interpreteru. Stoga deklarativna rjeenja imaju dvije nezavisne faze: deklariranje i interpretiranje.
Deklarativni jezici opisuju relacije (odnose) izmeu varijabli u kontekstu funkcija, pravila
nasljeivanja ili definiranja pojmova. Proces izvoenja programa (interpreterom ili compilerom)
primjenjuje odreeni algoritam na te relacije da bi generirao rezultat (najee je to odgovor na
neki upit).
Prednosti deklarativne paradigme ogledaju se u tome da se rjeenje problema moe prikazati na
apstraktnoj razini, bez ulaenja u irelevantne detalje. Na taj nain rjeenje postaje preglednije i
razumljivije. Logika interpretera (tj. u njega ugraeni algoritmi) moe se primjeniti na irokom
podruju problema, tj. deklarativnih specifikacija.
Deklarativni jezici intenzivno se upotrebljavaju u slijedeim podrujima: umjetna inteligencija,
problemi zadovoljavanja ogranienja, baze podataka, upravljanje konfiguracijama, komunikacija
izmeu procesa. Poznatiji predstavnici deklarativnih jezika su Prolog (PROgramming in LOGic)
i SQL (Structured Query Language).

Objektno orijentirana paradigma programiranja

Objektno orijentirano programiranje (u daljnjem tekstu upotrebljavati e se i skraenica OOP)
danas prevladava kao osnovna metodologija (paradigma) koja se upotrebljava pri razvoju gotovo
svih sloenih programskih sustava. Zbog vanosti OOP, ovoj metodologiji e biti posveeno
puno vie prostora nego ostalim metodologijama. Za rjeavanje jednostavnijih problema
pogodno je i dovoljno i imperativno (proceduralno) programiranje.
Kao uvod u izlaganje objektno orijentiranog programiranja najprije emo izvriti usporedbu
proceduralnog programiranja (s kojim smo se bavili u dosadanjem dijelu izlaganja) i objektno
orijentiranog programiranja. Treba napomenuti da varijable, izrazi i osnovne kontrolne strukture
na razini naredbi na jednak nain egzistiraju i u proceduralnom i u objektnom programiranju.

30
Usporedba proceduralnog i objektnog programiranja
Nedovoljno informirani programeri poetnici esto nepotrebno usporeuju programske jezike
razliitih kategorija i paradigmi, pa npr. izvode zakljuke kao: C++ ima puno vie "toga" pa je
stoga puno bolji jezik od C-a, pa u onda samo njega koristiti i slino. Pri odabiru programskog
jezika za rjeavanje nekog problema, odnosno za izradu sloenije aplikacije, nuno je poznavati
karakteristike paradigme programiranja kojoj jezik pripada. Stoga je u dodatku 2 ovih skripata
dana detaljna usporedba proceduralnog i objektnog programiranja, kao dvije danas dominantne
paradigme u inenjerskoj praksi. U okviru ovog poglavlja navedene su samo osnovne razlike
proceduralnog i objektnog programiranja.
Programski sustav moe se definirati kao skup mehanizama koji izvode odreene operacije nad
podacima. To znai da proces koncipiranja programskog sustava moemo promatrati sa dva
aspekta: moemo se usredotoiti primarno na procedure (funkcije) ili primarno na podatke. Bit
razlike izmeu tradicionalnih proceduralnih metodologija i novih objektno orijentiranih lei u
primarnom fokusu (aritu). Proceduralne tehnike usredotouju se na funkcije sustava - "to
sustav radi" (eng. what is it doing), a objektno orijentirane tehnike usredotouju se na podatke
(objekte) sustava - "emu su podvrgnuti" (eng. what is being done to). Takva naizgled
jednostavna promjena fokusa dovodi do radikalne promjene procesa koncipiranja programskog
sustava. Proceduralno programiranje karakterizira "top-down" pristup u razvoju sustava, poznat i
kao dekompozicija funkcija. Kree se od opih postavki o procesu rjeavanja problema prema
sve detaljnijim odredbama o svakom specifinom zadatku u procesu. Dekompozicija se odvija
striktno po funkcionalnim linijama, odnosno vodi se rauna samo o tome "to koji modul radi".
Primjer "top-down" dekompozicije procedure za prikupljanje podataka prikazan je na slici 24.

Procedura za
uitavanje
podataka

Otvaranje Verificiranje Uitavanje Korigiranje

datoteka ulaznih podataka podataka podataka

Korekcija
Kreiranje Kreiranje novih Korekcija prve Korekcija druge
pojedninog
direktorija tablica grupe podataka grupe podataka
podatka

Korekcija Korekcija Korekcija

podatka 1 podatka 2 podatka 3

Slika 24: Primjer "top-down" dekompozicije

Rezime osnovnih razlika proceduralnog i objektnog programiranja dan je u slijedeoj tabeli:

PROCEDURALNO (IMPERATIVNO) OBJEKTNO

naglasak na proceduralnoj apstrakciji naglasak na apstrakciji podataka
"top-down" razvoj programa "bottom-up" razvoj programa
stupnjevano poboljavanje ponovo upotrebljiva rjeenja
pogodno za manje programe pogodno za velike programske sustave

31
Prednost " Top-down" koncepcije (pristupa) je u tome da omoguuje fokusiranje na manje
detalja istovremeno, smanjujui na taj nain razinu kompleksnosti u svakoj fazi procesa razvoja.
Stoga takav pristup dalje najbolje rezultate kod problema koji su isto hijerarhijske prirode.
Naalost, mnogi problemi stvarnog svijeta (stvarni problemi) nisu hijerarhijski.
"Top-down" pristup temeljen na funkcijama ima i druge nedostatke koji dolaze do izraaja pri
razvoju i odravanju vrlo velikih sustava:
teko je razvijati "funkcionalnu toku gledanja" (eng. functional viewpoint)
realne sustave problematino je karakterizirati funkcionalno
funkcionalni fokus gubi pregled podataka
producira se programski kod koji je teko iznova upotrebljiv

OBJEKTNO ORIJENTIRANO PROGRAMIRANJE

Objektno orijentirani pristup modeliranju i programiranju kombinira podatke i naredbe
(programski kod) koje manipuliraju s podacima u jedinstveni koncept OBJEKT.
Vano je naglasiti da se objektno orijentirano programiranje ne bavi programiranjem u smislu
razvoja algoritama i struktura podataka, nego ga treba promatrati kao skup sredstava za
organiziranje programa, odnosno openitije kao tehnike za koncipiranje programa. Osnovni
gradbeni element jezika je objekt a ne algoritam (to ne znai da se algoritmi zanemaruju).
U objektno orijentiranom pristupu naglasak je na modeliranju stvarnosti u domeni problema
umjesto stvaranja arhitekture modela sustava koja vodi k implementaciji.
Temeljna je ideja (princip) objektno orijentiranog programiranja: modelirati raunalni program
kao skup objekata koji komuniciraju (funkcioniraju) zajedno da bi postigli cilj zadatka
postavljenog cjelokupnom sustavu. Pri tome svaki objekt modelira entitet ili dogaaj iz
aplikacijskog problema (domene, "stvarnog svijeta") objekti mogu obuhvaati apstrakcije
kompleksnih fenomena ili mogu reprezentirati elemente programskog sustava (npr. stogove ili
upravljanje grafikim prikazom). Dakle objekti su osnovna sredstva strukturiranja programa,
odnosno ine sredinji programski (softverski) koncept OOP. Objekt obuhvaa identitet,
strukturu i ponaanje aplikacijskih entiteta koje reprezentira (modelira). Operacijski gledano,
objekti kontroliraju raunalni proces. Iz perspektive razvoja programa, najvanija karakteristika
objekata nije njihovo ponaanje kao takvo, nego injenica da se ponaanje objekta moe opisati
apstraktnom karakterizacijom njegova suelja. Takva apstraktna karakterizacija dovoljna je za
poetno koncipiranje sustava. Stvarno ponaanje objekta moe se implementirati i doraditi
kasnije, prema potrebama.
U stvarnom svijetu mnogi objekti su slini - imaju zajednika svojstva i ponaanje. Ipak, svaki
objekt ima svoj identitet i svoje jedinstvene vrijednosti (unutar) zajednikih svojstava. Unato
jedinstvenosti identiteta i vrijednosti svakog objekta, smislenije je opisivati objekte u grupama.
Objektno orijentirani program opisuje objekte koji se pojavljuju u aplikaciji - to ini sa klasama
ije instance su objekti. Dakle "objekt" je programski (softverski) koncept koji modelira
aplikacijski entitet. "Klasa" je programski (softverski) koncept koji opisuje skup objekata.
Objekti se mogu usporediti sa varijablama u tradicionalnim programskim jezicima. Ipak, postoji
znaajna razlika izmeu objekta i varijable. Varijabla obuhvaa samo "podatkovni"
(informacijski) aspekt objekta (vrijednost), ali ne i ponaanje.
Kombinacija strukture podataka i deklaracije funkcija, zajedno sa sposobnou da iz sebe kreira
instance razliitih identiteta, naziva se klasom u objektno orijentiranim programskim jezicima.
Klasa usko povezuje strukture podataka i njima pridruene procedure koje ih obrauju.
Objektna tehnologija razvoja sustava koristi isti model kroz cijeli proces razvoja sustava:
- zapoeti sa objektno orijentiranom analizom
- konvertirati rezultate analize u objektne koncepte
- napisati objektno orijentirane programe
32
Dakle, moda najvea prednost objektne tehnologije je u konzistentnosti modela tijekom cijelog
procesa razvoja programskog sustava. to je sustav kompleksniji i vei, ta prednost vie dolazi
do izraaja.
Vjerojatno najvaniji doprinos objektne orijentacije programerskoj praksi je upotreba
nasljeivanja pri odreivanju relacija izmeu objekata, odnosno klasa objekata. Nasljeivanje
omoguuje inkrementalno dodavanje funkcionalnosti (specifikaciji). Na taj nain osigurano je
bolje konceptualno modeliranje - mogu se izvui zajedniki dijelovi specifikacije i omoguena je
ponovna upotrebljivost specifikacije programskog koda. Ako se (disciplinirano) primjenjuje na
odgovarajui nain, nasljeivanje omoguuje postupan razvoj specifikacije tipa klase objekata.
Razliiti objekti razliitih tipova mogu se promatrati kao elementi zajednikog "super" tipa.
Navedimo uvjete koje mora ispunjavati programski jezik da bude objektno orijentiran:
Treba podravati objekte koji predstavljaju apstrakciju entiteta iz domene problema. Objekti
moraju imati mogunost skrivanja lokalnog stanja i posjedovati suelje koje definira operacije
nad tim objektima. Objekti moraju pripadati nekoj klasi (razredu), a klase mogu nasljeivati
svojstva od nadklasa.
U ovom trenutku sigurno se namee pitanje da li je opravdano koristiti objektno orijentirano
programiranje kada iste zadatke moemo rijeiti i napisati i u jeziku koji nije objektan? Prednosti
ove paradigme i metodologije prvenstveno se oituju pri razvoju velikih i sloenih programskih
sustava. Apstrakcija podataka (eng. data abstraction) pridonosi lakem razumijevanju i
snalaenju u programskom kodu objekt ine strukture podataka zajedno sa procedurama nad
tim podacima. Ponovna iskoristivost programskog koda (eng. code reusability) uvelike olakava
proces razvoja i posebno odravanja - jednom napisani kod se koristi vie puta i na vie razliitih
naina. Ukoliko je potrebno promijeniti ili dodati neke postupke u ve definiranu klasu, to se
izvodi jednostavno pomou nasljeivanja i vieoblija. Ovom metodologijom programski
sustavi se grade na osnovi stabilnih meuformi, tako da sustav evoluira tijekom vremena.
Jedno od primarnih svojstava objekta je kombiniranje struktura podataka i funkcionalnosti -
programski kod i svi relevantni podaci su "spakirani" zajedno. Objekt moemo promatrati kao da
se nalazi unutar "ahure" (kapsule) koja osigurava da podaci i kod egzistiraju zajedno. ahura
takoer slui i kao zatita od neautoriziranog pristupa internim podacima i operacijama objekta.
Dozvola pristupa mora se eksplicitno definirati.

Koncept objekta
Osnovni elementi objekata su atributi i operacije.
Atribut je informacijski detalj svojstven objektu. Ovisno o konkretnom programskom jeziku,
atributi se nazivaju i varijablama ili svojstvenim poljima (eng. member fields).
Operacija je funkcionalni detalj svojstven objektu i spremljen kao dio objekta. Za operacije se
koriste i nazivi svojstvena funkcija (eng. member function) ili metoda.
objekt

atributi
suelje

operacije

unutranjost vanjski svijet

Slika 25: Dijagram objekta "unutranjost" i "vanjski svijet"

33
Pri modeliranju sustava korisno je prikazivati objekte i klase pomou dijagrama. Dijagram
objekta naglaava objekt kao neto to ograniava svoju "unutranjost" i komunicira sa
"vanjskim svijetom".
Objekti su dobro definirane konstrukcije prikaza konkretnih ili konceptualnih entiteta. Navesti
emo znaajke objekata:
Objekti:
" "Enkapsuliraju" strukturalne znaajke - atribute.
- Atributi:
- odreuju mogua stanja objekta
- su ekstrahirani iz domene upotrebom deklarativne ili informacijske apstrakcije
- mogu biti jednostavni ili kompleksni tipovi podatka
- mogu imati jednu ili vie (skup) vrijednosti
" "Enkapsuliraju" znaajke ponaanja - operacije.
- Operacije:
- odreuju mogua ponaanja objekta
- su ekstrahirane iz domene upotrebom proceduralne ili procesno orijentirane
apstrakcije
- sadre ulazne i izlazne parametre, te vrijednosti koje "vraaju"
- se pozivaju kao odgovor na primanje poruke
" Mogu biti aktivni i pasivni.
- Aktivni objekti imaju "nit kontrole" (eng. thread of control) i mogu inicirati aktivnosti.
- Pasivni objekti samo primaju zahtjeve od ostalih objekata i nemaju "nit kontrole".
" Mogu biti "stalni" (eng. persistent) ili tranzijentni (eng. transient). Stalni objekti postoje i
nakon prestanka postojanja njihovih kreatora, a tranzijentni objekti postoje samo za vrijeme
postojanja njihovog kreatora.
" Imaju identitet, tj. svaki objekt je jedinstven.
" Sudjeluju u relacijama i dogaajima.
" Sadre semantiku, odnosno znaenje i svrhu unutar problema ili rjeenja.
" Mogu biti kompleksni, s mogunou reduciranja u podreene objekte, ili mogu biti
primitivni, bez mogunosti reduciranja.
" Objekti su instance klasa. Kae se da objekti "instanciraju" klase. Relacija izmeu objekta i
klase je poznata kao "is-a" relacija.

Dakle "objekt" je programski (softverski) koncept koji modelira aplikacijski entitet.

"Klasa" je programski (softverski) koncept koji opisuje skup objekata.

Koncept klase
Unato jedinstvenosti identiteta i vrijednosti svakog objekta, smislenije je opisivati objekte u
grupama. To se ini sa klasama ije instance su objekti. Klasa opisuje skup entiteta koji imaju
zajednike temelje koncepta.
Kombinacija strukture podataka i deklaracije funkcija, zajedno sa sposobnou da iz sebe kreira
instance razliitih identiteta, naziva se klasom u objektno orijentiranim programskim jezicima.
Klasa usko povezuje strukture podataka i njima pridruene procedure koje ih obrauju.
Objekt je instanca klase, a klase slue kao predloci za kreiranje objekata. Klase imaju ivotni
ciklus koji dijele sa svojim objektima (slika 26).

34
 ivotni ciklus jedne klase

ivotni cilkus skupa

objekata klase

selekcije
inicijalizacija konstrukcija destrukcija finalizacija

mutacije

Slika 26: ivotni ciklus klase i njenih objekata

Navesti emo znaajke klasa:

Klase:
" Se bave implementacijom uniformnih strukturalnih znaajki i znaajki ponaanja.
" Imaju sposobnost definiranja uzoraka za objekte klase. Klasa odreuje strukturu i ponaanje
tih objekata.
" Imaju sposobnost kreiranja objekata. Klasa se moe promatrati kao "tvornica objekata". Klase
takoer mogu odravati reference na sve svoje objekte.
" "Enkapsuliraju" strukturalne znaajke - atribute.
- Atributi:
- su implementirani klasom
- mogu biti vezani uz objekte klase - svaki objekt moe imati svoju vrijednost, tj.
atribut objekta je unutar dosega odreenog objekta
- mogu biti vezani sa klasom kao cjelinom - svi objekti klase dijele istu vrijednost,
tj. atributi klase su unutar dosega svih objekata klase
" "Enkapsuliraju" znaajke ponaanja - operacije.
- Operacije:
- Su implementirane kao metode ili potprogrami, a obino se nazivaju servisima
koje nudi klasa (ili njeni objekti)
- mogu biti vezane uz objekte klase, odnosno primjenjene na objekte klase
- mogu biti vezane sa klasom kao cjelinom, odnosno primjenjene na samu klasu
- mogu biti apstraktne, tj. mogu imati specificirano samo suelje, bez
implementacije, ali takve klase ne mogu imati instance
" Definiraju pristupanost atributa i operacija iz vanjskog svijeta prema objektu klase.
Razlikuju se tri vrste pristupa:
- "public" - svi drugi objekti imaju pristup
- "protected" - pristup imaju objekti unutar iste klase
- "private" - nema pristupa iz vanjskog svijeta prema znaajkama objekta
" Mogu imati posebne mehanizme (protokole) kroz koje drugi objekti mogu doprijeti do
atributa i operacija, odnosno mijenjati ih, dodavati i brisati.
" Mogu biti parametrizirane, tj. zahtijevati parametre definiranja da bi postale sposobne za
kreiranje objekata. Parametrizirane klase obino se nazivaju i generike klase ili "klase
predloci" (template classes).
" Mogu omoguiti svojim objektima da budu klasificirani kao statiki ili dinamiki. Za razliku
od statikih, dinamiki objekti mogu mijenjati svoje klase.
" Omoguuju objektima da pripadaju direktno u vie klasa.

35
" Imaju ivotni ciklus koji dijele sa svojim objektima (slika 26). ivotni ciklus naznaen je
slijedeim vrstama operacija:
- operacije inicijalizacije - pozivaju se pri kreiranju prvog objekta klase
- operacije konstrukcije (eng. constructor operations) objekata
- operacije selekcije (eng. selector operations) koje daju suelje za "dobivanje"
informacija o objektu ili klasi i iz objekta ili klase
- operacije mutacije (eng. mutator operations) koje daju suelje za "postavljanje"
informacija o objektu ili klasi i iz objekta ili klase
- operacije destrukcije (eng. destructor operations) koje unitavaju objekte
- finalne operacije koje deinicijaliziraju klasu, a pozivaju se pri unitenju
posljednjeg objekta klase
" Sudjeluju u relacijama i dogaajima.
" Definiraju implementaciju za svoje objekte.
" Mogu biti kompleksne, s mogunou reduciranja u podreene klase, ili mogu biti primitivne,
bez mogunosti reduciranja.

Pojam kategorizacije je uobiajen u konvencionalnim metodama prikaza znanja - npr. zoolozi

koriste hijerarhijsku kategorizaciju vrsta. Relacije izmeu kategorija obino su tipa "jest" (eng.
"is a", "is instance of"), npr. automobil je (jest) vozilo.
Objektno orijentirano programiranje temelji se na ideji povezivanja klasa sa "is a" relacijama.
Klasa opisuje strukture podataka i funkcionalnost svojih instanci. Nema uvijek potrebe da klasa
ima instance. Klasa moe posluiti i kao osnovna klasa hijerarhije koja apstrahira zajednika
svojstva nekoliko deriviranih klasa. Apstraktna klasa je dakle klasa koja slui kao zajednika
osnovna klasa i nee imati instance.
Kompozitni objekt je agregacija drugih objekata, odnosno sadri kompoziciju ili agregaciju
drugih objekata kao podobjekata u svojoj implementaciji. Takvi podobjekti mogu biti instance
klasa koje predstavljaju entitete, ili mogu i sami biti kompozitni objekti. Na taj nain moe se
kreirati vierazinska hijerarhija sadravanja (ukljuivanja) objekata. Kompozitni objekt upravlja
postojanjem i meuzavisnostima svojih podobjekata, odnosno upravlja skupovima instanci
podobjekata.

Osnovni elementi objektnog modela

U ovom poglavlju izloiti emo slijedee osnovne elemente koji moraju postojati da bi neki
model entiteta i pojava iz stvarnog svijeta u programskom sustavu bio objektno orijentiran:
Apstrakcija (abstraction) realizira se pojmovima klase i objekta, koji su ve detaljno
izloeni
Uahurivanje (encapsulation)
Nasljeivanje (inheritance)
Vieoblije (polymorphism)

Uahurenje (enkapsulacija)
Jedno od primarnih svojstava objekta je kombiniranje struktura podataka i funkcionalnosti -
programski kod i svi relevantni podaci su "spakirani" zajedno.
Objekt moemo promatrati kao da se nalazi unutar "ahure" (kapsule) koja osigurava da podaci i
kod egzistiraju zajedno. ahura takoer slui i kao zatita od neautoriziranog pristupa internim
podacima i operacijama objekta. Dozvola pristupa mora se eksplicitno definirati.
Razlikujemo dva naina pristupa - pristup od strane klijenata (objekata koji nisu hijerarhijski
povezani s objektom kojem se pristupa) i pristup od strane podklasa iz hijerarhije klasa kojoj
pripada objekt.

36
 objekt
private public
atributi

suelje prema
klijentima
suelje
operacije

protected

suelje prema
unutranjost vanjski svijet podklasama

Slika 27: Zone pristupa objektu

Svi atributi i operacije koji su potpuno unutar objekta, skriveni su od vanjskog svijeta, odnosno
oni su "uahureni" (eng. encapsulated). Ostali objekti nemaju pristup do njih. Atributi i operacije
koji djelomino izlaze iz okvira objekta pristupani su "vanjskom svijetu" i oni ine suelje
objekta. Razlikujemo dva naina pristupa (slika 27) - pristup od strane klijenata (objekata koji
nisu hijerarhijski povezani s objektom kojem se pristupa) i pristup od strane podklasa iz
hijerarhije klasa kojoj pripada objekt.
Enkapsulacija promovira modularnost, tj. objekti se moraju promatrati kao blokovi za gradnju
kompleksnog sustava. Kad se jednom dostigne odgovarajua modularizacija, mogue je odgoditi
konane odluke o implementaciji. To svojstvo omoguuje brzu izradu prototipa modela.
Enkapsulacija omoguuje separaciju procesa kreiranja klase na faze specifikacije i
implementacije. Specifikaciju moe izraditi specijalist za koncipiranje programskih sustava (eng.
"software designer"), a implementaciju programer.

Vrste pristupa u .NET Visual Basic-u:

REZERVIRANA DOSTUPNOST
RIJE
public lan je dostupan svima
protected lanu se moe pristupiti samo iz klase koja ga definira i iz
klasa koje od nje nasljeuju
friend lan je dostupan iz svih klasa unutar istog programa
(projekta)
private lan je dostupan samo unutar klase
protected friend unija protected i friend

Nasljeivanje
Usporedba klasa sa konvencionalnim nainima kategorizacije dovodi do izraaja pojam
hijerarhije klasa (nasljeivanje). "Podklase" su zapravo proirenja i/ili specijalizacije postojeih
klasa i nasljeuju njihova svojstva. Objektno orijentirani programski jezici upotrebljavaju klase
za kategorizaciju entiteta koji se pojavljuju u aplikacijama. Relacije izmeu kategorija obino su
tipa "jest" (engl. "is a", "is instance of"), npr. automobil je (jest) vozilo. Kad je hijerarhija
jednom postavljena, jednostavno se proiruje. Da bi se opisao novi koncept (entitet), nije nuno

37
opisati sva njegova svojstva. Dovoljno je opisati samo razlike u odnosu na koncept unutar
postojee hijerarhije.
Najjednostavniji nain definiranja podklase je proirivanje osnovne klase s novom
deriviranom klasom. Podklasa nastoji proiriti svojstva definrana osnovne klase.
Drugi nain definiranja podklase je specijalizacija. U tom sluaju osnovna klasa se
upotrebljava za definiranje derivirane klase koja specijalizira svojstva osnovne klase.
Nasljeivanje nije ogranieno na jednu osnovnu klasu. Klasa se moe deklarirati i kao
ekstenzija dvije ili vie klasa, u tom sluaju govorimo o viestrukom nasljeivanju.
U kompleksnim hijerarhijama klasa moe se dogoditi da se osnovna klasa pojavljuje vie
nego jedanput., odnosno da neke "superklase" (klase koje se dalje deriviraju) imaju
zajedniku osnovnu klasu. Svojstva koja se nasljeuju iz tih "superklasa" ponavljaju se
tada u deriviranim klasama i u tom sluaju govorimo o ponovljenom nasljeivanju.
Drugim rijeima, isto svojstvo moe biti naslijeeno od razliitih "superklasa" koje su to
svojstvo naslijedile od zajednikog "pretka".

Normalno naslijeivanje Ponovljeno naslijeivanje Viestruko naslijeivanje

Slika 28: Vrste nasljeivanja

prikaz proizvoda

identifikator : String
opis : String
odgovorna osoba : String
ogranienja upotrebe : String
status : String
ugovorna dokumentacija

tehnike upute
lista zahtjeva

standardi
konstrukcijska dokumentacija

tehnoloka dokumentacija
3D CAD model

opi standardi
tehniki prorauni
crte

interni standardi

sastavnica proizvoda

radioniki crte
sklopni crte

dispozicijski crte

Slika 29: Primjer hijerarhijske strukture klasa

38
Primjer nasljeivanja metoda
Ovdje je dan primjer programskog koda u .NET Visual Basic-u za ilustraciju kako jedna klasa
nasljeuje metodu od druge klase koja joj je nadreena i u kojoj je ta metoda definirana. Klasa
"Class1" sadri dvije metode "Method1" i "Method2". Obje metode imaju samo po jednu
naredbu ("MessageBox") koja ispisuje tekst na ekranu. Klasa "Class2" nasljeuje sve (obje)
metode iz klase "Class1" naredbom "Inherits Class1". U klasi "Class2" redefinira se
metoda "Method2" pomou rezervirane rijei "Overrides", odnosno programski kod metode
"Method2" raditi e drugaije pozvan iz objekta klase "Class1" nego kad je pozvan iz objekta
klase "Class2". "Method1" nije promijenjena u "Class2" pa e njen poziv rezultirati ispisom istog
teksta, bez obzira iz kojeg objekta bude pozvana.

Public Class Class1

Sub Method1()
MessageBox.Show("ovo je prva metoda u osnovnoj klasi.")
End Sub
Overridable Sub Method2()
MessageBox.Show("ovo je druga metoda u osnovnoj klasi.")
End Sub
End Class

Public Class Class2

Inherits Class1
Public Field2 As Integer
Overrides Sub Method2()
MessageBox.Show("ovo je metoda u deriviranoj klasi.")
End Sub
End Class

Private Sub primjer_Click()

Dim C1 As New Class1()
Dim C2 As New Class2()
C1.Method1() 'poziv prve metode u osnovnoj klasi.
C1.Method2() 'poziv druge metode u osnovnoj klasi.
C2.Method1() 'poziv metode naslijeene iz osnovne klase.
C2.Method2() 'poziv metode iz derivirane klase.
End Sub

Procedura Sub primjer_Click() sadri instanciranje objekta C1 iz klase Class1 i

objekta C2 iz klase Class2. Nakon toga oba objekta pozivaju obje metode, a rezlutat ispisa na
ekranu je slijedei:
ovo je prva metoda u osnovnoj klasi.
ovo je druga metoda u osnovnoj klasi.
ovo je prva metoda u osnovnoj klasi.
ovo je metoda u deriviranoj klasi.

Vieoblije (polimorfizam)
Polimorfizam (vieoblije, vievrsnost) znai imati sposobnost preuzeti mnogo varijanti oblika.
U objektno orijentiranoj tehnologiji to se odnosi na mogunost entiteta da se u tijeku izvoenja
povee sa instancama razliitih klasa. U objektno orijentiranim jezicima mogu se razluiti dva
oblika polimorfizma - inkluzijski i operacijski.
Inkluzijski polimorfizam implementira se mehanizmom nasljeivanja. Taj nain
polimorfizma omoguuje da se objekt tretira kao da je pripadnik vie vrsta istovremeno.

39
 Objekt koji je instanca jedne klase moe se upotrijebiti kao da je isto tako i instanca
druge klase, uz uvjet da je prvi objekt podklasa drugog.
Operacijski polimorfizam implicira da se operacije mogu primjeniti na razliite tipove
koji pripadaju nepovezanim skupinama. Drugim rijeima, operacije istog naziva mogu se
primjeniti na razliite objekte koji nisu inkluzijski povezani. Postoje dvije vrste
operacijskog polimorfizma - parametarski i "preoptereenje operatora".
o Preoptereenje (eng. overloading) implicira da se ista operacija upotrebljava za
razliita implementacijska tijela. U takvom sluaju dvije operacije dijele isto ime,
ali imaju potpuno razliito ponaanje.
o U parametarskom polimorfizmu, operacija radi na isti nain za mnogo tipova,
implementirajui isto ponaanje. Takve operacije obino se nazivaju generike
funkcije. Generika funkcija moe raditi sa argumentima bilo kojeg tipa, openito
pokazujui isto ponaanje, nezavisno od tipova argumenata.
Polimorfizam, u kombinaciji sa dinamikim povezivanjem (eng. dynamic binding) omoguava
gradnju fleksibilnih sustava koje je lake proirivati. Dinamiko povezivanje je mogunost da
se objekt povee sa operacijom tek u tijeku izvoenja programa. Drugim rijeima dinamiko
povezivanje odlae povezivanje poziva funkcije i ciljnog bloka programskog koda do trenutka
izvoenja programa.

Neki naini implementacije vieoblija u .NET Visual Basic-u:

Overloading (preoptereenje)
o Razliite verzije metoda imaju isto ime ali prihvaaju razliite koliine
parametara ili razliite tipove parametara
Overriding (prekoraenje)
o Metode zamjenjuju naslijeene metode koje nisu prikladne u deriviranoj klasi.
Derivirane klase nasljeuju prekoraene metode
Shadowing (skrivanje)
o sakriveni lanovi lokalno zamjenjuju lanove koji imaju vei doseg

Primjer preotereenja u .NET Visual Basic-u:

Overloads Sub Display(ByVal theChar As Char)

' programski kod koji prikazuje znakovni podatak.
End Sub
Overloads Sub Display(ByVal theInteger As Integer)
' programski kod koji prikazuje cjelobrojni podatak.
End Sub
Overloads Sub Display(ByVal theDouble As Double)
' programski kod koji prikazuje decimalni broj.
End Sub

Display("9") - poziv procedure Display za ispis znaka (znamenke) 9

Display(9) - poziv procedure Display za ispis cjelobrojne vrijednosti 9
Display(9.9) - poziv procedure Display za ispis realne vrijednosti 9.9

Bez preopeteenja razliita imena za razliite procedure:

Sub DisplayChar(ByVal theChar As Char)

Sub DisplayInt(ByVal theInteger As Integer)
Sub DisplayDouble(ByVal theDouble As Double)

40
Osnove rada s objektima u .NET Visual Basic-u
Kontrole na traci s alatima (Toolbox) predstavljaju klase. Postavljanjem kontrole na formu
zapravo se kreira objekt instanca klase. Forma je isto tako klasa.
U izvoenju programa Visual Basic .NET kreira instancu forme, odnosno te klase. Objekti se
kreiraju kao identine kopije svojih klasa. U tijeku svojeg postojanja kao individualnih objekata,
mogu im se mijenjati svojstva.

Polja (Fields) i Svojstva (Properties) predstavljaju informacije koje objekt sadri.

Polja su ekvivalentna varijablama moe im se direktno pristupiti.
Svojstvima se vrijednosti pridruuju ili predaju pod kontrolom specijalnih procedura Property
Get i Property Set koje omoguuju postavljanje i provjeru dodatnih uvjeta pri manipulaciji sa
vrijednostima svojstava.

Deklariranje polja (field):

Dim X As Integer = 8
Deklariranje instance klase:
Dim Obj1 As New Class1
Pridruivanje vrijednosti polja (varijable) "X" svojstvu Prop1:
Obj1.Prop1 = X
Polju (varijabli) X pridruuje se vrijednost svojstva Prop1 uveana za 1:
X = Obj1.Prop1 + 1
Pridruivanje vrijednosti polju "Field1" objekta Obj1:
Obj1.Field1 = X

Metode (Methods) predstavljaju akcije koje objekt moe izvriti. Metode su procedure
definirane unutar klase. Upotrebljavaju se kao i sub procedure ili funkcije, ali im se pristupa
preko objekta kojem pripadaju. Slijedei fragment programskog koda poziva funkciju i sub
proceduru deklarirane unutar klase:
Deklariranje objekta kao instance klase:
Dim Obj2 As New Class2
Dim Y As Integer
Pridruivanje vrijednosti koju vraa metoda deklarirana kao funkcija:
Y = Obj2.GetNumber
Poziv metode deklarirane kao sub procedura (subroutine):
Obj2.StoreNumber(Y)

Dogaaji (Events) su poruke koje objekt prima od ili alje drugim objektima ili aplikacijama.
Dogaaji omoguuju objektima da izvode akcije kad god doe do specifine pojave. Dogaaji
dolaze od drugih objekata, aplikacija ili od ulaznih akcija korisnika programa (npr. klik miem).

41
Primjer kreiranja instanci klase:
Klasa koja sadri metodu ShowFrm za definiranje i instanciranje nove forme:
Public Class ShowMe
Sub ShowFrm()
Dim frmNew As Form1
frmNew = New Form1
frmNew.Show()
frmNew.WindowState = 1
End Sub
End Class

Procedura koja kreira novu instancu klase ShowMe i poziva njenu metodu ShowFrm
Private Sub Button1_Click()
Dim clsNew As New ShowMe
clsNew.ShowFrm()
End Sub
Svaki poziv procedure Button1_Click() rezultirati e otvaranjem i prikazivanjem nove
forme na ekranu.

Sintaksa Class naredbe u .NET Visual Basic-u:

[ Public | Private | Protected | Friend | Protected Friend ]

[ Shadows ] [ MustInherit | NotInheritable ]
Class name [ Inherits classname ]
[ Implements interfacenames ]
[ statements ]
End Class

Sloeni objektno orijentirani programski sustavi

Koncipiranje sloenih objektnih sustava
Neki autori definiraju objektno orijentirano koncipiranje kao "konstrukciju programskih sustava
u obliku strukturiranih skupova (kolekcija) implementacija apstraktnih tipova podataka. Objekt
se moe promatrati kao smislena povezanost odreenog znanja i odreenih operacija.
Izgraditi sustav sa objektno orijentiranim pristupom, znai analizirati problem i pronai objekte
ukljuene u sustav. Ope znaajke i ponaanje tih objekata modeliraju se i implementiraju kao
klase u objektno orijentiranom programskom jeziku. Kada se jednom objekti domene problema
modeliraju i kreiraju kao klase, te klase se spajaju zajedno u modeliranju sustava u raunalnom
okviru. Takav "bottom-up" pristup, temeljen na podacima, koristi prijanje napore kao polugu za
kreiranje sustava izgraenih od "gotovih dijelova".

Razvoj metoda modeliranja objektno orijentiranih programskih sustava

Prvi problem s kojim se suoavaju programeri koji razvijaju sustave koritenjem objektnih
tehnologija jest izbor odgovarajue metodologije za proces razvoja. Od poetaka razvoja
objektnih jezika do devedesetih godina razvijeno je i koriteno mnogo razliitih metodologija,
svaka sa svojom varijantom notacije. Od poetnih desetak dolo se do oko 50 metoda koje su
koritene izmeu 1989. i 1994. Te metode neki autori nazivaju metodama prve generacije. Takvo
stanje bilo je na neki nain kaotino, jer niti jedna metoda nije prevladavala niti je mogla

42
zadovoljiti sve zahtjeve iz prakse. Sve su te metode imale neke zajednike koncepte, ali izraene
na razliite naine. Takvo stanje ak je i odvraalo od upotrebe objektne tehnologije. Put prema
spajanju i unifikaciji metoda poeo je sredinom devedesetih godina, kada se javljaju metode
druge generacije.
U tom periodu razvija se nekoliko pravaca standardizacije, npr. CORBA, OPEN i UML. U isto
vrijeme tri metode se izdvajaju kao najprominentnije: Booch-ova, OMT (Rumbaugh) i OOSE
(Jacobson). Spomenuta tri autora spajaju svoje metode i zapoinju razvoj UML-a (Unified
Modeling Language), iju prvu verziju prikazuju 1995. OMG (Object Management Group)
konzorcij za razvoj programskih sustava preuzima ulogu katalizatora za spajanje svih nastojanja
u razvoju i standardizaciji UML-a. Okuplja se veliki broj tvrtki i iskusnih metodiara, te u srpnju
1997. nastaje prvi prijedlog standarda. Nakon slijedeeg koraka dorade, u studenom 1997. OMG
grupa prihvaa UML kao standardni jezik modeliranja. Tako UML postaje temelj za de facto
standard u domeni objektno orijentirane analize i koncipiranja. To ne znai da su sve ostale
metode odmah istisnute, ali primjetan je trend sve vee upotrebe UML-a.

Unified Modeling Language (UML)

UML je, prema definiciji njegovih autora, jezik za vizualiziranje, specificiranje, konstruiranje i
dokumentiranje rezultata procesa razvoja softvera kao i za modeliranje poslovnog sustava. UML
takoer omoguuje pohranu, razmjenu i primjenu znanja u procesima rjeavanja problema. UML
ne propisuje nikakav odreeni pristup rjeavanju problema, nego se moe prilagoditi svakom
pristupu. Autori UML-a jasno razdvajaju jezik za modeliranje od razvojnog procesa. Iako e se
UML koristiti u sklopu definiranih procesa, pokazuje se da razliite organizacije, razliiti tipovi
projekata i razliite problemske domene, trae i razliite odgovarajue razvojne procese.
Primjerice, razvojni proces prikladan za tvrtku koja proizvodi programe za obradbu teksta za
iroko trite ne moe biti istovjetan razvojnom procesu za poznatog naruitelja, recimo, u
zrakoplovnoj industriji. Meutim, jezik za objektno modeliranje moe biti jedinstven.
Treba naglasiti i da UML nije samo notacija (nain crtanja pojedinih dijagrama). To je skup
koncepata u objektnom modeliranju. Kao i svaki jezik, UML ima definiranu sintaksu (ovdje je to
grafika notacija i niz pravila vezanih uz dijagrame) i semantiku. Razvoj semantike jezika
iziskivao je najvie napora, posebno u usklaivanju postojeih i uvoenju novih koncepata.
Trebalo je definirati jezik koji je dovoljno bogat, a istodobno potpuno precizan. Semantika
UML-a opisana je i metamodelom u samome UML-u.
UML je pogodan za modeliranje irokog spektra programskih sustava, npr. velikih poslovnih
informacijskih sustava, distribuiranih Web aplikacija, pa i vrlo kompleksnih sustava realnog
vremena.

43