S v e u !

i l i t e u Z a g r e b u
F a k u l t e t s t r o j a r s t v a i b r o d o g r a d n j e
Katedra za osnove konstruiranja








N. Pavkovi!, D. Marjanovi!, N. Boj"eti!

PROGRAMIRANJE I ALGORITMI

Skripta, drugi dio



















Zagreb, 2005.

Sadraj

Potprogrami i funkcije (elementi modularizacije programa) .........................................3
Razmjena podataka izme!u 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
Matri"ni prikaz grafova.................................................................................................................................. 16
ALGORITMI ....................................................................................................... 16
Iteracija ......................................................................................................................17
Primjer uporabe strukture stoga u algoritmu evaluacije aritmeti!kog 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 doga!ajima..................................................................................................................... 28
Funkcijsko programiranje.................................................................................................................. 29
Deklarativno (logi"ko) 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
U"ahurenje (enkapsulacija)............................................................................................................................ 36
Naslje!ivanje ................................................................................................................................................. 37
Primjer naslje!ivanja metoda......................................................................................................................... 39
Vieobli"je (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 obi"no nazivamo modulima. Moduli mogu sadravati jednu ili vie
komponenti programskih procedura. Vrste procedura razlikuju se u programskim jezicima, a
obi"no se dijele na potprograme i funkcije. Mogu#nost razbijanja problema na manje cjeline
vano je svojstvo svakog programskog jezika na taj na"in olakava se razvoj, testiranje,
odravanje i pra#enje programa. Manje logi"ke 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 slijede#oj slici prikazan je primjer
dekompozicije sloenijeg problema shematski je prikazana hijerarhija poziva modula iz
glavnog programa.

GLAVNI PROGRAM ZA PRORACUN
ROTORA ELEKTROMOTORA
UCITAVANJE ULAZNIH
PODATAKA I PRIPREMA
PRORACUNA
IZRACUN TEINE
ROTORA
STATICKI PROGIB
ITERACIJA
PROGIB MAGN. SILA
POCETNA KRUTOST I
EKSCENTRICITET
ODREIVANJE
POJEDINIH
FAKTORA
PODJELA VRATILA
NA SEGMENTE I
POLJA
DINAMICKI
PROGIB
PROVJERA
VIJEKA
TRAJANJA
LEAJA
METODA
PRIJENOSNIH
MATRICA
IZRACUN MAKS.
NAPREZANJA,
PROGIBA I
NAGIBA
KRUTOST
LEAJEVA
METODA
PRIJENOSNIH
MATRICA
ODREIVANJE
IZLAZNIH PODATAKA
METODA
PRIJENOSNIH
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 sli"nih sekvenci programskog koda.
! Omogu#iti ponovnu uporabu dijelova programskog koda u razli"itim programima.
! Dekompozicija sloenih problema u manje i jednostavnije cjeline.
! Poboljanje ""itljivosti" i preglednosti programa.
! Repliciranje rjeenja za matemati"ke 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 omogu#uje bolji uvid u tok programa, tako da je panju lake posvetiti problemu
"to radi" za razliku od "kako to radi". Op#enito, da bi se ostvarila uporaba potprograma, koristi
se odre!ene forma naredbe poziva (eng. call). U trenutku izvo!enja naredbe poziva potprograma,
slijed (kontrola) izvo!enja naredbi predaje se pozvanoj cjelini, odnosno prelazi se na izvravanje
naredbi potprograma. Nakon to se izvedu sve naredbe pozvanog potprograma, kontrola se vra#a
"poziva"u" 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 me!u programskim jezicima male su razlike u:
! na"inu prevo!enja (mogu#nost nezavisnog prevo!enje i testiranja potprograma kao to to
omogu#uje Fortran, za razliku od npr. Pascala gdje se potprogrami deklariraju unutar
glavnog programa);
! na"inu prijenosa argumenata (po vrijednosti, ili po adresi);
4
! po vrsti:
o procedure-potprogrami "iji poziv je zasebna naredba unutar neke programske
cjeline
o funkcije - koje su dio nekog izraza i njihovo referenciranje vra#a vrijednost
Osnovne karakteristike potprograma koje razmatramo:
! imaju jednu ulaznu to"ku
! pozivaju#a procedura (program) se zaustavlja u toku izvravanja pozvanog potprograma,
samo jedan potprogram se izvrava u danom vremenu
! kontrola se uvijek vra#a pozivaju#oj proceduri po zavretku izvravanja potprograma
Postupak pozivanja u nekim situacijama druga"iji je u programiranju pokretanom doga!ajima,
jer je korisnik programa taj koji u ve#ini slu"ajeva zapravo bira i poziva procedure, tj. elementi
su"elja (odnosno korisnik) direktno sudjeluju u usmjeravanju tijeka izvo!enja programa.
Me!utim dijelovi programa koji se pokre#u doga!ajima mogu biti sastavljeni od vie
potprograma i funkcija, a osim mogu#nosti poziva procedure preko su"elja, postoje i procedure
koje se pozivaju naredbama unutar programskog koda.
Razmjena podataka izme!u potprograma
Potprogrami su zasebne programske jedinice koje stoga alociraju i razli"ite (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 rije"ima, 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 na"ina prijenosa (razmjene) podataka izme!u potprograma:
! Globalne varijable:
o U ovom na"inu varijable kojima treba pristupati vie programskih cjelina
deklariraju se "izvan" svake od njih, u posebnom "zajedni"kom" dijelu memorije
kojem imaju pristup sve programske cjeline. Uobi"ajeno je re#i da su globalne
varijable "vidljive" u svim potprogramima.
! Prenose se vrijednosti varijabli (call by value):
o Kopira se vrijednost lokalne varijable iz pozivaju#e procedure u lokalnu varijablu
pozvane procedure. Ako pozvana procedura promijeni vrijednost varijable, to
utje"e samo na lokalnu kopiju u pozvanoj proceduri.
! Prenose se adrese varijabli (call by reference):
o Pozvana procedura dobiva pristup lokalnim varijablama iz pozivaju#e procedure.
Pozvana procedura moe trajno promijeniti vrijednost varijablama "ije su adrese
prenesene.
Ako nije druk"ije navedeno, u Visual Basic-u se podrazumijeva call by reference.
Pojmovi dosega i trajanja varijabli vani su za razumijevanje prijenosa podataka (vrijednosti
varijabli) izme!u 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 slu"aju lokalnu varijablu treba deklarirati kao "stati"ku", ali tu mogu#nost
nemaju svi programski jezici.
Vrste potprograma
Uobi"ajena je podjela potprograma na dvije osnovne vrste:
! Funkcije, (function) koje imaju od nula do vie ulaznih argumenata i vra#aju jedan
rezultat. Funkcije se pozivaju kao dio izraza, npr. A = fun(B). Pojam "vra#anja"
vrijednosti zapravo je izra"unavanje vrijednosti funkcije koja se dalje tretira kao i ostale
varijable u izrazu.
5
! Op#enite potprograme (subroutine) koji imaju od nula do vie ulaznih argumenata i vie
izlaznih rezultata koje predaju argumentima. Pozivaju se naj"e#e posebnom naredbom
iza koje slijedi ime potprograma i lista ulaznih i izlaznih argumenata.
Navo!enje pojedina"nih podvrsta i na"ina implementacija potprograma u pojedinim jezicima
zahtijevalo bi previe vremena i prostora. Tako!er 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 tako!er koriste
i termini "funkcijski potprogram" ili "funkcijska procedura". Bez obzira na razlike u
terminologiji, osnovna razlika izme!u dvije vrste programskih jedinica je u na"inu 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
Zajedni"ki naziv svih vrsta potprograma u Visual Basic-u je "procedura" (eng. procedure).
Postoje tri vrste procedura:
! procedure vezane uz doga!aje (event procedures) pozivaju se aktiviranjem nekog
doga!aja (npr. "klik" miem na neki objekt na formi)
! op#e procedure (general procedures) pozivaju se naredbom Call
! funkcijske procedure (function procedures) pozivaju se kao dio izraza
Deklariranje procedura
Op#e procedure kao i procedure vezane uz doga!aje deklariraju se sa rezerviranom rije"i "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 doga!aje:
Doga!aj vezan uz kontrolu na formi:
Private Sub controlname_eventname (arguments )
statements
End Sub
Doga!aj vezan uz formu:
Private Sub Form_eventname (arguments)
statements
End Sub
Deklariranje funkcija
Funkcijske procedure deklariraju se sa rezerviranom rije"i "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 "vra#a" u pozivaju#u proceduru.

6
[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 ra"unalnoj znanosti jer se mnogi algoritmi mogu pomo#u nje
najbolje prikazati. Rekurzija je zapravo i jedan na"in implementacije potprograma u nekim
jezicima potprogram moe pozvati samog sebe uzrokuju#i zaustavljanje svojeg procesa
izvravanja za vrijeme dok traje drugi "ugnje!eni" proces izvravanja istog potprograma.
Kao primjer za bolje razumijevanje rekurzije razmotrimo definiciju predaka odre!ene osobe:
! roditelji neke osobe su njeni preci (osnovni slu"aj)
! roditelji bilo kojeg pretka su tako!er 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 beskona"no izvo!enje
programa:
! mora postojati odre!eni 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 kra#i, ali
izvo!enje programa je dulje. Za pohranjivanje rezultata i povratak iz rekurzije koristi se struktura
podataka stog.
Primjer rekurzivno definirane funkcije je slijede#a definicija funkcije faktorijela:
f(0) = 1
f(n) = n * f(n ! 1) za svaki cijeli broj n > 0
Prema danoj definiciji f(3) ra"una 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
Slijede#i primjer rekurzivne funkcije u programskom jeziku C tako!er izra"unava faktorijel
cijelog broja n:
int fakt(int n){
if (n <= 1) {
return 1;
} else {
return n * fakt(n-1);
}
}
7
STRUKTURE PODATAKA
U ra"unalnoj znanosti pojam "struktura podataka" ozna"ava na"in pohrane podataka u ra"unalu
koji omogu#ava efikasnu uporabu tih podataka. Vrlo "esto dobar odabir strukture podataka
omogu#uje i uporabu efikasnijeg algoritma obrade. Razli"ite vrste struktura podataka odgovaraju
razli"itim vrstama programskih problema, dapa"e neke strukture su visokospecijalizirane samo
za odre!ene 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 kona"nih rjeenja u mnogome ovise o izboru
najpogodnijih struktura podataka. Nakon to su odabrane strukture podataka, "esto je odmah s
time odre!en i algoritam kojeg treba upotrijebiti.
Ukratko, moemo re#i da je struktura podataka logi"ki ili matemati"ki model odre!ene
organizacije podataka.
Slijede#e strukture podataka i operacije na njima temelji su ra"unalne znanosti jer su osnovni
elementi brojnih algoritama:
! Polje (eng. array) sekvencijalni niz podataka istog tipa koje imaju zajedni"ko ime
! Slog (eng. record) - skup podataka koji mogu biti razli"itog tipa, niz slogova obi"no je
dio datoteke ili tablice
! Lista, povezana lista (eng. linked list) niz elemenata koji sadre podatke i pokaziva"e
na slijede#i 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 mogu#e 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) op#enita 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 to"no jedanput, da bi se odre!eni podatak
obradio (procesirao) primjer u"itavanje 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 odre!enog 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 na"ina prikaza linearnih struktura u
memoriji ra"unala:
! linearna veza izme!u elemenata ostvarena slijedom memorijskih lokacija to je
karakteristi"no za polja
! linearna veza izme!u elemenata ostvarena pokaziva"ima karakteristi"no 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 odre!enom redoslijedu i spajanja
(eng. merging) kombiniranja dvije liste u jednu. Izbor odre!ene vrste linearne strukture za
danu situaciju ovisi o relativnoj u"estalosti primjene pojedine od navedenih operacija.
8
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 (stati"nih) skupova podataka. S druge strane, u situacijama gdje se veli"ina
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 ne#emo ponavljati.
Polje zauzima sekvencijalni niz memorijskih lokacija, a elementima polja pristupa se preko
indeksa, dakle fizi"ki redoslijed memorijskih lokacija odre!uje povezanost elemenata polja.
Osnovni nedostaci polja su slijede#i:
! teko je dodavati i brisati elemente nakon to se elementima pridrue vrijednosti
! u ve#ini jezika problemati"no je pove#ati alokaciju memorije za elemente polja
Zbog navedenih nedostataka polja se smatraju stati"kim strukturama podataka.
Algoritam "pristupa i obrade" (eng. traversing) svih elemenata polja vrlo "esto se koristi npr. kod
u"itavanja ili ispisa elemenata polja ili kao dio drugih algoritama:
1. postavi broja" na po"etnu vrijednost jednaku indeksu po"etnog 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. pove#aj vrijednost broja"a za 1
Slog
Slog (eng. record) je skup me!usobno povezanih (ali heterogenih) podataka koje obi"no
nazivamo polja ili atributi. Zapisi nekih vrsta datoteka su zapravo skupovi slogova, odnosno
takve datoteke su linearne liste slogova. Vano je naglasiti osnovne razlike izme!u sloga i polja:
! elementi sloga mogu biti nehomogeni podaci (razli"itih tipova)
! ne mora postojati "prirodni" redoslijed elemenata sloga, elementi se ozna"avaju
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 mogu#ih na"ina pohrane i
manipulacije sa slogovima je koritenje vie paralelnih polja pri "emu svakom atributu sloga
odgovara jedno polje, odnosno elementi razli"itih polja sa istom vrijedno#u indeksa pripadaju
jednom slogu. Drugi na"in manipulacije sa slogovima je koritenje razli"itih sintakti"kih
elemenata specifi"nih za odre!eni jezik neki jezici imaju ugra!enu 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 MATI!NI
BROJ
DATUM
RO"ENJA
UPISANA
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
9
Povezana lista
Povezana lista (eng. linked list) je linearna struktura elemenata u kojoj je redoslijed odre!en
pokaziva"ima. Za razliku od polja, svaki element liste sadri pokaziva" (eng. pointer) na
slijede#i element. Poto pokaziva" sadri adresu slijede#eg elementa u listi, sukcesivni elementi
liste ne moraju biti spremljeni u sukcesivnom nizu memorijskih lokacija. Na taj na"in fizi"ki
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 slijede#eg "vora u listi
Zadnji "vor sadri tzv. null pokaziva" koji ozna"ava kraj liste.
Lista sadri posebni pokaziva" koji sadri adresu prvog "vora u listi.


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 po"etak
2. Ponavljaj korake 3 i 4 dok je PTR razli"it od null
3. Pristupi elementu liste i izvri eljenu obradu
4. Postavi pokaziva" (PTR) na slijede#i element


PTR

Slika 3: postupak pristupa i obrade elemenata povezane liste

Naj"e#i na"in prikaza povezane liste u memoriji je koritenjem dva paralelna polja i varijablom
(pokaziva"em) 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 slijede#eg "vora, odnosno podatka u listi. Varijabla "START" sadri
lokaciju po"etnog "vora u listi. Ako sloimo po redoslijedu elemente liste, dobiti #emo tekst
"PRIMJER".
x
POCETAK
CVOR (ELEMENT LISTE)
POKAZIVAC NA SLIJEDECI
ELEMENT
PODACI
KRAJ LISTE
10
1
2
3
4
5
6
7
8
9
10
11
12
9
R
R
J
P
E
M
3
4
7
6
0
11
10
DATA POINT
START
I

Slika 4: Prikaz povezane liste u memoriji pomo$u dva paralelna polja

Na slici 5 shematski je prikazano dodavanje elementa u povezanu listu. Prije dodavanja novog
elementa "vor A pokazuje na slijede#i "vor B. Nakon umetanja novog "vora izme!u "vorova A i
B, "vor A pokazuje na novi "vor N, a "vor N pokazuje na "vor B.
x
START
x
Cvor A
Cvor A
Cvor B
Cvor B
a) Prije umetanja
b) Nakon umetanja
START
Cvor N

Slika 5: dodavanje elementa u povezanu listu
Na sli"an na"in, 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 po"etka do
kraja i obrnuto. Svaki "vor (element) dvostruko povezane liste osim podatka, sadri i dva
pokaziva"a na prethodni i na slijede#i "vor u listi.

x
pocetak
x
kraj
cvor N
podatak
pokazivac na prethodni cvor
pokazivac na slijedeci cvor

Slika 6: dvostruko povezana lista

11
Stog
Polja i povezane liste dozvoljavaju dodavanje i oduzimanje (brisanje) elemenata na bilo kojem
mjestu po"etku, kraju ili izme!u. Postoje odre!ene situacije u programiranju kada elimo
ograni"iti dodavanja i brisanja elemenata samo na kraj ili po"etak 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 mogu#e 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 uobi"ajeni naziv za strukturu stoga :
LIFO lista (eng. last in first out). Drugim rije"ima stog je struktura podataka kod koje se
posljednji pohranjeni podatak prvi uzima u obradu.


Osnovne operacije na stogu su:

! 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 ra"unalnoj znanosti. Prikaz i manipulacija sa stogom moe se realizirati stati"kom 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 izvo!enje programa. Prazan stog ne mora zna"iti pogreku.

A B E N
1 2 3 4 5 6 7 8
STOG
4 10 MAX VRH
9 10

Slika 8: prikaz stoga pomo$u jednodimenzionalnog polja
Na slici 8 prikazan je primjer implementacije strukture stoga pomo#u 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 odre!ene korake obrade treba odgoditi
do trenutka ispunjenja drugih uvjeta. Primjeri uporabe strukture stoga detaljnije su objanjeni u
poglavlju "Algoritmi".
dodavanje
oduzimanje
12
Red
Red (eng. queue) je linearna struktura u kojoj se elementi dodaju isklju"ivo na jednom kraju, a
oduzimaju isklju"ivo na drugom kraju. Strukturu reda lako je predo"iti analogijom sa istim
pojmom u svakodnevnom ivotu npr. redom ispred blagajne u du#anu. Svaka nova osoba koja
do!e zauzima mjesto na kraju reda, a osoba sa po"etka reda pla#a svoju robu i odlazi. Drugi
uobi"ajeni naziv za ovu strukturu je FIFO lista (eng. first in first out).

Slika 9: red osoba
Struktura reda moe se u ra"unalu implementirati na razli"ite na"ine, a naj"e#e se koristi jedno
jednodimenzionalno polje i dvije varijable (pokaziva"a) koje sadre lokacije po"etka i kraja reda,
odnosno lokacije po"etnog i krajnjeg elementa u redu. Takav na"in implementacije reda prikazan
je na slici 10.

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

Slika 10: Implementacija strukture reda pomo$u polja
Varijabla "po"etak" sadri lokaciju prvog elementa na po"etku reda, a varijabla "kraj" lokaciju
zadnjeg elementa na kraju reda. Inicijalno red sadri 4 elementa, u drugom koraku brie se prvi
element sa po"etka reda, u tre#em koraku dodaju se dva nova elementa na kraj reda, a u "etvrtom
koraku brie se element sa po"etka reda. Uo"ite da se uz ovakav na"in brisanja i dodavanja
elemenata stalno "pomi"emo u desno", tj. za zapis elemenata reda koristi se zapravo samo jedan
segment polja, a nakon svakog brisanja pove#ava se po"etni dio polja koje ostaje neiskoriteno.
Ovaj problem moe se rijeiti tako da u odre!enom trenutku premjestimo krajnji "lan reda na
po"etak polja, tj. da napravimo tzv. cirkularno polje.
13
Na slici 11 prikazan je primjer
koritenja cirkularnog polja za red koji
moe sadravati maksimalno pet
"lanova.

Ako cirkularno polje sadri op#enito n
"lanova, tada polje(1) slijedi iza
polje(n) i na taj na"in ponovno se
iskoritava po"etni dio polja nakon to
su elementi reda iz njega obrisani.

U oba na"ina implementacije strukture
reda pomo#u polja moe do#i do tzv.
preljeva (eng. overflow), tj. situacije da
u polju nema vie dovoljno mjesta za
dodavanje novog "lana u red.


















Slika 11: Implementacija strukture reda pomo$u 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 izme!u elemenata. Primjer strukture stabla koju
koristimo u svakodnevnom radu je struktura direktorija, odnosno organizacija datote"nog sustava
na ra"unalu. Strukture stabla koje #emo ovdje razmatrati sastoje se od "vorova (eng. nodes) i
veza izme!u njih koje uobi"ajeno nazivamo grane. Takva stabla imaju jedan po"etni "vor na
vrhu hijerarhije, npr. u strukturi direktorija to je tzv. korijenski (osnovni) direktorij (eng. root
directory.)
Jedna od najvanijih vrsta strukture stabla u ra"unalstvu 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.

A B C
B C
B C D E
D E
F D E
F E
F G H E
F G H
G H
G H K
K
POCETAK: 0
KRAJ: 0
RED (QUEUE)
1 2 3 4 5
a) inicijano prazan red:
b) A, B i C ukljuceni:
c) A iskljucen:
d) D a zatim i E ukljuceni:
e) B i C iskljuceni:
f) F ukljucen:
g) D iskljucen:
h) G a zatim i H ukljucen:
i) E iskljucen:
j) F iskljucen:
k) K ukljucen:
l) G i H iskljuceni:
m) K iskljucen, RED prazan:
POCETAK: 2
KRAJ: 3
POCETAK: 2
KRAJ: 5
POCETAK: 4
KRAJ: 5
POCETAK: 1
KRAJ: 3
POCETAK: 4
KRAJ: 1
POCETAK: 5
KRAJ: 1
POCETAK: 5
KRAJ: 3
POCETAK: 1
KRAJ: 3
POCETAK: 2
KRAJ: 3
POCETAK: 2
KRAJ: 4
POCETAK: 4
KRAJ: 4
POCETAK: 0
KRAJ: 0
14

Slika 12: Primjer binarnog stabla
Jedna od primjena strukture binarnog stabla je prikaz aritmeti"kog izraza koji se koristi u
procesu prevo!enja programa u strojni jezik.
Koritenje tri paralelna polja jedan je od na"ina 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 po"etnog (korijenskog) "vora, a varijabla AVAIL pokazuje na lokaciju
prvog slobodnog indeksa sva tri paralelna polja za upis podataka slijede#eg "vora koji bi se
dodao u stablo.


A
B C
D E
F
G x H
J K
L
x
x x x
x x
x x
x x x
KORIJEN














Slika 13: Prikaz binarnog stabla u memoriji pomo$u tri paralelna polja

A
B
E D
F
C
H G
J
K
L
16
17
18
19
20
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
K
C
G
A
H
L
B
F
E
0
3
0
14
10
17
0
9
4
18
19
0
12
15
16
0
6
0
2
1
0
13
0
0
J
D
11
7
0
20
0
0
0
5
8
INFO LIJEVO DESNO
KORIJEN
AVAIL
15
Binarno stablo pretraivanja (eng. binary search tree)
Binarno stablo pretraivanja jedna je od najvanijih struktura podataka u ra"unalnoj znanosti
Za svaki "vor ove strukture vrijedi:
vrijednost u "voru je ve#a 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 slijede#e: vrijednost u "voru je ve#a ili
jednaka od vrijednosti svih "vorova ispod njega (svih sljedbenika).

Slika 15: Primjer strukture gomile
Graf
Struktura grafa (eng. graph) tako!er je nelinearna.
Definicija grafa:
Graf G sadri dva kona"na skupa: skup to"aka 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 to"ke"
("vora) do "terminalne to"ke" ("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 izme!u bilo koja dva "vora u G.
Ako svakom bridu grafa pripada neki podatak, takav graf se naziva ozna!enim. Ako su
bridovima grafa pridruene pozitivne numeri"ke vrijednosti, onda se takav graf naziva teinski ili
graf sa teinskim faktorima.
16
A
B
D
E C
B
A
E
D
C
1
7
4
5
6
8
2
a) graf
b) graf sa teinskim faktorima
F
F
2
3

Slika 16: Primjer prikaza strukture grafa
Matri"ni prikaz grafova
$vorovi grafa obi"no se ozna"avaju s v
1
, v
2
, . ili jednostavno brojevima, a bridovi
s e
1
, e
2
, . ili s njihove dvije krajnje to"ke ("vora) npr.: e
1
= (1,4), e
2
=(1,2)
Brid (v
i
, v
j
) je svojstven (upadan, zavisan, eng. "incident") "voru v
i
(vrhu); isto vrijedi za v
j
.
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 to"ke brida.
Za ra"unalni prikaz grafova najpogodnije je koristiti matrice, pa slijedi prikaz nekoliko oblika
matri"nih prikaza grafova.
Definicija matrice susjedstva (eng. adjacency matrix) grafa G:
" #
$ %
&
'
(
)
*
+
,
,
brida nema ako 0
brid ima ako 1 j i, G
a
a A
ij
ij

Matrica susjedstva op#eg grafa je simetri"na.
Element matrice susjedstva usmjerenog grafa, a
ij
= 1, onda kad postoji usmjereni brid (od "vora i
prema "voru j). Matrica susjedstva usmjerenog grafa nije simetri"na.
Definicija matrice incidencije grafa G:

" #
-
&
-
'
(
-
)
-
*
+
.
/
,
,
j k
j k
j k
a
a A
jk
jk
"vor dira ne grana ako 0
"vor u ulazi grana ako 1
"vora iz izlazi grana ako 1


ALGORITMI
Poznavanje algoritama temelj je uspjenog programiranja, pogotovu u razvoju sloenih
programskih sustava. Predvi!ena satnica predavanja i vjebi doputa izlaganje samo
najjednostavnijih osnovnih algoritama. Granicu izme!u "osnovnih" i "sloenih" algoritama teko
je postaviti. Zadaci na vjebama prezentiraju neke od temeljnih algoritama obrade numeri"kih
podataka koji se javljaju u inenjerskoj praksi. Najjednostavniji algoritmi pogodni su za po"etak
u"enja programiranja, pri "emu je vrlo bitno izgraditi i usvojiti na"in razmiljanja i postupke
rjeavanja problema pri programiranju.
Na vjebama se prvo obra!uju algoritmi operacija s nizovima u"itavanje niza, sumiranje
"lanova niza, pronalaenje minimalnog i/ili maksimalnog elementa niza, sortiranje, traenje i
ispis "lanova niza koji zadovoljavaju odre!ene uvjete. Nakon usvajanja navedenih algoritama na
nizovima isti i sli"ni algoritmi se obra!uju i na matricama. Pri tome se za nizove koristi struktura
17
jednodimenzionalnog polja, a za matrice dvodimenzionalna polja. Navedeni algoritmi detaljno
su obrazloeni u podlogama za vjebe, stoga se ovdje ne#e izlagati.
U ovom poglavlju posebna je panja posve#ena 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 odre!ivanje vrijednosti numeri"kog 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 prou"iti
specijaliziranu literaturu.
Algoritmi se mogu klasificirati na mnogo razli"itih na"ina, a kriteriji pojedinih klasifikacija
predmet su kontinuiranih rasprava u okruju ra"unalne znanosti.
Jedan na"in klasifikacije algoritama je prema metodologiji primjenjenoj u kreiranju algoritma.
Mogu#e je razlu"iti odre!en broj razli"itih 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 obi"no ponavlja na rekurzivan na"in.
! "Dinami"ko programiranje" pogodno je za probleme u kojima se cjelokupno rjeenje
moe kreirati na na"in da se rjeenja istih podproblema upotrijebe za rjeavanje brojnih
razli"itih instanci problema. Ovaj pristup nastoji izbje#i "rjeavanje ve# rijeenog".
! "Greedy" metoda sli"na je dinami"kom programiranju, osim to u svim koracima
nemamo rjeenje podproblema, pa se u takvim slu"ajevima radi "greedy" izbor onoga to
se "ini najpogodnijim u tom trenutku.
! Linearno programiranje Ovaj na"in rjeavanja problema svodi se na kreiranje sustava
linearnih nejednadbi, nakon "ega se nastoji maksimizirati ili minimalizirati ulazne
veli"ine.
! Pretraivanje i enumeracija mnogi problemi (npr. igranje aha) mogu se modelirati
pomo#u grafova. Algoritmi specifikacije pravila za kretanje (pretraivanje) po strukturi
grafa korisni su za ovakve probleme.
! Probabilisti"ki i heuristi"ki postupci ne odgovaraju u potpunosti definiciji algoritma, jer
generiraju rjeenja na temelju slu"ajnih odabira.
! Geneti"ki algoritmi nastoje prona#i rjeenje oponaanjem biolokih evolucijskih procesa
- ciklusima slu"ajnih mutacija generiraju se sukcesivne "generacije rjeenja".
Drugi na"in klasifikacije algoritama je prema na"inu implementacije.
Rekurzivni algoritam poziva (referencira) samog sebe do trenutka ispunjenja odre!enog uvjeta, a
takva metoda uobi"ajena je u tzv. funkcijskom programiranju. Algoritmi se uobi"ajeno
razmatraju sa pretpostavkom da ra"unalo 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 ra"unala.
Iteracija
Postupak iteracije nastoji rijeiti problem nalaenjem sukcesivnih aproksimacija to"nom
rjeenju, polaze#i od inicijalne pretpostavke. Naj"e#e 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 op#enitije 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 to"nom rjeenju garantirana je samo za odre!ene klase matrica.
Iteracija je jedan od najvanijih i vrlo "estih postupaka u rjeavanju inenjerskih problema. Kod
sloenijih jednadbi, "ru"no" ra"unanje brojnih koraka postaje mukotrpno i vrlo podlono
grekama, pogotovo ako se zahtijeva velika to"nost rjeenja. Stoga je daleko lake, bre, to"nije i
18
efikasnije takve probleme rjeavati ra"unalnim programima. U po"ecima razvoja ra"unala i
programskih jezika upravo su numeri"ki problemi bili prevladavaju#e podru"je primjene
ra"unala.
Sve iterativne metode karakterizira postupak rjeavanja zadataka usmjerenim pokuajima.
Ovisno o pojedinom problemu razlikovati #e se na"ini pribliavanja (konvergiranja) k rjeenju,
odnosno korigiranja po"etnih pretpostavki. Da bi mogli osigurati pribliavanje rjeenju, nuno je
poznavati karakter funkcija u odabranom podru"ju. Moramo naglasiti da bilo koji iterativni
postupak daje uvijek samo priblino rjeenje! Iteracija se primjenjuje se kad jednostavnim
matemati"kim postupcima nije mogu#e na#i 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 tre#i korak ponavljaju se tako dugo dok se ne prona!e zadovoljavaju#e rjeenje. Ako na
adekvatan na"in ne korigiramo pretpostavljeno rjeenje, moe se dogoditi da nema
konvergencije prema rjeenju i da se iteracija protegne na beskona"no ponavljanje drugog i
tre#eg koraka. Stoga obi"no treba uklju"iti i kontrolu realiziranog broja koraka, te ako je taj broj
prevelik treba prekinuti postupak. Takve situacije doga!aju se obi"no 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 odre!eno iskustvo i poznavanje problema numeri"ke
analize. Treba uvijek imati na umu na ra"unalo radi sa kona"nim brojem decimala i da kod
odre!enih problema moe do#i do multiplikacije greke na taj na"in da nije mogu#e do#i 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 na#i rjeenje tako dugo dok sam interval
ne postane manji od zadane to"nosti. Funkcija f1 kontinuirano pada na cijelom promatranom
podru"ju (prije i nakon sjecita), a funkcija f2 kontinuirano raste na cijelom promatranom
podru"ju. Traimo priblino rjeenje sa to"no#u %, tj. traimo onu vrijednost x za koju #e se y1 i
y2 razlikovati za manje od %. Za po"etnu pretpostavku uzimamo vrijednost x0. Izra"una 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 to"nosti %: Abs(y1-y2) < %. Daljnji postupak pribliavanja rjeenju prikazan
je na slici 18.


Slika 17: po#etni korak iteracije
0 X1
y1 = f (X)
y2 = f (X)
x, y1=Y2
Xo
(Y-1, Y+1)
19

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 zna"i 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 po"etnu pretpostavku. Ako smo sigurni da se nalazimo lijevo od rjeenja, treba
dakle dodati odre!eni iznos (&x1) i ponovno izra"unati 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 podru"ju onda moemo zaklju"iti gdje se nalazimo
u odnosu na rjeenje na temelju odnosa y1 i y2. Na prikazanom primjeru u podru"ju od x0 do x
y1 je uvijek ve#e od y2, a desno od x y2 je ve#e 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 odre!eni iznos, a ako je pretpostavka s
desne strane rjeenja, pri korekciji potrebno je oduzeti odre!eni iznos! Ako bi korekcije radili
tako da dodajemo i oduzimamo uvijek iste iznose, postupak bi "plesao" po istim to"kama oko
rjeenja, bez konvergencije. Dakle, nakon to "pre!emo" s druge strane rjeenja treba oduzeti ili
dodati razli"it iznos od korekcije u prethodnom koraku. U ovom primjeru nakon "promjene
strane" iznos nove korekcije jednak je polovini iznosa korekcije u prethodnom koraku. Uo"ite na
ne moemo uvijek to"no znati u kojem koraku #e se pre#i s jedne strane na drugu stranu od
rjeenja, stoga algoritam odre!ivanja korekcije mora uvijek pripremiti iznos korekcije za
suprotni smjer, tj. za jedan korak unaprijed.
Primjer uporabe strukture stoga u algoritmu evaluacije
aritmeti!kog izraza
Ovdje #e biti izloen pojednostavljeni algoritam evaluacije numeri"kog izraza kao primjer
jednog od brojnih algoritama u kojima se koristi struktura stoga. Algoritam u"itava aritmeti"ki
izraz kao niz znakova (string), a zada#a mu je izra"unati vrijednost tako u"itanog aritmeti"kog
izraza.


0 X1
y1 = f (X)
0 X1
0 X1
0 X2
0 X2
0 X1
0 X1
0 X2
y2 = f (X)
x, y1=Y2
(X-1, X+1)
Xo
(Y- 1 ,
Y+ 1 )
20
Radi pojednostavljenja algoritma u ovom primjeru uvedena su slijede#a ograni"enja:
! 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 ' a b +
Algoritam evaluacije izraza:
1. Dodaj ) na kraj izraza da bi se ozna"io 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 prona!en operand, stavi ga na stog, tj. na vrh stoga
4. Ako je prona!en operator o:
a. Uzmi dva elementa sa vrha stoga (A je na vrhu, a B ispod njega)
b. Izra"unaj 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 obra!uje znak po znak iz u"itanog niza, tj.
izdvaja se pojedini znak i ustanovljava se da li je to znamenka ili operand. U slu"aju
vieznamenkastih brojeva, postupak parsiranja je sloeniji jer treba ustanoviti za svaki broj
po"etak i kraj niza znamenki.
U slijede#oj 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 obra!uje, a u tre#em 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 odre!eni redoslijed. Naj"e#e se sortira po
numeri"kom 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 prona#i odre!eni "lan. Ve#ina algoritama sortiranja
21
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 kona"no
sortirani niz. Reduciranje niza se obi"no ponavlja na rekurzivan na"in. Algoritmi sortiranja
najvie se razlikuju u operacijama odnosno na"inima dijeljenja na podnizove i spajanja u
kona"no sortirani niz.
"Bubble" sort
Ovo je jedna od najjednostavnijih metoda sortiranja koja efikasno funkcionira samo za relativno
maleni broj elemenata koji se sortiraju. Za ve#i broj elemenata ova metoda je prespora. Stoga se
ova metoda vrlo rijetko upotrebljava osim za edukacijske svrhe.
Najve#i "lan u polju postavlja se na kraj polja, a u ostatku polja se na jednak na"in trai najve#i
"lan. Niz kojeg treba sortirati ima n "lanova. Osnovna je ideja premjetanje najve#eg "lana niza
na posljednje mjesto, a zatim se postupak ponavlja za prvih n-1 "lanova niza, jer je na n-toj
poziciji ve# najve#i "lan. Postupak premjetanja odre!enog "lana niza na njegovo mjesto sastoji
se od sukcesivnih usporedbi susjednih "lanova niza. Ukoliko je odre!eni "lan niza manji od onog
koji slijedi iza njega, izvrava se zamjena njihovog redoslijeda. Niz je nuno sortiran kada se
postupak uspore!ivanja (po"evi od prvog "lana niza do zadnjeg nesortiranog) ponovi n-1 puta.
Prvi puta nuno je izvriti n-1 usporedbu, da bi najve#i "lan doao na posljednje mjesto u nizu. U
svakom #e sljede#em 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 2 3 usporedbe 3
7 > 1 ! 2, 6, 1, 7 i = 1, n j 3
3 3 prolaza kroz podatke
2 < 6 ! 2, 6, 1, 7 j = 2 3
6 > 1 ! 2, 1, 6, 7 2 2 usporedbe ' n 1 prolaz
i = 1, n j 3 prolaz
3 j = 1, n - 1
j = 3 3
2 > 1 ! 1, 2, 6, 7 2 1 usporedba 3
i = 1, n j &

Algoritam "bubble" sort metode u pseudokodu:
1. U"itati broj "lanova niza N
2. U"itati 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.

22
Sortiranje umetanjem
Ova metoda sli"na je prethodnoj, ali je ipak neto efikasnija. Element niza uspore!uje se sa svim
prethodnim elementima dok se ne prona!e slijede#i manji element. Na taj na"in element niza
"ume#e" 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 odre!uju prvo najve#i (ili najmanji) element u listi te ga postavljaju na kraj (ili
po"etak) liste, te na isti na"in 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 ve#a ili jednaka od
vrijednosti svih njegovih sljedbenika. Lista se pretvara u gomilu, a korijenski "vor je sigurno
najve#i element liste. Korijenski "vor gomile se izuzima i stavlja se na kraj sortirane liste, tj.
gomila se skra#uje za 1 element i ponovno podeava.

"Shell" sort
Donald Shell objavio je ovu metodu 1959. To je zapravo unaprije!ena "bubble" metoda i
metoda "umetanja" na na"in da se elementi pomi"u 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 veli"ine oko 1000 elemenata. Prednost je ove
metode to ima male zahtjeve za memorijom.
23
"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 kona"no 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 slijede#ih koraka:
1. Odabir jednog "lana niza, tzv. "pivot-a".
2. Raspodijeliti "lanove niza na taj na"in da sve elemente manje od pivot-a stavimo ispred
njega (podniz 1), a sve "lanove ve#e od pivot-a stavimo iza njega (podniz 2). Nakon te
raspodjele "pivot" se nalazi na svojoj kona"noj poziciji.
3. Rekurzivno sortirati svaki podniz na isti na"in.

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
kona"nu poziciju. Izbor "pivot-a" nije jednozna"no odre!en, a nije niti jednozna"no odre!eno to
u"initi 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: mati"ni 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 mati"nom broju, tada se izdvoje u
posebno polje mati"ni brojevi s pripadnim pokaziva"ima na ostale podatke. Sortira se (bilo kojim
od postupaka) samo takvo izdvojeno polje.

Algoritmi pretraivanja
U ra"unalnoj znanosti algoritam pretraivanja u irem kontekstu je algoritam koji daje rjeenje
nekog problema nakon evaluacije skupa mogu#ih rjeenja. Skup svih mogu#ih rjeenja problema
naziva se uobi"ajeno "prostor pretraivanja". Osnovna podjela algoritama pretraivanja je na tzv.
"slijepe" (eng. blind, uninformed search) i "usmjerene" (engl. directed, informed search).
24
Slijepo pretraivanje
Strategija slijepog pretraivanja ne uzima u obzir specifi"nu prirodu problema. Na taj na"in
"slijepi" algoritmi pretraivanja mogu se poop#iti, odnosno na isti na"in mogu se primjeniti na
iroko podru"je problema. Me!utim ve#ina prostora pretraivanja je vrlo velika, te ovakvi
algoritmi nisu efikasni osim za male primjere (ve#inom za edukacijske svrhe). Slijepo
pretraivanje napreduje sistematski kroz prostor pretraivanja ili po nekom prethodno
definiranom redoslijedu ili biraju#i redoslijed evaluacije slu"ajno.
Pretraivanje liste (niza)
Ovo je najjednostavnija vrsta algoritma pretraivanja. Cilj je prona#i odre!eni element prema
nekom klju"u - element koji ima odre!enu vrijednost ili sadri informaciju povezanu sa klju"em.
To je jedan od naj"e#ih problema u ra"unalstvu, pa je sloenost i struktura ovakvih algoritama
temeljito prou"ena. Najjednostavniji takav algoritam je linearno pretraivanje, koje
jednostavno sekvencijalno ispituje jedan po jedan element iz liste. Vrijeme izvo!enja je duga"ko,
ali ovaj algoritam se moe direktno primjeniti na "neobra!enu" listu, za razliku od algoritama
koji npr. zahtijevaju da lista bude sortirana.
Binarno pretraivanje zapo"inje na polovici liste i nastavlja se stalnim raspolavljanjem
intervala u kojem bi se mogao na#i traeni zapis. Prosje"ni broj pretraivanja je log
2
n -1, gdje je
n broj elemenata u listi. Za binarno pretraivanje lista mora biti sortirana i mora biti omogu#en
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 odre!uje tip pretraivanja.
Postoje dva osnovna na"ina pretraivanja strukture stabla:
Pretraivanje u irinu (engl. breadth-first search) - ispituju se svi "vorovi na odre!enoj razini
prije prelaska na slijede#u razinu.
Pretraivanje u dubinu (engl. depth-first search) - pretrauje poniranjem niz stablo to je bre
mogu#e tako da uvijek generira djecu zadnjeg proirenog "vora dok ne do!e do rjeenja (ili
dok ne pre!e 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 po!etak reda tako da se ona prva ispituju.
A A
B C
D
E F G
B C
D D D
C E F G B
G G A A
E F G C E F G B
G G A A

Slika 21: Pretraivanje strukture stabla po irini i po dubini
Za pretraivanje strukture grafa tako!er postoji nekoliko algoritama, a neki od njih zapravo su
proirenja algoritama za pretraivanje strukture stabla.
25
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 obi"no se
nazivaju heuristi!ke temelje se na iskustvenim pravilima i tehnikama prosu!ivanja koje mogu
pomo#i, ali nuno ne osiguravaju pronalaenje rjeenja. Heuristi"ke informacije mogu se
oblikovati u heuristi!ku evaluacijsku funkciju koja zavisi od pojedinog "vora i od cilja koji se
trai. Ve#ina algoritama za usmjereno pretraivanje namijenjena je za strukture stabla, npr.
algoritam "najboljeg prvog" (eng. best-first search) koji zadrava procjene vrijednosti
heuristi"kih funkcija svih prethodno generiranih "vorova i izabire najbolji za nastavak
potrage.

Svi mogu#i potezi u nekoj igri (npr. ah ili "krii# krui#") mogu se prikazati strukturom stabla.
Takva struktura prikazuje prostor mogu#ih stanja koja nastupaju tijekom igre. Pretraivanje
takve strukture u svrhu pronalaenja efikasne strategije planiranja slijede#ih poteza dodatno je
oteano jer treba razmatrati i sve mogu#e poteze koje moe povu#i drugi igra". Ra"unalni
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, o"istiti).
Slika 22 sadri samo mali dio ukupnog prostora mogu#ih 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.

X X X
X X
X X X
X X X X X X X
O O O
O O O
O O O
O O O O O O O O
O
O
O
O
O
O O O O O O
O
O
O

Slika 22: Dio prostora stanja igre "krii$ krui$"
U ve#ini sli"nih prostora stanja izraen je problem tzv. "kombinatori"ke eksplozije", tj. sa
svakim novim elementom uzetim u obzir, eksponencijalno raste broj mogu#ih kombinacija
odnosno stanja koje treba pretraivati.
Primjeri usmjerenog pretraivanja u inenjerskoj praksi
U inenjerskoj praksi (naj"e#e u konstruiranju) vrlo "esti su problemi zadovoljenja ograni"enja.
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, fizi"kog oblika i
operativnih uvjeta. Uobi"ajeno je da se funkcionalni zahtjevi izraavaju kao funkcije parametara
konstrukcije, drugih funkcionalnih zahtjeva i razli"itih "internih varijabli" ("prijelaznih ili
26
pomo#nih" varijabli). Interne varijable i parametri konstrukcije "ine vektor nepoznanica
konstrukcije P = [p
1
, p
2
, p
3
, , p
n
]. Funkcionalni zahtjevi "ine vektor F = [F
1
, F
2
, F
3
, , F
n
].
Relacije izme!u zahtjeva i nepoznanica mogu se izraziti kao:
f
i
( F, P ) = 0 i = 1, k
g
j
( F, P ) 4 G
j
j = 1, s
Navedene jednadbe i nejednadbe u terminologiji znanosti o konstruiranju nazivaju se
"ograni"enja". Pri tome neke od navedenih relacija ne moraju sadravati funkcionalne zahtjeve,
nego samo parametre i "interne varijable". $esto je vrlo teko prona#i skup vrijednosti varijabli
(nepoznanica konstrukcije) tako da budu jednako kvalitetno zadovoljeni svi funkcionalni
zahtjevi, jer pojedini zahtjevi "esto budu u koliziji.
Metode rjeavanja problema ograni"enja uklju"uju kombinatori"ko pretraivanje i
"backtracking".
U novije vrijeme brojna su istraivanja tzv. geneti!kih algoritama koji simuliraju procese
bioloke evolucije i koriste ih za pronalaenje puta prema rjeenju problema.
PROGRAMSKI JEZICI
Programski jezik zapravo je skup sintakti"kih i semanti"kih pravila koja definiraju ra"unalni
program. Jezik omogu#uje programeru precizno specificiranje na kojim podacima #e ra"unalo
djelovati, kako #e ti podaci biti spremljeni i prikazani, te koje akcije treba poduzeti za razli"ite
uvjete. Kompleksne ra"unalne aplikacije danas nalazimo gotovo u svakom aspektu modernog
ivota: medicinski ure!aji, elektrane, video igre, sustavi u automobilu itd. Mnoge aplikacije
sadre milione linija koda (naredbi) od kojih se o"ekuje da rade ispravno u svim situacijama.
Softver op#enito mora biti izuzetno pouzdan - posljedice greki mogu biti u rangu od nelagode
pa do ivotne opasnosti. to je potrebna ve#a pouzdanost, to je i razvoj skuplji, pa uvijek treba
traiti kompromis izme!u cijene i pouzdanosti. Navedenim problemima bave se stru"njaci iz
podru"ja softverskog inenjerstva (eng. software engineering). Tehnike softverskog inenjerstva
nastoje unaprijediti funkcionalnost i pouzdanost programa, uz istovremeno pove#anje 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. Po"etkom sedamdesetih godina prolog stolje#a dolo je do
razvoja prvih izuzetno velikih programskih sustava koji su postavili pitanje kako se moemo
nositi sa veli"inom i sloeno#u modernih ra"unalnih 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 pove#ati
pouzdanost, odnosno minimizirati koli"inu "bugova" s kojima aplikacija izlazi na trite.
U ovom poglavlju izloen je kratki pregled podjele programskih jezika po razli"itim kriterijima,
a zatim slijedi opis "etiri metodologije (paradigme) programiranja koje su u svojim osnovama
bitno razli"ite kao i podru"ja njihove namjene. Razlike izme!u programskih jezika najbolje je
promatrati upravo kroz vrste metodologije programiranja kojima pripadaju, a ne po detaljima
implementacije ili perfromansi. Nastanak razli"itih metodologija uvjetovan je proirenjem sa
po"etnog koritenja softvera isklju"ivo za numeri"ke probleme na sve aspekte ivota, ali i svim
ranije izloenim problemima kojima se bavi softversko inenjerstvo. Objektno orijentirana
metodologija je danas prevladavaju#a metodologija programiranja u razvoju velikih i sloenih
programskih sustava za ve#inu podru"ja primjene ra"unala. Stoga je objektno programiranje
izloeno puno opirnije od ostalih metodologija, tj. posve#eno mu je cijelo poglavlje koje slijedi
iza ovog poglavlja.
27
Podjela programskih jezika
Mnogo je kriterija po kojima moemo izvriti podjele svih postoje#ih programskih jezika.
Podjela prema namjeni dosta je relativna - prvi razvijeni jezici bili su za numeri"ke i znanstvene
probleme (FORTRAN, ALGOL) i za poslovne probleme (COBOL). Daljnjim razvojem
podru"ja namjene su se stalno proirivala, mogli bi se npr. izdvojiti jezici za podru"je 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 najve#e razlike izme!u programskih jezika mogu se razlu"iti po na"inu
rada, odnosno prema metodologiji (paradigmi) programiranja. $etiri osnovne (naj"e#e koritene
paradigme su imperativna (proceduralna), funkcijska, logi"ka i objektno orijentirana. Svaka od
njih detaljnije je obra!ena u ovom poglavlju. Neki jezici ne mogu se svrstati isklju"ivo u jednu
paradigmu pa ih nazivamo hibridnima. Primjer takvog jezika je C++, koji se uobi"ajeno smatra
objektnim jezikom, ali nema sva svojstva ""istog" objektnog jezika, a s druge strane ima i ve#inu
karakteristika proceduralnog jezika.
Vaan je kriterij "proceduralnosti" u proceduralnim programskim jezicima slijed naredbi
odre!uje KAKO obaviti neki posao, a u neproceduralnim jezicima slijed naredbi odre!uje TO
treba u"initi.
Sa aspekta strukturiranosti razlikujemo nestrukturirane i strukturirane programske jezike.
Sa aspekta povijesnog razvoja odnosno generacijske podjele razlikujemo jezike prve, druge,
tre#e 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 razli"itih pristupa koji se
obi"no nazivaju paradigmama (eng. paradigm). U ovom kontekstu rije" "paradigm" pogodno bi
bilo prevesti kao "obrazac". Ovdje #e biti dani prikazi proceduralnog, funkcijskog, logi"kog i
objektno orijentiranog programiranja.
Paradigma programiranja odre!uje na"in koncipiranja programa, ali prvenstveno i na"in
izvravanja programa. Na primjer u objektnom programiranju, programer promatra program kao
skup objekata koji me!usobno komuniciraju, dok u funkcijskom programiranju program
moemo promatrati kao niz evaluacija funkcija.
Razli"iti programski jezici podravaju razli"ite paradigme programiranja. Ve#ina 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 generi"kog programiranja. U jeziku C++ mogu#e je napisati ""isto"
proceduralni program, ""isto" objektni program ili program koji sadri elemente obje paradigme.
Imperativno (proceduralno) programiranje
Imperativno programiranje opisuje ra"unalni proces u smislu stanja programa i naredbi koje
mijenjaju stanje, odnosno programi su niz naredbi koje ra"unalo treba izvesti. Hardverska
implementacija ve#ine ra"unala je imperativna, tj. ve#ina 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 "ugra!ene" u hardver, ve#ina 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 omogu#uju izra"unavanje sloenih mjeovitih izraza koji su
28
kombinacija aritmeti"kih, relacijskih i logi"kih operatora te poziva funkcija. Nakon
izra"unavanja vrijednost izraza dodjeljuje se memorijskoj lokaciji. Petlje ponavljaju niz naredbi
odre!eni broj puta ili do promjene odre!enog uvjeta. Uvjetno grananje omogu#uje izvo!enje
bloka naredbi samo pod odre!enim uvjetima. Naredbe bezuvjetnog grananja uklju"uju tzv.
bezuvjetni skok i poziv procedure odnosno potprograma.
Imperativno (proceduralno) programiranje naj"e#e se upotrebljava za rjeavanje ve#ine
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 druga"iji na"in! Zadaci koji se obra!uju 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 doga!ajima
Razvoj ra"unalne grafike potaknu je i razvoj grafi"kih su"elja koja koristimo pri radu sa
programskim sustavima, kao i u procesu razvoja programa. Programe prvih imperativnih jezika
ra"unala su u"itavala pomo#u buenih kartica. Slijedio je period uporabe alfanumeri"kih
terminala kada se za unos naredbi i pokretanje programa koristila tipkovnica, uz mogu#nost
prikaza upisanog teksta i/ili izlaznih podataka na ekranu. U to vrijeme ve#ina programa izvodila
se u slijede#im koracima:
1. pokretanje programa upisivanjem odgovaraju#e naredbe operativnog sustava,
2. upisivanje ulaznih podataka,
3. program obra!uje podatke, ispisuje izlazne podatke i zavrava s radom.
U ovakvom na"inu rada program kontrolira redoslijed izvo!enja pojedinih dijelova programskog
koda. Izvo!enje po"inje prvom "izvrnom" naredbom i slijedi unaprijed odre!ene putanje do
zadnje naredbe kojom se prekida izvravanje.
Pojava mia i grafi"kih elemenata u su"elju operativnog sustava znatno je unaprijedila
mogu#nosti komunikacije s ra"unalom. Tada se razvija posebna vrsta upravljanja sa radom
programa programiranje pokretano doga!ajima (eng. event driven programming).
U programu upravljanom doga!ajima programski kod ne slijedi u cijelosti unaprijed odre!ene
putanje, ve# se izvode razli"iti dijelovi programskog koda kao odgovori na doga!aje. Doga!aji
mogu biti pokrenuti akcijom korisnika, porukama sustava ili drugih programa te samog
programa. Redoslijed tih doga!aja odre!uje segmente putanje kojom #e programski kod biti
izveden. Unutar jedne procedure koja reagira na pojedini doga!aj putanja izvo!enja i dalje je
odre!ena naredbama po imperativnom principu.
Primjer implementacije programiranja pokretanog doga!ajima je Visual Basic .NET, i ostale
razvojne okoline s prefiksom "Visual". Doga!aji 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 obra!uje doga!aje te poziva
(aktivira) odgovaraju#e dijelove programskog koda (procedure) slika 23.
doga"aj
(event)
programski kod 1
(event procedure 1)
programski kod 2
(event procedure 2)
programski kod 3
(event procedure 3)
procesiranje doga"aja
(event processor)

Slika 23: program pokretan doga%ajima
29
Budu#i da se ne moe predvidjeti redoslijed doga!aja (pa niti koji #e se doga!aji "dogoditi", a
koji ne), programski kod mora uzeti u obzir neke pretpostavke o "op#em stanju" (su"elja i
podataka) kada se po"ne izvoditi npr. sadri li polje za upis podatka neku vrijednost ili ne i sl.
Ovdje je potrebno napomenuti da je vrlo teko grafi"ki prikazati putanje izvravanja programa u
ovakvim situacijama. Standardni elementi dijagrama toka razvijeni su u doba prije nastanka
tehnike programiranja pokretanog doga!ajima i nisu naknadno prilago!avani ovoj tehnici, pa ne
sadre sve elemente potrebne za prikaz situacija koje mogu nastupiti u programima upravljanim
doga!ajima.
Proces rada aplikacije upravljane doga!ajima moe se opisati slijede#im koracima:
1. Po"etak izvo!enja aplikacije u"itava se i prikazuje su"elje (u Visual Basicu se zove
forma) kao poseban "prozor" na ekranu.
2. Forma ili kontrola na formi prima doga!aj. Doga!aj moe biti uzrokovan akcijom
korisnika (npr. "klik" miem), sustavom (npr. mjera" vremena), ili posredno
programskim kodom (npr. doga!aj "Load" pri u"itavanju forme).
3. Ako postoji programski kod u odgovaraju#oj "event proceduri" ona se izvodi.
4. Aplikacija nakon toga "eka na idu#i doga!aj.
Koraci 2, 3 i 4 se ponavljaju, sve dok korisnik ili naredba u programskom kodu ne prekinu
izvo!enje aplikacije.
Programiranje pokretano doga!ajima nije svojstveno odre!enoj paradigmi programiranja, nego
se radi o na"inu rada sa programom tijekom njegova izvo!enja.
Funkcijsko programiranje
Funkcijsko programiranje vrsta je paradigme koja tretira ra"unalni proces kao evaluaciju
matemati"kih funkcija. Za razliku od imperativnog programiranja, funkcijsko programiranje
naglaava evaluaciju funkcijskih izraza umjesto izvo!enja niza naredbi. Neki mehanizmi i
operacije karakteristi"ni za imperativno programiranje u funkcijskom programiranju ne postoje
ili su rijeeni na drugi na"in. 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), karakteristi"an za imperativne jezike. Na taj
na"in eliminiraju se i negativne posljedice popratnih efekata poziva funkcije koje postoje u
imperativnim jezicima. Za odre!eni skup parametara, rezultat poziva funkcije u funkcijskom
jeziku biti #e uvijek isti bez obzira gdje ili kada je poziv funkcije izvren. Na taj na"in osigurava
se tzv. referencijalna transparentnost koja uvelike olakava dokazivanje ispravnosti programa i
omogu#uje automatsko odre!ivanje 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 op#enito se smatra da je efikasnija od mehanizama petlji
u imperativnim jezicima. To je i jedan od razloga da i ve#ina imperativnih jezika podrava
rekurziju (iznimke su npr. FORTRAN 77 i COBOL prije 2002).
Funkcijski jezici specificiraju TO treba napraviti, ostavljaju#i detalje organizacije podataka i
redoslijeda izvo!enja interpreteru, dakle naglasak je na tome to #e biti izra"unato, a ne kako #e
biti izra"unato.
Imperativni jezici detaljno opisuju KAKO treba do#i do rezultata, i to koritenjem postoje#e
arhitekture ra"unala (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.
30
IMPERATIVNO FUNKCIJSKO
Program: niz naredbi za von Neumann-ovu
arhitekturu ra"unala
Program: skup definicija funkcija (neovisan o
strojnom kodu ra"unala)
Izvrava se niz naredbi Izvravanje evaluacijom izraza
Iteracija Rekurzija
Varijable se mijenjaju tijekom izvravanja Varijablama se samo jednom pridruuje
vrijednost
Primjer:

i := 0; sum := 0;
while (i < n) do
i := i + 1;
sum := sum + i
end;
Primjer:

func sum(n:int) : int;
if n = 0
then 0
else n + sum(n-1)
end;

Deklarativno (logi"ko) programiranje
Deklarativno programiranje uklju"uje kreiranje skupa relacija koje opisuju prostor rjeenja.
Interpretacija specifi"nih koraka na putu pronalaenja rjeenja ostavlja se interpreteru. Drugim
rije"ima znanje sadrano u skupu relacija interpreter upotrebljava na razli"ite na"ine za
rjeavanje razli"itih upita. Takve relacije mogu biti "injenice i pravila. Kao i funkcijsko,
deklarativno programiranje definira TO treba u"initi, a KAKO #e se to u"initi ostavlja se
interpreteru. Stoga deklarativna rjeenja imaju dvije nezavisne faze: deklariranje i interpretiranje.
Deklarativni jezici opisuju relacije (odnose) izme!u varijabli u kontekstu funkcija, pravila
naslje!ivanja ili definiranja pojmova. Proces izvo!enja programa (interpreterom ili compilerom)
primjenjuje odre!eni algoritam na te relacije da bi generirao rezultat (naj"e#e 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 na"in rjeenje postaje preglednije i
razumljivije. Logika interpretera (tj. u njega ugra!eni algoritmi) moe se primjeniti na irokom
podru"ju problema, tj. deklarativnih specifikacija.
Deklarativni jezici intenzivno se upotrebljavaju u slijede#im podru"jima: umjetna inteligencija,
problemi zadovoljavanja ograni"enja, baze podataka, upravljanje konfiguracijama, komunikacija
izme!u 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 skra#enica OOP)
danas prevladava kao osnovna metodologija (paradigma) koja se upotrebljava pri razvoju gotovo
svih sloenih programskih sustava. Zbog vanosti OOP, ovoj metodologiji #e biti posve#eno
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 na"in egzistiraju i u proceduralnom i u objektnom programiranju.
31
Usporedba proceduralnog i objektnog programiranja
Nedovoljno informirani programeri po"etnici "esto nepotrebno uspore!uju programske jezike
razli"itih kategorija i paradigmi, pa npr. izvode zaklju"ke kao: C++ ima puno vie "toga" pa je
stoga puno bolji jezik od C-a, pa #u onda samo njega koristiti i sli"no. 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 odre!ene operacije nad
podacima. To zna"i da proces koncipiranja programskog sustava moemo promatrati sa dva
aspekta: moemo se usredoto"iti primarno na procedure (funkcije) ili primarno na podatke. Bit
razlike izme!u tradicionalnih proceduralnih metodologija i novih objektno orijentiranih lei u
primarnom fokusu (aritu). Proceduralne tehnike usredoto"uju se na funkcije sustava - "to
sustav radi" (eng. what is it doing), a objektno orijentirane tehnike usredoto"uju 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. Kre#e se od op#ih postavki o procesu rjeavanja problema prema
sve detaljnijim odredbama o svakom specifi"nom zadatku u procesu. Dekompozicija se odvija
striktno po funkcionalnim linijama, odnosno vodi se ra"una samo o tome "to koji modul radi".
Primjer "top-down" dekompozicije procedure za prikupljanje podataka prikazan je na slici 24.

Procedura za
u!itavanje
podataka
Otvaranje
datoteka
Verificiranje
ulaznih podataka
U!itavanje
podataka
Korigiranje
podataka
Korekcija
podatka 1
Kreiranje
direktorija
Kreiranje novih
tablica
Korekcija
pojedninog
podatka
Korekcija prve
grupe podataka
Korekcija
podatka 2
Korekcija
podatka 3
Korekcija druge
grupe podataka

Slika 24: Primjer "top-down" dekompozicije
Rezime osnovnih razlika proceduralnog i objektnog programiranja dan je u slijede#oj tabeli:
PROCEDURALNO (IMPERATIVNO) OBJEKTNO
naglasak na proceduralnoj apstrakciji
"top-down" razvoj programa
stupnjevano poboljavanje
pogodno za manje programe
naglasak na apstrakciji podataka
"bottom-up" razvoj programa
ponovo upotrebljiva rjeenja
pogodno za velike programske sustave
32
Prednost " Top-down" koncepcije (pristupa) je u tome da omogu#uje fokusiranje na manje
detalja istovremeno, smanjuju#i na taj na"in 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 to"ku gledanja" (eng. functional viewpoint)
! realne sustave problemati"no 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 op#enitije kao tehnike za koncipiranje programa. Osnovni
gradbeni element jezika je objekt a ne algoritam (to ne zna"i 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 ra"unalni program
kao skup objekata koji komuniciraju (funkcioniraju) zajedno da bi postigli cilj zadatka
postavljenog cjelokupnom sustavu. Pri tome svaki objekt modelira entitet ili doga!aj iz
aplikacijskog problema (domene, "stvarnog svijeta") objekti mogu obuhva#ati apstrakcije
kompleksnih fenomena ili mogu reprezentirati elemente programskog sustava (npr. stogove ili
upravljanje grafi"kim prikazom). Dakle objekti su osnovna sredstva strukturiranja programa,
odnosno "ine sredinji programski (softverski) koncept OOP. Objekt obuhva#a identitet,
strukturu i ponaanje aplikacijskih entiteta koje reprezentira (modelira). Operacijski gledano,
objekti kontroliraju ra"unalni proces. Iz perspektive razvoja programa, najvanija karakteristika
objekata nije njihovo ponaanje kao takvo, nego "injenica da se ponaanje objekta moe opisati
apstraktnom karakterizacijom njegova su"elja. Takva apstraktna karakterizacija dovoljna je za
po"etno koncipiranje sustava. Stvarno ponaanje objekta moe se implementirati i doraditi
kasnije, prema potrebama.
U stvarnom svijetu mnogi objekti su sli"ni - imaju zajedni"ka svojstva i ponaanje. Ipak, svaki
objekt ima svoj identitet i svoje jedinstvene vrijednosti (unutar) zajedni"kih 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
zna"ajna razlika izme!u objekta i varijable. Varijabla obuhva#a samo "podatkovni"
(informacijski) aspekt objekta (vrijednost), ali ne i ponaanje.
Kombinacija strukture podataka i deklaracije funkcija, zajedno sa sposobno"u da iz sebe kreira
instance razli!itih identiteta, naziva se klasom u objektno orijentiranim programskim jezicima.
Klasa usko povezuje strukture podataka i njima pridruene procedure koje ih obra#uju.
Objektna tehnologija razvoja sustava koristi isti model kroz cijeli proces razvoja sustava:
- zapo"eti sa objektno orijentiranom analizom
- konvertirati rezultate analize u objektne koncepte
- napisati objektno orijentirane programe
33
Dakle, moda najve#a prednost objektne tehnologije je u konzistentnosti modela tijekom cijelog
procesa razvoja programskog sustava. to je sustav kompleksniji i ve#i, ta prednost vie dolazi
do izraaja.
Vjerojatno najvaniji doprinos objektne orijentacije programerskoj praksi je upotreba
naslje!ivanja pri odre!ivanju relacija izme!u objekata, odnosno klasa objekata. Naslje!ivanje
omogu#uje inkrementalno dodavanje funkcionalnosti (specifikaciji). Na taj na"in osigurano je
bolje konceptualno modeliranje - mogu se izvu#i zajedni"ki dijelovi specifikacije i omogu#ena je
ponovna upotrebljivost specifikacije programskog koda. Ako se (disciplinirano) primjenjuje na
odgovaraju#i na"in, naslje!ivanje omogu#uje postupan razvoj specifikacije tipa klase objekata.
Razli!iti objekti razli!itih tipova mogu se promatrati kao elementi zajedni!kog "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 mogu#nost skrivanja lokalnog stanja i posjedovati su"elje koje definira operacije
nad tim objektima. Objekti moraju pripadati nekoj klasi (razredu), a klase mogu naslje!ivati
svojstva od nadklasa.
U ovom trenutku sigurno se name#e 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 o"ituju 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 razli"itih
na"ina. Ukoliko je potrebno promijeniti ili dodati neke postupke u ve# definiranu klasu, to se
izvodi jednostavno pomo#u naslje!ivanja i vieobli"ja. Ovom metodologijom programski
sustavi se grade na osnovi stabilnih me!uformi, 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
tako!er 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.
atributi
operacije
s
u
"
e
l
j
e
objekt
unutranjost vanjski svijet

Slika 25: Dijagram objekta "unutranjost" i "vanjski svijet"
34
Pri modeliranju sustava korisno je prikazivati objekte i klase pomo#u dijagrama. Dijagram
objekta naglaava objekt kao neto to ograni"ava svoju "unutranjost" i komunicira sa
"vanjskim svijetom".
Objekti su dobro definirane konstrukcije prikaza konkretnih ili konceptualnih entiteta. Navesti
#emo zna"ajke objekata:
Objekti:
" "Enkapsuliraju" strukturalne zna"ajke - atribute.
- Atributi:
- odre!uju mogu#a 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" zna"ajke ponaanja - operacije.
- Operacije:
- odre!uju mogu#a ponaanja objekta
- su ekstrahirane iz domene upotrebom proceduralne ili procesno orijentirane
apstrakcije
- sadre ulazne i izlazne parametre, te vrijednosti koje "vra#aju"
- 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 doga!ajima.
" Sadre semantiku, odnosno zna"enje i svrhu unutar problema ili rjeenja.
" Mogu biti kompleksni, s mogu#no#u reduciranja u podre!ene objekte, ili mogu biti
primitivni, bez mogu#nosti reduciranja.
" Objekti su instance klasa. Kae se da objekti "instanciraju" klase. Relacija izme!u 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
zajedni"ke temelje koncepta.
Kombinacija strukture podataka i deklaracije funkcija, zajedno sa sposobno#u da iz sebe kreira
instance razli"itih identiteta, naziva se klasom u objektno orijentiranim programskim jezicima.
Klasa usko povezuje strukture podataka i njima pridruene procedure koje ih obra!uju.
Objekt je instanca klase, a klase slue kao predloci za kreiranje objekata. Klase imaju ivotni
ciklus koji dijele sa svojim objektima (slika 26).

35
ivotni ciklus jedne klase
ivotni cilkus skupa
objekata klase
inicijalizacija konstrukcija destrukcija finalizacija
selekcije
mutacije

Slika 26: ivotni ciklus klase i njenih objekata

Navesti #emo zna"ajke klasa:
Klase:
" Se bave implementacijom uniformnih strukturalnih zna"ajki i zna"ajki ponaanja.
" Imaju sposobnost definiranja uzoraka za objekte klase. Klasa odre!uje strukturu i ponaanje
tih objekata.
" Imaju sposobnost kreiranja objekata. Klasa se moe promatrati kao "tvornica objekata". Klase
tako!er mogu odravati reference na sve svoje objekte.
" "Enkapsuliraju" strukturalne zna"ajke - atribute.
- Atributi:
- su implementirani klasom
- mogu biti vezani uz objekte klase - svaki objekt moe imati svoju vrijednost, tj.
atribut objekta je unutar dosega odre!enog objekta
- mogu biti vezani sa klasom kao cjelinom - svi objekti klase dijele istu vrijednost,
tj. atributi klase su unutar dosega svih objekata klase
" "Enkapsuliraju" zna"ajke ponaanja - operacije.
- Operacije:
- Su implementirane kao metode ili potprogrami, a obi"no 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 su"elje, bez
implementacije, ali takve klase ne mogu imati instance
" Definiraju pristupa"nost 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 zna"ajkama 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 obi"no se nazivaju i generi"ke klase ili "klase
predloci" (template classes).
" Mogu omogu#iti svojim objektima da budu klasificirani kao stati"ki ili dinami"ki. Za razliku
od stati"kih, dinami"ki objekti mogu mijenjati svoje klase.
" Omogu#uju objektima da pripadaju direktno u vie klasa.
36
" Imaju ivotni ciklus koji dijele sa svojim objektima (slika 26). ivotni ciklus nazna"en je
slijede#im vrstama operacija:
- operacije inicijalizacije - pozivaju se pri kreiranju prvog objekta klase
- operacije konstrukcije (eng. constructor operations) objekata
- operacije selekcije (eng. selector operations) koje daju su"elje za "dobivanje"
informacija o objektu ili klasi i iz objekta ili klase
- operacije mutacije (eng. mutator operations) koje daju su"elje 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 doga!ajima.
" Definiraju implementaciju za svoje objekte.
" Mogu biti kompleksne, s mogu#no#u reduciranja u podre!ene klase, ili mogu biti primitivne,
bez mogu#nosti reduciranja.

Pojam kategorizacije je uobi"ajen u konvencionalnim metodama prikaza znanja - npr. zoolozi
koriste hijerarhijsku kategorizaciju vrsta. Relacije izme!u kategorija obi"no 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 zajedni"ka
svojstva nekoliko deriviranih klasa. Apstraktna klasa je dakle klasa koja slui kao zajedni"ka
osnovna klasa i ne#e 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 na"in moe se
kreirati vierazinska hijerarhija sadravanja (uklju"ivanja) objekata. Kompozitni objekt upravlja
postojanjem i me!uzavisnostima svojih podobjekata, odnosno upravlja skupovima instanci
podobjekata.
Osnovni elementi objektnog modela
U ovom poglavlju izloiti #emo slijede#e 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
! U"ahurivanje (encapsulation)
! Naslje#ivanje (inheritance)
! Vieobli"je (polymorphism)
U"ahurenje (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 tako!er slui i kao zatita od neautoriziranog pristupa internim
podacima i operacijama objekta. Dozvola pristupa mora se eksplicitno definirati.
Razlikujemo dva na"ina 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.

37

Slika 27: Zone pristupa objektu
Svi atributi i operacije koji su potpuno unutar objekta, skriveni su od vanjskog svijeta, odnosno
oni su "u"ahureni" (eng. encapsulated). Ostali objekti nemaju pristup do njih. Atributi i operacije
koji djelomi"no izlaze iz okvira objekta pristupa"ni su "vanjskom svijetu" i oni "ine su"elje
objekta. Razlikujemo dva na"ina 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 odgovaraju#a modularizacija, mogu#e je odgoditi
kona"ne odluke o implementaciji. To svojstvo omogu#uje brzu izradu prototipa modela.
Enkapsulacija omogu#uje 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
RIJE$
DOSTUPNOST
public "lan je dostupan svima
protected "lanu se moe pristupiti samo iz klase koja ga definira i iz
klasa koje od nje naslje!uju
friend "lan je dostupan iz svih klasa unutar istog programa
(projekta)
private "lan je dostupan samo unutar klase
protected friend unija protected i friend

Naslje!ivanje
Usporedba klasa sa konvencionalnim na"inima kategorizacije dovodi do izraaja pojam
hijerarhije klasa (naslje%ivanje). "Podklase" su zapravo proirenja i/ili specijalizacije postoje#ih
klasa i naslje!uju njihova svojstva. Objektno orijentirani programski jezici upotrebljavaju klase
za kategorizaciju entiteta koji se pojavljuju u aplikacijama. Relacije izme!u kategorija obi"no 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
private
protected
public
su!elje prema
podklasama
s
u
!
e
l
j
e

p
r
e
m
a
k
l
i
j
e
n
t
i
m
a
atributi
operacije
s
u
"
e
l
j
e
objekt
unutranjost vanjski svijet
38
opisati sva njegova svojstva. Dovoljno je opisati samo razlike u odnosu na koncept unutar
postoje#e hijerarhije.
Najjednostavniji na"in definiranja podklase je proirivanje osnovne klase s novom
deriviranom klasom. Podklasa nastoji proiriti svojstva definrana osnovne klase.
Drugi na"in definiranja podklase je specijalizacija. U tom slu"aju osnovna klasa se
upotrebljava za definiranje derivirane klase koja specijalizira svojstva osnovne klase.
Naslje!ivanje nije ograni"eno na jednu osnovnu klasu. Klasa se moe deklarirati i kao
ekstenzija dvije ili vie klasa, u tom slu"aju govorimo o viestrukom naslje!ivanju.
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
zajedni"ku osnovnu klasu. Svojstva koja se naslje!uju iz tih "superklasa" ponavljaju se
tada u deriviranim klasama i u tom slu"aju govorimo o ponovljenom naslje!ivanju.
Drugim rije"ima, isto svojstvo moe biti naslije!eno od razli"itih "superklasa" koje su to
svojstvo naslijedile od zajedni"kog "pretka".



Slika 28: Vrste naslje%ivanja


Slika 29: Primjer hijerarhijske strukture klasa

prikaz proizvoda
identifikator : String
opis : String
odgovorna osoba : String
ograni!enja upotrebe : String
status : String
3D CAD model
konstrukcijska dokumentacija
sastavnica proizvoda
lista zahtjeva
ugovorna dokumentacija
tehni!ke upute
standardi
interni standardi
op#i standardi
tehnoloka dokumentacija
tehni!ki prora!uni
crte
radioni!ki crte
sklopni crte
dispozicijski crte
Normalno naslije"ivanje Ponovljeno naslije"ivanje Viestruko naslije"ivanje
39
Primjer naslje!ivanja metoda
Ovdje je dan primjer programskog koda u .NET Visual Basic-u za ilustraciju kako jedna klasa
naslje!uje metodu od druge klase koja joj je nadre!ena 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" naslje!uje sve (obje)
metode iz klase "Class1" naredbom "Inherits Class1". U klasi "Class2" redefinira se
metoda "Method2" pomo#u rezervirane rije"i "Overrides", odnosno programski kod metode
"Method2" raditi #e druga"ije 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 naslije#ene 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 slijede#i:
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.
Vieobli"je (polimorfizam)
Polimorfizam (vieobli"je, vievrsnost) zna"i imati sposobnost preuzeti mnogo varijanti oblika.
U objektno orijentiranoj tehnologiji to se odnosi na mogu#nost entiteta da se u tijeku izvo!enja
povee sa instancama razli"itih klasa. U objektno orijentiranim jezicima mogu se razlu"iti dva
oblika polimorfizma - inkluzijski i operacijski.
! Inkluzijski polimorfizam implementira se mehanizmom naslje!ivanja. Taj na"in
polimorfizma omogu#uje da se objekt tretira kao da je pripadnik vie vrsta istovremeno.
40
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 razli"ite tipove
koji pripadaju nepovezanim skupinama. Drugim rije"ima, operacije istog naziva mogu se
primjeniti na razli"ite objekte koji nisu inkluzijski povezani. Postoje dvije vrste
operacijskog polimorfizma - parametarski i "preoptere#enje operatora".
o Preoptere"enje (eng. overloading) implicira da se ista operacija upotrebljava za
razli"ita implementacijska tijela. U takvom slu"aju dvije operacije dijele isto ime,
ali imaju potpuno razli"ito ponaanje.
o U parametarskom polimorfizmu, operacija radi na isti na"in za mnogo tipova,
implementiraju#i isto ponaanje. Takve operacije obi"no se nazivaju generi"ke
funkcije. Generi"ka funkcija moe raditi sa argumentima bilo kojeg tipa, op#enito
pokazuju#i isto ponaanje, nezavisno od tipova argumenata.
Polimorfizam, u kombinaciji sa dinami"kim povezivanjem (eng. dynamic binding) omogu#ava
gradnju fleksibilnih sustava koje je lake proirivati. Dinami#ko povezivanje je mogu#nost da
se objekt povee sa operacijom tek u tijeku izvo!enja programa. Drugim rije"ima dinami"ko
povezivanje odlae povezivanje poziva funkcije i ciljnog bloka programskog koda do trenutka
izvo!enja programa.

Neki na#ini implementacije vieobli#ja u .NET Visual Basic-u:
! Overloading (preoptere#enje)
o Razli"ite verzije metoda imaju isto ime ali prihva#aju razli"ite koli"ine
parametara ili razli"ite tipove parametara
! Overriding (prekora"enje)
o Metode zamjenjuju naslije!ene metode koje nisu prikladne u deriviranoj klasi.
Derivirane klase naslje!uju prekora"ene metode
! Shadowing (skrivanje)
o sakriveni "lanovi lokalno zamjenjuju "lanove koji imaju ve#i doseg

Primjer preotere$enja 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 preopete#enja razli"ita imena za razli"ite procedure:

Sub DisplayChar(ByVal theChar As Char)
Sub DisplayInt(ByVal theInteger As Integer)
Sub DisplayDouble(ByVal theDouble As Double)

41
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 izvo!enju programa Visual Basic .NET kreira instancu forme, odnosno te klase. Objekti se
kreiraju kao identi"ne 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 omogu#uju 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 uve#ana 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. Slijede#i 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 vra#a metoda deklarirana kao funkcija:
Y = Obj2.GetNumber
Poziv metode deklarirane kao sub procedura (subroutine):
Obj2.StoreNumber(Y)

Doga%aji (Events) su poruke koje objekt prima od ili alje drugim objektima ili aplikacijama.
Doga!aji omogu#uju objektima da izvode akcije kad god do!e do specifi"ne pojave. Doga!aji
dolaze od drugih objekata, aplikacija ili od ulaznih akcija korisnika programa (npr. klik miem).

42
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 odre!enog znanja i odre!enih operacija.
Izgraditi sustav sa objektno orijentiranim pristupom, zna"i analizirati problem i prona#i objekte
uklju"ene u sustav. Op#e zna"ajke 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 ra"unalnom
okviru. Takav "bottom-up" pristup, temeljen na podacima, koristi prijanje napore kao polugu za
kreiranje sustava izgra!enih od "gotovih dijelova".
Razvoj metoda modeliranja objektno orijentiranih programskih sustava
Prvi problem s kojim se suo"avaju programeri koji razvijaju sustave koritenjem objektnih
tehnologija jest izbor odgovaraju#e metodologije za proces razvoja. Od po"etaka razvoja
objektnih jezika do devedesetih godina razvijeno je i koriteno mnogo razli"itih metodologija,
svaka sa svojom varijantom notacije. Od po"etnih desetak dolo se do oko 50 metoda koje su
koritene izme!u 1989. i 1994. Te metode neki autori nazivaju metodama prve generacije. Takvo
stanje bilo je na neki na"in kaoti"no, jer niti jedna metoda nije prevladavala niti je mogla
43
zadovoljiti sve zahtjeve iz prakse. Sve su te metode imale neke zajedni"ke koncepte, ali izraene
na razli"ite na"ine. Takvo stanje "ak je i odvra#alo od upotrebe objektne tehnologije. Put prema
spajanju i unifikaciji metoda po"eo 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 zapo"inju 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 metodi"ara, te u srpnju
1997. nastaje prvi prijedlog standarda. Nakon slijede#eg koraka dorade, u studenom 1997. OMG
grupa prihva#a UML kao standardni jezik modeliranja. Tako UML postaje temelj za de facto
standard u domeni objektno orijentirane analize i koncipiranja. To ne zna"i da su sve ostale
metode odmah istisnute, ali primjetan je trend sve ve#e 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
tako!er omogu#uje pohranu, razmjenu i primjenu znanja u procesima rjeavanja problema. UML
ne propisuje nikakav odre!eni 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 razli"ite organizacije, razli"iti tipovi
projekata i razli"ite problemske domene, trae i razli"ite odgovaraju#e 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 naru"itelja, recimo, u
zrakoplovnoj industriji. Me!utim, jezik za objektno modeliranje moe biti jedinstven.
Treba naglasiti i da UML nije samo notacija (na"in crtanja pojedinih dijagrama). To je skup
koncepata u objektnom modeliranju. Kao i svaki jezik, UML ima definiranu sintaksu (ovdje je to
grafi"ka notacija i niz pravila vezanih uz dijagrame) i semantiku. Razvoj semantike jezika
iziskivao je najvie napora, posebno u uskla!ivanju postoje#ih i uvo!enju 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.