C
+ +
Ranko Popoviæ Zona Kostiæ
Programski jezik
sa rešenim zadacima
UNIVERZITET SINGIDUNUM
Prof. dr Ranko Popović Zona Kostić
PROGRAMSKI JEZIK C++ SA REŠENIM ZADACIMA
Beograd, 2010.
PROGRAMSKI JEZIK C++ SA REŠENIM ZADACIMA Autori: Prof. dr Ranko Popović Zona Kostić Recenzenti: Prof. dr Dragan Cvetković Dr Boško Nikolić, docent Izdavač: UNIVERZITET SINGIDUNUM Beograd, Danijelova 32 www.singidunum.ac.rs Za izdavača: Prof. dr Milovan Stanišić Tehnička obrada: Ranko Popović Dizajn korica: Aleksandar Mihajlović
Godina izdanja: 2010. Tiraž: 250 primeraka Štampa: Mladost Grup Loznica
ISBN: 978-86-7912-286-5
Predgovor Knjiga ”Programski jezik C++ sa rešenim zadacima”, nastala je kao pratei materijal za kurseve koje su autori držali na Univerzitetu Singidunum (Fakultet za informatiku i raunarstvo i Fakultet za menadžment). Knjiga je orijentisana ka poslovnim aplikacijama i sadrži veliki broj rešenih zadataka sa objašnjenjima. U dodatku knjige detaljno su opisana Microsoftova integrisana razvojna okruženja Visual Studio C++ verzije 6 i 2008. Autori su uložili veliki napor da ova knjiga ne sadrži greške. Sve sugestije, korekcije i primedbe su više nego dobrodošle.
-3-
Sadržaj Predgovor ....................................................................................................... 3 Sadržaj ........................................................................................................... 4 1. Uvod .......................................................................................................... 6 1.1 Programski jezik C++ .......................................................................... 6 1.2 Proširenja programskog jezika C ......................................................... 7 1.3 Jednostavan C++ program ................................................................... 9 1.4 Celi brojevi i aritmetika ..................................................................... 16 2. Realni brojevi, iteracije i donošenje odluka ............................................ 23 2.1 Realni brojevi..................................................................................... 23 2.2 Iteracije (petlje) .................................................................................. 30 2.3 Donošenje odluke .............................................................................. 38 2.4 Pravila prioriteta ................................................................................ 42 3. Koncept funkcije ...................................................................................... 49 3.1 Definicija funkcije ............................................................................. 49 3.2 Prosleivanje parametara po vrednosti .............................................. 52 3.3 Promenljive kao atributi .................................................................... 54 4. Nizovi ...................................................................................................... 57 4.1 Definicija niza .................................................................................... 57 4.2 Višedimenzionalni nizovi .................................................................. 64 5. Pokazivai ................................................................................................ 68 5.1 Deklarisanje i inicijalizacija pokazivaa ........................................... 68 5.2 Pokazivai i nizovi ............................................................................. 71 6. C-stringovi, pokazivai, nizovi, funkcije, korisniki definisani tipovi podataka i tabele .......................................................................................... 76 6.1 Definicija i inicijalizacija stringa ....................................................... 76 6.2 String konstante i pokazivai ............................................................. 79 6.3 Nizovi stringova i pokazivaa ........................................................... 83 6.4 Pokazivai, reference na promenljive i funkcije................................ 86 6.5 Nizovi i funkcije ................................................................................ 93 6.6 Stringovi i funkcije ............................................................................ 98 6.7. Korisniki definisani tipovi podataka i tabele ................................ 110 6.8 Strukture .......................................................................................... 112 6.9 Nizovi struktura: tabele.................................................................... 117 7. Uvod u klase i objekte ........................................................................... 119 7.1 Objekti, klase i objektno orijentisani sistemi ................................... 119
-4-
7.2 Uvod u string objekte ....................................................................... 121 7.3 Donošenje odluka u radu sa stringovima ......................................... 131 7.4 Funkcije i string objekti ................................................................... 133 7.5 Primeri rada sa string objektima ...................................................... 138 7.6 Nizovi stringova ............................................................................... 147 8. Programerski definisane klase i objekti ................................................ 148 8.1 Deklarisanje objekata i klasa............................................................ 148 8.2 Konstruktor klase ............................................................................. 150 8.3 Preklapanje konstruktora.................................................................. 160 8.4 Destruktori ....................................................................................... 164 8.5 Opšte preklapanje funkcija i šabloni funkcija .................................. 174 9. Rad sa objektima .................................................................................... 178 9.1 Korišenje nizova, pokazivaa i dinamika alokacija memorije ..... 178 9.2 Konstruktor kopije ........................................................................... 185 9.3 Korišenje rezervisane rei const u radu sa klasama ....................... 197 9.4 Objekti, funkcije i pokazivai .......................................................... 215 9.5 Dinamika alokacija objekata .......................................................... 241 9.6 Statiki podaci lanovi i funkcije ..................................................... 247 10. Nasleivanje ......................................................................................... 256 10.1 Primeri nasleivanja i osnovna terminologija ................................ 256 10.2 Polimorfizam.................................................................................. 278 10.3 Apstraktne osnovne klase............................................................... 297 11. Fajlovi .................................................................................................. 299 11.1 Ulazno/izlazni tokovi ..................................................................... 299 11.2 Procesiranje fajla karakter po karakter........................................... 321 11.3 Sluajni pristup fajlu ...................................................................... 325 11.4 Procesiranje binarnog fajla sekvencijalno...................................... 332 12. Specijalne teme: Prijateljske funkcije, preklapanje operatora, makroi i inline funkcije ............................................................................................ 338 12.1 Prijateljske (friend) funkcije .......................................................... 338 12.2 Preklapanje osnovnih aritmetikih operatora ................................. 344 12.3 Makroi i inline funkcije ................................................................. 359 Dodatak A: Integrisano razvojno okruženje Microsoft Visual C++ .......... 365 Dodatak B: Integrisano razvojno okruženje Microsoft Visual C++ 2008 . 394 Reference: .................................................................................................. 412
-5-
1. Uvod 1.1 Programski jezik C++ Predmet „Uvod u programiranje II“ uvodi u osnovne koncepte objektno orijentisanog programiranja korišenjem jezika C++. C++ jezik je jedan od najpopularnijih programskih jezika korišenih za razvoj raunarskih aplikacija. Programski jezici se mogu svrstati u jezike niskog i visokog nivoa. Jezici niskog nivoa su asembleri. Asembleri dozvoljavaju programeru maksimalnu kontrolu raunarskog sistema. Asembleri se teško ue zato što su simboliki i programer mora da vodi rauna o svim detaljima programa. Asemblerski programi su, takoe, teški za održavanje i debagovanje. Asemblerski programi nisu portabilni, oni su specifini za hardver i operativni sistem raunarske platforme za koju su razvijeni. Na primer, ne može se direktno izvršiti asemblerski programski jezik za PC na Macintosh platformi. Suprotno, jezici visokog nivoa, kao što su COBOL, Visual Basic i Java su lakši za uenje, održavanje i debagovanje u odnosu na asemblere. C++ je jezik "srednjeg nivoa". Zadržava se kontrola nad raunarom kao kod asemblera i zadržavaju se dobre strane jezika "visokog nivoa". C++ je portabilan-prenosiv u smislu da se može izvršiti, sa minimalnim promenama, na više razliitih raunarskih sistema bez modifikacija. C++ je "mali" programski jezik. On ne sadrži ugraene karakteristike prisutne u drugim programskim jezicima (npr. Visual Basic, ima oko 150 rezervisanih rei) koje dalje poveavaju portabilnost. C++ ima oko 70 kljunih rei. C++ je objektno orijentisano proširenje C programskog jezika. Dennis Ritchie je razvio C jezik u Bell-ovim laboratorijama 1972. godine kao pomo pri pisanju UNIX operativnog sistema za PDP-11 miniraunare. Bjarne Stroustrup je 1980. godine u AT&T Bell laboratorijama razvio C++ jezik. Dok je C primer proceduralnog jezika, C++ vidi problem kao skup objekata (svaki sa svojim osobinama i ponašanjima) koji meusobno interaguju. Razlozi za uvoenje novog jezika bili su: zahtevi korisnika su se dratino poveali; bilo je neophodno poveati produktivnost programera; ponovna upotreba ranije napisanog koda; drastino poveani troškovi održavanja, ... Objektno orijentisano programiranje i C ++ kao odgovor daju: apstraktne tipove podataka, enkapsulaciju, nasleivanje, polimorfizam itd.
-6-
projektovanje nego na samu implementaciju (kodovanje). Razmišlja se najpre o problemu, a tek naknadno o programskom rešenju. Razmišlja se o delovima sistema (objektima) koji nešto rade, a ne o tome kako nešto radi
(obradu grešaka). ANSI standard za jezik C++ usvojen je 1997. godine. Knjiga je podeljena na dva dela. U prvom delu, poglavlja od 1 do 6, dati su aspekti C++ jezika koji nisu objektno orijentisani. Ovo daje delu knjige, poglavlja od 7 do 12, uvode se objektno orijentisane ideje kroz
razvoj objektno orijentisanog softvera. Na kraju knjige kao dodatak dat je kratak uvod u Microsoft Visual C++ okruženje kao integrisano razvojno 6.0 i Visual studio 2008. 1.2 Proširenja programskog jezika C Pored komentara /* i */ u jeziku C++ mogu da se koriste komentari
biblioteci funkcija jezika C. Tip bool spada u grupu celobrojnih tipova, i postoji automatska bool false se pretvara u celobrojnu vrednost nula, a true u jedan.
-7-
Ako se promenljivoj tipa bool dodeljuje numerika vrednost, vrednost nula se pretvara u false, a bilo koja nenulta vrednost u true. Znakovne konstante, na primer ’A’, u jeziku C++ su tipa char dok u jeziku C su tipa int. To dovodi do toga da se A i 65 razliito tretiraju, bez obzira što u sluaju korišenja ASCII koda imaju istu brojanu vrednost. U jeziku C te dve vrednosti ne mogu da se razlikuju ni pod kojim uslovima. U jeziku C++, dodavanjem modifikatora const na poetku naredbi za definisanje podataka dobijaju se prave konstante, pod uslovom da su inicijalizatori konstantni izrazi. Tako uvedeni identifikatori predstavljaju simbolike konstante koje mogu da se koriste i na mestima na kojima se izriito traže konstante. Deklarativne naredbe u jeziku C++ smatraju se izvršnim naredbama i mogu da se koriste bilo gde u programu gde su naredbe dozvoljene, a ne samo na poetku pojedinih blokova. Doseg uvedenih identifikatora se proteže od mesta definisanja do kraja bloka unutar kojeg su definisani. Identifikatori nabrajanja, struktura i unija u jeziku C++ mogu da se koriste kao identifikatori tipa bez službenih rei enum, struct, odnosno union, pod uslovom da su jedinstveni u svojim dosezima. Pokazivau na podatke poznatih tipova u jeziku C++ ne može da se dodeli vrednost generikog pokazivaa (void*). U jeziku C argumenti su prenošeni funkciji iskljuivo po vrednosti. Da bi neka funkcija mogla da promeni vrednost neke spoljne promenljive, trebalo je preneti pokaziva na tu promenljivu. U jeziku C++ mogu je i prenos po referenci. Referenca ili upuiva je alternativno ime za neki podatak. Reference mogu da budu formalni argumenti i vrednosti funkcije. Za potrebe dodele memorije u dinamikoj zoni memorije u vreme izvršavanja programa, u jeziku C++ uvedeni su operatori new i delete. Veliina dodeljenog prostora pomou operatora new automatski se odreuje na osnovu veliine podatka (kod funkcija iz C jezika malloc, calloc i realloc, veliina mora da se navede, obino primenom operatora sizeof). Za vrlo male funkcije, pozivanje funkcije i povratak iz funkcije može da traje znatno duže od izvršavanja samog sadržaja funkcije. Za takve funkcije je efikasnije da se telo funkcije ugradi neposredno u kôd na svakom mestu pozivanja. To, pored uštede u vremenu, esto znai i manji utrošak memorije. Treba dodati modifikator inline na poetku definisanja funkcije. U jeziku C nije bilo mogue definisati dve funkcije sa istim imenom. Mehanizam preklapanja imena funkcija (eng. function overloading) u jeziku C++ omoguava da se srodnim funkcijama daju ista imena. Pod preklapanjem imena funkcija podrazumeva se definisanje više funkcija sa
-8-
istim modifikatorima. Sve te funkcije mora da se meusobno razlikuju po broju i/ili tipovima argumenata na nain koji obezbeuje njihovu jednoznanu identifikaciju. Imenski prostori (namespace) služi za grupisanje globalnih imena u velikim programskim sistemima u više dosega. Objekat je neko podruje u memoriji podataka tokom izvršavanja programa. To može biti eksplicitno definisana promenljiva (globalna ili lokalna), ili privremeni objekat koji nastaje pri izraunavanju izraza. Objekat je primerak nekog tipa (ugraenog ili klase), ali ne i funkcije. C++ je strogo tipizirani jezik, odnosno svaki objekat ima tano odreeni tip. Kada se oekuje objekat jednog tipa, a koristi objekat drugog tipa, potrebno je izvršiti konverziju tipova. 1.3 Jednostavan C++ program Ciklus razvoja programa Da biste razvili program treba da uradite nekoliko koraka. Sledeih šest koraka su tipini kada razvijate C++ program. Prvi korak: definisanje problema - veoma je važno da razumete problem koji pokušavate da rešite. Budite sigurni da ste proitali pažljivo specifikacije programa. Treba da znate koji su ulazni podaci i u kojoj formi ti podaci treba da budu. Takoe, treba da znate kako treba procesiranje tih podataka da bude uraeno. Na kraju treba da odredite koje oekivane rezultate i u kakvoj formi dobijate.
-9-
Drugi korak: dizajn programa - postoji više naina da se opiše dizajn programa. Dva prosta metoda su dijagram toka i pseudokod. Dijagram toka je grafiki opis dizajna programa koji koristi kombinaciju razliitih simbola. Pseudokod opisuje dizajn programa izbegavajui sintaksu programskog jezika naglašavajui dizajn rešenja problema. Kada dizajnirate program, važno je da proverite njegovu logiku pre nego što ponete da pišete sam programski kôd. Dizajner programa je esto suviše blizak sa dizajnom da bi video neke greške. Trei korak: pisanje koda - koraci 3, 4, 5 i 6 - se izvršavaju u integrisanom razvojnom okruženju (eng. Integrated Development Environment, IDE). Primeri ovih okruženja su: Visual Studio.NET, Borland Enterprise Studio (windows platforma), Code Forge (Linux okruženje), KDevelop (Unix okruženje). Pisanje koda programa u tekst editoru odgovarajueg programskog jezika, kao i kompajliranje, odnosno prevoenje izvornog programa ili sors koda (eng. source) su sledei koraci. Korak 4: kompajliranje (prevoenje) i linkovanje (povezivanje) programa - jedini jezik koji dati raunar razume je njegov sopstveni mašinski jezik. Instrukcije mašinskog jezika su binarno kodirane instrukcije
- 10 -
(sastavljene od nula i jedinica) koje kažu raunaru da treba da uradi odreeni zadatak, kao što je add (dodaj) 1 u registar. Svaki raunar ima svoj sopstveni mašinski jezik koji se meusobno razlikuju. Kako je mašinski jezik binarni, teško je pisati kod i pronai greške u mašinskom programskom jeziku. Pošto raunar razume samo svoj sopstveni mašinski jezik, on ne može da direktno izvršava instrukcije programskih jezika srednjeg i visokog nivoa. Raunar koristei program koji se zove kompajler (prevodilac), treba da prevede programe programskih jezika u ekvivalentne programe mašinskog jezika. PC bazirani C++ kompajler prevodi C++ u PC mašinski jezik. Kompajler ne može da prevede razliite jezike (kao što je Java) i ne može se koristiti na razliitim tipovima raunara (kao što je Macintosh).
Kompajler ima dve glavne funkcije. Prvo, on proverava sintaksne greške sors programa. Sintaksne greške su greške u pravopisu-gramatici
- 11 -
programskog jezika. Ako kompajler ne nae fatalne greške, on prevodi svaku instrukciju jezika visokog nivoa u jednu ili više instrukcija mašinskog jezika. Ova verzija sors programa na mašinskom jeziku se zove objektni program. Mada je na mašinskom jeziku, objektni program nije spreman za izvršenje. Program može da sadrži reference, nazvane spoljne reference, prema drugim programima koje je korisnik napisao ili koje C++ kompajler obezbeuje na korišenje svim korisnicima sistema. U oba sluaja treba da koristite program koji se zove linker da bi razrešili ove spoljne reference. Linker nalazi druge programe koji su deo vašeg programa. Ovaj proces je linkovanje-povezivanje. Linker proizvodi izvršivi kôd (executable code). Ovo je program koji raunar izvršava. Korak 5: Izvršavanje programa - kada se program kompajlira i linkuje on može i da se izvrši preko ikone, menija ili komandne linije. Korak 6: testiranje i debagovanje programa - ak i kada se program izvršava ne znai da je korektan-ispravan. Program treba testirati pod raznim uslovima i sa raznim podacima. Greške u ciklusu Greške koje se mogu pojaviti u razliitim koracima su: sintaksne greške i upozorenja (eng. wornings), greške prilikom izvršavanja (eng. runtime) i logike greške. Sledi kôd prvog programa prikaz izlaza na displeju. // Vas prvi program u C++ koji ispisuje na monitoru (konzolni izlaz) tekstaulne //poruke #include
using namespace std; int main() { cout << "This is our first C++ program." << endl; cout << "It works!!!" <
- 12 -
Prve dve linije koda su komentari. Komentar poinje sa dva karaktera // i nastavlja do kraja linije. Komentar nije izvršna naredba, sledi, kompajler ignoriše sve od // do kraja linije. Prazne linije ili blank možete da postavite bilo gde u programu kako bi poveali preglednost programa. C++ program je kolekcija funkcija koje rade zajedno u cilju rešenja problema. Svaki program mora da sadrži funkciju main(). Ova funkcija kontroliše C++ program izvršavajui C++ naredbe i druge funkcije. Re int koja prethodi rei main() kaže C++ kompajleru da main() proizvodi (vraa) celobrojnu vrednost. Svaki postupak se naziva izraz (eng. expression). Izraz koji se završava znakom taka-zapeta ";" naziva se naredba (eng. statement). Zanemarivanje znaka ; izaziva sintaksnu grešku pri kompajliranju. Kada biste napisali glavni program na sledei nain, kompajler ne bi prijavio sintaksnu grešku. int main(){ cout << "This is our first C++ program." << endl; cout << "It works!!!" <
C++ je case sensitive, tj. kada pišemo C++ naredbe postoji razlika izmeu velikih slova i malih slova. Na primer: int Main() je nepravilno, treba da stoji int main(). Izlaz na monitor je tok podataka (eng. data stream), odnosno niz karaktera. Tok cout (konzolni izlaz "console output" i ita se kao "see-out") predstavlja standardni izlazni tok, koji se automatski prikazuje na korisnikovom monitoru kada se C++ program izvršava. Podaci se mogu poslati na izlazni tok cout koristei operator umetanja (eng. insertion operator), <<, koji se ita kao "poslato je" ili "uzima se". String (niz karaktera) se postavlja unutar znaka navoda. Završetak linije i skok u novi red se ostvaruje pomou endl (eng. end of line) i odgovara specijalnoj sekvenci '\n'.
- 13 -
Poslednja naredba return završava izvršenje funkcije main() i šalje ceo broj ija je vrednost 0 operativnom sistemu da bi pokazala da se program završio normalno. Kompajliranje C++ programa se izvodi u dva koraka. Prvo, program nazvan pretprocesor analizira C++ sors kod i izvršava sve pretprocesorske direktive. Svaka direktiva poinje karakterom #. Drugi korak kompajliranja je prevoenje programa u mašinski kod. Direktiva #include kao rezultat ima zamenu linije koja sadrži direktivu #include tekstom sadržaja heder (eng. header) fajla koji je unutar zagrada < >, tako da on postaje deo vašeg programa i kao takav se prevodi sa naredbama vašeg programa. Heder fajlovi obino sadrže informacije o konstantama, funkcijama, klasama i drugim C++ elementima koji se esto pojavljuju u C++ programima. Heder fajl iostream (input/output stream), je jedan od standardnih skupova sistemskih heder fajlova kojim je svaki od C++ kompajlera snabdeven. Heder fajl iostream sadrži informacije o standardnim ulazno/izlaznim tokovima. Treba obratiti pažnju da se pretprocesorska direktiva #include
ne završava sa ; zato što pretprocesorska direktiva nije naredba. Mehanizam prostora imena namespace (using namespace std) Kompajler C++ jezika koristi više fajlova da bi napravio C++ program koji se može izvršiti. Uz izvorni fajl, koji je program koji piše programer, kompajler koristi jedan ili više heder fajlova, kao što je iostream i biblioteke standardnih i korisniki definisanih funkcija za kreiranje izvršnog programa. Kako je mogue da više programera uestvuju u pisanju koda, mogue je da koriste ista imena za potpuno razliite stvari. Ovo dovodi do kompajlerske greške. Da bi se to izbeglo, C++ obezbeuje mehanizam prostora imena namespace, koji deli imena koje programeri mogu da koriste na dosege imena. Direktiva using namespace std;
dozvoljava da koristimo u našim programima cout (i kasnije cin) bez potrebe da pišemo kôd kao std::cout (i std::cin). Direktiva using u osnovi kaže
- 14 -
da možemo direktno da koristimo sva imena unutar std prostora imena (cout i cin su dva takva imena). Sva standardom predviena zaglavlja sve globalne identifikatore stavljaju u imenski prostor std. Standardom je predviena mogunost da uskladištavanje standardnih zaglavlja ne bude (mada može) u vidu tekstualnih datoteka. Zbog toga imena standardnih zaglavlja ne sadrže proširenja imena .h, što je uobiajeno u jeziku C. Rezervisane rei Do sada smo koristili rezervisane rei (kljune, službene rei ili eng. keywords) kao što su int, using, namespace i return. One imaju posebno znaenje i predstavljene su u tri grupe: Prva grupa 32 službene rei iz C jezika: auto break case char
const continue default do
double else enum extern
float for goto if
int long register return
short signed sizeof static
struct switch typedef union
unsigned void volatile while
Sledea grupa 30 novih službenih rei: asm bool catch class const_cast delete
dynamic_cast explicit false friend inline mutable
namespace new operator private public protected
reinterpret_cast static_cast template this throw true
try typeid typename using virtual wchar_t
i poslednja grupa 11 službenih rei koje se naješe koriste za rad sa operatorima: and and_eq
bitand bitor
compl not
not_eq or
or_eq xor
xor_eq
Specijalne sekvence (escape sequences) Koristei endl kontrolišemo prostor izmeu linija. Prostor izmeu linija možemo da kontrolišemo koristei specijalnu sekvencu-simbol za novi red. Svaka specijalna sekvenca poinje obrnutom kosom crtom (backslash character \). Specijalna sekvenca koja postavlja kursor na poetak novog
- 15 -
reda na ekranu monitora je \n (eng. newline character). Sledee dve linije koda proizvode isti efekat kao u prethodnom primeru: cout << "This is our first C++ program.\n"; cout << "It works!!!\n";
Postoji veliki broj specijalnih simbola koji se mogu koristiti u stringu koji se šalje na cout. Simboli treba da budu u stringu unutar znaka navoda. Sledi spisak specijalnih sekvenci-simbola: \a \b \f \n \r \t \v \\ \? \' \" \000 \xhh
upozorenje backspace formfeed novi red carriage return horizontalni tabulator vertikalni tabulator obrnuta kosa crta znak pitanja jednostruki znaci navoda dvostruki znaci navoda oktalni broj heksadecimalni broj 1.4 Celi brojevi i aritmetika
Identifikatori Svi programski jezici, ukljuujui i C++, zahtevaju da programer da imena razliitim uzorcima (promenljive, funkcije ...) koje program koristi. To su identifikatori. Sastoje se od maksimalno 31 karaktera, koji mogu biti slova (mala i velika), brojevi i donja crta (_). Ne mogu da ponu brojem i ne mogu da budu istog oblika kao rezervisane rei. Promenljiva je ime koje upuuje na lokaciju u glavnoj memoriji raunara u kojoj se skladišti poseban tip podatka. U C++ programu definišemo promenljivu u deklaraciji. Deklaracija je iskaz koji uvodi neko ime u program i govori prevodiocu kojoj jezikoj kategoriji pripada neko ime i šta sa tim imenom može da radi. Deklaracija promenljive poinje tipom podatka varijable. Postoji više tipova podataka, ukljuujui ugraene
- 16 -
(ceo broj int, znak char i realni broj float i double) i korisniki definisane tipove. Iza tipa podatka dolazi ime promenljive i završni znak naredbe (taka zarez ";"). Na primer, ovo je deklaracija promenljive: int i1;
U ovoj deklaraciji, rezervisana re int znai da je promenljiva sa imenom i1 tipa integer tj. ceo broj. Zavisno od platforme (platforma se sastoji od raunarskog hardvera, operativnog sistema i C++ kompajlera), ceo broj može biti predstavljen sa dva bajta (16 bits, 216 = 65536 celih brojeva) ili sa etiri bajta (32 bits). Kod raunara koji skladište cele brojeve u etiri bajta, opseg int variabli je isti kao za tip long. Da bismo odredili koliko bajtova raunar koristi za skladištenje promenljivih razliitig tipa, koristimo operator sizeof. Promenljiva može biti deklarisana bilo gde u programu pre njene upotrebe. Vrednost promenljive je podatak uskladišten u odreenoj lokaciji u memoriji raunara. Deklarisanje promenljive ne daje promenljivoj odreenu vrednost. Deklarisanje samo rezerviše prostor u memoriji za varijablu i pridružuje deklarisano ime toj lokaciji u memoriji. Pre nego što program smesti podatke u promenljive, vrednost promenljive nije važna za program. U ovom sluaju, kažemo da varijabla sadrži "ubre" (eng. garbage). Sledei program pita korisnika da ukuca ulazne vrednosti za cele brojeve, odradi odreenu aritmetiku i prikaže rezultat na displeju. Program sadrži sledee strukture: deklariše varijable, dobija podatke od korisnika, izvršava zahtevane aritmetike operacije sa podacima i prikazuje rezultate. // Ovaj program prikazuje koriscenje celih brojeva u C++. // Korisnik treba da ukuca ulazne vrednosti za 2 cela broja. // Rezultati aritmetickih operacija se prikazuju na izlazu. #include using namespace std; int main() { // Deklaracija promenljivih int i1, i2, sum,
- 17 -
difference, product, quotient, remainder; // Dobijanje podataka od korisnika cout << "Input an integer followed by a return: "; cin >> i1; cout << "Input an integer followed by a return: "; cin >> i2; // Izvrsavanje aritmetickih operacija sum = i1 + i2; difference = i1 - i2; product = i1 * i2; quotient = i1 / i2; remainder = i1 % i2; // Izlazni rezultati cout << endl; cout << "The sum of " << i1 << " and " << i2 << " is " << sum << endl; cout << "The difference of " << i1 << " and " << i2 << " is " << difference << endl; cout << "The product of " << i1 << " and " << i2 << " is " << product << endl; cout << "The quotient of " << i1 << " and " << i2 << " is " << quotient << endl; cout << "The remainder when " << i1 << " is divided by " << i2 << " is " << remainder << endl; return 0; }
Ulazni tok cin Ulazni tok cin (konzolni ulaz) dobija sledei podatak sa tastature i smešta ga u varijablu posle koje sledi operator "izvlaenja" (extraction
- 18 -
operator, >>). Naredba cin >> i1; uzima ceo broj koji korisnik ukuca na tastaturi kao odziv na prompt i smešta vrednost celog broja u varijablu i1. Celi brojevi koje korisnik ukuca na tastaturi se ne šalju odmah programu na procesiranje. Umesto toga raunar smesti karaktere u privremenu lokaciju za skladištenje zvanu ulazni bafer. Raunar šalje ove karaktere programu kada korisnik pritisne taster. Ovo nazivamo pražnjenje ulaznog bafera (eng. flushing the input buffer). Operator dodele ili pridruženja (eng. assignment operator) =, radi na sledei nain: raunar razvija izraz na desnoj strani operatora =, i dodeljuje rezultujuu vrednost varijabli na levoj strani znaka =. Ime varijable mora da bude na levoj strani operatora dodele. Izraz na desnoj strani je celobrojna konstanta, koja može biti pozitivna, negativna ili jednaka nuli. Aritmetiki operatori Izraz na desnoj strani operatora dodele ukljuuje jedan ili više aritmetikih operatora. Program koristi 5 osnovnih aritmetikih operatora: sabiranje (+), oduzimanje (-), proizvod (*), deljenje (/), i ostatak ili modul (%), iji su prioriteti i redosledi izraunavanja dati u sledeoj tabeli: Operatori () + (unarni) - (unarni) */% +=
Asocijativnost sa leva na desno sa desna na levo sa leva na desno sa leva na desno sa desna na levo
Rešavanje problema sa celim brojevima // Napisati program koji izracunava ukupnu cenu delova i cenu rada #include #include using namespace std;
- 19 -
int main() { const int HOURLY_RATE = 44; int parts, // Cena delova hours, // Broj radnih sati labor, // Cena rada total; // Ukupna cena za korisnika cout << "Enter the cost of parts: "; cin >> parts; cout << endl; cout << "Enter the number of hours worked: "; cin >> hours; cout << endl; // Trazena izracunavanja labor = HOURLY_RATE * hours; total = parts + labor; // Prikaz rezultata cout << "Cost of parts: " << setw(5) << parts << endl; cout << "Labor charge: " << setw(6) << labor << endl; cout << "--------------" << endl; cout << "Total charge: " << setw(6) << total << endl; return 0; }
Naredba cout sadrži novu karakteristiku, setw() I/O manipulator. I/O manipulator je poruka na koji nain izlazni tok treba da bude prikazan na displeju. Manipulator setw() postavlja širinu polja displeja sledeeg prikaza izlaza. Izlaz je desno poravnat, na primer: cout << "Cena delova: " << setw(5) << parts << endl;
- 20 -
prvo prikazuje string "Cena delova: " ("Cost of parts: ") sa blanko pozicijom nakon dvotake. Zatim, manipulator setw(5) kaže cout-u da smesti sledei uzorak u polje širine 5. Na taj nain variabla parts, ija je vrednost 239, je prikazana u poslednje tri pozicije od pet pozicija polja kao na donjoj slici:
Za drugu naredbu: cout << "Cena rada: " << setw(6) << labor << endl;
Da bi se iskoristio manipulator setw(), treba da smestite #include na poetak vašeg programa. Na kraju ove sekcije treba da iskoristite operator sizeof da bi pokazali tano koliko bajtova se zahteva za skladištenje tipova podataka koje koristimo, pri emu važi: sizeof(short) sizeof(int) sizeof(long). Ako aritmetiki izraz sadrži podatke razliitog tipa, da bi se odradile operacije, C++ konvertuje sve vrednosti u tip koji je najopštiji, tj. u tip za koji je predvieno u memoriji najviše bajtova. Na primer, pretpostavimo sledee deklaracije: short k = 3; int i = 8; long j = 56;
Da bi razvio izraz, i + j + k, C++ konvertuje vrednost promenljive i, koja je tipa int, u ekvivalent long, zato što tip long može da uskladišti vee vrednosti od int. Zatim, C++ konvertuje vrednost k, koja je tipa short, u ekvivalent long. Konano, C++ dodaje rezultujuu vrednost promenljivoj j. Prethodna naredba e prouzrokovati da kompajler izda upozorenje (eng. warning message). // Ovaj program izracunava ukupne naknade za delove i rad #include
- 21 -
using namespace std; int main() { const int HOURLY_RATE = 44; long parts, // cena delova hours, // broj radnih sati labor, // cena rada total; // ukupna cena za korisnika // Unos ulaznih podataka cout << endl; cout << "Enter the cost of parts: "; cin >> parts; cout << endl; cout << "Enter the number of hours worked: "; cin >> hours; // Izracunavanje labor = HOURLY_RATE * hours; total = parts + labor; // Prikaz rezultata cout << endl; cout << "Cost of parts: " << setw(9) << parts << endl; cout << "Labor charge: " << setw(10) << labor << endl; cout << "------------------------" << endl; cout << "Total charge: " << setw(10) << total << endl; return 0; }
- 22 -
2. Realni brojevi, iteracije i donošenje odluka 2.1 Realni brojevi Realni broj, ili floating point, je broj koji ima decimalni deo, tj. decimalnu taku. Postoje dva tipa floating point C++ podataka float i double. Sledee deklaracije definišu varijablu fl koja je tipa float i varijablu db koja je tipa double. float fl; double db;
Dva floating point tipa se razlikuju u preciznosti (broj znaajnih cifara koje svaki tip skladišti) i koliini memorije koju svaki tip zahteva. Na veini raunara, promenljiva tipa float je veliine 4 bajta i ima preciznost od 7 bitova. Promenljiva tipa double okupira 8 bajtova i ima preciznost 15 cifara.
Floating point promenljive mogu da se pojave u aritmetikim izrazima na isti nain kao i celobrojne varijable. Na primer, posmatrajmo sledee deklaracije i dodele: double db1 = 3.14159, db2 = -83.01267, db3; db3 = 2 * db1 + db2;
- 23 -
Operator dodele daje varijabli db3 rezultat sa desne strane 76.72949. Izraz sa desne strane operatora dodele sadrži razliite tipove podataka. Pre nego što uradi aritmetike operacije, raunar automatski konvertuje celobrojnu vrednost 2 u realan broj 2.0. Zatim raunar množi vrednost db1 sa 2.0, što daje 6.28318. Konano, raunar dodaje ovaj rezultat vrednosti db2, što daje 76.72949. Raunar tada izvršava operaciju dodele vrednosti koja je na desnoj strani, promenljivoj db3 na levoj strani. Tip float ima preciznost samo sedam cifara, pa se ne može tano raditi sa vrednostima veim od 99.999,99. Zbog toga što veina modernih poslovnih transakcija ukljuuje brojeve vee od 100.000,00 evra, tip float je neadekvatan. Problemi prilikom prikaza na displeju decimalnih brojeva koristei cout Objasniemo zbog ega se ukljuuju sledee tri linije koda. cout << setprecision(2) << setiosflags(ios::fixed) << setiosflags(ios::showpoint);
Ponekad cout ne prikazuje na displeju broj u obliku koji se oekuje. Na primer: cout << 345.60 << endl;
prikazuje na displeju broj 345.6, bez završne nule. Drugi problem sa cout je što se eše prikazuje broj u naunoj notaciji nego decimalnoj notaciji. Na primer, cout naredba cout << 3456789.70 / 2 << endl;
prikazuje rezultat deljenja kao 1.72839 e + 006. Ovaj oblik ne odgovora izlaznom zapisu kod poslovnih aplikacija. Umesto toga, želeli bismo da prikaz na izlaznom displeju bude oblika 1728394.85. Konano, trebalo bi da kontrolišemo broj cifara sa desne strane decimalne take. Na primer, ako izraunamo porez na promet kao 8.25% od koliine 19.95, želeli bismo da cout prikaže na displeju proizvod 0.0825 * 19.95 do najmanje vrednosti izražene u centima ili dinarima.
- 24 -
cout << 0.0825 * 19.95
Meutim, cout prikazuje proizvod kao 1.64588. Problemi: zanemarivanja završnih nula, prebacivanja na naunu notaciju i kontrola broja cifara sa desne strane decimalne take su meusobno povezani. Rešenje ovih problema je korišenje I/O (Input/Output) manipulatora. Podsetimo se da o I/O manipulatoru možete da razmišljate kao o cout strimu koji prikazuje brojeve na odreen nain. Manipulatori koje koristimo su: setprecision(), koji postavlja broj cifara sa desne strane decimalne take, i setiosflags(), koji kontroliše razliita postavljanja za cout. Mora da ukljuimo heder fajl iomanip koristei pretprocesorsku direktivu #include . Ubacujemo sledee naredbe na poetak funkcije main() bilo kog programa: cout << setprecision(2) // dva decimalna mesta << setiosflags(ios::fixed) // prikaz u fiksnoj notaciji << setiosflags(ios::showpoint); // stampanje zavrsnih nula
Manipulator setiosflags() ima složenu sintaksu. U zagradama nakon imena manipulatora setiosflags nalazi se ime klase ios. Nakon toga slede dve dvotake :: i ime zastavice (eng. flag name). Zastavica fixed kaže cout strimu da realni brojevi treba da se prikažu kao u formatu sa fiksnom takom a ne u naunoj notaciji. Zastavica showpoint kaže cout strimu da štampa završne nule. Ovako definisan efekat ostaje sve dok ga ne promenimo šaljui druge vrednosti setiosflags() cout-u. Ako se koristi setprecision() bez korišenja setiosflags(ios::fixed), onda setprecision() odreuje ukupan broj prikazanih cifara, ne samo broj cifara posle decimalne take. Razmotrimo sledei kôd: cout << setprecision(2) << setiosflags(ios::fixed) << setiosflags(ios::showpoint); cout << 3456789.70 / 2 << endl; cout << 0.0825 * 19.95 << endl; cout << 356.70 << endl;
Kao izlaz dobijamo:
- 25 -
1728394.85 1.65 356.70
Treba obratiti pažnju da ako je vrednost promenljive db 356.091, prikaz sa jednom decimalom ne utie na vrednost koja je uskladištena u db. Stvarna vrednost uskladištena u db je još uvek 356.091. Napomena, preciznost i ios zastavice važe sve dok se ne resetuju. Da bismo promenili preciznost, prosto koristimo setprecision() ponovo sa razliitom vrednošu. Da bismo resetovali ili ios::fixed ili ios::showpoint flag, treba da postavimo resetiosflags(ios::fixed) ili resetiosflags(ios::showpoint) kod cout. // Ovaj program izracunava porez na promet i cenu stavke #include #include using namespace std; int main() { const double TAX_RATE = 0.0825; double base_price, // cena jednog dela tax, // porez price; // prodajna cena (price + tax) //definisanje izlaza cout << setprecision(2) << setiosflags(ios::fixed) << setiosflags(ios::showpoint); cout << "Enter the price of the item: "; cin >> base_price; tax = base_price * TAX_RATE; price = base_price + tax; cout << endl; cout << "The base price is" << setw(11) << base_price << endl; cout << "The tax is" << setw(18) << tax << endl; cout << "The price is" << setw(16) << price << endl;
- 26 -
return 0; }
Rešavanje problema sa realnim brojevima // Ovaj program simulira jednostavnu kasu #include #include using namespace std; int main() { const double SALES_TAX_RATE = 0.0825; double meal_price, // cena obroka koju je uneo korisnik sales_tax, // iznos poreza na promet total, // ukupno: meal_price + sales_tax amt_tendered, // iznos dobijen od korisnika change; // kusur: amt_tendered - total // Definisanje izlaza cout << setprecision(2) << setiosflags(ios::fixed) << setiosflags(ios::showpoint); // Prikaz banera i dobijanje cene cout << "*** C++-Side Restaurant ***" << endl << endl; cout << "Enter the price of the meal: $"; cin >> meal_price; cout << endl; // Izracunavanje poreza i ukupne cene sales_tax = meal_price * SALES_TAX_RATE; total = meal_price + sales_tax; // Prikaz poreza ukupne cene
- 27 -
cout << endl; cout << "Price of Meal: " << setw(6) << meal_price << endl; cout << "Sales Tax: " << setw(10) << sales_tax << endl; cout << "---------------------" << endl; cout << "Total Amount: " << setw(7) << total << endl; // Dobijanje novca za naplatu cout << endl; cout << "Enter amount tendered: $"; cin >> amt_tendered; cout << endl; // Izracunavanje kusura change = amt_tendered - total; // Prikaz koliina i kusura cout << endl; cout << "Amount Tendered: $" << setw(7) << amt_tendered << endl; cout << "Total Amount: $" << setw(7) << total << endl; cout << "-------------------------" << endl; cout << "Change: $" << setw(7) << change << endl; // Stampanje zavrsnog banera racuna cout << endl << endl; cout << "*** Thank You ***" << endl; return 0; }
- 28 -
Kada aritmetiki izraz sadrži više promenljivih tipa int ili long i više promenljivih tipa float ili double, C++ automatski konvertuje sve promenljive u tip double pre nego što izvrši aritmetike operacije. Sledi, rezultat je tipa double. Tip cast (nakon koga sledi izraz u malim zagradama) menja tip podatka – vrednosti koja je ukljuena u odreeni tip, na primer int i = 5; double(i);
kastuje-menja vrednost promenljive i, odnosno konvertuje vrednost i u double 5.0. Kada se tip podatka sa desne strane znaka dodele razlikuje od tipa podatka promenljive sa leve strane, C++ konvertuje vrednost desne strane u tip podatka varijable sa leve strane. Primeri iz aritmetike Svaki izraz u C++ ima numeriku vrednost. int h = 17; i, j, k; i = j = k = h; ili sum = (count = 0); sum = 0;
Složeni operatori dodele prikazani su: +=, -=, *= i /=.
Operatori () + (unarni) - (unarni) */% += += -= *= /=
Asocijativnost sa leva na desno sa desna na levo sa leva na desno sa leva na desno sa desna na levo
- 29 -
Operatori uveanja i umanjenja (eng. increment, decrement) poveavaju ili smanjuju vrednost promenljive za jedan. Mogu da se koriste pre ili posle varijable sa prefiksom pre ili post. To su unarni operatori. Na donjoj slici je dat primer. Izraz j = 4 + -- i
j = 4 + i --
6 10 6
7 11 6
Inicijalna vrednost i je 7 Upotrebljena vrednost i Dodeljena vrednost j Konana vrednost i
2.2 Iteracije (petlje) Relacioni uslovi Razmotriemo sledee iteracije, odnosno petlje (while, do i for). Najprostiji tip uslova je relacioni uslov, koji uporeuje vrednosti dva operanda, koristei relacione operatore: ==, !=, <, <=, >, >=. U jeziku C++, ako je relacioni uslov true (tano), ceo uslov ima numeriku vrednost 1. Ako je relacioni uslov false (netano), ceo uslov ima numeriku vrednost 0. Sledi, C++ uzima svaku vrednost razliitu od nule kao true, a vrednost 0 kao false. Primer: koja vrednost promenljive rezult e biti odštampana na displeju koristei donju tabelu? #include using namespace std; int main() { int i = 3, j = 8, k = 5, result; result = (i < j < k); cout << "result = " << result << endl; return 0; }
- 30 -
Kompajler e upozoriti korisnika: warning C4804: '<' : unsafe use of type 'bool' in operation,
ali e se program izvršiti i prikazati na ekranu rezultat.
Operatori
Asocijativnost
() [] -> .
Sa leva u desno
! ~ ++ -- + - * (type) sizeof
Sa desna u levo
*/%
Sa leva u desno
+-
Sa leva u desno
<< >>
Sa leva u desno
< <= > >=
Sa leva u desno
== !=
Sa leva u desno
&
Sa leva u desno
^
Sa leva u desno
|
Sa leva u desno
&&
Sa leva u desno
||
Sa leva u desno
?:
Sa desna u levo
= += -= *= /= %= &= ^= |= <<= >>= Sa desna u levo
Sa leva u desno
,
- 31 -
Beskonane petlje: while i do Petlja while Naredba ima sledei oblik: while (kontrolni-izraz) telo-petlje
Kontrolni izraz, koji treba da bude u malim zagradama, može biti bilo koji ispravan C++ izraz odnosno relacioni uslov. Telo petlje može biti prosta C++ naredba završena sa ";" ili može biti sastavljeno iz više naredbi koje se nalaze unutar velikih zagrada. Posmatramo sledei kôd: int count = 0; while (count < 5) { ++count; cout << "Hello" << endl; } cout << endl; cout << "Hello je prikazan " << count << " puta." << endl;
Poetna vrednost promenljive count je 0 i uslov petlje je ispunjen sve dok je vrednost promenljive count manja od 5. Telo while petlje je složena naredba sastavljena iz dve proste naredbe i izvršava se ako je uslov petlje ispunjen, u ovom sluaju pet puta: Hello Hello Hello Hello Hello Hello je prikazan 5 puta.
Primer neodreene petlje koja koristi char tip podatka Pisanje koda za neodreenu petlju koristei while naredbu je pogodno kada se nezna koliko e se puta telo petlje izvršiti. Zbog toga se ove petlje i nazivaju neodreene. Pretpostavimo da želimo da napišemo program koji
- 32 -
broji karaktere jedne linije koje korisnik unosi sa tastature. Linija je niz karaktera završena sa return odnosno enter. Return nije deo linije i ne broji se kao karakter. Program ne zna unapred broj karaktera koje e korisnik da unese. Znakovna konstanta (eng. character constant) je prost karakter unutar jednostrukih znaka navoda. Na primer, 'A' i ';' su znakovne konstante. Možete da dodelite znakovnu konstantu promenljivoj tipa karakter (eng. character variable) na isti nain kao što se dodeljuje brojna konstanta brojnoj promenljivoj. Možete da incijalizujete promenljivu tipa karakter u deklaraciji char ch = 'A';
Korišenje cin.get() Ako deklarišemo promenljivu tipa karakter char ch;
Naredba koja pridružuje sledei karakter iz ulaznog toka varijabli ch je: ch = cin.get();
Uslov u while naredbi odreuje kada petlja prestaje sa izvršavanjem. U ovom programu, želimo da petlja prekine sa izvršavanjem kada korisnik unese karakter za novi red '\n'. Sledi, petlja se izvršava sve dok je ispunjen uslov (ch != '\n'). Prvi put kada program testira uslov petlje, promenljiva ch mora da ima ispravno deklarisanu i definisanu vrednost. // Ovaj program broji karaktere sa ulaza koje korisnik unosi kao jednu liniju // Linija se zavrsava ukucavanjem return, koji se ne broji kao karakter #include using namespace std; int main() { char ch; // Koristi se da skladisti ulazni karakter int num_chars = 0; // Broji karaktere cout << "Enter any number of characters terminated by return."
- 33 -
<< endl << endl; ch = cin.get(); // Dobija se prvi karakter while (ch != '\n') { ++num_chars; ch = cin.get(); } cout << endl; cout << "You entered " << num_chars << " characters." << endl; return 0; }
Program skladišti svaki karakter koji dobija znakovna promenljiva ch. Celobrojni broja num_chars, koji program inicijalizuje na nulu u svojoj deklaraciji, skladišti broj karaktera koje unese korisnik. Program pita korisnika da unese karaktere. Kada korisnik pritisne return taster, raunar prenese celu liniju (ukljuujui return karakter) ulaznom strimu. Prvo izvršenje cin.get() vraa prvi karakter iz ulaznog strima i smešta ga u ch. Naredba while testira uslov (ch != '\n'). Ako korisnik nije pritisnuo odmah return taster ve uneo odreeni karakter, uslov je true i telo petlje se izvršava. Program poveava vrednost num_chars za jedan i pre nego što završi telo petlje dobija sledei karakter iz ulaznog strima naredbom dodele ch = cin.get();
Nakon završetka izvršenja tela petlje, program testira uslov petlje ponovo, ali sada sa novim karakterom dobijenim izvršenjem cin.get() u telu petlje.
- 34 -
Proces se nastavlja sve dok izvršenje ch = cin.get() u telu petlje ne dodeli ch karakter za novi red '\n', kada je uslov false. Efikasnije rešenje umesto dela koda ch = cin.get(); // Uzima se prvi karakter while (ch != '\n') { ++num_chars; ch = cin.get(); }
je: while ( (ch = cin.get()) != '\n') ++num_chars; do-while petlja while petlja testira uslov petlje pre nego što izvrši telo petlje. Sledi,
ako je uslov petlje netaan- false prvi put kada se testira, program nee da izvršava telo petlje. Ponekad je potrebno da se program izvrši najmanje jednom pre nego što se testira uslov. Ova petlja se zove do-while, ili do, petlja. Format naredbe je: do loop body while (uslov petlje);
U prethodnom primeru deo koda napisan sa do-while naredbom je: do { ch = cin.get(); ++num_chars; } while (ch != '\n'); --num_chars;
Odreene petlje Kada se zna tano koliko esto program treba da izvršava telo petlje koristi se odreena iteraciona petlja, odnosno for petlja.
- 35 -
for petlja
Kada korisnik interaguje sa programom, ponekad je neophodno obrisati ekran monitora pre nastavka interakcije korisnika i programa. Jednostavan nain (koji nije i najbolji) je da se prikaže onoliko novih linija koliko treba da se pokrije ekran. Ako vaš monitor prikaže 25 linija pomou 25 karaktera za novi red rešava se problem. Nažalost, brojanje je jedini nain da budemo sigurni da je sve u redu. cout << "\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n";
Umesto prethodnog rešenja problem možemo da posmatramo kao jednu iteraciju: prikazati karakter za novi red 25 puta koristei petlju. Sledea while petlja izvršava ovo: int line_count = 1; while (line_count <= 25) { cout << endl; ++line_count; }
Naredba for je posebno dizajnirana za odreene iteracione petlje. Sledea for naredba ima isti efekat kao prethodna while naredba. int line_count; for (line_count = 1; line_count <= 25; ++line_count) cout << endl;
Kada program izvršava prvu naredbu unutar zagrada (u ovom sluaju, line_count = 1), to je inicijalizacija petlje, koju program izvršava samo jednom nakon ulaska u petlju. Nakon toga, program razvija sledeu naredbu (uslov line_count <= 25). Ovaj izraz je test for petlje. Ako se kao rezultat dobije true (bilo koja nenegativna vrednost) telo petlje se izvršava jednom. Trea naredba je podešavanje petlje (++ line_count). Program nakon toga ponovo testira uslov petlje i nastavlja sa radom. for (inicijalizacija_petlje; test_petlje; podesavanje_petlje) telo_petlje
- 36 -
Ugnježene while petlje Telo petlje može da sadrži bilo koju C++ naredbu. Petlje su ugnježene kada telo petlje sadrži drugu petlju. Kako da signaliziramo programu da ne želimo više da unosimo kataktere? C++ ima specijalnu simboliku konstantu EOF da bi se oznaio kraj ulaza koristei fajl. EOF je mnemonik koji znai "end of file“, definisan u standardnom heder fajlu iostream. Vrednost EOF je sistemski zavisna, mada veina sistema koristi celobrojnu vrednost 1. U Windows-u, da bi se ubacila sa terminala korektna vrednost EOF, mora da ukucate ^Z; U UNIX/Linux-u, treba da ukucate ^D za vrednost EOF. // Ovaj program koristi ugnjezdjene while-petlje za brojanje // karaktera sa ulaza koje ukucava korisnik ali u vise linija #include using namespace std; int main() { int ch; // skladisti karakter koji unosi korisnik int num_chars = 0; // broji karaktere koji se unose cout << "Ovaj program broji ukupan broj karaktera" << endl << "koje ukucate u vise linija. Svaku liniju zavrsavate ukucavajuci Enter"<< endl << "Program zavrsavate ukucavajuci Enter, [Ctrl]+Z, i Enter." << endl << endl; while ((ch = cin.get()) != EOF) { ++num_chars; while ((ch = cin.get()) != '\n') ++num_chars; } //cout << endl; cout << "You entered " << num_chars << " characters." << endl; return 0; }
- 37 -
Promenljiva ch u koju se smešta karakter koji korisnik unosi preko tastature je tipa int umesto tipa char. Jedina razlika u skladištenju karaktera recimo 'a', u varijablu tipa int, umesto u varijablu tipa char, je da int varijabla zahteva 2 ili 4 bajta memorije dok promenljiva tipa karakter zahteva 1 bajt (dva bajta za Unicode karaktere) memorije. U oba sluaja karakter 'a' je uskladišten kao ceo broj ija je vrednost 97. 2.3 Donošenje odluke U jeziku C++ kôd za donošenje odluke se piše koristei if naredbu iji je opšti oblik: if (kontrolni-izraz) true-deo else false-deo
Rei if i else su C++ rezervisane rei. Takoe treba da ubacite kontrolni izraz u zagrade. True i false deo if naredbe može biti bilo koja prosta naredba završena sa ; ili složena naredba. Složeni uslovi koji sadrže logike operatore Ponekad program mora da testira uslov koji je kombinacija drugih prostijih uslova. Možemo da kombinujemo proste uslove da bismo formirali složene uslove koristei logike operatore, koji su dati u tabeli: Operator
Znaenje
! &&
negacija i ili
- 38 -
Operator not ! Podsetimo se da vrednosti istinitosti izraza mogu biti ili true (bilo koja nenulta vrednost) ili false (nulta vrednost). Operator not ili negacija (eng. negation operator, "!") menja reverzno vrednosti operanda. Pretpostavimo da imamo sledee deklaracije i if naredbu int i = 7; char ch; if (!(i == 3)) ch = 'A'; else ch = 'B';
Kako je vrednost i jednaka 7, uslov (i == 3) je false. Operator not ! menja reverzno uslov u true. Zbog toga, if naredba dodeljuje vrednost 'A' varijabli ch. and operator && (konjukcija)
Operator and && kombinuje dva uslova na sledei nain: (uslov 1) && (uslov 2). Tablica istinitosti za operator konjukcije je true samo ako su oba uslova true; inae, vrednost je false. Tablica istinitosti za (uslov 1) && (uslov 2) Uslov 1 &&
Uslov 2
T T F
T F
F F F
Primer: if ( (salary >= 500.00) && (salary < 1000.00) ) tax_rate = 0.22;
Treba obratiti pažnju da if naredba sadrži dve male zagrade u kojima se nalazi složeni uslov i dva para zagrada u kojima se nalaze prosti uslovi.
- 39 -
Mada C++ esto ne zahteva to, treba da koristite zagrade za svaki prost uslov zbog jasnijeg prikaza koda. Sledei program pita korisnika da ukuca jedan karakter i zatim return. Program testira karakter da li je broj i prikazuje odgovarajuu poruku. // Ovaj program prikazuje koriscenje slozene if-naredbe // koja odlucuje da li je taster koji je korisnik pritisnuo numericki. // Program koristi cin.get() za unos jednog karaktera u jednom trenutku. #include using namespace std; int main() { char ch; cout << "Please press a key, then press enter: "; ch = cin.get(); cout << endl; if ( (ch >= '0') && (ch <= '9')) cout << "The key you pressed was a digit." << endl; else cout << "The key you pressed was not a digit." << endl; return 0; }
or operator || (disjunkcija)
Operator || (disjunkcija) kombinuje dva uslova na sledei nain: (uslov 1) || (uslov 2). Vrednost u tablici istinitosti disjunkcije je true ako je ili jedan uslov, ili drugi uslov ili oba uslova true; inae, vrednost u tablici istinitosti (truth vrednost) je false. Drugim reima, disjunkcija daje false
- 40 -
samo kada su oba uslova false. Donja tabela daje vrednosti istinitosti za disjunkciju za razliite kombinacije uslova. Tablica istinitosti za (uslov 1) (uslov 2) Uslov 1
Uslov 2
T F
T T T
F T F
Sledei primer, kao i prethodni, testira karakter koji korisnik unosi sa tastature da bi se videlo da li je on ceo broj (digit). Meutim, umesto da se koristi and operator (&&) za testiranje opsega brojeva, koristi se operator || za testiranje da li je karakter izvan validnog opsega. Karakter koji korisnik unosi nije validan ako je on manji od '0' ili ako je vei od '9'. // Ovaj program prikazuje da li je uneti karakter ceo broj #include using namespace std; int main() { char ch; cout << "Please press a key, then press enter: "; ch = cin.get(); cout << endl; if ( (ch < '0') || (ch > '9')) cout << "The key you pressed was not a digit." << endl; else cout << "The key you pressed was a digit." << endl; return 0; }
- 41 -
2.4 Pravila prioriteta Prioritet i redosled izraunavanja Ranije smo dali tabele koje definišu prioritet i asocijativnost aritmetikih operatora, operatora dodele i relacionih operatora. Treba da ubacimo i logike operatore u ovu hijerarhiju. Operatori () ! + (unarni) - (unarni) ++ -*/% +< <= > >= == != && || = += -= *= /=
Asocijativnost sa leva na desno sa desna na levo sa leva na desno sa leva na desno sa leva na desno sa leva na desno sa leva na desno sa leva na desno sa desna na levo
Negacija je najveeg prioriteta zajedno sa ostalim unarnim operatorima. Operator konjukcije && ima vei prioritet od operatora disjunkcije ||, i oba operatora imaju asocijativnost sleva u desno. Kao primer, pogledajmo sledei kôd: int i = 7, result; if ( (i != 0) && (i <= 10) || (i == 17) ) result = 1; else result = 0;
Kako && ima vei prioritet od ||, raunar izraunava, odnosno razvija konjukciju prvo. Uslov (i != 0) je istinit i uslov (i <= 10) je istinit. Zbog toga, konjukcija ova dva uslova je true. Ceo uslov u naredbi je true. Zbog toga kod postavlja vrednost result na 1. Donja slika prikazuje razvoj složenog uslova.
- 42 -
Ovaj primer pokazuje interesantan aspekt kako C++ razvija logike izraze; C++ koristi razvoj kratkog spoja (eng. short-circuit). Kada raunar zakljui da konjukcija (i != 0) && (i <= 10) daje true, on zna da konaan rezultat disjunkcije sa uslov (i == 17) mora biti true. Zbog toga raunar ne testira drugi uslov da vidi da li je promenljiva i jednaka 17. Ugnježene naredbe Ponekad je neophodno da se testira uslov ako postoji prethodno ispinjen uslov true ili false, odnosno ako postoji ugnježena if naredba. Ako se ne koriste zagrade, kompajler pridružuje svaki else susednoj if naredbi koja ne sadrži else. Sledei karakter Treba voditi rauna o sadržaju ulaznog bafera za unos sa tastature u program karaktera i brojeva. Pretpostavimo da korisnik ukuca karakter 'A' a zatim newline karakter. Pretpostavimo da program dobija sledei karakter iz ulaznog bafera izvršavanjem cin.get(). On e vratiti newline karakter koji je preostao u baferu nakon ubacivanja nove vrednosti od strane korisnika. Program nee dobiti karakter 'A'. Da bi odbacili ovaj newline karakter, program treba da izvrši cin.get() i odbaci karakter koji vraa. Program e izvršiti cin.get() ponovo i smestiti povratni karakter u promenljivu koju program kasnije testira. Kôd koji ovo izvršava je: cin.get(); employee_code = cin.get();
Prva naredba cin.get() dobija sledei karakter koji je na raspolaganju iz ulaznog bafera, ali ne dodeljuje ni jednoj varijabli ovu vrednost, odnosno odbacuje se newline character.
- 43 -
switch naredba
U C++ jeziku switch naredba implementira case strukturu strukturnog programiranja, odnosno višestruka grananja. Na taj nain, switch naredba se može iskoristiti u odreenim okolnostima umesto ugnježenih naredbi. Naredba switch ima sledei format. switch (celobrojni izraz) { case case-value-1: statement-body-1 case case-value-2: statement-body-2 . . . case case-statement-n statement-body-n default: default-statement-body }
Naješi celobrojni izraz je prosta int ili char varijabla. Telo switch naredbe mora biti u velikim zagradama. Telo switch naredbe se sastoji od skupa sluajeva. Svaki sluaj poinje oznakom case, nakon toga sledi case vrednost i dvotaka. Vrednost sluaja je mogua vrednost koju celobrojni izraz može da dobije. Program izvršava naredbe ako je vrednost celobrojnog izraza jednaka vrednosti sluaja koja je u case oznaci. Napomena, telo naredbe može biti bez naredbe. Naredba default (opciona je) sadrži naredbe koje program treba da izvrši ako vrednost celobrojnog izraza nije jednaka bilo kojoj vrednosti sa oznakom case. // Ovaj program odredjuje vrstu prodaje nepokretnosti #include #include #include using namespace std; int main() {
- 44 -
const double RESIDENTIAL_RATE = 0.060; const double MULTIDWELLING_RATE = 0.050; const double COMMERCIAL_RATE = 0.045; int property_code; double sale_price, commission_rate, commission; cout << setprecision(2) << setiosflags(ios::fixed) << setiosflags(ios::showpoint); cout << "Enter the property's selling price: "; cin >> sale_price; cout << endl; cout << "Enter the property code according to the following." << endl << endl; cout << "Residential, enter R" << endl; cout << "Multiple Dwelling, enter M" << endl; cout << "Commercial, enter C" << endl << endl; cout << "Please make your selection: "; cin.get(); // Odbaci \n property_code = cin.get(); switch (property_code) { case 'R': case 'r': commission_rate = RESIDENTIAL_RATE; break; case 'M': case 'm': commission_rate = MULTIDWELLING_RATE; break; case 'C': case 'c': commission_rate = COMMERCIAL_RATE; break; default: cout << endl << endl <<"Invalid Property Code! Try Again" << endl; exit(1); break; }
- 45 -
commission = sale_price * commission_rate; cout << endl << endl; cout << "The commission is " << commission << endl; return 0;
}
Naredba break Izvršenje break naredbe prouzrokuje da program završi while, do, switch ili for naredbu. Program zatim predaje kontrolu naredbi koja je nakon te kompletirane while, do, switch ili for naredbe. Dakle, break naredba proizvodi prevremen izlaz iz petlje. Sledei program prikazuje break naredbu korišenu u petlji. Program broji karaktere koje korisnik unosi pre pojave prvog @ karaktera. // Program broji karaktere koje korisnik unosi // pre pojave prvog @ karaktera. #include using namespace std; int main() { int ch, // uneti karakter count = 0; // broji karaktere pre pojave prvog @ karaktera cout << "Enter a line containing @" << endl; while ( (ch = cin.get()) != '\n') { if (ch == '@')
- 46 -
break; ++count; } if (ch == '\n') { cout << endl; cout << "You did not enter a @ character." << endl; cout << "You entered " << count << " characters." << endl; } else { cout << endl; cout << "You entered " << count << " characters before the first @" << endl; } return 0; }
Naredba continue Naredba continue prekida tok kontrole unutar while, do-while, ili for petlje. Meutim, umesto završetka kao kod naredbe break, naredba continue završava samo tekuu iteraciju. Sledea iteracija petlje poinje odmah nakon toga. Sledei primer broji karaktere u jednoj liniji (velika slova). // Ovaj program broji karaktere (velika slova) koje korisnik unese kao jednu liniju #include using namespace std; int main()
- 47 -
{ int ch, // uneti karakter count = 0; // broj unetih velikih slova cout << "Enter a line of characters:" << endl; while ( (ch = cin.get()) != '\n') { if ( (ch < 'A') || (ch > 'Z') ) continue; ++count; } cout << endl; cout << "Ukucali ste " << count << " velika slova" << endl; return 0; } Ukucali ste " << count << " velika slova" << endl;
- 48 -
3. Koncept funkcije Objasniemo prirodu funkcija i nauiti kako da deklarišemo, definišemo i koristimo proste funkcije. 3.1 Definicija funkcije Funkcija treba da izvrši jedan dobro definisan zadatak. Da bi to uradila funkcija može da zahteva više vrednosti, nazvanih argumenti, koji joj se prosleuju kada je pozivajua funkcija. Funkcija može i da ne sadrži argumente. Kada funkcija kompletira svoj zadatak, ona može da ne vrati vrednost ili da vrati jednu vrednost koja se zove povratna vrednost, pozivajuoj funkciji. Pozivajua funkcija može onda da koristi povratnu vrednost u bilo kojoj od svojih naredbi. Definicija funkcije: return-type ime-funkcije(type parameter, type parameter, ...) { telo fukcije }
Funkcija se deklariše preko prototipa funkcije. Prototip ima sledei format: return-type ime-funkcije(argument type, argument type, . . .);
return-type je tip podatka koji funkcija vraa. Prototip ne kaže šta funkcija radi ili kako funkcija izvršava svoj zadatak. Prototip daje kompajleru informacije o funkciji tako da kompajler može da proveri da li program koristi funkcije korektno. Na primer: double Calc_Sales_Tax(double, double);
//prototip funkcije
Prototip kaže C++ kompajleru da funkcija koja izraunava porez na promet Calc_Sales_Tax() zahteva dva argumenta, koji su tipa double i vraa vrednost koja je tipa double.
- 49 -
Korišenje void u deklaraciji Ako funkcija ne vraa vrednost, koristi se rezervisana re void kao povratni tip u prototipu. Ako funkcija nema argumenata, onda se koristi void za tip liste argumenata ili se zanemaruje lista tipova argumenata. #include using namespace std; void Print_10_Xs(); int main() { int i; cout << endl; for (i = 1; i <= 5; ++i) { Print_10_Xs(); cout << endl; } cout << endl; return 0; } void Print_10_Xs() { int j; for (j = 1; j <= 10; ++j) cout << 'X'; return; }
- 50 -
Argument/parametar Kada se argumenti prosleuju funkciji, prvom argumentu se dodeljuje prvi parametar u definiciji funkcije, i tako dalje. Na taj nain argumenti i parametri se podešavaju samo na osnovu pozicije, a ne po drugom znaenju. #include using namespace std; void Print_Char(char, int); int main() { int i, number_of_rows; char ch; cout << "Ukucajte karakter koji zelite da prikazete na displeju: "; cin >> ch; cout << endl; cout << "Ukucajte broj redova koje zelite da prikazete: "; cin >> number_of_rows; cout << endl; for (i = 1; i <= number_of_rows; ++i) { Print_Char(ch, i); cout << endl; } cout << endl; return 0; } void Print_Char(char display_char, int count) { int j; for (j = 1; j <= count; ++j) cout << display_char; return; }
- 51 -
3.2 Prosleivanje parametara po vrednosti // Ovaj program prikazuje kako se argument // prosledjuje po vrednosti. #include using namespace std; void PreInc(int); int main() { int i; // Promenljiva i je inicijalizovana na 5. i = 5; cout << "Pre poziva funkcije PreInc(), i = " << i << endl; PreInc(i); cout << "Nakon poziva funkcije PreInc(), i = " << i << endl; cout << endl; return 0; } void PreInc(int parm) { // Vrednost koja je dodeljena parametru parm se prosledjuje funkciji. // Funkcija povecava vrednost parametra parm i vraa kontrolu funkciji main().
- 52 -
++parm; return; }
Kada se izvršava PreInc(i) u glavnoj funkciji main(), vrednost i, koja iznosi 5, se prosleuje funkciji PreInc() i dodeljuje se parametru parm. U funkciji PreInc(), naredba ++parm; poveava vrednost parm. Zbog toga, vrednost i u glavnoj funkciji main() ostaje nepromenjena. C++ takoe dozvoljava prosleivanje argumenata po referenci. Kada se argumenti prosleuju po referenci, adrese argumenata u glavnoj memoriji se prosleuju funkciji. Tako, funkcija može da promeni vrednost argumentu u programu koji poziva funkciju. // Program izracunava konacne poene na osnovu poena sa kolokvijuma i // konacnog ispita // Koristi se funkcija Calc_Grade() za izracunavanje poena za konacnu ocenu // Funkcija vraca vrednost konacnih poena funkciji main(). #include using namespace std; int Calc_Grade(int, int); int main() { int midterm_exam, final_exam, final_grade; cout << "Unesite poene sa kolokvijuma: "; cin >> midterm_exam; cout << endl; cout << "Unesite poene sa zavrsnog ispita: "; cin >> final_exam; final_grade = Calc_Grade(midterm_exam, final_exam);
- 53 -
cout << endl; cout << "The Final Grade is " << final_grade << endl; cout << endl; return 0; } int Calc_Grade(int midterm, int final) { const double MIDTERM_WEIGHT = 0.40; const double FINAL_WEIGHT = 0.60; double grade; int rounded_grade; grade = MIDTERM_WEIGHT * midterm + FINAL_WEIGHT * final; rounded_grade = grade + 0.5; return rounded_grade; }
3.3 Promenljive kao atributi U C++ svaka promenljiva ima dva atributa koji odreuju njenu oblast važenja-doseg i trajanje. Doseg (scope) promenljive je deo programa gde je mogu pristup promenljivoj. Trajanje (duration) promenljive je vreme za koje program drži memoriju zauzetom za tu promenljivu. Doseg (scope) - oblast važenja Promenljiva deklarisana unutar funkcije ima lokalni doseg (local scope). Promenljiva je poznata samo unutar funkcije. Ni jedna naredba izvan funkcije ne može da promeni vrednost promenljive sa lokalnim dosegom. Varijabla deklarisana izvan tela funkcije ima globalni doseg (global scope) i poznata je svim funkcijama definisanim posle take u kojoj
- 54 -
se deklariše promenljiva. Na taj nain, svaka funkcija ija definicija dolazi posle deklaracije globalne promenljive može da promeni vrednost globalne promenljive. Treba izbegavati korišenje globalnih promenljivih deljenjem podataka izmeu funkcija koristei argumente i povratne vrednosti. Trajanje (duration) Klasa skladištenja promenljive (storage class) odreuje njeno trajanje. Klasa skladištenja promenljive je ili auto ili static. Lokalna promenljiva, koja po default-u ima storage class auto (ponekad nazvana automatska varijabla) je alocirana memorija kada se funkcija u kojoj je ona deklarisana pone izvršavati. Kada se promenljivoj dodeli memorija, raunar odvaja odreenu koliinu memorije (zavisno od tipa promenljive) za tu promenljivu i povezuje ime promenljive sa tom lokacijom. Kada se završi izvršavanje funkcije, dodeljena memorija automatskoj promenljivoj se dealocira i memorijski prostor se može ponovo koristiti od strane raunara. Promenljiva u stvari prestaje da postoji. Ako main() ponovo pozove funkciju, varijabla se ponovo kreira, verovatno na drugoj lokaciji u memoriji raunara. Statikoj promenljivoj (static variable) je dodeljena memorija kada program pone da se izvršava. Varijabla static postoji onoliko dugo koliko se program izvršava, nezavisno koja funkcija je trenutno aktivna. Globalna promenljiva ima static klasu skladištenja po default-u. Mogue je kreirati lokalnu statiku varijablu ukljuujui rezervisanu re static u deklaraciji varijable. Takva varijabla je dostupna samo u funkciji u kojoj je deklarisana. Meutim, zbog njene klase skladištenja koja je statika, varijabla ostaje u važenju i zadržava svoju vrednost nakon završetka funkcije gde je ona deklarisana. Izlazni tok cerr Za prikaz poruke greške na monitoru koristi se cerr izlazni tok, koji ne može biti preusmeren. C++ biblioteka matematikih funkcija C++ sadrži biblioteku matematikih funkcija. Ove funkcije ukljuuju standardne trigonometrijske funkcije (sin(), cos(), tan(), ...), eksponencijalne i logaritamske funkcije (exp() i log()) ... Koristi se heder fajl .
- 55 -
Prikazaemo primere korišenja dve proste matematike funkcije. Funkcija pow(osnova, eksponent) stepenuje prvi argument osnovu sa drugim argumentom tj. eksponentom. Oba argumenta moraju biti dvostruke preciznosti. Funkcija vraa double tip. Dakle p = be .
Naredba cout << pow(3.0, 1.35);
kao rezultat daje: 4.4067 Funkcija sqrt() vraa kvadratni koren njenog argumenta. Argument mora biti tipa double. Funkcija vraa tip double, na primer: cout << sqrt(125.0);
- 56 -
4. Nizovi 4.1 Definicija niza Niz je kolekcija konanog broja objekata istog tipa, koji su smešteni u memoriji raunara sekvencijalno. Ovi objekti su elementi niza. Veliina niza je fiksna za vreme trajanja programa. esto se nizovi zovu linearne strukture podataka ili jednodimenzionalne strukture podataka. Deklarisanje niza Format prema kome se deklariše niz je oblika: tip-niza ime-niza [ velicina-niza ];
Primer niza ije je ime rate, iji su elementi tipa double, koji može da memoriše 5 vrednosti je: double rate[5];
Referenciranje i inicijalizacija elemenata niza Svaki elemenat niza je definisan svojim pomerajem (offset) od poetka niza, koji se esto zove indeks (subscript ili index). Indeks prvog elementa niza je 0. Primer niza sa pet elemenata prikazan je preko sledee naredbe: double rate[5] = {0.075, 0.080, 0.082, 0.085, 0.088};
gde su lanovi niza rate[0], rate[1], rate[2], rate[3] i rate[4] sa odgovarajuim vrednostima. U nizu veliine N, opseg ofseta je od 0 do N-1. Da biste inicijalizovali niz u njegovoj deklaraciji, poetne vrednosti treba da smestite u velike zagrade. Nakon svake vrednosti je zapeta, osim nakon poslednje. Ako lista ne sadrži dovoljno vrednosti, kompajler e dopuniti preostale lanove liste nulama. Ako lista sadrži više elemenata od veliine niza, kompajler ignoriše suvišne elemente. Na primer, posmatrajmo sledeu deklaraciju:
- 57 -
double rate[5] = {0.075, 0.080, 0.082};
C++ kompajler kreira niz rate[] i alocira dovoljno memorije za tano 5 promenljivih tipa double. Nakon toga, kompajler inicijalizuje prva tri elementa na 0.075, 0.080, i 0.082, i smešta double 0.0 u preostale elemente niza. Treba obratiti pažnju da niz može da se inicijalizuje koristei inicijalizacionu listu samo u deklaraciji, ne kasnije dodelom. Sledi, primer neispravne dodele double rate[5]; rate[] = {0.075, 0.080, 0.082, 0.085, 0.088}; // pogresna dodela
Sledea deklaracija inicijalizuje sve elemente niza na nulu. int grade[10] = {0};
U sledeoj deklaraciji sedam vrednosti je na inicijalizacionoj listi, ali je niz veliine 5. Sledi, kompajler smešta samo prvih pet brojeva u niz customer_count[]. int customer_count[5] = {3, 4, 5, 6, 7, 8, 9};
Ako inicijalizujete niz u deklaraciji niza i zanemarite veliinu niza, kompajler e ukljuiti veliinu sa liste elemenata. Na primer, sledea deklaracija deklariše da veliina niza customer_count[] bude 5 zato što lista sadrži 5 elemenata: int customer_count[] = {3, 4, 5, 6, 7};
U sluaju da izostavite veliinu niza, mora da inicijalizujete niz. Sledi primer nepravilne deklaracije: int customer_count[]; // pogresno deklarisanje niza
Sledi jedan prost primer rada sa nizovima: // Ovaj program izracunava troskove dostave naloga za narudzbenice preko poste // na osnovu prodajne cene u regionu. // Program koristi broj regiona za pristup elementima niza
- 58 -
#include #include using namespace std; int Get_Valid_Region(); int main() { // Sledeca deklaracija definise niz rate[] sa 5 celobrojnih vrednosti double rate[5] = {0.075, 0.080, 0.082, 0.085, 0.088}; int region; double price, charge, total_price; cout << setprecision(2) << setiosflags(ios::fixed) << setiosflags(ios::showpoint); cout << "Enter the price of the item: $"; cin >> price; region = Get_Valid_Region(); charge = price * rate[region - 1]; total_price = price + charge; cout << endl << endl; cout << "Item Price: " << setw(9) << price << endl; cout << "Shipping Charge: " << setw(9) << charge << endl; cout << "Total Price: " << setw(9) << total_price << endl; return 0; } //Kraj "main()" funkcije int Get_Valid_Region() { bool invalid_data; int region; do { cout << endl; cout << "Enter shipping region (1-5): "; cin >> region; if (region < 1 || region > 5)
- 59 -
{ cerr << endl; cerr << "Region in invalid - Please reenter."; invalid_data = true; } else invalid_data = false; } while(invalid_data); return region; }
Korišenje for petlje Idealna kontrolna struktura za procesiranje niza je for petlja. Indeks niza se koristi kao broja petlje. Kao primer dat je program koji procesira studentske ocene. Nastavnik želi da unese deset ocena (poena) sa kviza koje je student osvojio tokom semestra. Program treba da prikaže srednju ocenu studenta. Ocene se smeštaju u niz od deset elemenata grade[]. // Program prikazuje kako se dobija srednja vrednost elemenata niza #include #include using namespace std; int main() { const int NUM_QUIZZES = 10; int grade[NUM_QUIZZES]; //Niz za skladistenje ocena sa kviza int quiz, // Indeks niza grade_sum = 0; double grade_avg;
- 60 -
cout << setprecision(1) << setiosflags(ios::fixed) << setiosflags(ios::showpoint); cout << "Please enter " << NUM_QUIZZES << " integer quiz grades." << endl << endl; for (quiz = 0; quiz < NUM_QUIZZES; ++quiz) { cout << endl; cout << "Enter grade for quiz " << quiz + 1 << ": "; cin >> grade[quiz]; } cout << endl; cout << "The grades you entered are:"; for (quiz = 0; quiz < NUM_QUIZZES; ++quiz) cout << setw(5) << grade[quiz]; for (quiz = 0; quiz < NUM_QUIZZES; ++quiz) grade_sum += grade[quiz]; grade_avg = double(grade_sum) / NUM_QUIZZES; cout << endl << endl; cout << "The average quiz grade is " << grade_avg << endl; return 0; }
- 61 -
Sortiranje niza Sortiranje niza znai aranžiranje elemenata niza po rastuem ili opadajuem sistemu. Pretpostavimo da nakon unošenja deset ocena za studenta, program treba da prikaže ocene po rastuoj vrednosti. Odabraemo bubble sort tehniku, koja se esto koristi za male nizove. Postoji više varijacija ovog algoritma. Algoritam koji mi koristimo nije najefikasniji, ali radi i daje osnove tehnike. // Ovaj program prikazuje kako se sortiraju elementi niza koristeci // bubble sort algoritam. #include #include using namespace std; int main() { const int NUM_QUIZZES = 10; int grade[NUM_QUIZZES]; //niz za skladistenje ocena sa kviza int quiz, // indeks niza „grade[]“ temp, // za zamenu elemenata niza pass, // broj prolaza limit; // vodi evidenciju o broju prolaza // Unos ocena cout << "Please enter " << NUM_QUIZZES << " integer quiz grades." << endl << endl; for (quiz = 0; quiz < NUM_QUIZZES; ++quiz) { cout << endl; cout << "Enter grade for quiz " << quiz + 1 << ": "; cin >> grade[quiz]; } // Prikaz ocena sa kviza cout << endl << endl; cout << "The grades you entered are as follows:" << endl; for (quiz = 0; quiz < NUM_QUIZZES; ++quiz) cout << setw(6) << grade[quiz];
- 62 -
cout << endl; // Primena bubble sort algoritma limit = NUM_QUIZZES - 2; for (pass = 1; pass <= NUM_QUIZZES - 1; ++pass) { for (quiz = 0; quiz <= limit; ++quiz) if (grade[quiz] > grade[quiz + 1]) { temp = grade[quiz]; grade[quiz] = grade[quiz + 1]; grade[quiz + 1] = temp; } limit; } // Prikaz sortiranih ocena sa kviza cout << endl << endl; cout << "The grades in increasing order are as follows:" << endl; for (quiz = 0; quiz < NUM_QUIZZES; ++quiz) cout << setw(6) << grade[quiz]; cout << endl; return 0; }
- 63 -
4.2 Višedimenzionalni nizovi Razmatraemo dvodimenzionalne nizove zato što ih programeri najviše koriste i laki su za opis. Kao primer, posmatraemo srednju ocenu sa kviza za pet studenata. Imamo ocene sa 10 kvizova za po pet studenata, ukupno 50 celobrojnih vrednosti. Možemo da klasifikujemo svaku ocenu prema dve kategorije: student kome ocena pripada i kviz na kome je ocena postignuta. Možemo da smestimo takve podatke u dvodimenzionalni niz, ili matricu. Slika prikazuje kako su ocene smeštene u dvodimenzionalni niz class_grades.
Podaci su grupisani u redove i kolone. Pet redova predstavljaju pet studenata u klasi. Deset kolona predstavlja deset ocena sa kviza. Veliina niza je 5 x 10, odnosno 5 redova i 10 kolona sa indeksima za redove 0 do 4 i kolone od 0 do 9. Da biste deklarisali dvodimenzionalni niz, odredite tip niza i njegovu veliinu. Smestite u 2 srednje zagrade broj redova i broj kolona respektivno. Na primer: int class_grades[5][10];
naredba se ita: class_grades je niz od 5 elemenata od kojih je svaki niz od deset celih brojeva. Jezik C++ skladišti elemente niza sekvencijalno po redovima. Mogue je inicijalizovati dvodimenzionalni niz u deklaraciji niza.
- 64 -
int class_grades[5][10] = {{50, 56, 87, 67, 98, 90, 68, 54, 67, 30}, {70, 68, 64, 78, 97, 57, 68, 90, 67, 74}, {64, 76, 87, 67, 95, 67, 56, 83, 60, 78}, {76, 65, 84, 47, 86, 65, 46, 66, 87, 65}, {76, 57, 65, 45, 90, 76, 76, 44, 67, 82}};
Svi elementi jednog reda se nalaze unutar velikih zagrada, i odvojeni su zapetom. Zapetama su odvojeni i svi redovi osim poslednjeg. Svi elementi se nalaze u velikim zagradama. Ako inicijalizator redova sadrži manje elemenata, ostali elementi reda se automatski inicijalizuju na nulu, a ako inicijalizator redova sadrži više elemenata, kompajler ekstra elemente reda ignoriše. Procesiranje dvodimenzionalnih nizova Glavni alat za procesiranje dvodimenzionalnih nizova je ugnježena for petlja. Pretpostavimo sledeu deklaraciju: int array[BR_REDOVA][BR_KOLONA];
Da biste procesirali svaki element u ovom dvodimenzionalnom nizu, koristite ugnježene for petlje strukturirane na sledei nain: for (row = 0; row < BR_REDOVA; ++row) for (column = 0; column < BR_KOLONA; ++column) {procesiraj jedan elemenat niza array[row][column]}
Spoljna for petlja ulazi u prvu iteraciju za prvi red niza (indeks 0). Unutrašnja petlja procesira svaki elemenat niza reda odreenog indeksom niza (u prvom sluaju 0), itd. // Ovaj program koristi dvodimenzionalni niz za skladistenje // rezultata kvizova studenata u nekoliko razreda. Program izracunava // srednju vrednost poena razlicitih kvizova za svakog studenta. #include #include using namespace std; int main() {
- 65 -
const int NUM_QUIZZES = 10; const int NUM_STUDENTS = 5; int class_grades[NUM_STUDENTS][NUM_QUIZZES]; int student, quiz, quiz_sum; double quiz_average; cout << setprecision(1) << setiosflags(ios::fixed) << setiosflags(ios::showpoint); // uzmi i sacuvaj ocene svakog studenta cout << "Enter exactly " << NUM_QUIZZES << " quiz grades for each student." << endl; cout << "Separate the grades by one or more spaces." << endl; for (student = 0; student < NUM_STUDENTS; ++student) { cout << endl << endl; cout << "Grades for Student " << student + 1 << ": "; for (quiz = 0; quiz < NUM_QUIZZES; ++quiz) cin >> class_grades[student][quiz]; } // Izracunaj i prikazi prosecnu ocenu svakog studenta for (student = 0; student < NUM_STUDENTS; ++student) { quiz_sum = 0; for (quiz = 0; quiz < NUM_QUIZZES; ++quiz) quiz_sum += class_grades[student][quiz]; quiz_average = (double) quiz_sum / NUM_QUIZZES; cout << endl << endl; cout << "Student: " << setw(3) << student + 1 << " Quiz Average: " << setw(5) << quiz_average; } cout << endl; return 0; }
- 66 -
- 67 -
5. Pokazivai U ovom poglavlju predstavljamo ideju pointera odnosno pokazivaa, kako ih deklarisati, inicijalizovati itd. Takoe, objasniemo kako se može menjati vrednost promenljive. 5.1 Deklarisanje i inicijalizacija pokazivaa Svaka promenljiva ima adresu, koja je broj koji odreuje lokaciju varijable u glavnoj memoriji raunara. Pointer je promenljiva ija je vrednost adresa druge promenljive. Na slici je prikazana promenljiva i ija je vrednost 5, a adresa (pretpostavimo) 004800. Promenljiva i_ptr je pointer ija je vrednost adresa promenljive i (tj. 004800). Zato kažemo da i_ptr pokazuje na i.
Kako adresa nije obian ceo broj, ne možemo ni pokaziva da deklarišemo kao obian ceo broj. Da bismo deklarisali pokaziva, poinjemo sa tipom podatka promenljive na koju e on pokazivati, za kojim sledi asterisk (*), za kojim sledi ime pokazivaa. Na primer: int* i_ptr; // int * i_ptr; // int *i_ptr; // double* d_ptr;‚
i_ptr je pokazivac na promenljivu tipa ceo broj - intidzer i_ptr je pokazivac na promenljivu tipa intidzer i_ptr je pokazivac na promenljivu tipa intidzer // d_ptr je pokazivac na promenljivu tipa dabl
Deklarisanje pokazivaa, kao i deklarisanje obine promenljive, ne daje pokazivau validnu vrednost. Pre korišenja pokazivaa, budite sigurni
- 68 -
da ste dali validnu vrednost pokazivau dodelom adrese promenljive na koju on pokazuje. Unarni operator adresa od (&), vraa adresu promenljive na koju je primenjen, na primer, ako je i celobrojna promenljiva, onda je &i njena adresa. Inicijalizacija pokazivaa Možete da dodelite vrednost pokazivau u deklaraciji, vodei rauna da je promenljiva prethodno deklarisana. int i = 5; double d = 3.14; int* i_ptr = &i; double* d_ptr = &d;
Sledei kôd je pogrešan zato što je i deklarisano nakon deklaracije i inicijalizacije i_ptr. U trenutku kada se i_ptr deklariše i inicijalizuje, kompajler ne zna ništa o varijabli i. int* i_ptr = &i; int i;
// pogresna inicijalizacija
Tip adrese treba da odgovara tipu pointera. Na primer: int i; double* d_ptr = &i;
// pogresna inicijalizacija pokazivaca
Ne možete direktno dodeliti celobrojnu vrednost pokazivacu: int* i_ptr = 004600;
// pogresna dodela
Jedini izuzetak je null pointer ija je vrednost 0. Možete koristiti i ranije definisanu konstantu NULL umesto nule. NULL je definasan u nekoliko heder fajlova ukljuujui iostream. Sledi: int* i_ptr = 0; // ispravna dodela int* j_ptr = NULL; // ispravna dodela
Inicijalizacijom pokazivaa na nulu, pokaziva ne pokazuje ni na šta. Vrednost 0 se može dodeliti pokazivau bilo kog tipa. Sledee deklaracije su ispravne. - 69 -
double* d_ptr = NULL; char* c_ptr = NULL;
Memorijski prikaz rada sa pokazivaima:
Operator indirekcije Deklarišimo i i i_ptr: int i; int* i_ptr = &i;
Direktna dodela je i = 17;
dok je indirektna dodela koristei operator indirekcije * *i_ptr = 17;
Operator indirekcije * je unarni operator. Sledi, ima isti prioritet i asocijativnost (sa desna-u-levo), kao i drugi unarni operatori. ita se kao target-cilj pokazivaa je promenljiva na koju on pokazuje. // Ovaj program ilustruje koriscenje pokazivaca i operatora indirekcije #include using namespace std;
- 70 -
int main() { int i; int* i_ptr = &i; cout << "The address of i is " << &i << endl; cout << "The value of i_ptr is " << i_ptr << endl << endl; // Smesti vrednost u promenljivu i koristeci indirekciju *i_ptr = 17; cout << "The value of i is " << i << endl << endl; cout << "The value of *i_ptr is " << *i_ptr << endl; return 0; }
5.2 Pokazivai i nizovi Ime niza je pokaziva na prvi elemenat niza. Na primer: int nums[5] = {3, 4, 5, 6, 7}; int* nums_ptr;
identifikator nums, koji je ime niza, je integer pointer na prvi elemenat niza. Tako, *nums, pokazuje na nums[0], ija je vrednost 3. Kako je nums pokaziva na ceo broj, sledea dodela je legalna: nums_ptr = nums;
// ispravna dodela pointeru
Nakon gornje dodele, *nums_ptr takoe upuuje na prvi elemenat niza nums[], odnosno nums[0].
- 71 -
Sledeu dodelu ne smete da uradite: nums_ptr = nums[2]; // neispravna dodela pointeru
Ime niza je konstantan pokaziva u smislu da ni jedna naredba C++ ne može da promeni njegovu vrednost. Sledi, neispravna dodela: nums = nums_ptr;
// neispravna dodela
Memorijski prikaz veze pokazivaa i niza:
Operacije sabiranja i oduzimanja mogu da se primene na pointere. Na primer, pretpostavimo sledeu dodelu nums_ptr = nums;
Možemo sada da izvršimo ++nums_ptr. Ovo kao rezultat daje uveanje vrednosti pokazivaa num_ptr za 1, odnosno on sada pokazuje na sledeu celobrojnu vrednost elementa nums[1], ili 4, kao na donjoj slici. Treba napomenuti, meutim da ++nums je neispravno zato što je to pokušaj promene imena niza, što je konstantan pokaziva.
- 72 -
Važno je napomenuti da je aritmetika pokazivaa unutar niza skalirana na tip niza. Na primer, pretpostavimo sledeu deklaraciju double d_array[4] = {3.2, 4.3, 5.4, 6.5}; double* d_ptr = d_array;
Sledi, pokaziva d_ptr pokazuje na prvi elemenat niza d_array, ija je vrednost 3.2. Naredba ++d_ptr kao rezultat daje da d_ptr pokazuje na sledei double u nizu, ija je vrednost 4.3. Ako ponovo izvršimo ++d_ptr, d_ptr e pokazivati na sledei double niza, tj. 5.4. Možete da koristite aritmetiku pointera na ime niza, ako to ne rezultuje promenom vrednosti imena niza, sledi: nums_ptr = nums + 2;
// validna dodela pokazivacu
Ova dodela kao rezultat daje da pointer nums_ptr pokazuje na element niza nums[2], kao na slici. Generalno, izraz nums + i je pointer na i-ti element niza nums[i]. Zato, *(nums + i) je isti elemenat kao i nums[i].
- 73 -
Treba voditi rauna da aritmetika pokazivaa ne pree broj elemenata niza. C++ kompajler nee vas upozoriti ako napravite ovakvu grešku. Pristup takvim lokacijama može da prouzrokuje run-time grešku u programu ili može da prouzrokuje nekorektne rezultate. //Ovaj program prikazuje aritmetiku pokazivaca i nizova #include #include using namespace std; int main() { int nums[5] = {3, 4, 5, 6, 7}; int* nums_ptr; int i; cout << "The array using nums[i] notation" << endl; for (i = 0; i < 5; ++i) cout << setw(4) << nums[i]; cout << endl << endl; cout << "The array using *(nums + i) notation" << endl; for (i = 0; i < 5 ; ++i) cout << setw(4) << *(nums + i); cout << endl << endl; cout << "The array using nums_ptr" << endl; for (nums_ptr = nums; nums_ptr < nums + 5; ++nums_ptr) cout << setw(4) << *nums_ptr; cout << endl << endl; return 0; }
- 74 -
- 75 -
6. C-stringovi, pokazivai, nizovi, funkcije, korisniki definisani tipovi podataka i tabele Ova sekcija razmatra rad sa stringovima. Poinjemo sa osnovnim idejama i tehnikama za rad sa stringovima. 6.1 Definicija i inicijalizacija stringa U jeziku C++ stringovi se mogu implementirati na dva naina. Definisaemo string kao niz karaktera koji je završen null karakterom. Null karakter je bajt iji su svi bitovi nule. Ovaj bajt oznaavamo specijalnim simbolom '\0'. Ako niz karaktera ne sadrži na kraju null karakter, niz ne predstavlja string. Ovako definisan string se naziva C-string zato što je tako definisan u C programskom jeziku. Podsetimo se da je C++ baziran na programskom jeziku C i da sadrži sve mogunosti C programskog jezika (C++ je uz minimalne izuzetke nadskup jezika C). Kasnije emo videti kako se stringovi mogu implementirati koristei string klasu. Sledea deklaracija i inicijalizacija kreiraju string sastavljen od rei "Hello". C-string je oblika: char greeting[6] = {'H', 'e', 'l', 'l', 'o', '\0'};
Drugi pristup za inicijalizaciju stringa koristi string konstantu, koja je niz karaktera pod znacima navoda, kao u primeru koji sledi: char greeting[6] = "Hello";
Programer ne smešta null character na kraj string konstante. C++ kompajler automatski smešta '\0' na kraj stringa kada inicijalizuje niz. Prethodna deklaracija kao rezultat daje da kompajler inicijalizuje memoriju na sledei nain greeting
H
e
l
l
o
\0
Takoe, podsetimo se da ako inicijalizujete niz u njegovoj deklaraciji, ne treba da postavite veliinu niza. C++ kompajler e izvesti
- 76 -
zakljuak o veliini niza iz inicijalizovanih vreednosti. Sledi, ova deklaracija je ekvivalentna prethodnoj deklaraciji. char greeting[] = "Hello";
String i ulaz sa tastature i izlaz na displej Pretpostavimo da želimo da napišemo jednostavan program koji pita korisnika za naziv proizvoda i njegovu cenu. Program treba nakon toga da prikaže na displeju naziv proizvoda, porez na cenu i konanu cenu koštanja (cena + porez). Podsetimo se da za dobijanje jednog karaktera sa tastature i ulaznog bafera, koristimo cin.get(), a za dobijanje stringa sa tastature i ulaznog bafera, koristimo cin.getline(). Funkcija lan getline() zahteva dva argumenta. Prvi argument mora biti ime niza u koji se smešta string. Drugi argument treba da bude veliina niza koji je prvi argument. Funkcija lan getline() uzima sve karaktere iz ulaznog bafera tastature ukljuujui i karakter za novi red, ili za jedan manje od broja karaktera koji je odreen drugim argumentom. Dodatna pozicija je ostavljena za završni null karakter. Funkcija smešta karaktere, završene null karakterom u niz sa imenom odreenim prvim argumentom. Na primer, pretpostavimo sledeu deklaraciju i naredbu: char buffer[6]; cin.getline(buffer, 6);
Naredba cin.getline() ita sve karaktere koje korisnik unese sa tastature zakljuno sa karakterom za novi red do 5 karaktera. Fukcija smešta string, sa dodatnim null karakterom u niz buffer []. Ako se '\n' proita sa cin.getline(), ne smešta se u bafer. // Ovaj program prikazuje koriscenje cin.getline() za ubacivanje string-a // i prikazuje na displeju stringove na nekoliko naina #include #include using namespace std; int main() { double const TAX_RATE = 0.0825;
- 77 -
char item_name[51]; double price, tax, total; cout << setprecision(2) << setiosflags(ios::fixed) << setiosflags(ios::showpoint); cout << "Enter the name of the item: "; cin.getline(item_name, 51); cout << endl; cout << "Enter the item price: "; cin >> price; tax = price * TAX_RATE; total = price + tax; cout << endl; cout << "Item: " << item_name << endl << endl;; cout << "Price: " << setw(9) << price << endl; cout << "Tax: " << setw(9) << tax << endl; cout << "--------------" << endl; cout << "Total: " << setw(9) << total << endl; return 0; }
Pretpostavljamo da je ime uzorka veliine najviše do 50 karaktera. Veliina niza item_name[] je 51 zbog dodatnog prostora za null karakter. item_name C
o
m
p
u
t
e
r
- 78 -
\0
6.2 String konstante i pokazivai Važna veza izmeu pokazivaa i stringa je da je string konstanta, kao što je "Hello", ustvari pokaziva na niz karaktera. Kada kompajler radi sa string konstantom, on tretira string konstantu kao pokaziva na prvi karakter stringa tako da je sledea deklaracija i inicijalizacija legalna: char* greeting_ptr = "Hello";
Na donjoj slici izraz *(greeting_ptr + 4) pokazuje na karakter '0' u stringu.
U nastavku ovog poglavlja dati su primeri koji koriste pokazivae i odreenu aritmetiku za rad sa stringovima. Brojanje karaktera u stringu Sledei primer broji karaktere u stringu koji unosi korisnik, koristei while petlju i pokaziva za kretanje kroz niz. // Ovaj program broji karaktere jedne linije sa ulaza koje unosi korisnik. // Koristi se pointer za kretanje kroz string i while petlja za brojanje karaktera #include using namespace std; int main() { char line[81]; char* ch_ptr = line; int count = 0; cout << "Enter a line of characters:" << endl << endl; cin.getline(line, 81);
- 79 -
while ( *ch_ptr != '\0' ) { ++count; ++ch_ptr; } cout << endl; cout << "The string you entered has " << count << " characters." << endl; return 0; }
Kako je normalna veliina ekrana monitora 80 karaktera, deklarišemo niz line[] da bude veliine 81. Deklarišemo karakter pointer ch_ptr, koji inicijalizujemo da pokazuje na prvi lan niza line[], i inicijalizujemo count na nulu. Poveanjem vrednosti pokazivaa ch_ptr za jedan, tako da pokazuje na sledei karakter stringa, broja se poveava za jedan, i petlja se izvršava do trenutka kada pointer ch_ptr ne pokaže na null karakter. Reverzno prikazivanje stringa Nakon unosa sa tastature stringa, program ispisuje obrnutim redosledom karaktere stringa. // Ovaj program ispisuje obrnutim redosledom karaktere stringa koje korisnik unese sa tastature #include using namespace std; int main() { char line[81]; char* ch_ptr = line;
- 80 -
cout << "Enter a line of characters:" << endl << endl; cin.getline(line, 81); // trazi kraj stringa while ( *ch_ptr != '\0' ) ++ch_ptr; // ch_ptr sada pokazuje na null karakter --ch_ptr; // ch_ptr sada pokazuje na poslednji karakter u stringu cout << endl; cout << "The line in reverse is:" << endl << endl; // while petlja prikazuje sve karaktere osim prvog while ( ch_ptr != line ) { cout << *ch_ptr; --ch_ptr; } // prikazuje se prvi karakter cout << *ch_ptr; cout << endl; return 0; }
Brojanje rei u stringu Posmatramo program za brojanje rei u stringu: // Ovaj program broji reci u stringu koji unosi korisnik
- 81 -
#include using namespace std; int main() { char line[81]; char* ch_ptr; int word_count = 0; cout << "Enter a line of words:" << endl << endl; cin.getline(line, 81); // Preskace sve prazne pozicije na pocetku linije for (ch_ptr = line; *ch_ptr == ' '; ++ch_ptr) ; // Procesiranje ostatka linije while (*ch_ptr != '\0') { ++word_count; // Brojanje reci // Preskakanje reci for ( ; (*ch_ptr != ' ') && (*ch_ptr != '\0'); ++ch_ptr) ; // Preskakanje praznih pozicija nakon reci for ( ; *ch_ptr == ' '; ++ch_ptr) ; } cout << "\nThe line you entered has " << word_count << " words." << endl; return 0; }
- 82 -
6.3 Nizovi stringova i pokazivaa U jeziku C++ elementi niza mogu biti podaci bilo kog tipa. U ovom poglavlju posmatraemo nizove stringova i nizove pokazivaa. Definisanje niza stringova Podsetimo se da je dvodimenzionalni niz ustvari niz iji su svi elementi takoe nizovi. Na primer, niz char dani_u_nedelji[7][10];
je niz od sedam elemenata od kojih je svaki niz od deset karaktera. Niz karaktera može da skladišti string. Zbog toga, dvodimenzionalni niz karaktera, kao što je dani_u_nedelji[][], je sposoban za smeštanje stringova. Razmotrimo, na primer, sledeu deklaraciju i inicijalizaciju: char dani_u_nedelji [7][10] = {"Ponedeljak", "Utorak", "Sreda", "Cetvrtak", "Petak", "Subota", "Nedelja"};
Niz karaktera dani_u_nedelji[][] veliine 7 x 10 karaktera prikazan je na slici:
Sada kada smo smestili imena dana u nedelji, kako im pristupiti u programu? Svaki element niza dani_u_nedelji[][] je niz karaktera. Sledi, referenciranje dani_u_nedelji[3] pristupa elementu broj tri niza, što je niz karaktera koji sadrži string "Cetvrtak."
- 83 -
Korišenje niza stringova - primer Menadžer prodaje želi da zna ukupnu prodaju za svakog prodavca u svom departmanu i da pronae dan u nedelji kada neko iz prodaje ima najveu prodaju. Sledi rešenje: // Ovaj program pronalazi dan najvece prodaje u nedelji. // Koristi se niz stringova za skladistenje imena dana u nedelji #include #include using namespace std; int main() { char dani_u_nedelji[7][10] = {"Ponedeljak", "Utorak", "Sreda", "Cetvrtak", "Petak", "Subota", "Nedelja"}; double sales[7]; char salesperson[41]; double max_sales, total_sales; int day, max_day; cout << setprecision(2) << setiosflags(ios::fixed) << setiosflags(ios::showpoint); cout << "Enter the name of the salesperson: "; cin.getline(salesperson, 41); for (day = 0; day < 7; ++day) { cout << endl << endl; cout << "Enter the sales for "<< dani_u_nedelji[day] << ": "; cin >> sales[day]; } total_sales = 0; max_day = 0; max_sales = sales[0]; for (day = 0; day < 7; ++day) { if (sales[day] > max_sales)
- 84 -
{ max_sales = sales[day]; max_day = day; } total_sales += sales[day]; } cout << endl << endl; cout << "The total sales for " << salesperson << " is " << total_sales << "." << endl << endl; cout << "The highest sales was " << max_sales << "." << endl << endl; cout << "The highest sales occurred on " << dani_u_nedelji[max_day]<< "." << endl; return 0; }
Korišenje niza pokazivaa za skladištenje stringova Metod koji smo koristili za skladištenje stringova u dvodimenzionalni niz je veoma neefikasan. Niz dani_u_nedelji[][], veliine 7 x 10 okupira 70 bajtova memorije. Svaki red je veliine 10 karaktera bez obzira na veliinu stringa. U ovom sluaju 19 % veliine niza se gubi. Ponekad su neka imena veoma duga pa je problem još vei. Efikasniji nain skladištenja imena je definisanje niza imena kao niza karakter pointera.
- 85 -
char* dani_u_nedelji [7] = {"Ponedeljak", "Utorak", "Sreda", "Cetvrtak", "Petak", "Subota", "Nedelja"};
Ova deklaracija dani_u_nedelji[] kao niza pokazivaa, uva memoriju zato što svaki string dobija onoliko memorije kolike je dužine. 6.4 Pokazivai, reference na promenljive i funkcije Funkcija može da ima pokaziva kao argument i pozivajuoj funkciji može da se vrati pokaziva. Može da vrati pokaziva pozivajuoj funkciji. Ovo poglavlje objašnjava tu problematiku. Poziv po adresi – pokazivai kao argumenti funkcija Argumenti funkcija u C++ se prosleuju po vrednosti. Ovo znai da se vrednost argumenta, ne sam argument, prosleuje funkciji. Razmotrimo sledei program: // Ovaj program prikazuje prosledjivanje argumenata po vrednosti #include using namespace std; int Neg_By_Value(int); int main() { int i = 4; i = Neg_By_Value(i);
- 86 -
cout << "i = " << i << endl; return 0; } int Neg_By_Value(int a) { return -a; }
Funkcija main() u naredbi dodele poziva funkciju Neg_By_Value() i prosleuje vrednost varijable i, tj. 4, funkciji. Funkcija nakon poziva vraa negativnu vrednost svog argumenta. Na taj nain funkcija Neg_By_Value() ne menja vrednost svog argumenta. Funkcija vraa vrednost -4. Naredba dodele u glavnoj funkciji main() zatim dodeljuje -4 promenljivoj i. U jeziku C++, promenljiva bilo kog tipa može da se prosledi funkciji kao argument, ak i pokaziva. Kada je pokaziva na promenljivu prosleen kao argument funkcije, funkcija dobija adresu promenljive. Koristei operator indirekcije, funkcija može da manipuliše sa vrednošu varijable kao da je varijabla lokalna funkciji. Sledei program daje negativnu vrednost celobrojnoj promenljivoj, ali koristi funkciju koja ima pointer argument. // Ovaj program prikazuje prosledjivanje argumenta po adresi #include using namespace std; void Neg_By_Address(int*); int main() { int i = 4; Neg_By_Address(&i);
- 87 -
cout << "i = " << i << endl; return 0; } void Neg_By_Address(int* a_ptr) { *a_ptr = -(*a_ptr); }
Funkcija Neg_By_Address() menja znak svom celobrojnom argumentu. Tip (int*) u prototipu funkcije kaže kompajleru da je argument pokaziva na ceo broj. Tako, kada koristimo funkciju, argument mora biti adresa celog broja. Treba obratiti pažnju da funkcija ne vraa vrednost. Da bi promenila znak vrednosti i, funkcija main() izvršava sledeu naredbu. Neg_By_Address(&i);
Ovaj poziv funkcije prosleuje adresu varijable i, ne vrednost promenljive i, funkciji Neg_By_Address(). U funkciji Neg_By_Address(), parametar a_ptr je deklarisan kao pokaziva na ceo broj. Kada funkcija main() pozove funkciju, funkcija smešta adresu koju main() prosleuje pointeru a_ptr. Pokaziva a_ptr sada pokazuje na varijablu i. Zbog toga, funkcija može da koristi operator indirekcije da manipuliše targetom pokazivaa a_ptr, nazvanim i. Telo funkcije sadrži samo sledeu naredbu: *a_ptr = -(*a_ptr); // dodela sadrzaja lokacije na koju pokazuje pokazivac sa // promenjenim znakom
Ova naredba zamenjuje vrednost cilja pointera a_ptr, odnosno vrednost i u memoriji, sa negativnom vrednošu targeta na koji pokazuje a_ptr. Sledi, funkcija Neg_By_Address() menja vrednost i u funkciji main().
- 88 -
Prosleivanje adrese varijable funkcije se oznaava kao poziv po adresi (eng. call by address). Funkcija može da vrati najviše jednu vrednost pozivajuoj funkciji. Meutim, koristei poziv po adresi, mogua je promena dve ili više varijabli u pozivajuoj funkciji. Podsetimo se da je funkcija zamene dve celobrojne promenljive (Swap_Int()) definisana ranije kao deo bubble sort algoritma. #include using namespace std; void Swap_Int(int*, int*); int main() { int i = 3, j = 5; cout << "Before swapping: i = " << i<< " j = " << j << endl; Swap_Int(&i, &j); cout << "After swapping: i = " << i<< " j = " << j << endl; return 0; } void Swap_Int(int* a_ptr, int* b_ptr) { int temp; temp = *a_ptr; *a_ptr = *b_ptr; *b_ptr = temp; }
- 89 -
Prototip funkcije Swap_Int() deklariše njenu povratnu vrednost da bude tipa void zato što funkcija ne vraa vrednost. Umesto toga, Swap_Int() zamenjuje vrednosti dve celobrojne promenljive u pozivajuoj funkciji koristei pokazivae. Oba argumenta funkcije su deklarisana kao integer pointeri. Sledi, mora da prosledimo adrese dve celobrojne promenljive funkciji. Deklaracija varijabli i i j u main() funkciji inicijalizuje varijable na 3 i 5, respektivno. Naredba cout prikazuje poetne vrednosti za i i j. Zatim main() funkcija izvršava Swap_Int() funkciju izvršavajui sledeu naredbu, koja prosleuje adrese za i i j funkciji Swap_Int(). Swap_Int(&i, &j);
Funkcija Swap_Int() dodeljuje ove adrese parametrima a_ptr i b_ptr. Swap_Int() koristi operator indirekcije za razmenu vrednosti targeta a_ptr i b_ptr, sa imenima i i j. Na taj nain funkcija menja vrednosti dve promenljive u funkciji main(). Reference na varijable i poziv po referenci Reference na promenljive i argumente su ponekad alternativa pokazivaima. Referenca na promenljivu (izvedeni tip) je alias, odnosno drugo ime za varijablu koja ve postoji. Na primer, pretpostavimo da imamo sledee deklaracije int i = 7; double d = 1.2;
Možemo da deklarišemo reference na varijable za i i d na sledei nain: int& r = i; double& s = d;
Znak & u ovim deklaracijama se ita kao "referenca". Prva deklaracija se ita kao "r je integer referenca (referenca na promenljivu tipa integer) inicijalizovana na i" a "s je double referenca inicijalizovana na d." Razmišljajte o imenu varijable kao o oznaci pridruženoj lokaciji varijable u memoriji, odnosno o drugoj oznaci pridruženoj memorijskoj
- 90 -
lokaciji. Sledi, možete pristupiti sadržaju varijable ili preko originalnog imena varijable ili preko reference. Možemo da promenimo sadržaje promenljive i koristei identifikator i ili referencu r. Na primer, bilo koja od ovih naredbi promenie vrednost promenljive i na 9. i = 9; r = 9;
Kao i kod pokazivaa, dodajemo & u deklaraciji reference na kraju tipa podataka da bi naglasili da je referenca drugi tip. Znak ampersand možemo smestiti bilo gde izmeu tipa podatka i imena reference na varijablu ispravno je: double & s = d; //ispravna deklaracija reference int &r = i;
// ispravna deklaracija reference
Pokazivai i reference Slinosti izmeu pokazivaa i reference: -pristup do objekta i preko pokazivaa i preko reference je posredan, -mnoga pravila, a naroito pravila konverzije, važe i za pokazivae i za reference. Razlike izmeu pokazivaa i reference: -pokaziva se može preusmeriti tako da ukazuje na drugi objekat, dok je referenca od trenutka svog nastanka, tj. od inicijalizacije, trajno vezana za isti objekat, -pokaziva može da ukazuje ni na šta (vrednost 0), dok referenca uvek, od poetka do kraja svog životnog veka, upuuje na jedan (isti) objekat, -pristup do objekta preko pokazivaa vrši se preko operatora *, dok je pristup do objekta preko reference neposredan. Ne postoje nizovi referenci, pokazivai na reference, ni reference na reference. U mnogim sluajevima, lakše je koristiti reference od pokazivaa
- 91 -
kao argumente funkcija. U ovim sluajevima, prosleujemo argumente po referenci ili koristei poziv po referenci. Kao primer poziva po referenci posmatrajmo sledei program: // Ovaj program prikazuje prosledjivanje argumenata po referenci #include using namespace std; void Neg_By_Reference(int&); int main() { int i = 4; Neg_By_Reference(i); cout << "i = " << i << endl; return 0; } void Neg_By_Reference(int& a) { a = -a; }
Kao drugi primer poziva po referenci posmatramo sledei program: // Ovaj program prikazuje prosledjivanje argumenata po referenci #include using namespace std; void Swap_Int(int&, int&);
- 92 -
int main() { int i = 3, j = 5; cout << "Before swapping: i = " << i<< " j = " << j << endl; Swap_Int(i, j); cout << "After swapping: i = " << i<< " j = " << j << endl; return 0; } void Swap_Int(int& a, int& b) { int temp; temp = a; a = b; b = temp; }
6.5 Nizovi i funkcije Ime niza je pokaziva na prvi lan niza. C-string je karakter pointer. Sledi, prosleivanje niza ili C-stringa funkciji, ekvivalentno je prosleivanju pokazivaa. Prosleivanje niza funkciji Da bi se prosledio niz funkciji, treba da se urade dve stvari u programu, jedna u prototipu funkcije i jedna u hederu definicije funkcije. Pretpostavimo da funkcija Avg() treba da pronae srednju vrednost celobrojnih lanova niza. Prosleujemo niz funkciji i to preko jednog parametra od dva parametra funkcije. Drugi parametar je veliina niza. Prototip funkcije je oblika: - 93 -
double Avg(int [], int);
Funkcija Avg() vraa vrednost tipa double i ima dva parametra. Prvi parametar je niz promenljivih tipa int. Srednje zagrade [] kažu kompajleru da se radi o nizu. Definicija funkcije koja odgovara prethodnom prototipu je: double Avg(int arr[], int size)
Sledei program nalazi srednju vrednost skupa od 10 poena (ocena) sa kviza koje korisnik unosi sa tastature, ali koristi funkciju Avg(). // Ovaj program pokazuje kako se nalazi srednja vrednost elemenata niza // prosledjivanjem niza funkciji #include #include using namespace std; double Avg(int [], int); int main() { const int NUM_QUIZZES = 10; int grade[NUM_QUIZZES]; // niz za skladistenje ocena sa kviza int quiz; // Indeks niza double grade_avg; cout << setiosflags(ios::fixed) << setiosflags(ios::showpoint) << setprecision(1); cout << "Please enter " << NUM_QUIZZES << " integer quiz grades." << endl << endl; for (quiz = 0; quiz < NUM_QUIZZES; ++quiz) { cout << "\nEnter grade for quiz " << quiz + 1 << ": "; cin >> grade[quiz]; } grade_avg = Avg(grade, NUM_QUIZZES); cout << endl;
- 94 -
cout << "The average quiz grade is " << grade_avg << endl; return 0; } // Kraj main() funkcije double Avg(int arr[], int size) { int i, // Indeks niza sum = 0; // Suma ocena double avg; // Prosecna ocena for (i = 0; i < size; ++i) sum += arr[i]; avg = double(sum) / size; return avg; } // Kraj Avg() funkcije
Kada prosleujemo ime niza funkciji, prosleujemo adresu niza, koja je pokaziva na prvi element niza. Ne prosleujemo vrednost elemenata niza ili kopiju celog niza.
- 95 -
Sortiranje niza Prosleivanjem niza funkciji koristei ime niza kao argument, prosleuje se adresa niza funkciji. Sledi, bilo koja promena koju funkcija naini nad parametrom niz menja niz u pozivajuoj funkciji. U sledeem programu korisnik sa tastature unosi elemente niza (10), program prikazuje niz, pa se zatim koristi bubble sort algoritam za sortiranje po rastuem redosledu. Konano, program prikazuje sortiran niz. // Ovaj program prikazuje kako se sortiraju elementi niza. // Program koristi funkcije za rad sa nizovima. // Funkcija Swap_Int() koristi poziv po referenci #include #include using namespace std; void Get_Grades(int [], int); void Display_Array(int [], int); void Bubble_Sort(int [], int); void Swap_Int(int&, int&); int main() { const int NUM_QUIZZES = 10; // Niz za skladištenje ocena sa kviza int grade[NUM_QUIZZES]; Get_Grades(grade, NUM_QUIZZES); cout << endl << endl; cout << "The grades are as follows:"; Display_Array(grade, NUM_QUIZZES); Bubble_Sort(grade, NUM_QUIZZES); cout << endl << endl; cout << "The grades in increasing order are as follows:"; Display_Array(grade, NUM_QUIZZES); cout << endl; return 0; }
// Kraj funkcije main()
- 96 -
void Get_Grades(int arr[], int size) { int quiz; cout << endl; cout << "Please enter " << size << " integer quiz grades." << endl << endl; for (quiz = 0; quiz < size; ++quiz) { cout << endl; cout << "Enter grade for quiz :" << quiz + 1 << ": "; cin >> arr[quiz]; } return; } // Kraj funkcije Get_Grades() void Display_Array(int arr[], int size) { int i; cout << endl; for (i = 0; i < size; ++i) cout << setw(6) << arr[i]; cout << endl; return; } // Kraj funkcije Display_Array() void Bubble_Sort(int arr[], int size) { int i, // Indeks niza pass, // Broj prolaza limit = size - 2; // Vodi racuna koliko daleko ici u jednom prolazu for (pass = 1; pass <= size - 1; ++pass) { for (i = 0; i <= limit; ++i) if (arr[i] > arr[i + 1]) Swap_Int(arr[i], arr[i + 1]); --limit; }
- 97 -
return; } // Kraj funkcije Bubble_Sort() void Swap_Int(int& a, int& b) { int temp; // privremena promenljiva za zamenu celobrojnih vrednosti temp = a; a = b; b = temp; return; } // Kraj Swap_Int() funkcije
Kada glavna funkcija main() poziva funkciju Bubble_Sort(), ona prosleuje adresu niza grade[]. Sledi, Bubble_Sort() manipuliše elementima niza grade[]. Na taj nain kada funkcija Bubble_Sort() završi sortiranje niza, elementi niza grade[] su ureeni po rastuem redosledu. Nakon toga, glavna funkcija main() prikazuje na displeju poruku i koristi funkciju Display_Array() da bi prikazala elemente niza grade[] u rastuem redosledu. 6.6 Stringovi i funkcije Pošto je C-string ekvivalentan pokazivau na karaktere, prosleivanje stringa funkciji je ekvivalentno prosleivanju pokazivaa funkciji. U ovoj sekciji prikazaemo kako se prosleuju stringovi
- 98 -
funkcijama. Takoe, prikazaemo kako se definiše i koristi funkcija koja vraa pokaziva. Korišenje funkcije za brojanje karaktera u stringu Program pita korisnika da unese sa tastature string a zatim program prikazuje broj karaktera u stringu. Program koristi funkciju Len_String() koja uzima string kao svoj jedini argument i vraa ceo broj jednak broju karaktera u stringu. Prototip funkcije je definisan na sledei nain: int Len_String(char*); // Ovaj program izracunava broj karaktera jedne linije koju korisnik unese sa // tastature // Za brojanje karaktera koristi se funkcija Len_String() #include using namespace std; int Len_String(char*); int main() { char line[81]; cout << "Enter a line of characters:" << endl; cin.getline(line,81); cout << endl; cout << "The string you entered has " << Len_String(line) << " characters" << endl;
}
return 0; // Kraj funkcije main()
int Len_String(char* ch_ptr) { int length = 0; while (*ch_ptr != '\0') { ++length; ++ch_ptr; }
- 99 -
}
return length; // Kraj funkcije Len_String()
Parametar deklarisan u hederu funkcije Len_String() je karakter pointer ch_ptr. Kada glavna funkcija main() izvršava poziv funkcije Len_String(line), ona prosleuje vrednost line (što je pokaziva na prvi elemenat niza line[]) funkciji Len_String(). Vrednost line se dodeljuje ch_ptr. Sledi, u funkciji Len_String(), ch_ptr inicijalno pokazuje na prvi karakter stringa koji je smešten u line[]. Lokalna promenljiva length, koja predstavlja dužinu stringa, inicijalizovana je na 0. Petlja while u funkciji Len_String() testira target pokazivaa ch_ptr. Ako target nije null karakter, koji je kraj stringa, onda se u telu petlje broji taj karakter poveavajui vrednost varijable length. Zatim, petlja poveava pokaziva za jedan. Korišenje funkcije za reverzno smeštanje elemenata stringa Ova funkcija menja elemente niza reverzno, tj. prikazuje obrnuto elemente niza. // Ovaj program koristi funkciju za reverzni prikaz stringa. #include using namespace std; void Reverse_String(char*); int main() { char line[81]; cout << "Enter a string:" << endl; cin.getline(line, 81);
- 100 -
Reverse_String(line); cout << endl; cout << "The string in reverse is as follows:" << endl; cout << line << endl; return 0; } void Reverse_String(char* ch_ptr) { char* front; // Pokazuje na pocetak stringa char* end; // Pokazuje na kraj stringa char temp; // Potrebno za zamenu karaktera // inicijalizacija pokazivaca front = end = ch_ptr; // pronalazenje kraja stringa while (*end != '\0') ++end; --end; // zamena karaktera while (front < end) { temp = *front; *front = *end; *end = temp; ++front; --end; } return; }
Nakon dobijanja stringa od korisnika, program pravi sledei poziv funkcije:
- 101 -
Reverse_String(line);
Funkcija Reverse_String() reverzno menja string "u mestu". Da bi uradila ovo funkcija deklariše dva karakter pointera front i end. Druga petlja while reverzno menja string zamenjujui karaktere na koje pokazuju front i end. Standardna biblioteka string funkcija C++ jezik sadrži oko dvadeset bibliotekih funkcija koje manipulišu C-stringovima. Ove funkcije nam dozvoljavaju da izvršimo neke proste string operacije. Prototipovi svih funkcija za rad sa stringovima nalaze se u heder fajlu cstring (u starijim implementacijama C++ jezika, koristio se heder fajl string.h). Sledi, treba ukljuiti sledeu pretprocesorsku direktivu: #include
Dužina stringa - funkcija strlen() Biblioteka funkcija strlen() nalazi dužinu stringa. Na primer: int length; char greeting[6] = "Hello"; length = strlen(greeting);
Dodela u treem redu smešta 5 u varijablu length. Dodela stringa - funkcija strcpy() Ako želimo da smestimo kopiju stringa greeting1 u string greeting2 char greeting1[6] = "Hello"; char greeting2[10];
dodela sledeeg oblika je pogrešna (kompajler prijavljuje grešku), zato što je ime niza konstantan pointer ija se vrednost ne može menjati: greeting2 = greeting1; // pogresna dodela
- 102 -
Biblioteka funkcija strcpy() dodeljuje jedan string drugom kopirajui izvorni string, karakter po karakter u target string, ija veliina je odgovarajua. Funkcija ima sledei format: strcpy(target-string-name, source-string-name)
Kopiranje stringa greeting1 u string greeting2 je pomou sledee naredbe: strcpy(greeting2, greeting1);
Funkcija strcpy() vraa pokaziva na prvi karakter u target stringu. Ako pretpostavimo sledeu deklaraciju na poetku programa: char* ch_ptr;
sledea naredba je ispravna: ch_ptr = strcpy(greeting2, greeting1);
Na taj nain, ch_ptr pokazuje na prvi karakter greeting2[]. Možete napisati i sledei kôd koji prikazuje string koji je u greeting2[]: cout << strcpy(greeting2, greeting1);
Sledea naredba kopira "llo" u greeting2: strcpy(greeting2, greeting1 + 2);
Poreenje stringova - funkcija strcmp() Za poreenje dva stringa koristi se biblioteka funkcija strcmp(), sa sledeim formatom: strcmp(string1, string2)
Kada funkcija strcmp() uporeuje dva stringa, ona poinje poreenje od prvog karaktera svakog stringa. Ako su karakteri jednaki, uporeuje se sledei par karaktera, itd.
- 103 -
Poreenje karakter po karakter nastavlja se dok se ne naie na razliite karaktere (funkcija vraa negativan ceo broj ako prvi string prethodi drugom, a pozitivan ceo broj ako prvi string sledi drugi, prema vrednostima karaktera u tabeli ASCII koda) ili dok se ne doe do kraja karaktera koji su isti (funkcija vraa 0). Pretpostavimo sledee deklaracije i inicijalizacije: char string1[5] = "abcd"; char string2[5] = "abCd"; char string3[7] = "abcd "; char string4[5] = "abCd"; strcmp(string1, string2) vraa positivan ceo broj. strcmp(string1, string3) vraa negativan ceo broj. strcmp(string2, string4) vraa 0.
Dodavanje stringova - funkcija strcat() Ponekad je neophodno dodati jedan string na kraj drugog. Na primer: char string1[27] = "abcdef"; char string2[27] = "ghij";
Pretpostavimo da želimo da dodamo sadržaj string2 na kraj sadržaja string1. Sledi, nakon dodavanja, string1 treba da sadrži string "abcdefghij". Format poziva funkcije je: strcat(target-string, source-string)
pa se funkcija poziva na sledei nain: strcat(string1, string2);
Funkcije za klasifikaciju prema karakterima i funkcije za konverziju Standardna C++ biblioteka sadrži nekoliko funkcija koje su korisne za rad sa stringovima.
- 104 -
Funkcije za klasifikaciju prema karakterima Ponekad je neophodno klasifikovati karaktere prema zajednikim osobinama, npr. da li je karakter iz skupa znakova interpunkcije. U donjoj tabeli su date standardne biblioteke funkcije klasifikovane prema karakterima. Imena svih funkcija poinju sa "is" (da li je) i imaju jedan argument tipa int. Treba zapamtiti da možete da memorišete karakter u varijablu tipa int. Ove funkcije takoe rade ispravno ako im se prosledi argument tipa char. Svaka funkcija vraa vrednost razliitu od nule (true) ako je testirani karakter u odreenoj kategoriji, i vraa nulu (false) ako karakter nije u odreenoj kategoriji. Prototipovi funkcija su u heder fajlu cctype. Ime funkcije isalnum(ch) isalpha(ch) isdigit(ch) islower(ch) ispunct(ch) isspace(ch) isupper(ch)
Kategorija broj ili slovo (veliko ili malo) slovo (veliko ili malo) broj od 0 do 9 malo slovo znak interpunkcije (karakter koji nije prazan, nije broj ni slovo) white-space karakter (blank, newline, carriage return, vertical tab, ili form feed) veliko slovo
Funkcije za konverziju karaktera Standardna C++ biblioteka sadrži nekoliko funkcija za konverziju individualnih karaktera. Ako int varijabla ch sadrži malo slovo, funkcija toupper(ch) vraa odgvarajue veliko slovo kao integer. Ako int varijabla ch sadrži veliko slovo, funkcija tolower(ch) vraa odgovarajue malo slovo kao integer. U ostalim sluajevima, funkcija vraa nepromenjeni argument. Funkcije se nalaze u cctype. Primer palindroma koji koristi više funkcija Rei "otto" i "mom" su palindromi - isto se itaju unapred i unazad. String može biti palindrom ako se ignorišu prazna mesta i znaci interpunkcije. Na primer string "Madam, I'm Adam" je palindrom.
- 105 -
Napisaemo program koji pita korisnika da ubaci string (do 80 karaktera) i odluuje da li je string palindrom. Veoma je prosto da se odlui da li je re palindrom. Proverava se da se vidi da li su prvi i poslednji karakter isti. Ako nisu, string nije palindrom. Ako su isti, proverava se sledei par karaktera. Kada se stigne do sredine rei i ako su svi karakteri jednaki, re je palindrom. String mora biti oišen od praznih karaktera, sa malim slovima i bez znakova interpunkcije. Primer koristi string "Madam, I'm Adam!" i program skladišti string u niz line[]. Da bi se oistio string od blanko znakova i znakova interpunkcije, program kopira string u drugi niz buffer[], kopira samo slovne karaktere. Program zatim menja sve karaktere u nizu buffer[] u mala slova. Konano, program proverava da li je rezultujua re palindrom. // Ovaj program koristi bibliotecke funkcije za rad sa stringovima i karakterima // kako bi ocenio da li je string koji korisnik unosi palindrom. // Palindrom je string koji se isto cita unapred i unazad // String mora biti ociscen od praznih karaktera, sa malim slovima i bez znakova // interpunkcije #include #include using namespace std; void Copy_Alpha(char*, char*); void Convert_To_Lower(char*); bool Palindrome(char*); int main() { char line[81]; char buffer[81]; // Unost stringa cout <<"Enter a string:" << endl; cin.getline(line, 81); // Kopiranje samo slovnih karaktera Copy_Alpha(buffer, line); // Konvertuje string u mala slova
- 106 -
Convert_To_Lower(buffer); // Testira se rezultat da li je palindrom if ( Palindrome(buffer) ) { cout << endl; cout <<"The string you entered is a palindrome." << endl; } else { cout << endl; cout <<"The string you entered is not a palindrome." <
- 107 -
{ char* start; char* end; start = end = source; while (*end != '\0') ++end; --end; while (start < end) if (*start != *end) return false; else { ++start; --end; } return true; } // Kraj Palindrome() funkcije
Funkcije za numeriku konverziju i numeriku proveru Sledee funkcije konvertuju numeriki string u broj. U svakom sluaju, funkcija vraa broj koji numeriki string predstavlja. Svaka funkcija prestaje sa konverzijom stringa kada naie na znak koji nije numeriki, funkcija tada vraa nulu. Mora da se ukljui i #include da bi se koristile funkcije. atoi() konvertuje numeriki string u integer. atol() konvertuje numeriki string u long. atof() konvertuje numeriki string u double.
- 108 -
Dinamika alokacija memorije Hip (heap) memorija Pretpostavimo da želimo da napišemo program koji treba da memoriše imena pet klijenata, koje treba korisnik da unese sa tastature. Pretpostavimo da je najvee ime dužine 80 karaktera. Možete da deklarišete niz na sledei nain: char client[5][81];
Niz client[][] zahteva 5 x 81 = 405 bajtova memorije. Meutim, imena su proseku duga 15 do 20 karaktera. Verovatno se gubi oko 300 ili više od 405 bajtova dodeljenih nizu client[][]. U sluaju da koristimo niz pokazivaa kao u prethodnom poglavlju, problem je što unapred ne znamo dužinu niza. Kad god je memorija potrebna programu, mogue je u C++ alocirati memoriju za promenljive, nizove itd. iz specijalne zone memorije koja se zove hip (heap). Hip memorija je kompletno pod kontrolom korisnika, tj. korisnik može da alocira i dealocira memoriju kada je to neophodno. Proces alokacije i dealokacije memorije kada se program izvršava zove se dinamika alokacija memorije. C++ operator new alocira hip memoriju, a operator delete dealocira hip memoriju. Operator new ima jedan argument, tip podatka skladišta koje želimo da alociramo, i vraa pointer na alocirani prostor. Na primer: int* i_ptr; i_ptr = new int;
Operator new alocira dovoljno hip memorije za skladištenje intidžera i vraa pointer na tu memoriju. Naredba dodele dodeljuje taj pointer i_ptr. Ako nema dovoljno slobodne heap memorije da bi se zadovoljio alokacioni zahtev, new vraa null pokaziva. Kao drugi primer posmatramo dinamiku alokaciju memorije niza od 20 celih brojeva. int* arr_ptr; arr_ptr = new int [20];
- 109 -
Memorija za statike i automatske promenljive i hip memorija Hip memorija se razlikuje od drugih zona memorije koje vaš C++ program koristi, kao što su memorija za statike i automatske (static i automatic) promenljive. Ako se deklariše promenljiva kao static ili ako se deklariše promenljiva van funkcije, prostor za promenljivu se alocira iz static memorije pre nego što program pone. Samo kada se main() završi raunar dealocira prostor za static varijable. Automatska (automatic) varijabla, tj. varijabla deklarisana unutar bloka, kreira se u zoni zvanoj stack kada program ulazi u blok. Takve varijable se dealociraju kada program napušta blok. Prostor za automatic varijable se alocira i dealocira kada se program izvršava. Meutim, alokacija i dealokacija su dati automatski. Programer nema kontrolu nad alokacijom i dealokacijom automatskih varijabli. Pre izlaska iz funkcija operator oslobaanja memorije delete treba da dealocira hip memoriju koja je alocirana operatorom new. 6.7. Korisniki definisani tipovi podataka i tabele Naredbe koje koriste typedef i enum U ovoj sekciji razmotriemo typedef za definisanje sinonima za postojei tip, i enum za definisanje novog tipa ije promenljive mogu biti male celobrojne vrednosti. Naredba typedef Naredba typedef ne definiše novi tip podatka nego drugo ime za postojei tip. Naredba je sledeeg oblika: typedef old_type new_type;
Na primer: double vrednost, kolicina;
Ako se ove varijable odnose na novac, deklarišimo promenljive kao typedef double NOVAC_KOLICINA; NOVAC_KOLICINA vrednost, kolicina;
- 110 -
Ako je: typedef char NAME[51];
možemo da deklarišemo nove nizove first i last da budu nizovi sa 51 karakterom: NAME first, last;
Naredba enum Tip nabrajanja koji koristi rezervisanu re enum, definiše celobrojne konstante koje su predstavljene identifikatorima na sledei nain: enum enumerated-type-name {identifier list}
Na primer, sledea naredba deklariše tip nabrajanja RESPONSE: enum RESPONSE {cancel, ok};
Jednom kada deklarišete tip nabrajanja, možete da deklarišete promenljive tog tipa. Na primer, možemo da napišemo kôd za sledeu deklaraciju: RESPONSE result;
Sledi, promenljivoj se može dodeliti: result = ok;
Tip nabrajanja C++ kompajler posmatra kao novi tip. Nabrojani tipovi vrednosti su celi brojevi (na primer, u tipu RESPONSE type, ok ima vrednost 1). Meutim, C++ kompajler izdaje poruku upozorenja za sledeu naredbu: result = 1;
Varijabla result je tipa RESPONSE a konstanta 1 je ceo broj. Mada naredba dodeljuje korektnu vrednost varijabli result, kompajler izdaje upozoravajuu (warning) poruku da tipovi možda nisu kompatibilni.
- 111 -
U deklaraciji tipa nabrajanja ne treba da se da lista identifikatora vrednosti koje su uzastopne od 0 pa naviše. U deklaraciji enum COLOR {red = 3, green, blue, white = 8, black}; red ima vrednost 3, green 4, blue 5, white 8, black 9.
6.8 Strukture Strukture su složeni tipovi podataka koji se sastoje od ureenih nizova elemenata koji mogu da budu meusobno razliitih tipova. Ti elementi nazivaju se polja strukture. Polja struktura se obeležavaju identifikatorima. Opšti oblik opisa strukture u naredbama za definisanje podataka je: struct ime_strukture {niz_deklaracija}
Pretpostavimo da treba da procesiramo informacije o inventaru. Na primer, treba da uskladištimo broj dela (kôd od sedam karaktera), koliinu (ceo broj) i jedininu cenu (promenljiva tipa double). Možemo da deklarišemo promenljivu za svaku osobinu. Meutim, gubimo informaciju da se osobine odnose na isti deo. Potrebna nam je jedna promenljiva gde emo da smestimo sve tri veliine. Veina programskih jezika koristi varijablu nazvanu zapis-record za ovaj problem. U jeziku C++, struktura može da reši problem. Sledea definicija strukture rešava problem inventara. struct PART_STRUCT { char part_no[8]; int quantity_on_hand; double unit_price; };
Definicija poinje sa struct (rezervisana re). Identifikator PART_STRUCT je ime strukture. U velikim zagradama se nalaze lanovi strukture. Definicija strukture se završava sa takom zarez. Važno je shvatiti da definicija strukture PART_STRUCT ne deklariše promenljivu. Ona ne rezerviše bilo koji prostor u memoriji. Definicija strukture ustvari definiše šablon za kompajler kada deklarišemo
- 112 -
PART_STRUCT promenljive. Kao i kod enum, naredba struct ustvari definiše drugi tip podatka, sama po sebi ne deklariše promenljivu. Takoe, part_no, quantity_on_hand, i unit_price lanovi strukture su prosto imena strukture i nisu
promenljive. Struktura PART_STRUCT je podeljena na tri dela odnosno tri lana, part_no, quantity_on_hand, i unit_price, po tom redosledu.
PART_STRUCT part_no
quantity on_hand unit_price
Da bismo deklarisali promenljivu koja je deo tipa PART_STRUCT, pišemo sledei kôd: PART_STRUCT part;
Ova deklaracija definiše promenljivu part, koja je podatak tipa PART_STRUCT. Promenljiva part ima strukturu koju smo definisali u naredbi struct za PART_STRUCT. Na donjoj slici je prikazana struktura promenljive part part PART_STRUCT part_no
quantity on_hand unit_price
Mada tip podatka PART_STRUCT ne rezerviše memoriju raunara, varijabla part to ini, odnosno zahteva neophodnu veliinu memorije za skladištenje niza od osam karaktera, celog broja i promenljive tipa double. Pristup lanovima strukture lanovima strukture se pristupa koristei operator lana (member operator) koji se kodira kao taka izmeu imena promenljive strukture i lana strukture kome se pristupa, na primer: part.quantity_on_hand = 62;
Ova dodela se ita kao "62 se dodeljuje promenljivoj quantity_on_hand lanu strukture part". - 113 -
Sledei program prikazuje kako pristupiti lanu strukture: // Ovaj program ilustruje deklaraciju i koriscenje promenljive tipa strukture // i operatora clan za pristup varijablama koje su clanovi strukture. #include #include using namespace std; struct PART_STRUCT { char part_no[8]; int quantity_on_hand; double unit_price; }; int main() { PART_STRUCT part; cout << setprecision(2) << setiosflags(ios::fixed) << setiosflags(ios::showpoint); cout << "Enter the seven-character part number: "; cin.getline(part.part_no, 8); cout << endl; cout << "Enter the quantity on hand: "; cin >> part.quantity_on_hand; cout << endl; cout << "Enter the unit price: "; cin >> part.unit_price; cout << endl; cout << "You entered the following information:" << endl << endl; cout << "Part Number: " << part.part_no << endl; cout << "Quantity On Hand: " << setw(7) << part.quantity_on_hand << endl; cout << "Unit Price: " << setw(7) << part.unit_price << endl; return 0; }
- 114 -
Nakon dobijanja podataka sa tastature od korisnika, možemo da oznaimo sadržaj promenljivih part tipa strukture kao na slici: part PART_STRUCT
AB12345\0 part_no
56
78.5
quantity on_hand unit_price
Inicijalizacija promenljive tipa structure Promenljiva tipa struktura može da se inicijalizuje slino inicijalizaciji niza. Na primer, koristei PART_STRUCT tip podatka koji je definisan ranije, možemo da deklarišemo i inicijalizujemo promenljivu old_part na sledei nain: PART_STRUCT old_part = {"XY98765", 17, 99.99};
Složene strukture Struktura može, takoe, da bude složena, odnosno može da sadrži druge ugnježene strukture. Na primer, pretpostavimo da želimo da memorišemo sledee informacije o zaposlenima kompanije: ime, adresu, broj socijalnog osiguranja i vrednost radnog asa. Kako su ime i adresa sastavljeni iz više delova definisaemo ih preko struktura. struct NAME_STRUCT { char first_name[31]; char mid_initial;
- 115 -
char last_name[31]; }; struct ADDRESS_STRUCT { char st_adress[31]; char city[31]; char state[3]; char zip[6]; }; struct EMPLOYEE_STRUCT { NAME_STRUCT name; ADDRESS_STRUCT address; char soc_sec_no[10]; double pay_rate; }; EMPLOYEE_STRUCT employee;
Promenljiva employee tipa struktura ima etiri lana, kao na slici. Prvi lan name je struktura tipa NAME_STRUCT. Drugi lan address je struktura tipa ADDRESS_STRUCT, trei lan soc_sec_no je niz kraktera. etvrti lan je tipa double. Ako želimo da inicijalizujemo kod za državu od dva karaktera za promenljivu employee na "NY", treba da koristimo operator lana dva puta: employee.address.state
Da bismo kopirali string "NY" u niz, koristimo funkciju strcpy() na sledei nain: strcpy(employee.address.state, "NY");
Ako želimo da pristupimo prvom karakteru koda države, koristiemo sledeu referencu: employee.address.state[0]
- 116 -
6.9 Nizovi struktura: tabele Tabele su podaci organizovani u redove i kolone. Na primer donja slika prikazuje listu delova. Svaki red tabele predstavlja deo. Prva kolona sadrži broj dela, druga sadrži koliinu, a trea jedininu cenu dela. Part Number A123456 A987654 D001234 B109897 A035467 C837289 D346246 C253146 B194791 A826749
Quantity on Hand 123 53 93 44 15 0 35 104 33 56
Unit Price 12.99 52.99 22.95 13.95 59.95 57.99 25.99 110.99 14.95 41.95
Definisanje tabele koristei strukture Tabela u jeziku C++ je niz struktura. Na primer, posmatrajmo strukturu PART_STRUCT: struct PART_STRUCT { char part_no[8]; int quantity_on_hand; double unit_price; };
Možemo da definišemo tabelu za skladištenje podataka deset delova na sledei nain: PART_STRUCT part_table[10];
Dakle, part_table je niz od 10 elemenata od kojih je svaki tipa PART_STRUCT. Ako želimo da dodelimo vrednost 102 lanu quantity_on_hand u petom redu tabele (sa indeksom 4), pisaemo: - 117 -
part_table[4].quantity_on_hand = 102;
Kada se vrednosti u tabeli ne menjaju esto, možete na sledei nain ubaciti vrednosti tabele u program. PART_STRUCT partial_part_table[4] = { {"A123456", 123, 12.99}, {"A987654", 53, 52.95}, {"D001234", 93, 22.95}, {"B109897", 44, 13.95} };
- 118 -
7. Uvod u klase i objekte 7.1 Objekti, klase i objektno orijentisani sistemi Klasa je realizacija apstrakcije koja ima svoju internu predstavu (svoje atribute) i operacije koje se mogu vršiti nad njenim primercima. Klasa definiše tip. Jedan primerak takvog tipa (instanca klase) naziva se objektom te klase. Podaci koji su deo klase nazivaju se podaci lanovi klase. Funkcije koje su deo klase nazivaju se funkcije lanice klase. Objekat klase ima unutrašnje stanje, predstavljeno vrednostima atributa, koje menja pomou operacija. Funkcije lanice nazivaju se još i metodima klase, a poziv ovih funkcija – upuivanje poruke objektu klase. Objekat klase menja svoje stanje kada se pozove njegov metod, odnosno kada mu se uputi poruka. Mogue je preklopiti (overload) funkcije lanice. U objektno orijentisanom programiranju aplikaciju vidimo kao sistem objekata koji meusobno interaguju. Svaki objekat je odgovoran za svoje akcije. Objekti interaguju slanjem poruka i ponašanjem na odgovarajui nain kao odziv na poruke. Kao primer, pretpostavimo da želite da podignete €100 sa rauna u banci na ATM (automatic teller machine). Da biste podigli €100, šaljete poruku ATM objektu (koristei touch screen) za izvršenje podizanja €100. ATM objekat šalje poruku vašem štednom raunu (savings account objektu koji se nalazi u bazi podataka banke) da se podigne €100. ATM objekat može da uradi ovo šaljui poruku Withdraw (100.00) vašem savings account objektu. Objekat savings account sada odreuje da li je njegovo stanje (koliina novca na vašem savings account) vee ili jednako €100.00. Ako jeste, objekat smanjuje njegovo stanje za €100 i šalje poruku ATM objektu da isplati €100. ATM mašina kao odgovor na tu poruku, isplauje pet novanica od €20 i prikazuje poruku da je novac spreman. Vaš odziv odnosno odgovor na tu poruku je da uzmete novac iz automata. Ispitajmo sistem malo detaljnije. Objekat štedni raun koji predstavlja vaš raun je jedan od mnogih takvih bankovnih rauna. Svi oni imaju stanje i svi se ponašaju na slian nain. Možemo da kažemo da je svaki objekat za uvanje rauna lan klase Savings_Account. U terminologiji objektno orijentisanog programiranja, kažemo da pojedinani raun savings account predstavlja instancu-primerak klase Savings_Account. Svi lanovi klase mora da se ponašaju na isti nain. Podizanje novca sa rauna poziva
- 119 -
isti metod (niz akcija) kao što je podizanje novca sa vašeg rauna. Ono što se razlikuje su stanja, odnosno vrednosti podataka koji se nalaze u objektu. Stanje savings account objekta može da ukljui korisnikov ID lan, balance – stanje i interest rate - kamatnu stopu. Ovo je princip skrivanja informacija – pošiljalac poruke ne treba da zna nain na koji se primalac brine o zahtevu. Koja je razlika izmeu objektno orijentisanog pristupa slanja poruka i proceduralnog pristupa koji koristi funkcije? Prvo, kod objektno orijentisanog programiranja, poruke imaju prijemnik. Funkcije nemaju prijemnik. Funkcije obino rade na neemu. Na primer, proceduralna verzija ATM sistema za podizanje €100 izvršava poziv funkcije na sledei nain: Withdraw(your_account, 100.00);
Funkcija Withdraw() e ustvari raditi na raunu. S druge strane, kod objektno orijentisanog programiranja ATM objekat zahteva vaš account objekat za izvršenje servisa, za podizanje €100 sa svog sopstvenog stanja. Druga razlika izmeu slanja poruka i korišenja funkcija je da kod objektno orijentisanog pristupa prijemnik odreuje interpretaciju poruke. Zbog toga interpretacija može da varira kod razliitih tipova prijemnika. Slinost klasa i objekata U prethodnom poglavlju predstavili smo standardne ulazne i izlazne strimove cin i cout. C++ jezik dolazi sa nekoliko predefinisanih klasa. Dve od njih su klasa koja definiše ulaz istream i klasa ostream, koja definiše izlaz. Standardni ulazni strim cin je objekat klase istream. Definicije klasa istream i ostream i definicije objekata cin i cout se nalaze u heder fajlu iostream. U program dovodimo podatke sa tastature primenjujui operator ekstrakcije-izvlaenja >> na cin objekat. Naredba cin >> price;
kaže cin objektu da "izvue" broj iz ulaznog strima i smesti njegovu vrednost u varijablu price. Na taj nain, šaljemo poruku cin objektu i on odgovara na odgovarajui nain na tu poruku. Na slian nain možemo da prikažemo podatke na monitoru primenjujui operator insertovanja-ubacivanja << na cout objekat. Možemo da vidimo naredbu
- 120 -
cout << "The value is " << price;
kao slanje poruke cout objektu da prikaže na ekranu monitora string "The value is" za kojim sledi vrednost varijable price. Koristimo get() i cin na sledei nain ch = cin.get();
gde je ch varijabla tipa karakter. Funkcija get() je metod istream klase. Kada pišemo kod sa cin.get(), šaljemo get() poruku cin objektu. Kao odziv na ovu poruku, objekat vraa programu vrednost sledeeg karaktera u ulaznom baferu. Treba obratiti pažnju da koristimo isti operator . (taka) koji smo koristili kod struktura. Isto je i sa getline(). Kada napišemo cin.getline(name, 81);
šaljemo getline() poruku cin objektu. Kao odgovor na poruku, cin objekat "izvlai" celu liniju teksta iz ulaznog bafera i smešta njenu kopiju u niz name. 7.2 Uvod u string objekte C-string smo definisali kao niz karaktera. Objekti klase string su lakši za rad, bezbedniji i prirodniji za korišenje od C-stringova. Nije važno da znate kako su string objekti ili operacije na njima implementirani. Važno je da znate kako da koristite string objekte. Klasa string je ugraena u C++, tako da je nije potrebno deklarisati na bilo koji nain osim ukljuenjem direktive #include
Kreiranje string objekata Pre nego što nauimo kako da koristimo string objekte, mora da znamo kako da napravimo primerak (instancu) objekta, odnosno kako da ga kreiramo. Mada string objekat predstavlja više, u suštini on je skup karaktera. Skup karaktera string objekta zvaemo vrednost string objekta. Ovaj skup karaktera je smešten u string objekat, mogue zajedno sa drugim
- 121 -
podacima kao što je dužina stringa. Ovi podaci ukljuuju stanje string objekta. Obratite pažnju da je string objekat više nego njegova vrednost. Treba napomenuti da re string nije C++ kljuna re, to je ime klase. U C++, bilo koja klasa, ukljuujui i string, je validan tip podatka. Sledi, mogu se deklarisati string objekti skoro na isti nain kao što se deklarišu numeriki tipovi podataka. Posmatrajmo sledee deklaracije: string str1; string str2 = "Hello"; string str3("Hello"); string str4(50, '*');
String koji nije inicijalizovan u svojoj deklaraciji automatski se postavlja na prazan string po default, ili null string, tj. string koji nema karaktere, kao što je sluaj sa str1 u prvoj deklaraciji. Ovo je suprotno u odnosu na deklaraciju neinicijalizovanog intidžera ili karakter pointera, koji ima garbage vrednost. Kada se kreira jedan objekat, izvršava se specijalan metod, nazvan konstruktor. Glavni cilj konstruktora je inicijalizacija objekta. Kako ni jedna poetna vrednost nije odreena u prvoj deklaraciji, objekat izvršava takozvani konstruktor bez argumenata, koji inicijalizuje vrednost stringa na prazan string. Druga i trea deklaracija definišu str2 i str3 kao string objekte koji imaju vrednost "Hello" (bez znaka navoda). U oba ova sluaja, konstruktor sa jednim argumentom inicijalizuje vrednost stringa na "Hello". Treba obratiti pažnju da je trea deklaracija slina pozivu funkcije, mada str3 nije ime funkcije. Praktino nema ogranienja za broj karaktera koje string objekat može da uskladišti. etvrta deklaracija definiše str4 kao string od 50 zvezdica (asteriska *). Ova deklaracija koristi konstruktor sa dva argumenta za inicijalizaciju vrednosti stringa. Prvi argument (ceo broj) je broj ponavljanja drugog argumenta (karakter) u stringovoj vrednosti. //Ovaj program prikazuje razlicite nacine deklarisanja string objekata // i prikazuje na izlazu string objekte #include #include using namespace std; int main() {
- 122 -
string str1; string str2 = "Hello"; string str3("Hello"); string str4(50, '*'); cout << "str1 = " << str1 << endl; cout << "str2 = " << str2 << endl; cout << "str3 = " << str3 << endl; cout << "str4 = " << str4 << endl; return 0; }
U ovom programu string "Hello" nije string objekat - on je string literal. Zato, konstruktor sa jednim argumentom mora da konvertuje string literal u ekvivalentan objekat. Kako objekat str1 nije inicijalizovan, prva linija na izlazu ne prikazuje ništa sa desne strane znaka dodele (str1 je prazan string). Objekti str2 i str3 imaju istu vrednost "Hello", a str4 je string od 50 zvezdica. String Input Možete ubaciti vrednosti string objekata koristei cin >> operator, kao u primeru: string first_name; cout << "Enter your first name: "; cin >> first_name;
Sledei program primenjuje ovaj deo koda: //Ovaj program koristi cin za unos imena i prezimena u program #include #include using namespace std;
- 123 -
int main() { string first_name; string last_name; cout << "Enter your first name: "; cin >> first_name; cout << endl; cout << "Enter your last name: "; cin >> last_name; cout << endl << endl; cout << "Welcome, " << first_name << " " << last_name << endl; return 0; }
U poslednjoj cout naredbi, smeštamo blanko prostor kao string literal "" u izlazni strim izmeu imena i prezimena. Šta se dešava kada na pitanje za unos imena unesemo pored imena i srednje slovo sa takom?
Kada se pritisne enter taster nakon ukucavanja Petar P., program ne eka na nas da ubacimo last name, ve prikazuje na displeju pozdravnu poruku. Program se ponaša ovako zbog toga što kada se ubaci string
- 124 -
podatak cin koristi white space (blank, ili enter, ili tab) da odvoji stringove. Sledi cin može da se iskoristi za ulaz samo jedne rei u jednom trenutku. Za unos stringa sastavljenog od više rei, mora da koristimo funkciju getline(). Na primer: string state; cout << "Enter your state of residence: "; getline(cin, state);
Funkcija getline() pita cin da uzme jednu liniju iz ulaznog strima tj. sve što korisnik ukuca dok ne pritisne taster enter. Tekst koji je ukucan (bez enter karaktera) se predaje string objektu state, koji uzima tekst kao njegovu vrednost. Funkcija getline() nije metod string klase. //Ovaj program ilustruje koriscenje funkcije getline() za unos stringa sastavljenog //iz vise reci #include #include using namespace std; int main() { string full_name; string state_name; cout << "Enter your full name: "; getline(cin, full_name); cout << endl; cout << "Enter your state of residence: "; getline(cin, state_name); cout << endl << endl; cout << "Welcome, " << full_name << endl; cout << state_name << " is a nice place to live." << endl; return 0; }
- 125 -
//Program izracunava srednju vrednost rezultata sa tri testa #include #include #include using namespace std; int main() { int quiz1, quiz2, quiz3; double average; string name;
// Ocena sa prvog testa // Ocena sa drugog testa // Ocena sa treceg testa // Prosecna ocena sa sva tri testa // String koji cuva ime studenta
// Postaviti izlazno stampanje sa jednim decimalnim mestom cout << setprecision(1) << setiosflags(ios::fixed) << setiosflags(ios::showpoint); cout << "Enter the name of the Student: "; getline(cin, name); cout << endl; cout << "Enter the grade for Quiz 1: "; cin >> quiz1; cout << "Enter the grade for Quiz 2: "; cin >> quiz2; cout << "Enter the grade for Quiz 3: "; cin >> quiz3; // Tip cast double() se zahteva za konvertovanje sume ocena sa kviza, koja je // integer u tip floating point. Greska u konverziji izraza sa desne strane dodele kao // rezultat ce dati da je srednja vrednost ceo broj bez decimalnog broja.
- 126 -
average = double (quiz1 + quiz2 + quiz3) / 3; cout << endl; cout << "The average of the three quizzes for student " << name << " is " << average << endl; return 0; }
Rad sa string objektima Klasa string ima više metoda koji vam dozvoljavaju da dobijete informacije o stringu i da radite sa vrednostima string objekta. Takoe, možete da koristite više operatora u radu sa string objektima skoro na isti nain na koji ih koristite u radu sa numerikim tipovima podataka. Dodela stringova Ispravno je dodeliti jedan string objekat drugom na sledei nain: string str1 = "Hello"; string str2; str2 = str1;
Nakon dodele, vrednost string objekta str2 je kopija vrednosti string objekta str1. To je suprotno u odnosu na dodelu C-stringova. Možete da inicijalizujete jedan string objekat drugim kao u sledeoj deklaraciji: string str1 = "Hello"; string str2 = str1;
ili na sledei nain:
- 127 -
string str1 = "Hello"; string str2(str1);
Spajanje dva stringa Možete spojiti dva stringa koristei operator +, isti operator koji smo koristili za sabiranje brojeva. Na primer, sledea deklaracija smešta string "Hello, World" na kraj vrednosti string objekta str3: string str1 = "Hello, " string str2 = "World!" string str3 = str1 + str2;
U C++ mogue je definisati operator, na primer kao operator sabiranja (+), da radi razliite stvari zavisno od tipova podataka na koje se operator odnosi. Ovo se naziva preklapanje operatora (overloading). Sledi, operator sabiranja u izrazu i + j, gde su i i j celi brojevi, radie drugaije od operatora sabiranja u izrazu str1 + str2. Preklapanje operatora ne radi automatski za bilo koju kombinaciju objekata. Preklapanje mora biti negde isprogramirano. U sluaju klase string, preklapanje je isprogramirano u heder fajlu . Na primer: string str3 = "Hello, "; str3 += "World!";
Deklaracija inicijalizuje str3 na string "Hello, ". Druga naredba je ekvivalentna dodeli str3 = str3 + "World!";, što kao rezultat daje da str3 sadrži string "Hello, World!". Sledi, operatori =, +, += se mogu preklopiti za string objekte. Dužina stringa Metod length() klase string služi za odreivanje broja karaktera u vrednosti string objekta (dužina stringa). Da bismo primenili metod na objekat str1 koristimo operator taka (dot .) na sledei nain: str1.length()
- 128 -
odnosno, class_object.method_name()
Sledei program prikazuje operacije koje smo do sada razmatrali: //Ovaj program ilustruje dodelu i spajanje stringova //kao i length() metod. #include #include using namespace std; int main() { string first_name; string last_name; string full_name; int name_length; cout << "Enter your first name: "; getline(cin, first_name); cout << endl; cout << "Enter your last name: "; getline(cin, last_name); full_name = first_name + " " + last_name; name_length = full_name.length() - 1; cout << endl <
- 129 -
Pristup odreenim karakterima u stringu Da bi se pristupilo pojedinim karakterima string objekta, treba da se zna da su karakteri u vrednosti string objekta numerisani poevši od nule (indeksi). 0
1
2
3
4
H
e
l
l
o
Prvi karakter ima indeks 0, dok poslednji karakter ima indeks koji je jednak dužini stringa -1. Dobiti ili promeniti individualni karakter u string objektu možemo koristei metod at() string klase. Ako je str1 string objekat, onda izvršavanjem str1.at(i) pitamo string objekat str1 da vrati karakter sa indeksom i u stringovoj vrednosti. Posmatrajmo sledei kôd: string str1 = "Hippopotamus"; int last_index = str1.length() - 1; cout << "Prvi karakter u stringu je " << str.at(0) << endl; cout << "Poslednji karakter u stringu je " << str.at(last_index) << endl;
String objekat je inicijalizovan na "Hippopotamus". Promenljiva last_index je inicijalizovana na dužinu stringa -1. Dve cout naredbe prikazuju prvi karakter (na index-u 0) i poslednji karakter (sa indeksom last_index). Ovaj metod se može iskoristiti za promenu karaktera u string objektu str1.at(i). Na primer sledea naredba menja prvi karakter u stringu str u karakter X: str.at(0) = 'X';
Sledei program ilustruje ovaj primer: //Koriscenje metoda at() klase string #include #include using namespace std;
- 130 -
int main() { string str = "Hippopatamus"; int last_index = str.length() - 1; cout << "The first character in the string is " << str.at(0) << endl; cout << "The last character in the string is " << str.at(last_index) << endl; str.at(0) = 'X'; cout << "The new string is " << str << endl; return 0; }
7.3 Donošenje odluka u radu sa stringovima Operatori koje smo koristili za poreenje brojeva su preklopljeni za korišenje sa string objektima. Jednakost Operator jednakosti (= =) se može iskoristiti za poreenje da li su dva stringa jednaka. Dva string objekta su jednaka samo ako su njihove vrednosti (karakteri koje sadrže) identine, karakter po karakter. string str1 = "Hello"; string str2 = str1;
Onda test if (str1 == str2)
daje true.
- 131 -
Nejednakost Testiranje nejednakosti izmeu dva string objekta može da se obavi koristei uobiajene operatore !=, >, <, >=, i <=. Na primer, ako su str1 i str2 string objekti, onda izraz str1 < str2 uporeuje vrednosti str1 i str2. Za string objekte operator < treba da se ita kao "predhodi" i operator > treba da se ita kao "sledi", uporeujui vrednosti (karakter po karakter) string objekata koristei ASCII tabelu. Sledei program koristi više razliitih koncepata rada sa string klasom. // Ovaj program koristi nekoliko string koncepata #include #include using namespace std; int main() { string first_name; string last_name; string full_name; string full_name_chk; cout << "Please enter your first name: "; getline(cin, first_name); cout << endl; cout << "Please enter your last name:" ; getline(cin, last_name); full_name = first_name + " " + last_name; cout << endl << endl; cout << "Hello " << full_name << ". Welcome to the program." << endl << endl; cout << "Your first name has " << first_name.length() << " characters in it." << endl << endl; cout << "Your last name has "<< last_name.length() << " characters in it." << endl << endl; cout << "Now please enter your first and last names" << endl;
- 132 -
cout << "separated by one space: "; getline(cin, full_name_chk); if (full_name == full_name_chk) { cout << endl << endl; cout << "Congratulations! You followed the instructions." << endl; } else { cout << endl; cout << "You did not follow the instructions!" << endl; cout << "Please try the program again." << endl; } return 0; }
7.4 Funkcije i string objekti Klasa je složeni tip podatka u jeziku C++. Objekat string može da se koristi kao argument funkcije i funkcija može da vrati string objekat. Testiranje da li je string prazan Ponekad je potrebno testirati da li je vrednost string objekta prazna (null), odnosno da objekat nema karaktere. Ako je string prazan, metod vraa true, inae, vraa false. Na primer, ako imamo sledeu deklaraciju: string str1;
- 133 -
gde string objekat nije inicijalizovan, prazan je, odnosno ima vrednost 0. Sledi, str1.empty() daje true. Ako imamo sledeu deklaraciju: string str2 = "Hello";
Sledi, str2.empty() daje false. Funkcije koje koriste string objekte Sledei program koristi funkciju koja ima string argument i vraa string kao rezultat kako bi se proverilo da li je ulazni string prazan. //Ovaj program koristi funkciju koja ima string argument i vraa string kao rezultat //za proveru da li je ulazni string prazan ili ne #include #include using namespace std; string Get_Name(string); int main() { string first_name; string last_name; string full_name; string full_name_chk; string first_initial; string last_initial; first_name = Get_Name("Please enter your first name: "); last_name = Get_Name("Please enter your last name: "); full_name = first_name + " " + last_name; first_initial = first_name.at(0); last_initial = last_name.at(0); cout << endl << endl; cout << "Hello " << full_name << ". Welcome to the program." << endl << endl; cout << "Your first name has " << first_name.length() << " characters in it." << endl << endl; cout << "Your last name has "<< last_name.length()
- 134 -
<< " characters in it." << endl << endl; cout << "Your initials are " << first_initial + last_initial << endl << endl; cout << "Now please enter your first and last names" << endl; cout << "separated by one space: "; getline(cin, full_name_chk); if (full_name == full_name_chk) { cout << endl << endl; cout << "Congratulations! You followed the instructions." << endl; } else { cout << endl; cout << "You did not follow the instructions!" << endl; cout << "Please try the program again." << endl; } return 0; } string Get_Name(string prompt) { string name; bool invalid_data; do { cout << endl << prompt; getline(cin, name); cout << endl; if (name.empty()) { cerr << "You did not enter a name - Please try again." << endl; invalid_data = true; } else invalid_data = false; } while(invalid_data); return name; }
- 135 -
Prototip funkcije Get_Name() je: string Get_Name(string);
i pokazuje da e funkcija vratiti string objekat i da funkcija uzima prost string objekat kao argument. Vrednost koju funkcija vraa nije prazan string objekat. Objekat koji prosleujemo funkciji je prompt koji funkcija koristi da dobije ime. Zato, da bi iskoristili funkciju za dobijanje imena koje nije prazno, treba da prosledimo prompt kao argument funkcije: first_name = Get_Name("Please enter your first name: "); String objekat koji se koristi kao argument funkcije prosleen je po vrednosti, kao obina brojna varijabla. Pozvana funkcija radi sa kopijom string objekta. Originalni string objekat u pozivajuoj funkciji ne može biti promenjen od strane pozivajue funkcije. Napomena, string objekti se mogu proslediti funkciji po referenci. U tom sluaju funkcija može da promeni string objekat. Sledei program ilustruje prosleivanje stringova po referenci. Koristi se funkcija Swap_Strings() koja ima kao argumente dve string reference. //Ovaj program ilustruje prosledjivanje string objekata po referenci. //On zamenjuje vrednosti dva string objekta koristeci funkciju
- 136 -
#include #include using namespace std; void Swap_Strings(string&, string&); int main() { string str1; string str2; cout << "Enter string 1: "; getline(cin, str1); cout << "Enter string 2: "; getline(cin, str2); cout << endl; cout << "Before the swap:" << endl; cout << "String 1 = " << str1 << endl; cout << "String 2 = " << str2 << endl; Swap_Strings(str1, str2); cout << endl; cout << "After the swap:" << endl; cout << "String 1 = " << str1 << endl; cout << "String 2 = " << str2 << endl; return 0; } void Swap_Strings(string& s1, string& s2) { string temp; temp = s1; s1 = s2; s2 = temp; }
- 137 -
Funkciji se može proslediti i pokaziva na string objekat. 7.5 Primeri rada sa string objektima U ovoj sekciji dati su primeri rada sa metodima string klase i string objektima. Kao primer koristi se string sa slike: 0
1
2
3
T h
i
s
4
5
6
i
s
7
8
9
a
n
10
11
e
12
13
x a
14
15
m p
16
17
l
e
18
19
20
21
22
23
24
s
t
r
i
n g
Pronalaženje stringa u stringu Prvi metod koji razmatramo je find(). On locira poziciju podstringa u stringu. Na primer, pretpostavimo sledee deklaracije: string str1 = "This is an example string"; int position;
Neka string objekat str1 ima vrednost oznaenu na slici, onda naredba position = str1.find("an");
pita string objekat str1 da pronae prvo pojavljivanje podstringa "an" u njegovoj vrednosti i vraa vrednost indeksa te pozicije. Naredba e smestiti broj 8 u varijablu position, zato što podstring "an" startuje u lokaciji 8 u stringu str1. U sluaju da string objekat ne locira podstring koji se traži, metod vraa -1.
- 138 -
Druga verzija metoda find() dozvoljava da se startuje pretraživanje lokacije podstringa nakon date pozicije. Na primer, pronai lokaciju prve blanko pozicije u str1 na ili nakon 11 pozicije. position = str1.find(" ", 11)
Naredba smešta broj 18 u varijablu position zato što je sledea blanko pozicija nakon 11 pozicije u vrednosti str1 na poziciji 18. I ova verzija metoda find() takoe vraa -1 ako podstring nije naen. Obe verzije metoda find() poinju pretraživanjem stringa sleva u desno, dok metod rfind() (r u rfind znai "reverse", tj. obrnuto) pretražuje string sdesna u levo. Pronalaženje odreenog karaktera sa date liste Ponekad je neophodno pronai prvi karakter u stringu iz grupe karaktera. Na primer, pretpostavimo da želimo da naemo znak interpunkcije (,.:;!?) u stringu. Metod koji koristimo za pronalaženje prve pojave bilo kog karaktera iz skupa znakova interpunkcije je find_first_of(). Na primer posmatrajmo sledee deklaracije: string str2 = "Hello, my name is John."; string punctuation = ",.:;!?";
Naredba str2.find_first_of(punctuation);
vraa 5, tj. lokaciju zapete (,) u stringu. Ako metod find_first_of() ne pronae bilo koji od karaktera sa liste, metod vraa -1. Verzija find_first_of() koja startuje sa pretraživanjem stringa od odreene pozicije stringa je str2.find_first_of(punctuation, 7);
vraa 22, što je pozicija take (.) u stringu
- 139 -
Izvlaenje podstringa iz stringa Metod substr() izvlai odreeni broj karaktera iz vrednosti string objekta poevši od odreene pozicije. Na primer, posmatrajmo sledeu deklaraciju: string str2;
Sledea naredba (izvlai dva karaktera-podstring iz vrednosti str1 poevši od lokacije 5) smešta podstring "is" u str2. str2 = str1. substr(5, 2);
String metodi se mogu kombinovati meusobno. Insertovanje i uklanjanje podstringova Postoje string metodi koji vam dozvoljavaju da insertujete i uklanjate podstring iz stringa. String metod replace() zamenjuje jedan podstring drugim. Na primer, sledea naredba zamenjuje 4 karaktera (drugi argument) poevši od lokacije 0 (prvi argument) stringom "Here" (trei argument): str1.replace(0, 4, "Here");
Metod insert() može da se koristi za insertovanje stringa u vrednost string objekta. Ovo se razlikuje od metoda replace(). Metod replace() zamenjuje podstring drugim stringom. S druge strane metod insert() smešta string na odreenu lokaciju u drugom stringu sa karakterima koji slede na desno. Na primer, ako je str1 string ija je vrednost prikazana na ranije iznad rezultat izvršenja naredbe str1.insert(19, "of a ");
daje vrednost stringa: "This is an example of a string"
Metod append() dodaje string na kraj stringa na koji se primenjuje metod.
- 140 -
String metod erase() briše podstring iz stringa. Na primer, brisanje rei "is" iz str1 str1.erase(5, 3);
Prvi argument je startna pozicija, a drugi argument je broj karaktera koji se brišu. Nakon izvršenja prethodne narebe, str1 sadrži string "This an example string".
Metod erase() može da se koristi sa jednim argumentom. Naredba str1. erase(10);
briše sve karaktere iz stringa od pozicije 10 do kraja stringa. Sledei program ilustruje string metode koje smo definisali u ovoj sekciji //Ovaj program ilustruje neke od raspolozivih metoda za rad sa string objektima #include #include using namespace std; int main() { string str1 = "This is an example string"; string str2 = "sample"; string str3; string punctuation = ".,:;!?"; int position; cout << "The original string, str1, is : " << str1 << endl << endl; //Nadji prvo pojavljivanje dela stringa "is" u stringu str1 position = str1.find("is"); cout << "The first occurrence of \"is\" is at position " << position << endl << endl;
- 141 -
// Nadji prvo pojavljivanje dela stringa "is" u str1 nakon pozicije 3 position = str1.find("is", 3); cout << "The first occurrence of \"is\" after position 3 is " << "at position " << position << endl << endl; // Nadji prvo pojavljivanje dela stringa "is" od kraja stringa str1 position = str1.rfind("is"); cout << "The first occurrence of \"is\" from the end of str1 is " << "at position " << position << endl << endl; //Pokusaj da nadjes podstring koji nije u stringu str1. position = str1.find("Hello"); if (position == -1) cerr << "The substring \"Hello\" was not found in str1." << endl << endl; //prosiri dati string str1 od pozicije 11 podstringom duzine 8 karaktera str3 = str1.substr(11, 8); cout << "The 8-charater substring of str1 beginning at position 11 is: " << str3 << endl << endl; //Zameni 7 karaktera na pocetku str1 od pozicije 11 stringom str2 str1.replace(11, 7, str2); cout << "After replacing the word \"example\" " << endl << "by the word \"sample\", in str1 the string is: " << str1 << endl << endl; //Obrisi podstring duzine 7 karaktera stringa str1 od njegove //11 pozicije od pocetka strl.erase(11, 7); cout << "After erasing the word \"sample \", in str1 the string is: " << str1 << endl << endl; //Insertuj novi string "example " na poetak stringa od pozicije 11 strl.insert(11, "example "); cout << "After putting back the word \"example \", in str1 the string is: " << endl << str1 << endl << endl; //Dodaj tacku na kraj stringa strl.append(".");
- 142 -
cout << "After appending a period, the string str1 is: " << str1 << endl << endl; // Pronadji prvo pojavljivanje bilo kog znaka interpunkcije u stringu str1 position = strl.find_first_of(punctuation); cout << "The first punctuation mark in str1 is " << "at position " << position << endl << endl; return 0; }
Slede dva složenija primera rada sa stringovima. Uklanjanje i štampanje rei iz stringa //Ovaj program pita korisnika da unese string sastavljen iz vise reci //i zatim stampa jednu rec u jednoj liniji. //Program koristi find(), length(), substr() i erase() metode klase string #include #include using namespace std; int main() { string the_string;
- 143 -
string word; int space_location; cout << "Enter a string. Separate words by spaces: " << endl << endl; getline(cin, the_string); cout << endl; cout << "Following are the words in the string - one word per line: " << endl << endl; //Nadji prvi blanko karakter. //Ako ne postoji blanko karakter, posalji na izlaz samo tu rec kao string space_location = the_string.find(" ", 0); if (space_location == -1) cout << the_string << endl << endl; //Petlja se izvrsava dok postoji blanko karakter while (space_location != -1) { if (space_location == 0) //Ako je pocetni prostor blanko, preskoci ga if (the_string.length() == 1) //Ako je string jedan razmak break; else the_string = the_string.substr(1, the_string.length()); else { //inace, dohvati prvu rec i prikazi je word = the_string.substr(0, space_location); cout << word << endl; //Ukloni rec the_string.erase(0, word.length()); } //Nadji sledecu blanko poziciju space_location = the_string.find(" ", 0); //Ako ne postoji blanko karakter, posalji na izlaz taj string if (space_location == -1) cout << the_string << endl << endl; } return 0; }
- 144 -
Problem palindroma // Ovaj program koristi bibliotecke funkcije koje rade sa string objektima // i karakterima i odredjuje da li je uneti string palindrom #include #include #include using namespace std; void Copy_Alpha(string&, string); void Convert_To_Lower(string&); bool Palindrome(string); int main() { string line; string buffer; // Unos stringa u program cout <<"\nEnter a string:\n"; getline(cin, line); // Kopiranje samo slovnih karaktera Copy_Alpha(buffer, line); // Konverzija stringa u mala slova Convert_To_Lower(buffer); // Provera da li je string palindrom
- 145 -
if ( Palindrome(buffer) ) cout <<"\nThe string you entered is a palindrome."; else cout <<"\nThe string you entered is not a palindrome."; cout << endl; return 0; } // Kraj funkcije main() void Copy_Alpha(string& target, string source) { for (int i = 0; i < source.length(); ++i) if (isalpha(source.at(i))) target.append(1, source.at(i)); return; } // Kraj funkcije Copy_Alpha() void Convert_To_Lower(string& source) { for (int i = 0; i < source.length(); ++i) source.at(i) = tolower(source.at(i)); return; } // Kraj funkcije Convert_To_Lower() bool Palindrome (string source) { int end = source.length() - 1; int start = 0; while (start < end) if (source.at(start) != source. at(end)) return false; else { ++start; end; } return true; } // Kraj funkcije Palindrome()
- 146 -
7.6 Nizovi stringova Možete da deklarišete niz objekata istog tipa, odnosno možete da deklarišete niz string objekata. Sledi deklaracija niza string objekata i inicijalizacija niza sa imenima dana u nedelji: string dani_u_nedelji [] = {"Ponedeljak", "Utorak", "Sreda", "Cetvrtak", "Petak", "Subota", "Nedelja"};
- 147 -
8. Programerski definisane klase i objekti 8.1 Deklarisanje objekata i klasa Definišimo klasu Savings_Account (štedni raun): class Savings_Account { private: string id_no; double balance; double rate; public: Savings_Account(string, double, double); double Calc_Interest(); }; Savings_Account::Savings_Account(string id, double bal, double rt) { id_no = id; balance = bal; rate = rt; } double Savings_Account::Calc_Interest() { return balance * rate; }
Definicija klase poinje rezervisanom rei class nakon koje je ime klase. Nakon imena klase u velikim zagradama se definiše klasa, nakon ega sledi taka zarez. Delovi deklarisani u klasi su lanovi klase. Klasa ima tri podatka lana (ili instance-primerka promenljivih) id_no (identifikacioni broj), balance (stanje), i rate (kamatna stopa). To su instance promenljivih zato što svaki Savings_Account (štedni raun) objekat iju instancu pravimo sadrži svoje sopstvene kopije ova tri podatka lana. Vrednosti instanci varijabli za odreeni objekat odreuju stanje tog objekta. Klasa Savings_Account takoe sadrži dva metoda, Savings_Account(), koji je konstruktor klase, i Calc_Interest(), koji izraunava kamatu. Podsetimo se da metodi klase odreuju ponašanje svih objekata te klase. Svaki objekat klase ima isto ponašanje.
- 148 -
Postoje dve nove rezervisane rei u definiciji klase. Specifikatori pristupa private i public odreuju vidljivost lanova klase. lanovima klase koji su deklarisani posle oznake private mogu da pristupe samo metodi te klase. Ako su id_no, balance, i rate, privatne instance varijabli, njima pristupaju samo metodi Savings_Account() i Calc_Interest(). Ni jedna druga funkcija nema pristup id_no, balance, ili rate. Ako deklarišemo jedan Account objekat u funkciji main(), ne možemo direktno da referenciramo te objektove privatne instance varijabli zato što main() nije metod klase Savings_Account. Zbog toga je sledea naredba u funkciji main() neispravna. cout << acc1.rate;
Privatni lanovi klasa su nain da se u jeziku C++ primeni princip skrivanja informacija. Stvari koje ine jedan objekat, stanje objekta, održavaju se skriveni od spoljneg sveta. Jedini nain da se promeni privatna instanca varijable jednog objekta je kroz korišenje metoda klase. Skrivanje informacija kontroliše objekte, odnosno objekte možemo da koristimo samo kroz metode klasa. Svim lanovima klase koji su nakon oznake public, u našem primeru Calc_Interest() i Savings_Account(), može se pristupiti iz svih funkcija. Javni pristup znai da main(), ili bilo koja druga funkcija ili klasa, može da koristi javne metode za slanje odgovarajuih poruka objektima te klase. Ponekad se javni metodi klase zovu javni interfejs klase. Meutim, kako metodi rade, odnosno stvarni kod metoda nije poznat izvan klase. Skoro uvek su instance varijabli klase privatni, a metodi klase su javni. Mogue je, mada neuobiajeno, imati javne instance varijabli i privatne metode klase. Default specifikator pristupa je private. Sledea deklaracija je ekvivalentna prethodnoj deklaraciji klase: class Account { string id_no; //Ovo su privatni clanovi po defaultu double balance; double rate; public: Savings_Account(string, double, double); double Calc_Interest(); };
- 149 -
Uobiajeno je da se drže svi public lanovi zajedno i svi private lanovi zajedno. Ali, to nije neophodno. Svi metodi klase mora da budu deklarisani unutar definicije klase, ukljuujui one metode koji su definisani izvan deklaracije klase. Metodi klase Bilo koji metod koji je definisan izvan deklaracije klase mora da koristi operator rezolucije opsega (scope resolution) ::, u hederu svoje definicije: return-type ClassName::MethodName(parameter-list)
ita se Calc_Interest() kao "Savings_Account-ov Calc_Interest()". Veoma je važno zapamtiti da metodi klase imaju pristup svim primercima varijabli klase. Nema potrebe deklarisati primerke varijabli klase unutar metoda klase - samo koristite instance varijabli u metodu. 8.2 Konstruktor klase Konstruktor je metod klase koji se automatski izvršava kada se kreira objekat te klase. Ime konstruktora mora da bude isto kao ime klase i on ne može imati return type (zato što on uvek kao rezultat daje kreiranje objekta klase) i mora biti public. Ako konstruktor nije eksplicitno deklarisan u definiciji klase, po default-u, C++ obezbeuje default constructor. Default konstruktor samo kreira objekat klase, on ne inicijalizuje objektove podatke lanove. Operator razrešenja dosega mora biti korišen u definiciji konstruktora zato što je definicija izvan deklaracije klase. Treba zapamtiti da ako deklarišemo konstruktor tako da ima jedan ili više argumenata (kao što Savings_Account() konstruktor ima tri argumenta) deafult konstruktor bez argumenata nije više na raspolaganju programu. U ovom sluaju, svaki objekat koji je deklarisan mora biti inicijalizovan. Ako postoji potreba za konstruktorom bez argumenata, možete sami da napravite kod. Da bismo koristili konstruktor u funkciji main(), treba da napišemo sledei deo koda: void main() {
- 150 -
int id; double bal; double rt; cout << "\nEnter Account ID: "; cin >> id; cout << "\nEnter Balance: "; cin >> bal; cout << "\nEnter Interest Rate: "; cin >> rt; Savings_Account acc1(id, bal, rt); . . . }
Naredba Savings_Account acc1(id, bal, rt);
kreira primerak acc1 objekta i daje primercima varijabli odreene vrednosti. Treba obratiti pažnju da konstruktor nije eksplicitno pozvan; kada se objekat deklariše konstruktor se automatski primenjuje na objekat koristei obezbeene argumente. Sledi, argumenti id, bal, i rt se prosleuju konstruktoru Savings_Account. Konstruktor dodeljuje vrednost id parametra id_no, vrednost bal parametra balance, i vrednost rt dodeljuje rate. Slika prikazuje objekat koji je konstruktor kreirao ako korisnik ubaci sa tastature 5678, 200.00, i 0.07. id_no balance 5678 200.00
rate 0.07
Metodi U prethodnom poglavlju videli smo kako da primenimo metode na objekte. Objekat cin nije objekat istream klase. Funkcije get() i getline() su public metodi klase istream. Kada pišemo kod cin.get() ili cin.getline(), primenjujemo ove funkcije lanice na cin objekat. Koristimo dot (taka) operator da bismo primenili metod na objekat. Ove tehnike se takoe
- 151 -
primenjuju na klase koje smo deklarisali u našim programima. Jednom kada deklarišemo Savings_Account objekat, možemo da koristimo dot operator sa metodima klasa za rad sa objektima. U naredbi cout << "The interest on the account is " << acc1.Calc_Interest() << endl;
primenjujemo metod Calc_Interest() na acc1 objekat šaljui poruku objektu acc1 da izrauna interest, odnosno, kamatu. Podsetimo se da definicija metoda Calc_Interest() sadrži samo jednu naredbu return balance * rate;
Sada možemo da prikažemo kompletan program: //Ovaj program ilustruje koriscenje obicne klase i funkcija lanica #include #include #include using namespace std; class Savings_Account { private: string id_no; double balance; double rate; public: Savings_Account(string, double, double); double Calc_Interest(); }; Savings_Account::Savings_Account(string id, double bal, double rt) { id_no = id; balance = bal; rate = rt; } double Savings_Account::Calc_Interest() { return balance * rate; }
- 152 -
int main() { cout << setprecision(2) << setiosflags(ios::fixed) << setiosflags(ios::showpoint); string id; // Varijable za skladistenje ulaznih podataka double bal; double rt; //Dobijanje informacija o novom racunu od korisnika cout << "\nEnter Account ID: "; getline(cin, id); cout << endl; cout << "Enter Balance: "; cin >> bal; cout << endl; cout << "Enter Interest Rate: "; cin >> rt; Savings_Account acc1(id, bal, rt);
//Inicijalizacija objekta
cout << endl; cout << "The interest on the account is " << acc1.Calc_Interest() << endl; return 0; }
Struktura programa koji koristi klase je: //Pretprocesorske direktive //Deklaracije klasa
- 153 -
//Definicije metoda //Definicija funkcije main()
Za složenije programe možemo podeliti program na nekoliko fajlova, jedan fajl koji sadrži main() i drugi koji sadrže definicije klasa. Nakon kompajliranja izvornog fajla, linker kombinuje objektne fajlove u jedan izvršni program. Objasniemo detalje prethodnog programa. Unutar glavne funkcije main(), deklarišemo varijable id, bal, i rt da bismo koristili lokacije skladištenja za ulazne podatke koje unosi korisnik. Nakon unošenja ulaznih vrednosti, program pravi instancu acc1 objekta koristei konstruktor sa tri argumenta. Podsetimo se da u C++ možete da deklarišete varijablu ili objekat bilo gde u programu. Poslednja naredba cout u funkciji main() sadrži referencu na acc1.Calc_Interest(). Metod Calc_Interest() vraa vrednost. Sledi, naredba cout prikazuje vrednost kamate 5.00. Veza izmeu klase i strukture Klasa je kao i struktura agregatni tip podataka u smislu da njeni podaci lanovi mogu biti razliitog tipa. U stvari, u C++ postoji mala razlika izmeu klasa i struktura. C++ strukture mogu da imaju funkcije lanice, kao i klase. Koja je onda razlika izmeu klasa i struktura? Default pristup kod klase je private. Difolt pristup kod strukture je public. U C jeziku za razliku od C++, strukture ne mogu da imaju funkcije lanice i ne postoje specifikatori pristupa kao što su public i private. Takoe, rezervisana re class ne postoji u C jeziku jer ne postoje klase u C jeziku. Accessor i mutator metodi klase Klasa Savings_Account iz prethodne sekcije nije mnogo korisna iz više razloga. Prvo, metod Calc_Interest() izraunava samo kamatu. Metod ne primenjuje kamatu na stanje rauna, što želimo da uradimo u stvarnoj aplikaciji. Takoe, ne postoji nain da dodamo ili oduzmemo novac sa rauna nakon kreiranja rauna. Konano, ne postoji nain da vidimo koliko je novca na raunu. Ponovo emo definisati metod Calc_Interest() i dodati metode klase Get_Balance() koji prikazuje stanje na raunu, Deposit() koji omoguuje stavljanje novca na raun, i Withdraw() koji omoguuje podizanje novca sa rauna.
- 154 -
class Savings_Account { private: string id_no; double balance; double rate; public: Savings_Account(string, double, double); double Calc_Interest(); double Get_Balance(); void Deposit(double); bool Withdraw(double); };
Nova verzija Calc_Interest() ne izraunava samo kamatu za odreeni raun, nego primenjuje kamatu na stanja rauna. Metodi Deposit() i Withdraw() imaju jedan argument tipa double. Prosleujemo metodu Deposit() koliinu novca koji želimo da uložimo. Metodu Withdraw() prosleujemo koliinu novca koji želimo da podignemo. Sledi nova definicija Calc_Interest(): double Savings_Account::Calc_Interest() { double interest; interest = balance * rate; balance += interest; return interest; }
Definicija Calc_Interest() sadrži deklaraciju lokalne promenljive interest. Lokalne promenljive koje su deklarisane unutar metoda klase ponašaju se po istim pravilima za doseg i trajanje kao i sve druge lokalne promenljive. Sledi, lokalna promenljiva je poznata samo unutar metoda u kome je deklarisana. Lokalna promenljiva poinje da postoji kada se deklariše u metodu, i prestaje da postoji kada se metod završi. Promenljivoj interest se daje vrednost prvom naredbom dodele u metodu. Drugom naredbom dodele poveava se vrednost primerka promenljive balance za vrednost interest. Kao kod originalne verzije metoda, metod vraa vrednost promenljive interest. Metod Get_Balance() je veoma prost.
- 155 -
double Savings_Account::Get_Balance() { return balance; }
Pretpostavimo da je acc1 objekat klase Savings_Account koja ima lan balance ija je vrednost 100.00. Sledea naredba prikazuje vrednost lana balance objekta acc1 cout << "The balance in the account is " << acc1.Get_Balance() << endl;
Metod iji je jedini cilj da pristupi vrednosti privatne instance promenljive date klase se ponekad zove accessor metod. Get_Balance() je primer accessor metoda ija svrha je pristup lanu balance objekta Account. Accessor metodi su neophodni zato što su private instance varijabli skrivene od svih funkcija osim sopstvenih metoda date klase. Definišimo sada metod Deposit(). void Savings_Account::Deposit(double amount) { balance += amount; }
Ponovo naglašavamo da su sve instance promenljivih date klase na raspolaganju metodu klase bez potrebe za ponovnom deklaracijom. Zato, Deposit() ima pristup primerku promenljive balance. Naredba u definiciji metoda poveava balance za vrednost amount depozita. Da bi uplatili depozit €55.42 na raun, recimo acc1, treba da napišemo sledei kôd: acc1.Deposit(55.42);
Metod Deposit() menja vrednost instanci promenljive i naziva se mutator metod. Definicija metoda Withdraw() mora da uzme u obzir da li vrednost promenljive amount prelazi stanje na raunu. Sledi definicija: bool Savings_Account::Withdraw(double amount) { bool result; if (amount <= balance) {
- 156 -
balance -= amount; result = true; } else result = false; return result; }
Sada koristimo novu definiciju i ubacujemo je u program: //Ovaj program koristi prosirenu verziju klase Savings_Account #include #include #include using namespace std; class Savings_Account { private: string id_no; double balance; double rate; public: Savings_Account(string, double, double); double Calc_Interest(); double Get_Balance(); string Get_ID(); void Deposit(double); bool Withdraw(double); }; Savings_Account::Savings_Account(string id, double bal, double rt) { id_no = id; balance = bal; rate = rt; } double Savings_Account::Get_Balance() { return balance; }
- 157 -
string Savings_Account::Get_ID() { return id_no; } double Savings_Account::Calc_Interest() { double interest; interest = balance * rate; balance += interest; return interest; } void Savings_Account::Deposit(double amount) { balance += amount; } bool Savings_Account::Withdraw(double amount) { bool result; if (amount <= balance) { balance -= amount; result = true; } else result = false; return result; } int main() { cout << setprecision(2) << setiosflags(ios::fixed) << setiosflags(ios::showpoint); string id; double bal; double rt; double amount; cout << endl; cout << "Enter Account ID: "; getline(cin, id);
- 158 -
cout << endl; cout << "Enter Balance: "; cin >> bal; cout << endl; cout << "Enter Interest Rate: "; cin >> rt; Savings_Account acc1(id, bal, rt); cout << endl; cout << "Account ID Number is " << acc1.Get_ID() << endl << endl; cout << "The balance in the account is now " << acc1.Get_Balance() << endl << endl; cout << "Enter an amount to deposit: "; cin >> amount; acc1.Deposit(amount); cout << endl << endl; cout << "A deposit of " << amount << " was made." << endl; cout << "The balance in the account is now " << acc1.Get_Balance(); acc1.Calc_Interest(); cout << endl << endl; cout << "Interest was applied to the account." << endl; cout << "The balance in the account is now " << acc1.Get_Balance(); cout << endl << endl; cout << "Enter an amount to withdraw: "; cin >> amount; if (acc1.Withdraw(amount)) { cout << endl << endl; cout << "A withdrawal of " << amount << " was made."; } else { cout << endl << endl; cout << "WITHDRAWAL NOT MADE: Insufficient funds."; } cout << endl;
- 159 -
cout << "The balance in the account is now " << acc1.Get_Balance() << endl; return 0; }
Do sada smo koristili konstruktor sa tri argumenta u definiciji klase Savings_Account. Sada emo razmotriti korišenje više konstruktora u klasi, kao i destruktora koji se izvršava kada se jedan objekat uništava. 8.3 Preklapanje konstruktora C++ dozvoljava definisanje više konstruktora klase. Ovo se zove preklapanje funkcija (function overloading). Preklapanje dozvoljava da koristimo konstruktore u razliitim okolnostima. U klasi Savings_Account, imamo konstruktor koji dozvoljava da kreiramo štedni raun koristei identifikacioni broj rauna account ID number, stanje na raunu balance, i kamatnu stopu interest rate. Možemo da definišemo konstruktor koji dozvoljava da kreiramo štedni raun dajui samo broj rauna account number, sa stanjem i kamatom sa default-nim vrednostima od 0.00 i 0.02 respektivno, ili možda želimo konstruktor koji nam dozvoljava da kreiramo raun dajui broj rauna i stanje sa kamatom koja je data unapred 0.02. Mora da deklarišete sva tri konstruktora u definiciji klase kao što sledi:
- 160 -
class Savings_Account { . . . public: Savings_Account(string, double, double); Savings_Account(string, double); Savings_Account(string); . . . };
Konstruktor je sada preklopljen zato što imamo tri razliita konstruktora zavisno od broja argumenata datih u deklaraciji objekta štedni raun Savings_Account. Slede tri definicije konstruktora: Savings_Account::Savings_Account(string id, double bal, double rt) { id_no = id; balance = bal; rate = rt; } Savings_Account::Savings_Account(string id, double bal) { id_no = id; balance = bal; rate = 0.02; } Savings_Account::Savings_Account(string id) { id_no = id; balance = 0.0; rate = 0.02; }
U funkciji main(), možemo sada da napišemo sledee deklaracije: Savings_Account acc3("3333", 100.00, 0.06); Savings_Account acc2("2222", 200.00); Savings_Account acc1("1111");
- 161 -
U jeziku C++ kompajler razlikuje tri konstruktora po broju i tipu argumenata obezbeenih u deklaraciji objekta. Prva deklaracija koristi konstruktor sa tri argumenta i kreira raun 3333 sa stanjem 100.00 i kamatom 0.06. Druga deklaracija kreira raun 2222 sa otvorenim stanjem od 200.00 i unapred datom kamatom od 0.02. Trea deklaracija koristi konstruktor sa jednim argumentom i kreira raun 1111 sa unapred definisanim stanjem 0.00 i kamatom 0.02. Sledei program prikazuje preklapanje konstruktora. Dodali smo cout naredbu za svaki konstruktor da bismo verifikovali da se odgovarajui konstruktori izvršavaju. Treba obratiti pažnju da funkcija main() ima samo jednu cout naredbu koja objavljuje kraj programa. Drugi izlazi potiu od konstruktora. //Ovaj program koristi prosirenu verziju klase Savings_Account //On prikazuje preklapanje konstruktora #include #include #include using namespace std; class Savings_Account { private: string id_no; double balance; double rate; public: Savings_Account(string, double, double); Savings_Account(string, double); Savings_Account(string); double Calc_Interest(); double Get_Balance(); string Get_ID(); void Deposit(double); bool Withdraw(double); }; Savings_Account::Savings_Account(string id, double bal, double rt) { id_no = id; balance = bal; rate = rt;
- 162 -
cout << "Three-arg constuctor for " << id_no << endl; } Savings_Account::Savings_Account(string id, double bal) { id_no = id; balance = bal; rate = 0.02; cout << "Two-arg constuctor for " << id_no << endl; } Savings_Account::Savings_Account(string id) { id_no = id; balance = 0.0; rate = 0.02; cout << "One-arg constuctor for " << id_no << endl; } double Savings_Account::Get_Balance() { return balance; } string Savings_Account::Get_ID() { return id_no; } double Savings_Account::Calc_Interest() { double interest; interest = balance * rate; balance += interest; return interest; } void Savings_Account::Deposit(double amount) { balance += amount; }
- 163 -
bool Savings_Account::Withdraw(double amount) { bool result; if (amount <= balance) { balance -= amount; result = true; } else result = false; return result; } int main() { Savings_Account acc3("3333", 100.00, 0.06); Savings_Account acc2("2222", 200.00); Savings_Account acc1("1111"); cout << endl; cout << "*** End of Program ***" << endl; return 0; }
8.4 Destruktori Kada jedan objekat izlazi iz dosega, C++ uništava objekat. Na primer, ako deklarišemo objekat unutar funkcije, to je lokalni objekat i zato je klasa skladištenja automatska. Kada se funkcija završi, objekat se uništava. Klasi je po default-u dat destruktor - default destruktor, koji je metod koji uništava objekat. Kao i konstruktor, default destruktor se ne poziva eksplicitno ve se automatski izvršava kada objekat ispadne iz dosega. Kao i u sluaju konstruktora, možemo da napišemo naš sopstveni destruktor za klasu. Ime destruktora je isto kao i ime klase sa prefiksnim
- 164 -
karakterom "tilde" ~. Destruktor ne može imati argumente, ne može imati povratni tip i mora biti public. Ne može biti preklopljen. Sledi primer kako destruktor radi: //Ovaj program koristi prosirenu verziju klase Savings_Account. //Program ilustruje korišenje destruktora #include #include #include using namespace std; class Savings_Account { private: string id_no; double balance; double rate; public: Savings_Account(string, double, double); Savings_Account(string, double); Savings_Account(string); ~Savings_Account(); double Calc_Interest(); double Get_Balance(); string Get_ID(); void Deposit(double); bool Withdraw(double); }; Savings_Account::Savings_Account(string id, double bal, double rt) { id_no = id; balance = bal; rate = rt; cout << "Three-arg constuctor for " << id_no << endl; } Savings_Account::Savings_Account(string id, double bal) { id_no = id; balance = bal;
- 165 -
rate = 0.02; cout << "Two-arg constuctor for " << id_no << endl; } Savings_Account::Savings_Account(string id) { id_no = id; balance = 0.0; rate = 0.02; cout << "One-arg constuctor for " << id_no << endl; } Savings_Account::~Savings_Account() { cout << "Destructor executed for " << id_no << endl; } double Savings_Account::Get_Balance() { return balance; } string Savings_Account::Get_ID() { return id_no; } double Savings_Account::Calc_Interest() { double interest; interest = balance * rate; balance += interest; return interest; } void Savings_Account::Deposit(double amount) { balance += amount; } bool Savings_Account::Withdraw(double amount) {
- 166 -
bool result; if (amount <= balance) { balance -= amount; result = true; } else result = false; return result; } int main() { Savings_Account acc3("3333", 100.00, 0.06); Savings_Account acc2("2222", 200.00); Savings_Account acc1("1111"); cout << endl; cout << "*** End of Program ***" << endl; return 0; }
Redosled prikazanih poruka je važan. Kada se acc3 deklariše, konstruktor se izvršava za taj objekat. To isto važi i za acc2 i za acc1. Sva tri objekta prestaju da važe kada se funkcija main() završi. Zato, main() prikazuje poruku da se program završava. Zatim se destruktor izvršava za svaki objekat obrnutim redom od kreiranja objekta. Default argumenti U prethodnoj sekciji preklopili smo konstruktor štedni raun Savings_Account da bismo deklarisali Savings_Account objekat na bilo koji od tri
- 167 -
naina. Ponekad možemo postii efekat preklapanja konstruktora koristei jedan konstruktor sa default argumentima. Potrebno je da specificirate default argumente u deklaraciji konstruktora, a ne u definiciji. Sledi, u deklaraciji klase treba da napišete sledei kôd: public: Savings_Account(string id, double bal = 0.00, double rt = 0.02); //konstruktor sa default veliinama //koji služi kao konstruktor sa jednim argumentom //i kao konstruktor sa dva argumenta
Ova deklaracija znai da ako izostavimo poslednja dva argumenta kada deklarišemo Savings_Account objekat, default vrednost 0.00 bie iskorišena kao drugi argument i default-na vrednost 0.02 bie iskorišena kao trei argument. Sledea deklaracija kreira Savings_Account objekat sa identifikacionim brojem ID ija je vrednost 1111, stanje 0.00 i kamatna stopa 0.02: Savings_Account acc1("1111");
Samo završni argumenti se mogu izostaviti. Konstruktor bez argumenata nije iskoristljiv. Sledei program ilustruje korišenje konstruktoru klase štedni raun Savings_Account.
default
//Ovaj program koristi proširenu verziju klase Savings_Account. //Program ilustruje default argumente u deklaraciji konstruktora #include #include #include using namespace std; class Savings_Account { private: string id_no; double balance; double rate; public:
- 168 -
argumenata
u
Savings_Account(string id, double bal = 0.00, double rt = 0.02); ~Savings_Account(); double Calc_Interest(); double Get_Balance(); string Get_ID(); void Deposit(double); bool Withdraw(double); }; Savings_Account::Savings_Account(string id, double bal, double rt) { id_no = id; balance = bal; rate = rt; cout << "Default-argument constuctor for " << id_no << endl; cout << "Value of balance is " << balance << endl; cout << "Value of rate is " << rate << endl << endl; } Savings_Account::~Savings_Account() { cout << "Destructor executed for " << id_no << endl; } double Savings_Account::Get_Balance() { return balance; } string Savings_Account::Get_ID() { return id_no; } double Savings_Account::Calc_Interest() { double interest; interest = balance * rate; balance += interest; return interest; } void Savings_Account::Deposit(double amount) {
- 169 -
balance += amount; } bool Savings_Account::Withdraw(double amount) { bool result; if (amount <= balance) { balance -= amount; result = true; } else result = false; return result; } int main() { cout << setprecision(2) << setiosflags(ios::fixed) << setiosflags(ios::showpoint); Savings_Account acc3("3333", 100.00, 0.06); Savings_Account acc2("2222", 200.00); Savings_Account acc1("1111"); cout << endl; cout << "*** End of Program ***" << endl; return 0; }
- 170 -
Default argumenti u deklaraciji konstruktora nam dozvoljavaju da deklarišemo objekat Savings_Account na isti nain kao ranije, gde smo imali tri preklopljena konstruktora. Dodali smo cout naredbe u konstruktoru da bismo verifikovali vrednosti primeraka promenljivih. Dodela jednog objekta drugom Mogue je dodeliti jedan objekat drugom objektu ako pripadaju istoj klasi. U ovom sluaju dodela je data po principu lan po lan. Na primer: Savings_Account acc1("1111", 100.00, 0.03); Savings_Account acc2("2222", 200.00); acc2 = acc1;
Objekat acc1 ima svoje lanove id, balance i rate inicijalizovane na "1111", 100.00 i 0.03, respektivno. Objekat acc2 ima svoj id i balance inicijalizovane na "2222" i 200.00. Vrednost za rate za objekat acc2 je difoltna 0.02. Kada se dodela izvršava, id lan objekta acc1 se kopira u id lan objekta acc2; balance lan acc1 se kopira u balance lan acc2; rate lan acc1 se kopira u rate lan acc2. Ovo emo ilustrovati u sledeem programu. Treba obratiti pažnju da smo izbacili destruktor i cout narebe iz konstruktora. Takoe smo dodali Get_Rate() metod, tako da možemo da prikažemo vrednosti svih primeraka varijabli. //Ovaj program koristi prosirenu verziju klase Savings_Account //Program ilustruje dodelu objekata #include #include #include using namespace std; class Savings_Account { private: string id_no; double balance; double rate; public: Savings_Account(string id, double bal = 0.00, double rt = 0.02);
- 171 -
double Calc_Interest(); double Get_Balance(); double Get_Rate(); string Get_ID(); void Deposit(double); bool Withdraw(double); }; Savings_Account::Savings_Account(string id, double bal, double rt) { id_no = id; balance = bal; rate = rt; } double Savings_Account::Get_Balance() { return balance; } string Savings_Account::Get_ID() { return id_no; } double Savings_Account::Get_Rate() { return rate; } double Savings_Account::Calc_Interest() { double interest; interest = balance * rate; balance += interest; return interest; } void Savings_Account::Deposit(double amount) { balance += amount; } bool Savings_Account::Withdraw(double amount) {
- 172 -
bool result; if (amount <= balance) { balance -= amount; result = true; } else result = false; return result; } int main() { cout << setprecision(2) << setiosflags(ios::fixed) << setiosflags(ios::showpoint); Savings_Account acc1("1111", 100.00, 0.03); Savings_Account acc2("2222", 200.00); acc2 = acc1; cout << "The new values for acc2 are: " << endl << endl; cout << "ID = " << acc2.Get_ID() << endl; cout << "Balance = " << acc2.Get_Balance() << endl; cout << "Rate = " << acc2.Get_Rate() << endl; return 0; }
Savings_Account konstruktor se izvršava dva puta za acc1 i jednom za acc2. Program zatim dodeljuje vrednost acc1 desnoj strani, tj. objektu acc2. Dodela je data po principu lan po lan. Zato se podaci lanovi objekta acc1 kopiraju u podatke lanove objekta acc2. Program verifikuje dodelu kada prikaže vrednosti podataka lanova objekta acc2.
- 173 -
8.5 Opšte preklapanje funkcija i šabloni funkcija Bilo koja funkcija može biti preklopljena u C++. Preklopljene verzije funkcija mora da imaju isti povratni tip i mora da se razlikuju u broju i/ili tipu argumenata. Sledea funkcija zamenjuje dva celobrojna argumenta. void Swap(int& i, int& j) { int temp; temp = i; i = j; j = temp; }
U C++ jeziku možemo da preklopimo integer verzije funkcije Swap() sa sledeom double verzijom Swap(). void Swap(double& x, double& y) { double temp; temp = x; x = y; y = temp; }
Šablon funkcije dozvoljava programeru da napiše kod za funkciju ija je definicija nezavisna od tipa podatka njenih argumenata i/ili njenog return tipa. Na taj nain, šablon funkcije se ustvari koristi da kompajler automatski preklopi funkcije kao što je potrebno programu. Šablon funkcije Swap() je: template void Swap(Type& x, Type& y) { Type temp; temp = x; x = y; y = temp; }
- 174 -
Definicija poinje rezervisanom rei template za kojom sledi rezervisana re class i jedan identifikator Type. Re template kaže kompajleru da napravi definiciju šablona. Identifikator Type se koristi kao ime proizvoljne klase ili tipa podatka. Type se ponaša kao varijabla ija vrednost može biti bilo koja klasa ili tip podatka. Nakon deklaracije šablona sledi definicija funkcije. Jedino pravilo koga treba da se držite kada pišete funkciju je da koristite identifikator Type kad god želite da referencirate na tip podatka parametra ili kada deklarišete varijablu. U primeru koji sledi u hederu funkcije imamo Swap(Type& x, Type& y) deklarisanje parametara bilo kog tipa. Takoe, u telu funkcije deklarišemo promenljivu temp kao što sledi Type temp;
Sledei program sadrži nekoliko primera šablona funkcija: //Ovaj program prikazuje sablone funkcija #include using namespace std; template Type Max(Type x, Type y) { return (x > y)? x: y; } template void Swap(Type& x, Type& y) { Type temp; temp = x; x = y; y = temp; } template TypeA Func(TypeA x, TypeB y) { TypeA r; r = 3 * x + 2 * y; return r; } template Type Sum(Type a[], int n) {
- 175 -
Type t = 0; for (int i = 0; i < n; ++i) t += a[i]; return t; } int main() { int i = 3, j = 5; double d = 8.62, e = 4.14; float f_arr[6] = {1.2, 2.3, 3.4, 4.5, 5.6, 6.7}; int i_arr[4] = {4, 5, 6, 7}; cout << "i = " << i << " and j = " << j << endl; cout << "d = " << d << " and e = " << e << endl << endl; cout << "The larger of i and j is " << Max(i, j) << endl; cout << "The larger of d and e is " << Max(d, e) << endl << endl; Swap(i, j); Swap(d, e); cout << "i = " << i << " and j = " << j << endl; cout << "d = " << d << " and e = " << e << endl << endl; cout << "Func() applied to i and d is " << Func(i, d) << endl; cout << "Func() applied to d and i is " << Func(d, i) << endl << endl; cout << "The sum of f_arr[] is " << Sum(f_arr, 6) << endl; cout << "The sum of i_arr[] is " << Sum(i_arr, 4) << endl; return 0; }
- 176 -
Šabloni funkcija su definisani pre funkcije main(), što zahteva veina kompajlera. Ako pokušate da iskoristite šablon funkcije za primer u kome kompajler ne može da podesi tipove, program se nee kompajlirati.
- 177 -
9. Rad sa objektima 9.1 Korišenje nizova, pokazivaa i dinamika alokacija memorije Da bismo napravili klasu Savings_Account da bude što realnija, menjamo tip podatka id_no, tj. lan koji skladišti broj rauna i uvodimo pokaziva kao lan za skladištenje imena vlasnika rauna. Niz i pokaziva kao lanovi klase U veini aplikacija broj rauna (identifikacioni broj) ili ID ima odreen broj karaktera. Želimo da naš ID rauna bude 4 karaktera, pa ga smeštamo u niz karaktera veliine 5 (dodata je pozicija za null karakter, '\0'). Pretpostavimo da smo deklarisali sledee u private sekciji definicije Savings_Account: char id_no[5];
Dodaemo i definiciju primerka varijable name klase Savings_Account, koja predstavlja ime osobe koja je vlasnik rauna. Ime uvamo u stringu. Meutim, da bi ilustrovali odreene karakteristike jezika C++, napraviemo da podatak lan name bude karakter pointer (C-string) i dinamiki alocira tano onoliko memorije koliko zahteva ime vlasnika kada kreiramo štedni raun. char* name;
Sledi nova deklaracija štednog rauna Savings_Account, koja ukljuuje deklaraciju novog konstruktora sa 4 argumenta, sa 2 default argumenta i deklaracijom destruktora. Takoe, dodajemo metode za prikaz varijabli id_no i name. class Savings_Account { private: char id_no[5]; char* name; double balance; double rate;
- 178 -
public: Savings_Account(char id[], char* n_p, double bal = 0.00, double rt = 0.04); ~Savings_Account(); double Calc_Interest(); double Get_Balance(); void Deposit(double); int Withdraw(double); void Display_ID(); void Display_Name(); };
Novi konstruktor pretpostavlja da su prvi i drugi argument karakter stringovi. Podsetimo se da je ime niza bez srednjih zagrada pointer na prvi elemenat niza. Tretiraemo prvi od stringova kao niz karaktera fiksne veliine, a drugi kao karakter pointer. Ako želimo da kreiramo tekui raun sa ID brojem 1111 koji pripada Jane Doe sa otvorenim stanjem od 200.00 i default kamatnom stopom od 0.04, deklarisaemo sledee: Account acc("1111", "Jane Doe", 200.00);
Konstruktor mora da kopira prvi argument "1111" u lan niz id_no[], i napravi lan pointer name koji pokazuje na karakter string "Jane Doe". Da bismo ovo ostvarili koristimo funkcije za rad sa C-string-om i dinamiku alokaciju memorije. Kod za konstruktor je: Savings_Account::Savings_Account(char id[], char* n_p, double bal, double rt) { strcpy(id_no, id); //kopira prvi argument u id_no[] name = new char[strlen(n_p) + 1]; //kreira prostor u memoriji za pokazivac name strcpy(name, n_p); //kopira drugi argument u novi prostor balance = bal; rate = rt; }
Prva naredba u konstruktoru koristi biblioteku funkciju strcpy() da bi se kopirao prvi argument u lan niza id_no[] sa pet karaktera. Da bi lan name pokazivao na string koji je drugi argument potrebne su dve naredbe. Prva naredba koristi new operator za alokaciju dovoljnog prostora za niz karaktera koji e da drži drugi argument i dodeli name-u pokaziva koji new vraa.
- 179 -
String funkcija strlen(), vraa broj karaktera u drugom argumentu, plus 1 za null karakter. Nakon izvršenja dodele, name pokazuje na niz karaktera koji je tano toliko velik da drži string koji je drugi argument konstruktora. Druga naredba kopira drugi argument, na koji pokazuje n_p, u prostor na koji pokazuje name.
Sledi definicija destruktor funkcije: Savings_Account::~Savings_Account() { cout << "\nAccount " << id_no << " terminated."; delete [] name; }
Kada program kreira Savings_Account objekat, konstruktor alocira prostor u hip memoriji za ime vlasnika štednog rauna. Kada jedan objekat izlazi iz dosega, tj. kada se objekat uništava, mora da dealociramo tu hip memoriju izvršenjem naredbe delete u destruktoru. Proces dealociranja hip prostora kada više nije potreban se naziva "garbage collection". Greška pri dealokaciji hip prostora prouzrokuje da prostor ostane alociran ali beskoristan ("ubre") zato što pokaziva na taj prostor, name, više ne postoji. Ako se ovo desi za više Savings_Account objekata, bie problem sa neiskorišenim prostorom u glavnoj memoriji. Ubaciemo sada promenjenu klasu u program. //Ovaj program koristi prosirenu verziju klase Savings_Account. //Program koristi konstruktor sa default argumentima. //ID broj je uskladisten kao niz a ime klase Savings_Account je pokazivac. //Konstruktor koristi dinamicku alokaciju memorije.
- 180 -
#include #include #include using namespace std; class Savings_Account { private: char id_no[5]; char* name; double balance; double rate; public: Savings_Account(char id[], char* n_p, double bal = 0.00, double rt = 0.04); ~Savings_Account(); double Calc_Interest(); double Get_Balance(); void Deposit(double); bool Withdraw(double); void Display_ID(); void Display_Name(); }; Savings_Account::Savings_Account(char id[], char* n_p, double bal, double rt) { strcpy(id_no, id); // kopira prvi argument u id_no[] name = new char[strlen(n_p) + 1]; // kreira prostor na unos imena strcpy(name, n_p); // kopira drugi argument u novi prostor balance = bal; rate = rt; } Savings_Account::~Savings_Account() { cout << endl << endl; cout << "Account " << id_no << " terminated." << endl; delete [] name; } double Savings_Account::Get_Balance() { return balance; } double Savings_Account::Calc_Interest() {
- 181 -
double interest; interest = balance * rate; balance += interest; return interest; } void Savings_Account::Deposit(double amount) { balance += amount; } bool Savings_Account::Withdraw(double amount) { bool result; if (amount <= balance) { balance -= amount; result = true; } else result = false; return result; } void Savings_Account::Display_ID() { cout << id_no; } void Savings_Account::Display_Name() { cout << name; } int main() { cout << setprecision(2) << setiosflags(ios::fixed) << setiosflags(ios::showpoint); char id[5]; char buffer[81]; //Privremeno skladisti ime
- 182 -
double bal; double rt; double amount; cout << endl; cout << "Enter Account ID: "; cin.getline(id, 5); cout << endl; cout << "Enter Account Holder's Name: "; cin.getline(buffer, 81); cout << endl; cout << "Enter Balance: "; cin >> bal; cout << endl; cout << "Enter Interest Rate: "; cin >> rt; Savings_Account acc1(id, buffer, bal, rt); cout << endl; cout << "The Account number is "; acc1.Display_ID(); cout << endl; cout << "The owner of the Account is "; acc1.Display_Name(); cout << endl << endl; cout << "The balance in the Account is now " >> acc1.Get_Balance(); cout << endl << endl; cout << "Enter an amount to deposit: "; cin >> amount; acc1.Deposit(amount); cout << endl << endl; cout << "A deposit of " << amount << " was made." << endl; cout << "The balance in the Account is now " << acc1.Get_Balance() << endl; acc1.Calc_Interest(); cout << endl; cout << "Interest was applied to the Account." << endl; cout << "The balance in the Account is now "
- 183 -
<< acc1.Get_Balance() << endl << endl; cout << "Enter an amount to withdraw: "; cin >> amount; if (acc1.Withdraw(amount)) { cout << endl <
Treba obratiti pažnju da destruktor prikazuje poruku kada se program završi.
- 184 -
9.2 Konstruktor kopije Jedan objekat može da se dodeli drugom objektu kada se kreira objekat, kao u sledeem sluaju: Savings_Account acc1("1111", "Larrabee Maxwell", 100.00, 0.02); Savings_Account acc2 = acc1;
Kao što se može videti, kada se jedan objekat kreira kroz inicijalizaciju, (kao što je objekat acc2), konstruktor klase se ne izvršava. Metod koji se izvršava za vreme inicijalizacije je konstruktor kopije. U ovoj sekciji, objasniemo konstruktor kopije i okolnosti pod kojima treba da napišete kod za konstruktor kopije za klasu. Konstruktor kopije: prost primer U jeziku C++, postoji razlika izmeu dodele i inicijalizacije. Pri dodeli, receiving-objekat mora da postoji pre dodele. Pri inicijalizaciji, objekat je inicijalizovan za vreme procesa kreiranja. Na primer: int i = 7, j; j = i;
Ceo broj i je deklarisan i inicijalizovan na 7. Kada se kreira, kreira se sa vrednošu 7. Ne postoji vreme za koje i postoji bez ispravne vrednosti. Sa druge strane, kada se j deklariše, on ne prima vrednost. Zbog toga, on ima garbage vrednost dok mu se validna vrednost ne dodeli. Operacija dodele kopira vrednost i u postojei objekat j, dajui objektu j validnu vrednost. Posmatrajmo primer: //Ovaj program ilustruje dodelu jednog objekta drugom objektu. //Treba obratiti paznju da inicijalizacija jednog objekta ne koristi //konstruktor sa jednim argumentom #include using namespace std;
- 185 -
class Test_Class { private: int n; public: Test_Class(int); ~Test_Class(); int Get_Value(); }; Test_Class::Test_Class(int i) { n = i; cout << endl; cout << "Constructor Executed: Data member initialized to " << n << endl; } Test_Class::~Test_Class() { cout << endl; cout << "Destructor Executed for object with data member " << n << endl; } int Test_Class::Get_Value() { return n; } int main() { Test_Class tc_object1(4); Test_Class tc_object2(0); cout << endl; cout << "After object creation:" << endl <
- 186 -
cout << "After initializing object 3:" << endl << endl; cout << "Object 3: " << tc_object3.Get_Value() << endl; return 0; }
Test_Class konstruktor izvršava se dva puta – jednom za tc_object1 i jednom za tc_object2. Nakon kreiranja objekta, program prikazuje vrednosti podataka lanova objekata. Program zatim dodeljuje vrednost tc_object1 objektu tc_object2. Dodela je data na osnovu "member-by-member". Zbog toga se, podatak n lan objekta tc_object1 kopira u n podatak lan objekta tc_object2. Program verifikuje dodelu kada prikaže vrednosti podataka lanova objekata. Napomena: konstruktor sa jednim argumentom se ne izvršava kada program kreira i inicijalizuje tc_object3 izvršavajui sledeu naredbu: Test_Class tc_object3 = tc_object1;
Konstruktorove poruke se ne prikazuju u ovoj taki programa! Vrednost tc_object3 se prikazuje u funkciji main(), ali ne od strane konstruktora. Konano, na kraju programa, destruktor se izvršava tri puta, jednom za svaki objekat koji kreira program.
- 187 -
Zato što se operacija inicijalizacije razlikuje od dodele, specijalan konstruktor se koristi u C++ za inicijalizaciju konstruktora kopije (copy constructor). Kao i kod obinog konstruktora, ako eksplicitno ne napišete kôd za konstruktor kopije, klasi se daje default konstruktor kopije. Default konstruktor kopije kopira podatke lanove iz tc_object1 i inicijalizuje ih, na bazi lan po lan, u odgovarajue podatke lanove objekta tc_object3. Kod konstruktora kopije koji ste vi kreirali za Test_Class je: class Test_Class { . . . public: Test_Class(Test_Class&); // Deklaracija konstruktora kopije . . . };
Konstruktor kopije mora, kao i drugi konstruktori, da ima isto ime kao i klasa. On se razlikuje od drugih konstruktora po formi svog argumenta, koji je referenca na jedan objekat klase za koju je on konstruktor kopije. Sintaksa deklaracije konstruktora kopije je oblika: Class_Name (Class_Name& r_object);
Kada se piše kod za konstruktor kopije, razmišljajte o konstruktorovom argumentu kao o objektu sa desne strane operatora dodele = pri inicijalizaciji. U kodu konstruktora kopije, da bi uputili (referencirali) na lanove ovog objekta, koristite parametar name r_object, sa dot operatorom, za kojim sledi primerak promenljive name. Konstruktor kopije se primenjuje na objekat koji se kreira. Zbog toga, primenjen je na objekat sa leve strane znaka = pri inicijalizaciji. Test_Class::Test_Class(Test_Class& tc_r) { n = tc_r.n; //Kopira podatak n clan objekta sa desne strane operatora dodele // u inicijalizaciji u podatak n clana objekta koji se kreira cout << endl << endl;
- 188 -
cout << "Copy Constructor executed: " << "Data member initialized to " << n << endl; }
Konstruktor kopije se poziva kada se jedan objekat inicijalizuje u deklaraciji. Zbog toga, druga deklaracija koja sledi prouzrokuje da se konstruktor kopije izvrši Test_Class tc_object1(3); //regularan konstruktor se izvršava Test_Class tc_object2 = tc_object1; //konstruktor kopije se izvršava
O parametru tc_r u definiciji konstruktora kopije razmišljate kao o predstavljanju desne strane operatora dodele = pri inicijalizaciji (u prethodnoj drugoj deklaraciji, tc_object1). Na taj nain konstruktor kopije dodeljuje n data lanu novog objekta koji se kreira (objekat tc_object2 u ovoj inicijalizaciji) odgovarajui data lan objekta na desnoj strani operatora dodele =, nazvanom, tc_r.n (koji predstavlja n data lan objekta tc_object1). Objasniemo u narednoj sekciji zašto argument konstruktora kopije mora da bude referenca. Sledei program ilustruje korišenje konstruktora kopije. //Ovaj program ilustruje koriscenje konstruktora kopije. #include using namespace std; class Test_Class { private: int n; public: Test_Class(int); //Konstruktor sa jednim argumentom Test_Class(Test_Class&); //Konstruktor kopije ~Test_Class(); int Get_Value(); }; Test_Class::Test_Class(int i) { n = i;
- 189 -
cout << endl; cout << "Constructor Executed: Data member initialized to " << n << endl; } Test_Class::Test_Class(Test_Class& tc_r) { n = tc_r.n; cout << endl << endl; cout << "Copy constructor executed: " << "Data member initialized to " << n << endl << endl; } Test_Class::~Test_Class() { cout << endl << endl; cout << "Destructor Executed for object with data member " << n << endl; } int Test_Class::Get_Value() { return n; } int main() { Test_Class tc_object1(4); Test_Class tc_object2(0); cout << "After object creation:" << endl << endl; cout << "Object 1: " << tc_object1.Get_Value() << endl; cout << "Object 2: " << tc_object2.Get_Value() << endl << endl; tc_object2 = tc_object1; cout << "After object assignment:" << endl << endl; cout << "Object 1: " << tc_object1.Get_Value() << endl; cout << "Object 2: " << tc_object2.Get_Value() << endl << endl; Test_Class tc_object3 = tc_object1; cout << "After initializing object 3:" << endl << endl; cout << "Object 3: " << tc_object3.Get_Value() << endl; return 0; }
- 190 -
Obratite pažnju da se konstruktor kopije izvršava kada se program kreira i inicijalizuje objekat tc_object3. Konstruktor kopije za klasu Savings_Account Mada nije neophodno da se napiše kôd za konstruktor kopije za Test_Class (default konstruktor kopije takoe radi dobro), važno je da napišete vaš sopstveni kôd za konstruktor kopije kad god klasa sadrži pokaziva kao instancu promenljive. Da biste videli zašto, posmatrajmo Savings_Account, koji ima character pointer name, kao primerak promenljive. Zato što klasa nema eksplicitno kodiran konstruktor kopije, default konstruktor kopije klase bie korišen pri inicijalizaciji bilo kog objekta. Pretpostavimo da smo u programu koji koristi Savings_Account napravili sledee deklaracije (možemo da napravimo takvu dodelu da bi eksperimentisali sa kopijom objekta acc1, a da ne menjamo original): Account acc1("1111", "Maxwell Larrabee"); Account acc2 = acc1;
- 191 -
Zato što je default konstruktor kopije korišen pri inicijalizaciji, acc2 je "lan-po-lan" kopija od acc1. Zbog toga, pointer acc1.name koji pokazuje na string "Maxwell Larrabee" biva kopiran u pointer acc2.name. Obratite pažnju da se pokaziva, koji je adresa, kopira, a ne kopira se string na koji pokaziva pokazuje. Na taj nain, imamo name pokaziva dva razliita objekta koji pokazuje na istu zonu hip memorije. Sa slike sledi da promena cilja jednog od ovih pokazivaa kao rezultat daje promenu oba. Na taj nain ako promenimo string na koji pokazuje name lan objekta acc2, takoe menjamo string na koji pokazuje name lan objekta acc1. Ovo je upravo ono što nismo želeli da se desi!
Kako bismo rešili ovaj problem, napisali smo konstruktor kopije za Savings_Account koji kopira cilj na koji pokazuje pointer name. Savings_Account::Savings_Account(Savings_Account& acc_r) { strcpy(id_no, acc_r.id_no); // kopira prvi argument u id_no[] name = new char[strlen(acc_r.name) + 1]; strcpy(name, acc_r.name);
// kreira prostor na unos imena
// kopira drugi argument u novi prostor
balance = acc_r.balance; rate = acc_r.rate; }
Zapamtite da je argument u konstruktoru kopije objekat na desnoj strani operatora = u inicijalizaciji i da je konstruktor kopije primenjen na objekat koji se kreira.
- 192 -
Obratite pažnju na slinost izmeu koda konstruktora sa etiri argumenta i konstruktora kopije. Prvo, id_no lan objekta koji se kopira, kopira se u id_no lana objekta koji se kreira. Zatim se prostor alocira iz hip memorije za string dovoljno velik da drži kopiju od name lana objekta koji se kopira. Nakon kopiranja name u novi hip prostor, stanje i kamatna stopa lanovi objekta koji se kopira se kopiraju u odgovarajue lanove objekta koji se kreira. Na taj nain, ako napravimo prethodni konstruktor kopije lana od Savings_Account, sledee deklaracije kao rezultat daju situaciju oznaenu na slici: Savings_Account acc1("1111", "Maxwell Larrabee"); Savings_Account acc2 = acc1;
Sledi program koji ilustruje korišenje konstruktora kopije u klasi Savings_Account. //Ovaj program ilustruje koriscenje konstruktora kopije //u klasi koja ima pokazivac kao podatak clan. #include #include #include using namespace std; class Savings_Account { private: char id_no[5];
- 193 -
char* name; double balance; double rate; public: Savings_Account(char id[], char* n_p, double bal = 0.00, double rt = 0.04); Savings_Account(Savings_Account&); ~Savings_Account(); double Calc_Interest(); double Get_Balance(); void Deposit(double); bool Withdraw(double); void Display_ID(); void Display_Name(); }; Savings_Account::Savings_Account(char id[], char* n_p, double bal, double rt) { strcpy(id_no, id); // kopira prvi argument u id_no[] name = new char[strlen(n_p) + 1]; //kreira prostor za pokazivac name strcpy(name, n_p); //kopira drugi argument u novi prostor balance = bal; rate = rt; cout << endl << endl; cout << "Constructor executed." << endl; } Savings_Account::Savings_Account(Savings_Account& acc_r) { strcpy(id_no, acc_r.id_no); // kopira prvi argument u id_no[] name = new char[strlen(acc_r.name) + 1]; // kreira prostor na unos imena strcpy(name, acc_r.name); // kopira drugi argument u novi prostor balance = acc_r.balance; rate = acc_r.rate; cout << endl << endl; cout << "Copy constructor executed." << endl; }
- 194 -
Savings_Account::~Savings_Account() { cout << endl << endl; cout << "Account " << id_no << " terminated." << endl; delete [] name; } double Savings_Account::Get_Balance() { return balance; } double Savings_Account::Calc_Interest() { double interest; interest = balance * rate; balance += interest; return interest; } void Savings_Account::Deposit(double amount) { balance += amount; } bool Savings_Account::Withdraw(double amount) { bool result; if (amount <= balance) { balance -= amount; result = true; } else result = false; return result; } void Savings_Account::Display_ID() { cout << id_no; }
- 195 -
void Savings_Account::Display_Name() { cout << name; } int main() { cout << setprecision(2) << setiosflags(ios::fixed) << setiosflags(ios::showpoint); char id[5]; char buffer[81]; //Privremeno skladisti ime double bal; double rt; cout << "Enter Account ID: "; cin.getline(id, 5); cout << endl; cout << "Enter Account Holder's Name: "; cin.getline(buffer, 81); cout << endl; cout << "Enter Balance: "; cin >> bal; cout << endl; cout << "Enter Interest Rate: "; cin >> rt; Savings_Account acc1(id, buffer, bal, rt); cout << endl << endl; cout << "Account created with Account number "; acc1.Display_ID(); cout << endl; cout << " and owner name "; acc1.Display_Name(); cout << endl << endl; cout << "Account now being created by initialization."; Savings_Account acc2 = acc1; cout << endl << endl; cout << "Initialized Account created with Account number "; acc2.Display_ID();
- 196 -
cout << endl; cout << "\n and owner name "; acc2.Display_Name(); cout << endl; return 0; }
9.3 Korišenje rezervisane rei const u radu sa klasama Rezervisana re const može da se iskoristi na više naina zavisno od objekata i metoda klasa. Konstantni objekti i metodi Mogue je deklarisati konstantne objekte, kao što je mogue deklarisati konstantne cele brojeve, promenljive tipa double, itd. Konstantan objekat je onaj ije vrednosti primeraka promenljivih ne mogu da se menjaju. Na primer, posmatrajmo Test_Class, definisanu u prethodnoj sekciji sa dodatnim metodom Change_Value().
- 197 -
#include using namespace std; class Test_Class { private: int n; public: Test_Class(int i = 0); //Konstruktor sa jednim argumentom i default vrednoscu int Get_Value(); void Change_Value(int); }; Test_Class::Test_Class(int i) { n = i; cout << "\n\nConstructor Executed: Data member initialized to " << n; } int Test_Class::Get_Value() { return n; } void Test_Class::Change_Value(int i) { n = i; } Suppose we declare the following in main(). const Test_Class tc_object1(4); Test_Class tc_object2(7);
Sledea naredba dodele nije ispravna zato što je objekat tc_object1 konstantan i ne možemo da modifikujemo konstantan objekat u funkciji main(). tc_object1 = tc_object2;
//pogresno - ne mozemo da modifikujemo konstantan //objekat
Kada je objekat konstantan, ne možemo da menjamo vrednost njegove instance promenljive, n. Ne postoji nain da kompajler sazna
- 198 -
razliku izmeu aksesor metoda (koji ne menja vrednost instance varijable) i mutator metoda (koji menja vrednost instance promenljive). Kompajler e izbaciti poruku: ili warning ili error, ako primenimo bilo koji od metoda klase Test_Class na objekat tc_object1. tc_object1.Get_Value(); //Kompajler izbacuje poruku tc_object.Change_Value(); // Kompajler izbacuje poruku
Veoma je ozbiljno ogranienje ne dozvoliti bilo kom metodu da ne radi sa konstantnim objektom. Želimo da možemo da primenimo aksesor metod na konstantan objekat zato što takav metod ne pokušava da promeni primerke varijabli te klase. Da bismo rekli kompajleru da je metod tipa aksesor metod i da treba da mu bude dozvoljeno da radi sa konstantnim objektima, on treba da bude deklarisan kao konstantan. Ovo je dato dodavanjem rezervisane rei const nakon zagrada koje slede nakon imena aksesor metoda i u deklaraciji i u definiciji funkcije. Konstantni metodi Bilo koji metod klase koji je accessor (znai, ne menja vrednost bilo koje instance promenljive) treba da bude deklarisan kao konstantan. Ovo je dato dodavanjem rezervisane rei const nakon zagrada koje slede nakon imena metoda i u deklaraciji i u definiciji. Ovo dozvoljava da takav metod bude primenjen na konstantan objekat. Sledi korektna verzija deklaracije Test_Class. #include using namespace std; class Test_Class { private: int n; public: Test_Class(int i = 0);
// Konstruktor sa jedim argumentom koji ima default // vrednost int Get_Value() const; //Accessor funkcija deklarisana kao konstanta - const void Change_Value(int);
};
- 199 -
Test_Class::Test_Class(int i) { n = i; cout << "\n\nConstructor Executed: Data member initialized to " << n; } int Test_Class::Get_Value() const { return n; }
//const se zahteva
void Test_Class::Change_Value(int i) { n = i; }
Sledei program ilustruje korišenje konstantnih metoda. Treba napomenuti da ako ukljuite naredbu u main() koja je u komentaru, kompajler e izdati "error message" zato što naredba pokušava da promeni konstantan objekat. //Ovaj program ilustruje konstantne funkcije lanice. //Napomena: naredba u komentaru u funkciji main() prouzrokuje //kompajlerovu poruku o gresci #include using namespace std; class Test_Class { private: int n; public: Test_Class(int i = 0); // Konstruktor sa jedim argumentom koji ima default // vrednost int Get_Value() const; void Change_Value(int); }; Test_Class::Test_Class(int i) { n = i; cout << endl;
- 200 -
cout << "Constructor Executed: Data member initialized to " << n << endl << endl; } int Test_Class::Get_Value() const { return n; } void Test_Class::Change_Value(int i) { n = i; } int main() { const Test_Class tc_object1(4); cout << "The value of the object is " << tc_object1.Get_Value() << endl; //Dodavanje sledeceg reda prouzrokovalo bi gresku u kompajliranju //tc_object1.Change_Value(7); return 0; }
const u deklaracijama pokazivaa
Rezervisana re const može da se koristi na dva naina u radu sa pokazivaima, prvo, pokaziva može da se deklariše kao konstanta, i cilj na koji pokazuje pokaziva može da bude konstantan. Ako const neposredno predhodi imenu pokazivaa u deklaraciji, onda je pokaziva konstantan. Sledi, jednom inicijalizovan pokaziva ne može da se promeni, tj. ne može da pokazuje na nešto drugo. Posmatrajmo kao primer sledee deklaracije: int i = 4, j = 7; int* const i_p = &i; //pointer i_p je konstantan, zato, njegova vrednost &i, ne moze //da se menja. Ona mora uvek da pokazuje na i.
- 201 -
i_p
i_p = &j; //pogresno jer je pokazivac i_p konstanta i_p. *i_p = 5; //ispravno – cilj pokazivaca i_p NIJE konstanta. const pojavi pre tipa podatka u deklaraciji
deklaracije: int n = 3, m = 5; const int* n_p = &n;
konstantu; tj. n_p
//Cilj od n_p, sa imenom n, ne može da se promeni //preko n_p. n_p n_p kao o "read-
n_p
*n_p = m;
//neispravno - target pointera n_p je konstantan
S druge strane, n_p nije konstanta. Zato možemo da napravimo n_p = &m;
//ispravno - sam pokazivac nije konstanta
Mada smo promenili cilj na koji pointer pokazuje, n_p je još uvek target pointera n_p *n_p = 6; //neispravno:ne moze se promeniti konstantan objekat na koji pokazuje //pointer.
- 202 -
Meutim, možemo još uvek promeniti vrednost m kao što sledi: m = 6;
Mešanje konstantnih pokazivaa i pokazivaa koji nisu konstantni Važan princip mešanja pokazivaa koji treba zapamtiti je: deklaracija može da uvede restrikcije koje se tiu konstante, ali se ne mogu ukinuti. Razmotrimo sledee deklaracije: int i = 9; int* i_p = &i; const int* j_p = i_p; //ispravno
Pokaziva i_p nije konstantan niti je njegov cilj. Meutim, deklaracija j_p, koja inicijalizuje j_p na i_p, kaže da je target od j_p konstantan. Ogranienje koje se odnosi na j_p je da je njegov target konstantan, restrikcija koja nije true za i_p. Zbog toga, ispravno je promeniti i, target od i_p, preko i_p ali ne preko j_p. *i_p = 2; //ispravno: target od i_p, i, nije konstantan *j_p = 1;
//neispravno: target od j_p, i, je konstanta kada je //referencirana preko j_p
S druge strane, razmotrimo sledee deklaracije. int n = 8; const int* n_p = &n; int* m_p = n_p; //neispravno – ne moze se ukloniti restrikcija za konstantu
Poslednja deklaracija je neispravna. Pointer n_p je deklarisan kao pointer na objekat sa konstantnim podacima. Deklaracija m_p je jedan obian pointer. Zato je neispravna inicijalizacija m_p, pokazivaa koji nije konstantan, na n_p, konstantan pokaziva.
- 203 -
Konstantni argumenti u funkciji Rezervisana re const može takoe da se pojavi sa pokazivaem i referencom kao argumentima funkcije. Na primer, razmotrimo sledeu deklaraciju funkcije void Func(char* p, const char* q);
U ovom sluaju, const u drugom argumentu znai da je target od q konstantan. Zbog toga, podaci na koje pokazuje argument q ne mogu da se promene preko pokazivaa. // Ovaj program prikazuje kako da se nadje srednja vrednost elemenata u jednom // nizu // Program nalazi srednju vrednost prosledjivanjem niza funkciji koja izracunava // srednju vrednost. #include #include using namespace std; double Avg(const int [], int); int main() { const int NUM_QUIZZES = 10; int grade[NUM_QUIZZES]; // Niz sa ocenama iz kviza int quiz; // Indeks niza double grade_avg; cout << setiosflags(ios::fixed) << setiosflags(ios::showpoint) << setprecision(1); cout << "Please enter " << NUM_QUIZZES << " integer quiz grades." << endl << endl; for (quiz = 0; quiz < NUM_QUIZZES; ++quiz) { cout << endl; cout << "Enter grade for quiz " << quiz + 1 << ": "; cin >> grade[quiz]; } grade_avg = Avg(grade, NUM_QUIZZES);
- 204 -
cout << endl; cout << "The average quiz grade is " << grade_avg << endl; return 0; }
// Kraj main() funkcije
double Avg(const int arr[], int size) { int i, // Indeks niza sum = 0; // Zbir ocena double avg; // Prosecna ocena for (i = 0; i < size; ++i) sum += arr[i]; avg = double(sum) / size; return avg; } // Kraj funkcije Avg()
Konstantni argumenti i konstruktor kopije Ako ukljuite konstruktor kopije u definiciju klase, argument treba da bude deklarisan sa const da bi se obezbedilo da se kod konstruktora kopije ne menja ništa u vezi sa argumentom. Ovo je poželjno zbog toga što - 205 -
konstruktor kopije treba samo da kopira i ništa drugo. Slede deklaracija i definicija za konstruktor kopije za štedni raun Savings_Account sa bezbednijim kodom: Deklaracija: Savings_Account(const Savings_Account&);
Definicioni heder: Savings_Account::Savings_Account (const Savings_Account& acc_r)
Aksesor metodi koji vraaju konstantne pokazivae U verzijama klase Savings_Account koje smo razvijali u ovom poglavlju, nismo imali aksesor funkcije koje vraaju id_no ili name lanove klase. Umesto toga koristili smo funkcije Display_ID() i Display_Name(), koji prosto prikazuju na displeju odgovarajue podatke lanove. Ako pišemo kod za aksesor funkciju za name kao što sledi char* Savings_Account::Get_Name() { return name; }
onda, kada funkcija main() primenjuje ovo na Savings_Account objekat, main() e imati pristup lanu name objekta kroz pokaziva koji vraa Get_Name(). Ovo može da naruši princip skrivanja podataka i ne uvaži injenicu da je name deklarisano kao private u deklaraciji klase. Na primer, main() koristi pokaziva koji vraa Get_Name() da bi promenio ime objekta u string "XXX". //Ovaj program ilustruje koriscenje konstruktora kopije u klasi //koja ima pokaziva na podatak clan klase. //Klasa sadrzi aksesor funkcije koje vracaju konstantan pokazivac. #include #include #include using namespace std; class Savings_Account { private: char id_no[5];
- 206 -
char* name; double balance; double rate; public: Savings_Account(char id[], char* n_p, double bal = 0.00, double rt = 0.04); Savings_Account(const Savings_Account &); ~Savings_Account(); double Calc_Interest(); double Get_Balance(); char* Get_Name(); void Deposit(double); bool Withdraw(double); }; Savings_Account::Savings_Account(char id[], char* n_p, double bal, double rt) { strcpy(id_no, id); //kopira prvi argument u „id_no[]“ name = new char[strlen(n_p) + 1]; //kreiranje prostora za ime strcpy(name, n_p); //kopiranje drugog argumenta u novi prostor balance = bal; rate = rt; cout << endl << endl; cout << "Constructor executed." << endl << endl; } Savings_Account::Savings_Account(const Savings_Account& acc_r) { strcpy(id_no, acc_r.id_no); // kopira prvi argument u „id_no[]“ name = new char[strlen(acc_r.name) + 1]; // kreiranje prostora za ime strcpy(name, acc_r.name); // kopiranje drugog argumenta u novi prostor balance = acc_r.balance; rate = acc_r.rate; cout << endl << endl; cout << "Copy constructor executed." << endl << endl; } Savings_Account::~Savings_Account() {
- 207 -
cout << endl << endl; cout << "Account " << id_no << " terminated." << endl; delete [] name; } double Savings_Account::Get_Balance() { return balance; } char* Savings_Account::Get_Name() { return name; } double Savings_Account::Calc_Interest() { double interest; interest = balance * rate; balance += interest; return interest; } void Savings_Account::Deposit(double amount) { balance += amount; } bool Savings_Account::Withdraw(double amount) { bool result; if (amount <= balance) { balance -= amount; result = true; } else result = false; return result; } int main() {
- 208 -
cout << setprecision(2) << setiosflags(ios::fixed) << setiosflags(ios::showpoint); char id[5]; char buffer[81]; //Privremeno skladisti ime double bal; double rt; cout << "Enter Account ID: "; cin.getline(id, 5); cout << endl; cout << "Enter Account Holder's Name: "; cin.getline(buffer, 81); cout << endl; cout << "Enter Balance: "; cin >> bal; cout << endl; cout << "Enter Interest Rate: "; cin >> rt; cout << endl << endl; cout << "Account now being created." << endl << endl; Savings_Account acc1(id, buffer, bal, rt); cout << "Account Owner: " << acc1.Get_Name() << endl << endl; char* name = acc1.Get_Name(); strcpy(name, "XXX"); cout << "Account Owner: " << acc1.Get_Name() << endl; return 0; }
- 209 -
Da bismo napisali siguran kod za aksesor metod koji vraa pokaziva, treba da napravimo da metod vraa konstantan pokaziva. Ovo obezbeuje da objekat na koji se pokazuje ne može biti promenjen kroz pokaziva od strane pozivajue funkcije. Na primer, u klasi Savings_Account, bezbedan metod koji vraa vrednost ID broja je: const char* Get_Name() { return name; }
U funkciji main(), možemo da napišemo kôd koji sledi, ali nam onda nee biti dozvoljeno da promenimo ime-name objekta acc1 kroz pointer. const char* name_p = acc1.Get_Name();
Obratite pažnju da je sledea naredba neispravna zato što uklanja restrikcije koje postavlja const. Pokaziva koji vraa Get_Name() je pokaziva na konstantu, dok je name_p pokaziva koji nije konstantan. char* name_p = acc1.Get_Name();
Sledei program ilustruje ovu ideju.
- 210 -
//Ovaj program ilustruje koriscenje konstruktora kopije //u klasi koja ima pokazivac kao podatak clan. //Klasa sadrzi accessor funkcije koje vracaju konstantan pokazivac. #include #include #include using namespace std; class Savings_Account { private: char id_no[5]; char* name; double balance; double rate; public: Savings_Account(char id[], char* n_p, double bal = 0.00, double rt = 0.04); Savings_Account(const Savings_Account&); ~Savings_Account(); double Calc_Interest(); double Get_Balance(); const char* Get_Id(); const char* Get_Name(); void Deposit(double); bool Withdraw(double); }; Savings_Account::Savings_Account(char id[], char* n_p, double bal, double rt) { strcpy(id_no, id); //kopira prvi argument u „id_no[]“ name = new char[strlen(n_p) + 1]; //kreiranje prostora za ime strcpy(name, n_p); //kopiranje drugog argumenta u novi prostor balance = bal; rate = rt; cout << endl << endl; cout << "Constructor executed." << endl; } Savings_Account::Savings_Account(const Savings_Account& acc_r) {
- 211 -
strcpy(id_no, acc_r.id_no); // kopira prvi argument u „id_no[]“ name = new char[strlen(acc_r.name) + 1]; // kreiranje prostora za ime strcpy(name, acc_r.name); // kopiranje drugog argumenta u novi prostor balance = acc_r.balance; rate = acc_r.rate; cout << endl << endl; cout << "Copy constructor executed." << endl; } Savings_Account::~Savings_Account() { cout << endl << endl; cout << "Account " << id_no << " terminated." << endl; delete [] name; } double Savings_Account::Get_Balance() { return balance; } const char* Savings_Account::Get_Id() { return id_no; } const char* Savings_Account::Get_Name() { return name; } double Savings_Account::Calc_Interest() { double interest; interest = balance * rate; balance += interest; return interest; } void Savings_Account::Deposit(double amount) {
- 212 -
balance += amount; } bool Savings_Account::Withdraw(double amount) { bool result; if (amount <= balance) { balance -= amount; result = true; } else result = false; return result; } int main() { cout << setprecision(2) << setiosflags(ios::fixed) << setiosflags(ios::showpoint); char id[5]; char buffer[81]; //Privremeno skladisti ime double bal; double rt; cout << "Enter Account ID: "; cin.getline(id, 5); cout << endl; cout << "Enter Account Holder's Name: "; cin.getline(buffer, 81); cout << endl; cout << "Enter Balance: "; cin >> bal; cout << endl; cout << "Enter Interest Rate: "; cin >> rt; cout << endl <
- 213 -
Savings_Account acc1(id, buffer, bal, rt); cout << endl << endl; cout << "Account ID: " << acc1.Get_Id() << endl <
Aksesor metodi Get_Id() i Get_Name() vraaju const char*. Ovo garantuje da pozivajua funkcija, main() u ovom sluaju, ne može da menja cilj pokazivaa koji vraa svaki metod.
- 214 -
9.4 Objekti, funkcije i pokazivai Klasa je tip podatka. Sledi, funkcija može da vrati objekat i možemo da prosledimo objekat kao argument funkcije. Postoje tri naina na koji se funkciji može proslediti objekat: po vrednosti, po pokazivau i po referenci. Funkcije koje vraaju objekat Napisaemo kôd funkcije Get_Account() koji vraa glavnoj funkciji main() objekat Savings_Account. U hederu definicije Get_Account(), nije potrebno koristiti ime klase i operator dosega ::, zato što funkcija nije lan klase Savings_Account. Funkcija vraa Savings_Account objekat, što je razlog zbog ega se identifikator Savings_Account pojavljuje pre imena funkcije. Savings_Account Get_Account() { char id[5]; char buffer[81]; double bal; double rt; cout << endl; cout << "Enter Account ID: "; cin.getline(id, 5); cout << endl; cout << "Enter Account Holder's Name: "; cin.getline(buffer, 81); cout << endl; cout << "Enter Balance: "; cin >> bal; cout << endl; cout << "Enter Interest Rate: "; cin >> rt; Savings_Account acc(id, buffer, bal, rt); return acc; }
- 215 -
Ova funkcija sadrži vei deo koda koji se pojavljuje u glavnoj funkciji main() u programima koji koriste Savings_Account. Get_Account() kreira lokalni Savings_Account objekat, acc, koristei korisnikove ulazne podatke. Zato, name lan objekta acc pokazuje na prostor koji je alociran na hipu od strane Savings_Account konstruktora. Naredba return šalje privremenu kopiju objekta acc pozivajuoj funkciji. Kada se funkcija završi, lokalni objekat acc izlazi iz dosega i, zbog toga, se uništava. Ovo prouzrokuje da se Savings_Account destruktor izvršava, i on dealocira prostor na koji je name lan objekta acc pokazivao. Sada, ako je naredba return poslala lan-po-lan kopiju objekta acc nazad pozivajuoj funkciji, name lan te kopije pokazivae na nealocirani prostor. Ovaj pogrešan pokaziva može da prouzrokuje da se program sruši. Da bismo obezbedili da se ovo ne desi, C++ koristi Savings_Account konstruktor kopije da bi napravio privremenu kopiju objekta acc. Zbog toga, name lan privremene kopije pokazuje na razliito mesto na hipu od onoga koje je bilo za name lan objekta acc.
Sledi kompletan program koji koristi novu funkciju. //Ovaj program ilustruje koriscenje konstruktora kopije //u klasi koja ima pokazivac kao data clan. //Konstruktor kopije se koristi da bi napravio privremenu kopiju //vracenog objekta u funkciji Get_Account(). #include #include
- 216 -
#include using namespace std; class Savings_Account { private: char id_no[5]; char* name; double balance; double rate; public: Savings_Account(char id[], char* n_p, double bal = 0.00, double rt = 0.04); Savings_Account(const Savings_Account&); ~Savings_Account(); double Calc_Interest(); double Get_Balance(); void Deposit(double); bool Withdraw(double); }; Savings_Account::Savings_Account(char id[], char* n_p, double bal, double rt) { strcpy(id_no, id); //kopira prvi argument u „id_no[]“ name = new char[strlen(n_p) + 1]; //kreira prostor za ime strcpy(name, n_p); //kopira drugi argument u novi prostor balance = bal; rate = rt; cout << endl << endl; cout << "Constructor executed." << endl; } Savings_Account::Savings_Account(const Savings_Account& acc_r) { strcpy(id_no, acc_r.id_no); // kopira prvi argument u „id_no[]“ name = new char[strlen(acc_r.name) + 1]; // kreira prostor za ime strcpy(name, acc_r.name); // kopira drugi argument u novi prostor balance = acc_r.balance;
- 217 -
rate = acc_r.rate; cout << endl << endl; cout << "Copy constructor executed." << endl; } Savings_Account::~Savings_Account() { cout << endl <
- 218 -
Savings_Account Get_Account(); //Prototip za Get_Account() int main() { cout << setprecision(2) << setiosflags(ios::fixed) << setiosflags(ios::showpoint); cout << endl << endl; cout << "Account now being created."; Savings_Account acc1 = Get_Account(); cout << endl << endl; cout << "Account now being created by initialization." << endl; Savings_Account acc2 = acc1; return 0; } Savings_Account Get_Account() { char id[5]; char buffer[81]; double bal; double rt; cout << endl; cout << "Enter Account ID: "; cin.getline(id, 5); cout << endl; cout << "Enter Account Holder's Name: "; cin.getline(buffer, 81); cout << endl; cout << "Enter Balance: "; cin >> bal; cout << endl; cout << "Enter Interest Rate: "; cin >> rt; Savings_Account acc(id, buffer, bal, rt);
- 219 -
return acc; }
Poruku "Konstruktor izvršen" je proizveo konstruktor kada se kreira lokalni objekat acc u funkciji Get_Account(). Kada se return nardba izvršava, ona naini privremenu kopiju objekta acc, koju izvršava konstruktor kopije. Prva poruka "Account 1111 terminated" se izvršava kada se lokalni objekat acc uništi kada se funkcija završi. Nazad u funkciji main(), privremena kopija objekta acc koja je bila kreirana od strane funkcije dodeljena je objektu acc1. Treba obratiti pažnju da ovo ne prouzrokuje da se kopija konstruktora izvrši. Objekat acc1 postaje privremena kopija koja je bila vraena od funkcije. Sledei korak u funkciji main() je kreiranje inicijalizacijom objekta acc2. Ovo prouzrokuje da se konstruktor kopije izvršava. Konano, kada se funkcija main() završava, acc1 i acc2 se uništavaju, što kao rezultat daje da se destruktor izvršava za svaki od njih. Napomena, ako definišete funkciju koja vraa objekat klase koju je definisao korisnik, obezbedite klasu sa konstruktorom kopije.
- 220 -
Prosleivanje objekta po vrednosti Pretpostavimo da želimo da prosledimo objekat po vrednosti funkciji Display_Account() na takav nain da izvršavanje Display_Account(acc1) prikazuje informacije o raunu za objekat acc1. Pretpostavimo definiciju hedera funkcije Display_Account() na sledei nain: Display_Account(Savings_Account acc)
Kada program izvršava Display_Account(acc1), parametri funkcije objekta acc su inicijalizovani na vrednost objekta acc1. Zato, konstruktor kopije za Savings_Account se koristi da prosledi argument funkciji. Podsetimo se da treba da napišete kôd za sopstveni konstruktor kopije kad god klasa ima lan podatak koji je pokaziva. Zbog toga, kada prosleujemo objekat po vrednosti, moramo da budemo sigurni da naša klasa sadrži konstruktor kopije. Sledi program koji ilustruje korišenje konstruktora kopije kada prosleuje jedan objekat po vrednosti. //Ovaj program ilustruje prosledjivanje objekta po vrednosti. //Konstruktor kopije se zahteva da bi se korektna kopija objekta //prosledila funkciji. #include #include #include using namespace std; class Savings_Account { private: char id_no[5]; char* name; double balance; double rate; public: Savings_Account(char id[], char* n_p, double bal = 0.00, double rt = 0.04); ~Savings_Account(); Savings_Account(const Savings_Account&); const char* Get_Id() const; const char* Get_Name() const;
- 221 -
double Calc_Interest(); double Get_Balance(); void Deposit(double); bool Withdraw(double); }; Savings_Account::Savings_Account(char id[], char* n_p, double bal, double rt) { strcpy(id_no, id); //kopira prvi argument u „id_no[]“ name = new char[strlen(n_p) + 1]; //kreira prostor za ime strcpy(name, n_p); //kopira drugi argument u novi prostor balance = bal; rate = rt; } Savings_Account::Savings_Account(const Savings_Account& acc_r) { strcpy(id_no, acc_r.id_no); // kopira prvi argument u „id_no[]“ name = new char[strlen(acc_r.name) + 1]; // kreira prostor za ime strcpy(name, acc_r.name); // kopira drugi argument u novi prostor balance = acc_r.balance; rate = acc_r.rate; cout << endl << endl; cout << "Copy constructor executed." << endl; } Savings_Account::~Savings_Account() { cout << endl << endl; cout << "Account " << id_no << " terminated." << endl; delete [] name; } const char* Savings_Account::Get_Id() const { return id_no; } const char* Savings_Account::Get_Name() const {
- 222 -
return name; } double Savings_Account::Get_Balance() { return balance; } double Savings_Account::Calc_Interest() { double interest; interest = balance * rate; balance += interest; return interest; } void Savings_Account::Deposit(double amount) { balance += amount; } bool Savings_Account::Withdraw(double amount) { bool result; if (amount <= balance) { balance -= amount; result = true; } else result = false; return result; } void Display_Account(Savings_Account); int main() { cout << setprecision(2) << setiosflags(ios::fixed) << setiosflags(ios::showpoint);
- 223 -
//prototip funkcije
char id[5]; char buffer[81]; //privremeno skladisti ime double bal; double rt; double amount; cout << endl; cout << "Enter Account ID: "; cin.getline(id, 5); cout << endl; cout << "Enter Account Holder's Name: "; cin.getline(buffer, 81); cout << endl; cout << "Enter Balance: "; cin >> bal; cout << endl; cout << "Enter Interest Rate: "; cin >> rt; Savings_Account acc1(id, buffer, bal, rt); Display_Account(acc1); cout << endl << endl; cout << "Enter an amount to deposit: "; cin >> amount; acc1.Deposit(amount); cout << endl << endl; cout << "A deposit of " << amount << " was made."; Display_Account(acc1); acc1.Calc_Interest(); cout << endl << endl; cout << "Interest was applied to the account."; Display_Account(acc1); cout << endl << endl; cout << "Name: " << acc1.Get_Name();
- 224 -
cout << endl << endl; cout << "Enter an amount to withdraw: "; cin >> amount; if (acc1.Withdraw(amount)) { cout << endl << endl; cout << "A withdrawal of " << amount << " was made."; } else { cout << endl << endl; cout << "WITHDRAWAL NOT MADE: Insufficient funds."; } cout << endl << endl; cout << "Name: " << acc1.Get_Name(); Display_Account(acc1); cout << endl; return 0; } void Display_Account(Savings_Account acc) { cout << endl << endl; cout << "Data for Account# " << acc.Get_Id(); cout << endl << endl; cout << "Owner's Name: " << acc.Get_Name(); cout << endl << endl; cout << "Account Balance: " << acc.Get_Balance(); }
- 225 -
- 226 -
Treba obratiti pažnju da odmah pre nego što Display_Account() prikaže liniju, program prikazuje poruku iz konstruktora kopije. Konstruktor kopije se izvršava kada se parametar u Display_Account() inicijalizuje na vrednost rauna koji se prosleuje funkciji. Kada se funkcija završava, parametri funkcije, koji su Savings_Account objekti, izlaze iz dosega. Sledi, parametri se uništavaju i destruktori klase izvršavaju, što prouzrokuje prikaz poruke destruktora. Šta se dogaa ako programer ne obezbedi konstruktor kopije i umesto toga se osloni na difolt konstruktor kopije? Kada se funkcija Display_Account() poziva po prvi put, difolt konstruktor e napraviti kopiju (lan po lan) argumenta i smestiti je u parametar funkcije. Zbog toga e name lan parametra pokazivati na isti hip prostor argumenta. Problem nastaje kada se funkcija završava zbog toga što se destruktor klase izvršava. Ovo prouzrokuje da se prostor na koji pokazuje parametrov name lan dealocira. Ali ovo je isti prostor na koji pokazuje argumentov name lan. Rezultat je da argumentov name lan pokazuje na nezaštieni hip prostor - tj. prostor koji može biti ponovo korišen od strane sistema.
Napomena u vezi pitanja kada koristiti konstruktor kopije: -Kada se jedan objekat kreira od postojeeg objekta te klase kroz inicijalizaciju. -Jedan objekat se prosleuje po vrednosti funkciji. -Privremena kopija jednog objekta se kreira da bi držala return vrednost objekta u funkciji koja vraa objekat te klase.
- 227 -
Kada se konstruktor kopije ne koristi: -Kada se objekat dodeljuje drugom objektu iste klase. Pokazivai na objekte Možete da deklarišete pokaziva na objekat na isti nain kao da deklarišete pokaziva na bilo koji tip. Na primer, posmatrajmo Test_Class: class Test_Class { private: int n; public: Test_Class(int i = 0); //konstruktor sa jednim argumentom sa //default-nom vrednosšu int Get_Value() const; void Change_Value(int); };
U funkciji main(), možemo da nainimo sledee deklaracije, koje su ilustrovane na donjoj slici. Test_Class tc_object(5); Test_Class* tc_p = &tc_object;
Metodi se mogu primeniti na ciljni objekat koristei operator indirektnog pristupa lanu -> koji se koristi i za pokazivae kod struktura. Dakle, tc_p -> Get_Value() primenjuje Get_Value() metod na cilj tc_p. Podsetimo se da tc_p -> Get_Value() je ekvivalentno (*tc_p).Get_Value(). Podsetimo se da mora da koristimo zagrade oko *tc_p zato što taka operator ima vei prioritet od operatora dereferenciranja *.
- 228 -
Sledei kod prikazuje vrednost cilja tc_p pokazivaa, menja vrednost cilja na 7, i prikazuje novu vrednost cout << "The value of the object is " << tc_p -> Get_Value(); tc_p -> Change_Value(7); cout << end; cout << "\nThe new value of the object is " << tc_p -> Get_Value();
U sledeem programu koristimo pokaziva na objekat da bi prikazali vrednost objekta, promenili njegovu vrednost i zatim prikazali novu. //Ovaj program prikazuje koriscenje pokazivaca na objekte //i koriscenje operatora -> za poziv metoda. #include using namespace std; class Test_Class { private: int n; public: Test_Class(int i = 0); //Konstruktor sa jednim argumentom i //default-nom vrednoscu int Get_Value() const; void Change_Value(int); }; Test_Class::Test_Class(int i) { n = i; cout << endl << endl; cout << "Constructor Executed: Data member initialized to " << n << endl; } int Test_Class::Get_Value() const { return n; }
- 229 -
void Test_Class::Change_Value(int i) { n = i; } int main() { Test_Class tc_object(5); Test_Class* tc_p = &tc_object; cout << "The value of the object is " << tc_p -> Get_Value(); tc_p -> Change_Value(7);
//Promena vrednosti promenljive //na koju pokazivac pokazuje
cout << endl; cout << "The new value of the object is " << tc_p -> Get_Value(); cout << endl; return 0; }
Prosleivanje objekta po pokazivau U prethodnoj sekciji, koristili smo funkciju Display_Account() za prikaz podataka Savings_Account objekta. Sledei program koristi pokazivae u definiciji Display_Account(). //Ovaj program koristi prosirenu verziju Savings_Account. //Program koristi konstruktor sa default argumentima. //ID broj je uskladisten kao niz a ime vlasnika racuna character pointer. //Konstruktor koristi dinamicku alokaciju memorije. //Objekat Savings_Account je prosledjen po pointeru funkciji Display_Account() #include
- 230 -
#include #include using namespace std; class Savings_Account { private: char id_no[5]; char* name; double balance; double rate; public: Savings_Account(char id[], char* n_p, double bal = 0.00, double rt = 0.04); ~Savings_Account(); const char* Get_Id() const; const char* Get_Name() const; double Calc_Interest(); double Get_Balance(); void Deposit(double); bool Withdraw(double); }; Savings_Account::Savings_Account(char id[], char* n_p, double bal, double rt) { strcpy(id_no, id); // kopira prvi argument u „id_no[]“ name = new char[strlen(n_p) + 1]; // kreira prostor za ime strcpy(name, n_p); // kopira drugi argument u novi prostor balance = bal; rate = rt; } Savings_Account::~Savings_Account() { cout << endl << endl; cout << "Account " << id_no << " terminated." << endl; delete [] name; } const char* Savings_Account::Get_Id() const {
- 231 -
return id_no; } const char* Savings_Account::Get_Name() const { return name; } double Savings_Account::Get_Balance() { return balance; } double Savings_Account::Calc_Interest() { double interest; interest = balance * rate; balance += interest; return interest; } void Savings_Account::Deposit(double amount) { balance += amount; } bool Savings_Account::Withdraw(double amount) { bool result; if (amount <= balance) { balance -= amount; result = true; } else result = false; return result; } void Display_Account(Savings_Account*); int main() {
- 232 -
//prototip funkcije
cout << setprecision(2) << setiosflags(ios::fixed) << setiosflags(ios::showpoint); char id[5]; char buffer[81]; //Privremeno skladisti ime double bal; double rt; double amount; cout << "Enter Account ID: "; cin.getline(id, 5); cout << endl; cout << "Enter Account Holder's Name: "; cin.getline(buffer, 81); cout << endl; cout << "Enter Balance: "; cin >> bal; cout << endl; cout << "Enter Interest Rate: "; cin >> rt; Savings_Account acc1(id, buffer, bal, rt); Display_Account(&acc1); cout << endl << endl; cout << "Enter an amount to deposit: "; cin >> amount; acc1.Deposit(amount); cout << endl <
- 233 -
cout << endl << endl; cout << "Name: " << acc1.Get_Name(); cout << endl << endl; cout << "Enter an amount to withdraw: "; cin >> amount; if (acc1.Withdraw(amount)) { cout << endl << endl; cout << "A withdrawal of " << amount << " was made." << endl; } else { cout << endl << endl; cout << "WITHDRAWAL NOT MADE: Insufficient funds." << endl; } cout << endl << endl; Display_Account(&acc1); cout << endl; return 0; } void Display_Account(Savings_Account* acc_p) { cout << endl; cout << "Data for Account# " << acc_p -> Get_Id() << endl << endl; cout << "Owner's Name: " << acc_p -> Get_Name() << endl << endl; cout << "Account Balance: " << acc_p -> Get_Balance(); }
- 234 -
Reference na objekte Mogu se definisati reference na varijable objekta na isti nain kao kada definišete reference na varijable za ugraene (native) tipove podataka. Posmatrajmo sledeu deklaraciju: Savings_Account acc1("1111", "Maxwell Larrabee", 100.00, 0.06); Savings_Account& acc_r = acc1;
Promenljiva acc_r je referenca, odnosno drugo ime za varijablu acc1. Rad sa acc_r je ekvivalentan radu sa acc1. Sledi:
- 235 -
acc_r.Deposit(50.00);
poveava za 50.00 vrednost koja se uplauje za acc1. Prosleivanje objekata po referenci Možemo da prosledimo objekat funkciji po referenci. Posmatramo sledei primer: //Ovaj program koristi prosirenu verziju klase Savings_Account. //Program koristi konstruktor sa default argumentima. //ID broj je uskladisten kao niz a ime vlasnika racuna je //pokazivac na promenljivu tipa karakter. //Konstruktor koristi dinamicku alokaciju memorije. //Savings_Account objekat je prosledjen po referenci funkciji Display_Account() #include #include #include using namespace std; class Savings_Account { private: char id_no[5]; char* name; double balance; double rate; public: Savings_Account(char id[], char* n_p, double bal = 0.00, double rt = 0.04); ~Savings_Account(); const char* Get_Id() const; const char* Get_Name() const; double Calc_Interest(); double Get_Balance(); void Deposit(double); bool Withdraw(double); }; Savings_Account::Savings_Account(char id[], char* n_p, double bal, double rt) { strcpy(id_no, id); // kopira prvi argument u „id_no[]“
- 236 -
name = new char[strlen(n_p) + 1]; //kreira prostor za ime strcpy(name, n_p); //kopira drugi argument u novi prostor balance = bal; rate = rt; } Savings_Account::~Savings_Account() { cout << endl << endl; cout << "Account " << id_no << " terminated." << endl; delete [] name; } const char* Savings_Account::Get_Id() const { return id_no; } const char* Savings_Account::Get_Name() const { return name; } double Savings_Account::Get_Balance() { return balance; } double Savings_Account::Calc_Interest() { double interest; interest = balance * rate; balance += interest; return interest; } void Savings_Account::Deposit(double amount) { balance += amount; } bool Savings_Account::Withdraw(double amount) {
- 237 -
bool result; if (amount <= balance) { balance -= amount; result = true; } else result = false; return result; } void Display_Account(Savings_Account&); int main() { cout << setprecision(2) << setiosflags(ios::fixed) << setiosflags(ios::showpoint); char id[5]; char buffer[81]; //Privremeno skladisti ime double bal; double rt; double amount; cout << "Enter Account ID: "; cin.getline(id, 5); cout << endl; cout << "Enter Account Holder's Name: "; cin.getline(buffer, 81); cout << endl; cout << "Enter Balance: "; cin >> bal; cout << endl; cout << "Enter Interest Rate: "; cin >> rt; Savings_Account acc1(id, buffer, bal, rt); Display_Account(acc1); cout << endl << endl;
- 238 -
//prototip funkcije
cout << "Enter an amount to deposit: "; cin >> amount; acc1.Deposit(amount); cout << endl << endl; cout << "A deposit of " << amount << " was made." << endl; Display_Account(acc1); acc1.Calc_Interest(); cout << endl << endl; cout << "Interest was applied to the account." << endl; Display_Account(acc1); cout << endl << endl; cout << "Name: " << acc1.Get_Name(); cout << endl << endl; cout << "Enter an amount to withdraw: "; cin >> amount; if (acc1.Withdraw(amount)) { cout << endl << endl; cout << "A withdrawal of " << amount << " was made." << endl; } else { cout << endl << endl; cout << "WITHDRAWAL NOT MADE: Insufficient funds." << endl; } cout << endl << endl; Display_Account(acc1); cout << endl; return 0; } void Display_Account(Savings_Account& acc) { cout << endl; cout << "Data for Account# " << acc.Get_Id() << endl << endl; cout << "Owner's Name: " << acc.Get_Name() << endl << endl;
- 239 -
cout << "Account Balance: " << acc.Get_Balance(); }
- 240 -
9.5 Dinamika alokacija objekata Podsetimo se da celi brojevi, realni brojevi dvostruke preciznosti i drugi ugraeni objekti podataka mogu biti kreirani i uništeni dinamiki koristei new i delete operatore. Takoe možemo da koristimo ove operatore za dinamiko kreiranje i uništavanje objekata. Objekti mogu dinamiki da se alociraju koristei operator new. Na primer: Test_Class* t_p = new Test_Class(5); Savings_Account* acc_p = new Savings_Account("3456", "Smith", 250.00, 0.062);
Prva naredba deklariše Test_Class pokaziva i postavlja ga da je jednak adresi Test_Class objekta sa podatkom lanom ija je vrednost 5. Konstruktor sa jednim argumentom se poziva kada se objekat kreira u hip memoriji pomou new operatora. Druga naredba deklariše Savings_Account pokaziva i postavlja ga da je jednak adresi od Savings_Account objekta sa ID brojem 3456, name - Smith, balance - $250.00, i rate - 0.062. Konstruktor sa 4 argumenta se poziva kada se objekat kreira na hipu koristei new operator. Pretpostavimo da želimo da napišemo program koji pita korisnika da kreira do 10 Savings_Account objekata. Jedan nain da se reši problem je da se deklariše niz od 10 Savings_Account objekata, od kojih ni jedan nije inicijalizovan sa znaajnim podacima. Kada korisnik odlui da kreira raun, program popunjava sledei iskoristljivi account objekat podacima. Ovaj pristup vredi ali troši memoriju. Svaki od Savings_Account objekata zahteva najmanje 25 bajtova glavne memorije bez hip memorije potrebne za skladištenje imena vlasnika rauna. Ako korisnik odlui da kreira samo tri rauna, drugih sedam Savings_Account objekata okupirae 175 bajtova, koji e ostati neiskorišeni. Umesto korišenja niza od 10 Savings_Account objekata, možemo da koristimo niz od 10 pokazivaa na Savings_Account objekte. Ovaj pristup koristi samo onoliko Savings_Account objekata koliko je potrebno, izbegavajui gubljenje prostora kao kod prvog pristupa.
- 241 -
Sledi program koji ilustruje korišenje niza pokazivaa na objekte. //Ovaj program ilustruje koriscenje dinamicki alociranih objekata. #include #include #include #include using namespace std; class Savings_Account { private: char id_no[5]; char* name; double balance; double rate; public: Savings_Account(char id[], char* n_p, double bal = 0.00, double rt = 0.04); ~Savings_Account(); const char* Get_Id() const; const char* Get_Name() const; double Calc_Interest(); double Get_Balance(); void Deposit(double); bool Withdraw(double); }; Savings_Account::Savings_Account(char id[], char* n_p, double bal, double rt) { strcpy(id_no, id); //kopira prvi argument id_no[] name = new char[strlen(n_p) + 1]; //kreira prostor za ime strcpy(name, n_p); //kopira drugi argument u novi prostor balance = bal; rate = rt; } Savings_Account::~Savings_Account() { cout << endl << endl; cout << "Account " << id_no << " terminated." << endl;
- 242 -
delete [] name; } const char* Savings_Account::Get_Id() const { return id_no; } const char* Savings_Account::Get_Name() const { return name; } double Savings_Account::Get_Balance() { return balance; } double Savings_Account::Calc_Interest() { double interest; interest = balance * rate; balance += interest; return interest; } void Savings_Account::Deposit(double amount) { balance += amount; } bool Savings_Account::Withdraw(double amount) { bool result; if (amount <= balance) { balance -= amount; result = true; } else result = false; return result; }
- 243 -
void Display_Account(Savings_Account&); Savings_Account* Create_Account();
//prototipovi funkcija
int main() { cout << setprecision(2) << setiosflags(ios::fixed) << setiosflags(ios::showpoint); Savings_Account* account_table[10]; int count = 0; char response; cout << endl; cout << "Do you want to create an account?(Y/N): "; response = cin.get(); cin.get(); //Brise ulazne podatke while (toupper(response) == 'Y' && count < 10) { account_table[count] = Create_Account(); ++count; cout << endl; cout << "Do you want to create an account?(Y/N): "; response = cin.get(); cin.get(); //Brise ulazne podatke } //Prikaz racuna for (int i = 0; i < count; ++i) Display_Account(*account_table[i]); //Brisanje for (i = 0; i < count; ++i) delete account_table[i]; cout << endl; return 0; } void Display_Account(Savings_Account& acc) { cout << endl << endl << endl; cout << "Data for Account# " << acc.Get_Id() << endl << endl;
- 244 -
cout << "Owner's Name: " << acc.Get_Name() << endl << endl; cout << "Account Balance: " << acc.Get_Balance(); } Savings_Account* Create_Account() { char id[5]; char buffer[81]; double bal; double rt; Savings_Account* acc_ptr; cout << endl; cout << "Enter Account ID: "; cin.getline(id, 5); cout << endl; cout << "Enter Account Holder's Name: "; cin.getline(buffer, 81); cout << endl; cout << "Enter Balance: "; cin >> bal; cout << endl; cout << "Enter Interest Rate: "; cin >> rt; cin.get(); //Brise newline karakter iz ulaznog buffer-a acc_ptr = new Savings_Account (id, buffer, bal, rt); return acc_ptr; }
- 245 -
Identifikator account_table[i] je pokaziva na Savings_Account objekat. Funkcija Display_Account() zahteva ime Savings_Account objekta kao argument zato što je njegov argument Savings_Account referenca.
- 246 -
9.6 Statiki podaci lanovi i funkcije Statiki podaci lanovi Static data member (statiki podatak lan) za datu klasu je nezavisna instanca, što znai da bez obzira koliko class objekata je kreirano u programu, postoji samo jedna kopija static data member. Zbog toga, njena vrednost je nezavisna od postojanja bilo kog objekta. Ako deklarišemo lan rate klase Savings_Account da je static, svi Savings_Account objekti e deliti ovu jednu vrednost. Ako promenimo vrednost rate, svi Savings_Account objekti e koristiti ovu novu vrednost automatski. Kako statiki podatak lan postoji nezavisno od bilo kog objekta, kada se on kreira tako dobija vrednost. Kao sve static promenljive (bilo da su lanovi klase ili ne), static podatak lan klase se kreira za vreme kompajliranja, pre izvršenja main() funkcije i prima poetnu vrednost nula. Kada deklarišemo podatak lan kao static u deklaraciji klase, to je samo deklaracija, ne definicija. (Kod deklaracije klase ne može da se dodeli vrednost class data lanu.) Zbog toga mora da definišemo lan kao static lan i, ako je neophodno, dati poetnu vrednost izvan definicije klase. Sledi deklaracija klase Savings_Account sa rate data member koji je deklarisan kao static: class Savings_Account { private: char id_no[5]; char* name;
- 247 -
double balance; static double rate; //rate se deklarise kao staticka promenljiva public: Savings_Account(char id[], char* n_p, double bal = 0.00); ~Savings_Account(); const char* Get_Id() const; const char* Get_Name() const; double Calc_Interest(); double Get_Balance(); void Deposit(double); int Withdraw(double); }; //Definicija tipa podatka clana klase kao static double Savings_Account::rate = 0.040;
Treba obratiti pažnju da rate još uvek ostaje private. Takoe, kada definišemo rate izvan definicije klase, ne koristimo kljunu re static ponovo i mora da okvalifikujemo ime imenom klase koristei operator razrešenja dosega. Konano, mora takoe da promenimo deklaraciju konstruktora. Više ne mora da se ukljuuje rate u konstruktor zato što e svi objekti sada da koriste zajedniki static rate lan. Statiki metodi Za pristup statikom podatku lanu, treba da se koristi statiki metod. Sledi druga deklaracija klase Savings_Account koja ukljuuje statiki podatak lan number_accounts, nove definicije konstruktora, destruktora i definicija statikog metoda Total_Accounts(). Treba obratiti pažnju da se u definiciji Total_Accounts(), ne koristi rezervisana re static. class Savings_Account { private:
- 248 -
char id_no[5]; char* name; double balance; static double rate; static int number_accounts; public: Savings_Account(char id[], char* n_p, double bal = 0.00); ~ Savings_Account(); const char* Get_Id() const; const char* Get_Name() const; double Calc_Interest(); double Get_Balance(); void Deposit(double); bool Withdraw(double); static int Total_Accounts(); //static tip metoda }; // Definicije tipa podatka clana klase kao static double Savings_Account::rate = 0.040; int Savings_Account::number_accounts = 0; Savings_Account:: Savings_Account(char id[], char* n_p, double bal) { strcpy(id_no, id); //kopira prvi argument u id_no[] name = new char[strlen(n_p) + 1]; //kreira prostor za ime strcpy(name, n_p); //kopira drugi argument u novi prostor balance = bal; ++number_accounts; } Savings_Account::~ Savings_Account() { cout << endl << endl; cout << "Account " << id_no << " terminated." << endl; delete [] name; --number_accounts; cout << endl; cout << "Number Accounts Remaining: " << number_accounts << endl; }
- 249 -
int Savings_Account::Total_Accounts() { return number_accounts; }
Statiki metod, kao i statiki podatak lan, je nezavisna instanca. To znai da može da se izvrši nezavisno od bilo kog objekta u klasi. Da biste izvršili takav metod, morate da povežete ime metoda sa imenom klase i operatorom razrešenja dosega, kao u sledeem primeru. cout << "Number Existing Accounts: " << Savings_Account::Total_Accounts() << endl;
Sledi program koji ilustruje korišenje statikih podataka lanova i statikih metoda. //Program ilustruje koriscenje static data clanova i funkcija. #include #include #include #include using namespace std; class Savings_Account { private: char id_no[5]; char* name; double balance; static double rate; //static clan static int number_accounts; //static clan public: Savings_Account(char id[], char* n_p, double bal = 0.00); ~Savings_Account(); const char* Get_Id() const; const char* Get_Name() const; double Calc_Interest(); double Get_Balance(); void Deposit(double); bool Withdraw(double); static int Total_Accounts(); //deklaracija metoda kao static };
- 250 -
//Static data member definitions double Savings_Account::rate = 0.040; int Savings_Account::number_accounts = 0; Savings_Account::Savings_Account(char id[], char* n_p, double bal) { strcpy(id_no, id); //kopira prvi argument u id_no[] name = new char[strlen(n_p) + 1]; //kreira prostor za ime strcpy(name, n_p); //kopira drugi argument u novi prostor balance = bal; ++number_accounts; } Savings_Account::~Savings_Account() { cout << endl << endl; cout << "Account " << id_no << " terminated." << endl; delete [] name; --number_accounts; cout << endl; cout << "Number Accounts Remaining: " << number_accounts << endl; } const char* Savings_Account::Get_Id() const { return id_no; } const char* Savings_Account::Get_Name() const { return name; } double Savings_Account::Get_Balance() { return balance; } double Savings_Account::Calc_Interest()
- 251 -
{ double interest; interest = balance * rate; balance += interest; return interest; } void Savings_Account::Deposit(double amount) { balance += amount; } bool Savings_Account::Withdraw(double amount) { bool result; if (amount <= balance) { balance -= amount; result = true; } else result = false; return result; } int Savings_Account::Total_Accounts() { return number_accounts; } void Display_Account(Savings_Account&); Savings_Account* Create_Account(); int main() { cout << setprecision(2) << setiosflags(ios::fixed) << setiosflags(ios::showpoint); Savings_Account* account_table[10]; int count = 0; char response; cout << endl;
- 252 -
//prototipovi funkcija
cout << "Do you want to create an account?(Y/N): "; response = cin.get(); cin.get(); //Prazni ulazni bafer while (toupper(response) == 'Y' && count < 10) { account_table[count] = Create_Account(); account_table[count] -> Calc_Interest(); ++count; cout << endl; cout << "Do you want to create an account?(Y/N): "; response = cin.get(); cin.get(); //Prazni ulazni bafer } //Prikaz racuna for (int i = 0; i < count; ++i) Display_Account(*account_table[i]); //Brisanje for (i = 0; i < count; ++i) delete account_table[i]; cout << endl; return 0; } void Display_Account(Savings_Account& acc) { cout << endl << endl << endl; cout << "Data for Account# " << acc.Get_Id() << endl << endl; cout << "Owner's Name: " << acc.Get_Name() << endl << endl; cout << "Current Account Balance: " << acc.Get_Balance(); } Savings_Account* Create_Account() { char id[5]; char buffer[81]; double bal; Savings_Account* acc_ptr; cout << endl; cout << "Enter Account ID: ";
- 253 -
cin.getline(id, 5); cout << endl; cout << "Enter Account Holder's Name: "; cin.getline(buffer, 81); cout << endl; cout << "Enter Balance: "; cin >> bal; cin.get(); //Brise ulazni bafer sa karakterom za novi red acc_ptr = new Savings_Account (id, buffer, bal); cout << endl << endl; cout << "Number Existing Accounts: " << Savings_Account::Total_Accounts() << endl; return acc_ptr; }
- 254 -
- 255 -
10. Nasleivanje Jedan od najvažnijih koncepata u objektno orijentisanom programiranju je nasleivanje. Nasleivanje dozvoljava da definišemo klasu u odnosu na druge klase, što ini lakšim kreiranje i održavanje jedne aplikacije. Poinjemo sa nekoliko primera. 10.1 Primeri nasleivanja i osnovna terminologija Do sada smo razmatrali probleme koji sadrže samo jednu klasu. Uopšteno govorei, problemi iz "realnog života" ukljuuju više klasa. Mogue je da neke klase u problemu nisu direktno povezane u smislu da ne dele bilo koji lan podatak ili metod. Na primer, ako rešavamo problem crtanja geometrijskih slika, možemo da definišemo klase Rectangle i Circle na takav nain da one nemaju bilo kakve zajednike lanove podatke ili zajednike metode. Pravougaonik se opisuje svojom dužinom i širinom, a krug poluprenikom. Svaka klasa ima svoje sopstvene metode za izraunavanje površine i obima: Area(), Perimeter(), ... Meutim, postoje klase koje su povezane hijerarhijski od opštih klasa ka specifinim. Takva hijerarhija primenjuje relaciju "je" u smislu da jedan objekat klase koja je ispod druge klase u hijerarhiji "je" tipa objekat u klasi iznad. Na primer, u bankarskim aplikacijama mogu postojati tri vrste kamatnih rauna: savings accounts - štedni rauni, money market accounts - rauni na tržištu novca i certificates of deposit (CD) - sertifikati o ulaganju. Svaki tip rauna "je" baziran na kamati, za razliku od tekueg rauna koji ne zavisi od kamate. Tri tipa rauna imaju zajednike atribute. Na primer, sva tri tipa rauna imaju identifikacioni broj ID number, ime vlasnika name, stanje balance, i kamatnu stopu interest rate. Tri tipa rauna takoe imaju iste zajednike metode. Na primer, svi imaju metod za proraun kamate Calc_Interest(). Mada, svi imaju metod Withdraw(), svaka verzija klase za dati metod se ponaša drugaije. Na primer, preuranjeno podizanje novca sa CD-a zahteva da banka koristi zatezne kamate. Tri tipa rauna mogu da definišu kao odvojene klase, svaka sa svojim sopstvenim ID number, name, balance i interest rate, ali svaka je specijalna verzija opšteg tipa rauna interest-bearing (raun baziran na kamati). Bolje je program dizajnirati da koristi klase hijerarhijski kao na slici. Veza izmeu klasa u ovakvoj hijerarhiji, gde se klase definišu iz osnovne klase, od opštih ka posebnim klasama, poznata je kao nasleivanje. Klasa
- 256 -
Interest_Bearing_Account je poznata kao osnovna klasa (roditelj klasa ili super
klasa). Klase ispod osnovne u hijerarhiji su izvedene klase (dete klase ili podklase). Klase mogu biti direktno i indirektno izvedene.
Kada
deklarišemo
takvu
hijerarhiju
klasa
u
programu,
Interest_Bearing_Account e ukljuiti ID number, name, balance, i rate lanove (što
je prikazano sa desne strane klase na donjoj slici). Izvedena klasa nasleuje ove lanove iz osnovne klase. Mi deklarišemo u izvedenoj klasi samo one lanove koji su specifini za tu klasu. Definisanje izvedenih klasa Zbog jednostavnosti, prvo radimo sa klasom Test_Class iz prethodnog poglavlja. Želimo da klasa Test_Class služi kao osnovna klasa za izvedenu klasu Derived_Test_Class, koja takoe ima samo jedan podatak m.
Sledi definicija klase Test_Class iz prethodnog poglavlja. Uklonili smo metod Get_Value() da bi klasa bila što jednostavnija.
- 257 -
class Test_Class { private: int n; public: Test_Class(int i = 0); Test_Class(Test_Class&); ~Test_Class(); };
//Konstruktor sa jednim argumentom //Konstruktor kopije //Destruktor
Kao što smo napomenuli u prethodnoj sekciji, bilo koja klasa koju smo izveli iz Test_Class nasleuje sve primerke varijabli klase Test_Class, ukljuujui i privatne lanove i veinu metoda. Zbog toga, Derived_Test_Class objekat e imati n primerak varijable. Meutim, kako je n privatan lan klase Test_Class, nije dostupan bilo kojoj funkciji izvan Test_Class. Sledi da mada Derived_Test_Class objekat ima primerak varijable n u smislu nasleivanja, objekat nema pristup toj varijabli. Nepraktino je da objekat nema pristup jednom od svojih lanova. Ovo možemo da ispravimo deklarisanjem nove kategorije pristupa protected za primerak varijable n klase Test_Class. lan u osnovnoj klasi, bez obzira da li je instanca promenljive ili metoda, koji ima kategoriju pristupa protected ponaša se kao da je private lan za sve funkcije osim za metode iz klasa izvedenih iz osnovne klase. Metodi u izvedenoj klasi imaju pristup svim protected lanovima u osnovnoj klasi. Specifikator pristupa protected Zaštien primerak u osnovnoj klasi se ponaša kao da je privatan (private) za sve funkcije, osim za metode u klasama koje su izvedene iz osnovne klase. Metodi u izvedenoj klasi imaju pristup svim zaštienim (protected) lanovima u osnovnoj klasi. Tabela prikazuje pristupe osnovnoj i izvedenim klasama za lanove klase koji su public, protected i private. Ako je lan osnovne klase Pristup preko metoda izvedene klase Pristup preko metoda koji ne pripada ni osnovnoj ni izvedenoj klasi
public DA
protected DA
private NE
DA
NE
NE
- 258 -
Prema tome, ako želimo da metodi klase Derived_Test_Class imaju pristup primerku varijable n klase Test_Class, mora da promenimo kategoriju pristupa za n na protected. class Test_Class { protected: //Podaci kojima se može pristupiti u izvedenim klasama int n; public: Test_Class(int i = 0); //Konstruktor sa jednim argumentom Test_Class(Test_Class&); //Konstruktor kopije ~Test_Class(); };
Kako
da napišemo kod koji prikazuje injenicu da je Derived_Test_Class izvedena iz Test_Class? Da biste definisali Derived_Test_Class kao izvedenu iz Test_Class, prvo pišemo ime izvedene klase, pa dvotaku, pa rezervisanu re public i ime osnovne klase. class Derived_Test_Class : public Test_Class { protected: int m; public: Derived_Test_Class(int j = 0); Derived_Test_Class(Derived_Test_Class&); ~Derived_Test_Class(); };
U ovom sluaju kljuna re public znai da smo javno izveli ovu klasu iz osnovne klase. Javno izvoenje znai da se protected i public lanovi osnovne klase posmatraju kao protected i public lanovi izvedene klase. Default tip izvoenja je private, a ne public. Sledi, ako zanemarimo rezervisanu re public, izvedena klasa bie privatno izvedena iz osnovne klase. Dobra je praksa da ukljuujemo re public ili private a da ne koristimo default. Koristimo public izvoenje ako želimo da korisnici izvedene klase imaju pristup public metodima osnovne klase. Koristimo private izvoenje, ako želimo da blokiramo korisnike izvedene klase od korišenja public metoda osnovne klase. Da biste izveli klasu iz osnovne klase, u deklaraciji izvedene klase, nakon imena izvedene klase sledi zapeta pa onda kljuna re
- 259 -
public ili private, i ime osnovne klase. Tabela prikazuje mogunost pristupa pri public i private izvoenju.
Kategorija pristupa lanu osnovne klase private protected public
Javno izvedena klasa osnovne klase - Pristup lanovima kod javnog nasleivanja private protected public
Privatno izvedena klasa osnovne klase - Pristup lanovima kod privatnog nasleivanja private private private
U srednjoj koloni (javno izvedena klasa), primerak promenljive ili metoda ima istu kategoriju pristupa kao i u osnovnoj klasi. U privatno izvedenoj klasi (desna kolona), svi primerci promenljivih i funkcija su private, bez obzira koja im je kategorija pristupa u osnovnoj klasi. Na primer, posmatrajmo hijerarhiju klase sa donje slike. Promenljiva a1 je public primerak promenljive osnovne klase Class_A. Nasleivanjem, primerak promenljive a1 je takoe primerak promenljive Class_B. Šta je kategorija pristupa primerka promenljive a1 kao lana Class_B? Prema prethodnoj tabeli, zato što je Class_B javno izvedena iz Class_A, promenljiva a1 je takoe public promenljiva klase Class_B. S druge strane, promenljiva a1, nasleivanjem, je takoe primerak promenljive Class_C. Meutim, iz treeg reda tabele sledi da je a1 private lan Class_C zato što je Class_C privatno izvedena iz Class_A. Dva primerka varijable Class_C, c1 (koja je public u Class_C) i izvedena a1 (koja je private u Class_C) su nasleene u Class_D. Zbog toga, c1 je public lan i a1 je private lan Class_D zato što je Class_D javno izvedena iz Class_C. Promenljivoj a1, kao privatnom lanu Class_C, ne može se pristupiti metodima Class_D.
- 260 -
Treba obratiti pažnju da smo primerak promenljive m izvedene klase Derived_Test_Class definisali kao protected. Ovo omoguava da, ako smo izveli klasu iz Derived_Test_Class, lanu m moi e da se pristupi kao protected lanu svih javno izvedenih klasa. Konstruktori u izvedenoj klasi Izvedene klase nasleuju sve metode osnovne klase osim: -konstruktora i konstruktora kopije -destruktora -preklopljenih operatora -prijateljskih funkcija Sledi, mora da obezbedimo izvedene konstruktore, konstruktore kopija i destruktore date klase. Oni se ne nasleuju. Kada kreiramo objekat dtc_object, klase Derived_Test_Class, objekat ima dva primerka promenljivih. Ima n, lan nasleen iz Test_Class i m, lan iz Derived_Test_Class.
Pretpostavimo
da
želimo
da
sledea
deklaracija
kreira
Derived_Test_Class objekat sa m primerkom promenljive ija je vrednost 7 i n primerkom promenljive sa vrednošu 8. Derived_Test_Class dtc_object1(7);
Kada kreiramo objekat klase Derived_Test_Class, takoe kreiramo objekat klase Test_Class. Ovo je zato što Derived_Test_Class objekat "je" Test_Class objekat. Konstruktor za Derived_Test_Class se takoe izvršava. U stvari, konstruktor za Test_Class se izvršava pre konstruktora za Derived_Test_Class zato što objekat mora da dobije svoj identitet kao Test_Class objekat pre nego što dobije svoj identitet kao Derived_Test_Class objekat. Definicija konstruktora za Derived_Test_Class reflektuje ovo. Derived_Test_Class::Derived_Test_Class(int j) : Test_Class(j+1) { m = j;
- 261 -
cout << endl; cout << "Derived_Test_Class Constructor Executed: " << "Data member initialized to " << m << endl; }
Nakon zagrade zatvaranja u hederu definicije konstruktora je dvotaka nakon koje sledi eksplicitni poziv konstruktora sa jednim argumentom osnovne klase. Ovo se zove inicijalizaciona lista. Primerci na ovoj listi konstruktora se izvršavaju kako se objekat kreira. Tako, akt kreiranja Derived_Test_Class objekta sa poetnom vrednošu j prouzrokuje da se konstruktor sa jednim argumentom osnovne klase izvršava sa poetnom vrednošu od j+1. Ovo e prouzrokovati kreiranje Test_Class objekta sa n primerkom promenljive koja ima vrednost j+1. Ovo se dešava pre izvršenja tela Derived_Test_Class konstruktora. Konstruktor za izvedenu klasu treba eksplicitno da pozove konstruktor osnovne klase. Poziv konstruktora osnovne klase je u inicijalizacionoj listi. Inicijalizaciona lista nije ograniena na poziv konstruktora osnovne klase. Možemo je koristiti u bilo kom konstruktoru za inicijalizaciju podataka lanova. Na primer, daemo definiciju Test_Class konstruktora koji smo koristili ranije: Test_Class::Test_Class(int i) { n = i; cout << endl; cout << "Test_Class Constructor Executed: Data member initialized to " << n << endl; }
Kada deklarišemo Test_Class objekat, objekat je kreiran sa jednim primerkom promenljive n koja ima nedefinisanu vrednost. Kada se konstruktor izvršava, naredba dodele u konstruktor smešta vrednost i (ili default vrednost 0) u n, kada n nema validnu vrednost. Sledea definicija Test_Class konstruktora koristi inicijalizacionu listu da bi smestila vrednost i u n. Test_Class::Test_Class(int i) : n(i) {
- 262 -
cout << endl; cout << "Test_Class Constructor Executed: Data member initialized to " << n << endl; }
Napomena, operator dodele se ne koristi na inicijalizacionoj listi. Izraz n(i) inicijalizuje vrednost n na i. Sa takvom inicijalizacionom listom kada se objekat Test_Class kreira, primerak varijable n se kreira sa vrednošu i. Sledi, primerak varijable n uvek ima validnu vrednost. Ne postoji vreme za koje n ima nedefinisanu vrednost. Kako je ovo bezbednije i efikasnije za inicijalizaciju podatka lana u konstruktoru, uradiemo ovo u sledeim programima. Ako primenimo ovo na Derived_Test_Class konstruktor, imaemo: Derived_Test_Class::Derived_Test_Class(int j) : Test_Class(j+1), m(j) { cout << endl; cout << "Derived_Test_Class Constructor Executed: " << "Data member initialized to " << m << endl; }
Inicijalizaciona lista za konstruktor sadrži dve naredbe odvojene zapetom. Prva naredba je eksplicitni poziv konstruktora osnovne klase, a druga je inicijalizacija m podatka lana na vrednost j. Destruktor u izvedenoj klasi Kada se jedan objekat izvedene klase (Derived_Test_Class) uništava, takoe uništavamo objekat osnovne klase (Test_Class) zato što, na osnovu nasleivanja, objekat izvedene klase je takoe i objekat osnovne klase (Test_Class). Kada se destruktor za izvedenu klasu izvršava, destruktor za osnovnu klasu takoe treba da se izvrši. Meutim, destruktor za izvedenu klasu treba da se izvrši pre destruktora za osnovnu klasu. Za razliku od toga šta mora da uradimo za konstruktore, ne treba da uradimo ništa specijalno u kodu destruktora da bi sistem pozvao destruktor osnovne klase. C++ sistem radi ovo automatski, kao u sledeem primeru: //Ovaj program ilustruje kako se konstruktori i destruktori izvršavaju //u osnovnoj klasi.
- 263 -
#include using namespace std; class Test_Class { protected: int n; public: Test_Class(int i = 0); //Konstruktor sa jednim argumentom ~Test_Class(); }; Test_Class::Test_Class(int i) : n(i) { cout << endl; cout << "Test_Class Constructor Executed: Data member initialized to " << n << endl; } Test_Class::~Test_Class() { cout << endl; cout << "Test_Class Destructor Executed for object with data member " << n << endl; } class Derived_Test_Class : public Test_Class { protected: int m; public: Derived_Test_Class(int j = 0); ~Derived_Test_Class(); }; Derived_Test_Class::Derived_Test_Class(int j) : Test_Class(j+1), m(j) { cout << endl; cout << "Derived_Test_Class Constructor Executed: " << "Data member initialized to " << m <
- 264 -
Derived_Test_Class::~Derived_Test_Class() { cout << endl; cout << "Derived_Test_Class Destructor Executed " << "for object with data member " << m << endl; } int main() { cout << "Test_Class object being created:" << endl; Test_Class tc_object1(4); cout << endl; cout << "Derived_Test_Class object being created:" << endl; Derived_Test_Class dtc_object1(7); return 0; }
Treba obratiti pažnju na redosled izvršavanja konstruktora. Kada se kreira objekat tc_object1 klase Test_Class, konstruktor osnovne klase Test_Class se izvršava. Kada se kreira Derived_Test_Class objekat dtc_object1, Derived_Test_Class konstruktor se poziva. Meutim, pre nego što se bilo koja njegova naredba izvrši, poziva se konstruktor osnovne klase, Test_Class(). Nakon izvršenja i prikaza poruke, Test_Class konstruktor se završava. U toj taki telo konstruktora za Derived_Test_Class se izvršava i prikazuje svoju poruku. Kada se program završava, objekti se uništavaju obrnutim redosledom u odnosu na kreiranje. Zbog toga, dtc_object1 se prvo uništava. Destruktor za Derived_Test_Class se izvršava, a zatim se destruktor za
- 265 -
Test_Class izvršava. Konano, Test_Class objekat tc_object1 se uništava, Test_Class destruktor za ovaj objekat se izvršava.
Konstruktor kopije u izvedenoj klasi Ako izvedena klasa ima konstruktor kopije, on treba da bude tretiran na isti nain kao obian konstruktor. Zbog toga, definicija konstruktora kopije izvedene klase treba da pozove konstruktor kopije osnovne klase na inicijalizacionoj listi. Sledi primer: //Ovaj program ilustruje konstruktor kopije u izvedenoj klasi. #include using namespace std; class Test_Class { protected: int n; public: Test_Class(int i = 0); //Konstruktor sa jednim argumentom Test_Class(const Test_Class &); //Konstruktor kopije ~Test_Class(); }; Test_Class::Test_Class(int i) : n(i) { cout << endl; cout << "Test_Class Constructor Executed: Data member initialized to " << n << endl; } Test_Class::Test_Class(const Test_Class & tc_r) : n(tc_r.n) { cout << endl; cout << "Test_Class Copy constructor executed: " << "Data member initialized to " << n << endl; } Test_Class::~Test_Class() { cout << endl; cout << "Test_Class Destructor Executed for object with data member " << n << endl; }
- 266 -
class Derived_Test_Class : public Test_Class { protected: int m; public: Derived_Test_Class(int j = 0); Derived_Test_Class(const Derived_Test_Class &); ~Derived_Test_Class(); }; Derived_Test_Class::Derived_Test_Class(int j) : Test_Class(j+1), m(j) { cout << endl; cout << "Derived_Test_Class Constructor Executed: " << "Data member initialized to " << m << endl; } Derived_Test_Class::Derived_Test_Class(const Derived_Test_Class & dtc_r) : Test_Class(dtc_r), m(dtc_r.m) { cout << endl; cout << "Derived_Test_Class Copy constructor executed: " << "Data member initialized to " << m << endl; } Derived_Test_Class::~Derived_Test_Class() { cout << endl; cout << "Derived_Test_Class Destructor Executed " << "for object with data member " << m << endl; } int main() { Derived_Test_Class dtc_object1(7); Derived_Test_Class dtc_object2 = dtc_object1; cout << endl; return 0; }
- 267 -
Kôd za konstruktor kopije slian je kodu za konstruktor. Treba obratiti pažnju da u definiciji konstruktora kopije za Test_Class, koristimo izraz n(tc_r.n) u inicijalizacionoj listi. Ovo inicijalizuje n primerak promenljive objekta koja je inicijalizovana na vrednost n primerka promenljive objekta koji je na desnoj strani inicijalizacije. Definicija konstruktora kopije za Derived_Test_Class poziva konstruktor kopije, Test_Class(dtc_r), na svojoj inicijalizacionoj listi i inicijalizuje m primerak varijable objekta koji je bio incijalizovan na vrednost m primerka promenljive na desnoj strani inicijalizacije, m(dtc_r.m). Važan je redosled izvršenja konstruktora i destruktora. Program prvo deklariše Derived_Test_Class objekat dtc_object1. Zatim se konstruktor za Test_Class izvršava. Nakon toga izvršava se konstruktor za Derived_Test_Class. Sledee, program deklariše i inicijalizuje Derived_Test_Class objekat dtc_object2. Kako je objekat inicijalizovan, konstruktor kopije se koristi. Kao i kod obinog konstruktora, konstruktor kopije osnovne klase se izvršava prvo. Odnosno, konstruktor kopije za Test_Class, nakon ega sledi izvršenje konstruktora kopije za Derived_Test_Class. Kada se program završi, destruktori se pozivaju po obrnutom redosledu od kreiranja objekata. Prvo se izvršava destruktor za dtc_object2, zatim se automatski izvršava destruktor za osnovnu klasu Test_Class. Funkcije u hijerarhiji klasa Sve funkcije se nasleuju osim konstruktora, konstruktora kopije, destruktora, preklopljenih operatora i friend funkcija. Ova sekcija opisuje rad sa funkcijama koje se nasleuju.
- 268 -
Nasleivanje funkcija Pretpostavimo da osnovna klasa Test_Class sadrži sledei metod Get_Value(). int Test_Class::Get_Value() { return n; }
Metod Get_Value() nasleuje izvedena klasa Derived_Test_Class. Sledi, možemo da primenimo Get_Value() na bilo koji objekat izvedene klase Derived_Test_Class kao što sledi: Derived_Test_Class dtc_object(7); cout << endl << endl; cout << "The value returned by Get_Value() is " << dtc_object.Get_Value() << endl;
Kada se metod primeni na objekat odgovarajue klase, kompajler proverava da vidi da li je metod, metod te klase. Ako je metod lan klase, kompajler primenjuje metod na objekat. Ako nije, kompajler proverava da vidi da li je metod lan osnovne klase (ako takav postoji) za tu klasu, ako jeste, onda on primenjuje taj metod na objekat, itd. U našem sluaju, kompajler vidi da metod nije lan Derived_Test_Class i gleda u osnovnu klasu Test_Class. Zato što je Get_Value() metod osnovne klase Test_Class, kompajler primenjuje metod osnovne klase Get_Value() na dtc_object. Ima smisla uraditi ovo zato što, u znaenju nasleivanja, dtc_object je takoe Test_Class objekat. Objekat dtc_object ima m primerak promenljive vrednosti 7 i n primerak promenljive vrednosti 8. Tako da e prethodna cout naredba da prikaže: The value returned by Get_Value() is 8
Ovo je prikazano u sledeem programu. //Ovaj program ilustruje kako se funkcija nasledjuje. #include
- 269 -
using namespace std; class Test_Class { protected: int n; public: Test_Class(int i = 0); //Konstruktor sa jednim argumentom ~Test_Class(); int Get_Value(); }; Test_Class::Test_Class(int i) : n(i) { cout << endl; cout << "Test_Class Constructor Executed: Data member initialized to " << n << endl; } Test_Class::~Test_Class() { cout << endl; cout << "Test_Class Destructor Executed for object with data member " << n << endl; } int Test_Class::Get_Value() { return n; } class Derived_Test_Class : public Test_Class { protected: int m; public: Derived_Test_Class(int j = 0); ~Derived_Test_Class(); }; Derived_Test_Class::Derived_Test_Class(int j) : Test_Class(j+1), m(j) { cout << endl; cout << "Derived_Test_Class Constructor Executed: "
- 270 -
<< "Data member initialized to " << m << endl; } Derived_Test_Class::~Derived_Test_Class() { cout << endl; cout << "Derived_Test_Class Destructor Executed " << "for object with data member " << m << endl; } int main() { Derived_Test_Class dtc_object(7); cout << endl; cout << "The value returned by Get_Value() is " << dtc_object.Get_Value(); cout << endl; return 0; }
Overriding (nadjaavanje) metoda Šta se dešava ako i izvedena klasa Derived_Test_Class i osnovna klasa Test_Class imaju svoj sopstveni Get_Value() metod? Posmatrajmo sledei program u kome je definisan metod Get_Value() i u osnovnoj klasi Test_Class i u izvedenoj klasi Derived_Test_Class. //Ovaj program ilustruje nadjacavanje metoda - method overriding. #include using namespace std;
- 271 -
class Test_Class { protected: int n; public: Test_Class(int i = 0); //Konstruktor sa jednim argumentom Test_Class(Test_Class &); //Konstruktor kopije ~Test_Class(); int Get_Value(); }; Test_Class::Test_Class(int i) : n(i) { cout << endl; cout << "Test_Class Constructor Executed: Data member initialized to " << n << endl; } Test_Class::Test_Class(Test_Class & tc_r) : n(tc_r.n) { cout << endl; cout << "Test_Class Copy constructor executed: " << "Data member initialized to " << n << endl; } Test_Class::~Test_Class() { cout << endl; cout << "Test_Class Destructor Executed for object with data member " << n << endl; } int Test_Class::Get_Value() { return n; } class Derived_Test_Class : public Test_Class { protected: int m; public: Derived_Test_Class(int j = 0); Derived_Test_Class(Derived_Test_Class &);
- 272 -
~Derived_Test_Class(); int Get_Value(); }; Derived_Test_Class::Derived_Test_Class(int j) : Test_Class(j+1), m(j) { cout << endl; cout << "Derived_Test_Class Constructor Executed: " << "Data member initialized to " << m << endl; } Derived_Test_Class::Derived_Test_Class(Derived_Test_Class & dtc_r) : Test_Class(dtc_r), m(dtc_r.m) { cout << endl; cout << "Derived_Test_Class Copy constructor executed: " << "Data member initialized to " << m << endl; } Derived_Test_Class::~Derived_Test_Class() { cout << endl; cout << "Derived_Test_Class Destructor Executed " << "for object with data member " << m << endl; } int Derived_Test_Class::Get_Value() { return m; } int main() { Test_Class tc_object(3); Derived_Test_Class dtc_object(7); cout << endl; cout << "The n value of the Test_Class object is " << tc_object.Get_Value() << endl <
- 273 -
Primenjujemo Get_Value() na dva objekta u razliitim klasama. C++ kompajler zna koji Get_Value() metod da koristi po objektu na koji je metod primenjen. U prvom sluaju, Get_Value() se primenjuje na Test_Class objekat. Iz tog razloga, Get_Value() metod iz Test_Class se koristi. U drugom sluaju, Get_Value() se primenjuje na Derived_Test_Class objekat. Zato, Get_Value() metod iz Derived_Test_Class se koristi. Ovo je method overriding; kada se metod primenjuje na objekat u izvedenoj klasi, metod u izvedenoj klasi overrides („nadjaa-pokrije“) metod sa istim imenom i potpisom (tj. isti broj i tipovi argumenata) u osnovnoj klasi. Ako su imena metoda ista i potpisi razliiti, overriding se ne izvršava. Na primer, pretpostavimo da je metod Get_Value() izvedene klase Derive_Test_Class definisan kao što sledi: int Get_Value(int i) { return m + i; }
Onda, poziv metoda dtc_object.Get_Value() koristi Get_Value() metod od Test_Class, a poziv metoda dtc_object.Get_Value(4) koristi Get_Value() metod od Derived_Test_Class. Korišenje operatora razrešenja dosega Pretpostavimo opet da Test_Class i Derived_Test_Class imaju svoje sopstvene metode Get_Value() i da želimo da primenimo Get_Value() metod osnovne klase na Derived_Test_Class objekat da bi pristupili njenom n primerku promenljive.
- 274 -
Da biste primenili Get_Value() metod osnovne klase na objekat u izvedenoj klasi, mora da kvalifikujete ime metoda sa imenom klase nakon koje sledi operator razrešenja dosega "::". Tako, izraz dtc_object.Test_Class::Get_Value()
primenjuje metod Get_Value() osnovne klase Test_Class na dtc_object. Operator razrešenja dosega može takoe da bude korišen za pristup globalnoj varijabli kada postoji lokalna varijabla sa istim imenom. Sledei program prikazuje korišenje operatora razrešenja dosega. //Ovaj program ilustruje operator razresenja dosega #include using namespace std; class Test_Class { protected: int n; public: Test_Class(int i = 0); //Konstruktor sa jednim argumentomr Test_Class(const Test_Class &); //Konstruktor kopije ~Test_Class(); int Get_Value(); }; Test_Class::Test_Class(int i) : n(i) { cout << endl; cout << "Test_Class Constructor Executed: Data member initialized to " << n << endl; } Test_Class::Test_Class(const Test_Class & tc_r) : n(tc_r.n) { cout << endl; cout << "Test_Class Copy constructor executed: " << "Data member initialized to " << n << endl; } Test_Class::~Test_Class() {
- 275 -
cout << endl; cout << "Test_Class Destructor Executed for object with data member " << n << endl; } int Test_Class::Get_Value() { return n; } class Derived_Test_Class : public Test_Class { protected: int m; public: Derived_Test_Class(int j = 0); Derived_Test_Class(const Derived_Test_Class &); ~Derived_Test_Class(); int Get_Value(); }; Derived_Test_Class::Derived_Test_Class(int j) : Test_Class(j+1), m(j) { cout << endl; cout << "Derived_Test_Class Constructor Executed: " << "Data member initialized to " << m << endl; } Derived_Test_Class::Derived_Test_Class(const Derived_Test_Class & dtc_r) :Test_Class(dtc_r), m(dtc_r.m) { cout << endl; cout << "Derived_Test_Class Copy constructor executed: " << "Data member initialized to " << m << endl; } Derived_Test_Class::~Derived_Test_Class() { cout << endl; cout << "Derived_Test_Class Destructor Executed " << "for object with data member " << m << endl; } int Derived_Test_Class::Get_Value() {
- 276 -
return m; } int main() { Test_Class tc_object(3); Derived_Test_Class dtc_object(7); cout << endl << endl; cout << "The n value of the Test_Class object is " << tc_object.Get_Value() << endl << endl; cout << "The m value of the Derived_Test_Class object is " << dtc_object.Get_Value() << endl << endl; cout << "The n value of the Derived_Test_Class object is " << dtc_object.Test_Class::Get_Value(); cout << endl; return 0; }
Prethodno definisani rezultati se mogu predstaviti na sledei nain: -Metod osnovne klase nasleuju sve klase izvedene iz nje ili direktno ili indirektno. -Ako izvedena klasa sadrži metod sa istim imenom i karakteristikama kao metod osnovne klase, verzija izvedene klase metoda „nadjaava“ verziju osnovne klase. -Da biste primenili metod osnovne klase na objekat izvedene
- 277 -
klase, kvalifikujte ime metoda sa imenom osnovne klase za kojim sledi operator razrešenja dosega :: . 10.2 Polimorfizam U hijerarhiji klasa, više klasa mogu da sadrže svoje sopstvene verzije metoda. Kada se koriste pokazivai za pristup objektima, polimorfizam dozvoljava da tip podatka objekta odredi koji je od ovih metoda primenjen. Svojstvo da svaki objekat izvedene klase, ak i kada mu se pristupa kao objektu osnovne klase, izvršava metod tano onako kako je to definisano u njegovoj izvedenoj klasi, naziva se polimorfizam. Hijerarhija klasa Pretpostavimo da razvijamo aplikaciju za crtanje koja treba da definiše i radi sa prostim geometrijskim slikama, odnosno da izrauna njihove površine. Slike su pravougaonici, krugovi i trapezoidi. Pošto su to geometrijski oblici, izvodimo ih iz klase Shape. Sa desne strane svake klase su privatne instance promenljivih date klase. Svaka klasa e imati konstruktor, destruktor i metod Area() koji izraunava površinu prema datoj formuli. Koristiemo veoma prostu hijerarhiju klasa baziranu na familiji geometrijskih slika i njihovih površina. Pretpostavimo da razvijamo aplikaciju za crtanje koja treba da definiše i manipuliše sa prostim geometrijskim slikama i izrauna njihove površine. Slike su pravougaonici, krugovi i trapezi. Kako su ove slike geometrijski oblici (shapes), odluujemo da ih izvedemo iz klase Shape. Hijerarhija klasa je prikazana na donjoj slici. Sa desne strane svake klase na slici su private primerci promenljivih klase. Svaka klasa ima konstruktor, destruktor i metod Area() koji izraunava površinu slike koristei odgovarajuu formulu.
- 278 -
Problem: pretpostavimo da želimo da omoguimo korisniku da kreira seriju geometrijskih slika prema sopstvenom izboru. Na taj nain, korisnik može prvo da odlui da kreira pravougaonik odreenih dimenzija, zatim krug odreenog poluprenika itd. Nakon kreiranja geometrijskih slika, želimo da program prikaže površine svih geometrijskih slika. Kako da uradimo ovo? Možemo da kreiramo niz geometrijskih slika. Meutim svi elementi niza mora da budu istog tipa. Ne možemo da smestimo objekat pravougaonik i objekat krug u isti niz, zato što su razliitog tipa. Odgovor je, kao što emo videti, u korišenju niza pokazivaa Shape i primena koncepta polimorfizma. Definicija klasa U nastavku su date deklaracije klasa Shape, Rectangle, Circle i Trapezoid. Zbog jednostavnosti, definišimo sve metode u deklaracijama klasa. Ne treba vam prefiks imena klase i operatora razrešenja dosega za ime metoda u definiciji metoda. Kako je metod definisan unutar deklaracije klase kompajler zna kojoj klasi metod pripada. class Shape { protected: string figure_type; public: Shape(string ft = "Default Figure") : figure_type(ft) {cout << endl << "Shape Constructor" << endl;} string Get_Type() {return figure_type;} ~Shape() {cout << endl << "Shape Destructor" << endl;} double Area() {return 0.0;} }; class Rectangle : public Shape { protected: double height, width; public: Rectangle(double h, double w): Shape("Rectangle"), height(h),width(w) {cout << endl << "Rectangle Constructor" << endl;} ~Rectangle() {cout << endl << "Rectangle Destructor" << endl;} double Area() {return height * width;} };
- 279 -
class Circle : public Shape { protected: double radius; public: Circle(double r) : Shape("Circle"), radius(r) {cout << endl << "Circle Constructor" << endl;} ~Circle() {cout << endl << "Circle Destructor" << endl;} double Area() {return 3.1416 * radius * radius;} }; class Trapezoid : public Shape { protected: double base1, base2, height; public: Trapezoid(double b1, double b2, double h) : Shape("Trapezoid"), base1(b1), base2(b2), height(h) {cout << endl << "Trapezoid Constructor" << endl;} ~Trapezoid() {cout << endl << "Trapezoid Destructor" << endl;} double Area() {return 0.5 * height * (base1 + base2);} };
Osnovna klasa Shape ima jedan podatak lan, string objekat figure_type, ija je vrednost ime tipa geometrijske slike (Rectangle, Circle, ili Trapezoid). Takoe ukljuujemo accessor metod Get_Type() koji vraa ime geomtrijske slike. Oba metoda figure_type i Get_Type() nasleuju klase Rectangle, Circle, i Trapezoid. Konstruktori izvršavaju inicijalizaciju na svojim inicijalizacionim listama. Telo svakog konstruktora i destruktora prikazuje identifikacionu poruku. Obratite pažnju da na inicijalizacionoj listi za konstruktor Shape je figure_type(ft). Ulaz na inicijalizacionu listu je ekvivalentan inicijalizaciji. Sledi, figure_type(ft) je ekvivalentno sledeem: string figure_type = ft;
Definišimo Area() metod u Shape class-i koja vraa vrednost 0. Svaka od drugih klasa je izvedena javno iz klase Shape. Konstruktor za Rectangle, Circle, i Trapezoid poziva konstruktor za osnovnu klasu Shape i prosleuje tom konstruktoru ime objekta koji se kreira. Area() metod za svaku klasu vraa površinu na osnovu matematike formule za površinu geometrijske slike tog oblika.
- 280 -
Pokazivai u hijerarhiji klasa Možemo da deklarišemo Rectangle pokaziva, ili Circle pokaziva, ili Trapezoid pokaziva, gde svaki pokazuje na objekat odgovarajueg tipa. Na primer, možemo da napravimo sledee deklaracije: Rectangle r1(3, 5); Circle c1(7); Trapezoid t1(4, 2, 6); Rectangle* r_p = &r1; Circle* c_p = &c1; Trapezoid* t_p = &t1; Shape pokaziva može da pokazuje na Rectangle objekat, ili Circle objekat, ili Trapezoid objekat zato što, nasleivanjem, svaki od njih je i Shape objekat. Tako, nastavljajui prethodne deklaracije, ispravno je: Shape* s_p1; Shape* s_p2; Shape* s_p3; s_p1 = &r1; s_p2 = &c1; s_p3 = &t1;
Mada su s_p1, s_p2, i s_p3 Shape pokazivai, dozvoljeno im je da pokazuju na objekte u bilo kojoj izvedenoj klasi. Obrnuto ne važi, Rectangle pokaziva (ili Circle pokaziva ili Trapezoid pokaziva) ne može da pokazuje na Shape objekat. U hijerarhiji klasa, pokaziva osnovne klase može da pokazuje na objekat bilo koje izvedene klase (ili direktno ili indirektno) iz osnovne klase. Obrnuto nije mogue, pokaziva na izvedenu klasu ne može da pokazuje na objekat osnovne klase. Koristei prethodne deklaracije i dodele, pretpostavimo sledee: cout << "The area of the rectangle is " << s_p1 -> Area() << endl;
Pokaziva s_p1 je Shape pointer, ali on pokazuje na Rectangle objekat. iji Area() metod e ova naredba izvršiti: klase Rectangle ili metod Area() osnovne klase Shape? Odgovor daje izvršenje sledeeg programa:
- 281 -
//Ovaj program prikazuje koriscenje pokazivaca i metoda u hijerarhiji klasa. #include #include #include using namespace std; class Shape { protected: string figure_type; public: Shape(string ft = "Default Figure") : figure_type(ft) {cout << endl << "Shape Constructor" << endl;} string Get_Type() {return figure_type;} ~Shape() {cout << endl << "Shape Destructor" << endl;} double Area() {return 0.0;} }; class Rectangle : public Shape { protected: double height, width; public: Rectangle(double h, double w): Shape("Rectangle"), height(h),width(w) {cout << endl << "Rectangle Constructor" << endl;} ~Rectangle() {cout << endl << "Rectangle Destructor" << endl;} double Area() {return height * width;} }; class Circle : public Shape { protected: double radius; public: Circle(double r) : Shape("Circle"), radius(r) {cout << endl << "Circle Constructor" << endl;} ~Circle() {cout << endl << "Circle Destructor" << endl;} double Area() {return 3.1416 * radius * radius;} }; class Trapezoid : public Shape { protected: double base1, base2, height; public:
- 282 -
Trapezoid(double b1, double b2, double h) : Shape("Trapezoid"), base1(b1), base2(b2), height(h) {cout << endl << "Trapezoid Constructor" << endl;} ~Trapezoid() {cout << endl << "Trapezoid Destructor" << endl;} double Area() {return 0.5 * height * (base1 + base2);} }; int main() { cout << setprecision(4) << setiosflags(ios::fixed) << setiosflags(ios::showpoint); Shape* s_p1; Circle* c_p1; Circle c1(5); s_p1 = &c1;
//Shape pointer pokazuje na objekat Circle
c_p1 = &c1;
//Circle pointer pokazuje na objekat Circle
cout << endl; cout << "Area() applied through Circle pointer: " << c_p1 -> Area() << endl << endl; cout << "Area() applied through Shape pointer: " << s_p1 -> Area() << endl << endl; cout << endl; return 0; }
Iz dve linije koje prikazuje cout u main() funkciji, vidimo da Area() metod primenjen na Circle objekat kroz Circle pokaziva daje korektnu
- 283 -
površinu 78.5400. Meutim, Area() metod koji je primenjen na Circle objekat kroz Shape pokaziva je Area() metod iz Shape klase. Mada s_p1 pokazuje na Circle objekat, metod osnovne klase se poziva kada je on primenjen na objekat kroz pokaziva osnovne klase. Sledi, "nadjaavanje" metoda (overriding) ne radi u ovom sluaju. Virtuelni metodi i polimorfizam Koncept polimorfizma (bukvalno znai više oblika - many forms) proširuje method overriding na sluaj objekata u izvedenoj klasi kojima se pristupa kroz pokaziva osnovne klase. Da biste primenili polimorfizam, metod koji treba da bude nadjaan mora da bude deklarisan kao virtuelni. Rezervisana re virtual mora da se pojavi u deklaraciji metoda u osnovnoj klasi. Sledei program prikazuje razliku koja deklarisanjem metoda Area() da je virtuelni, ini izlaz iz prethodnog problema. //Ovaj program prikazuje koriscenje virtuelne funkcije //u hijararhiji klasa #include #include #include using namespace std; class Shape { protected: string figure_type; public: Shape(string ft = "Default Figure") : figure_type(ft) {cout << endl << "Shape Constructor" << endl;} string Get_Type() {return figure_type;} ~Shape() {cout << endl << "Shape Destructor" << endl;} virtual double Area() {return 0.0;} }; class Rectangle : public Shape { protected: double height, width; public: Rectangle(double h, double w): Shape("Rectangle"), height(h),width(w) {cout << endl << "Rectangle Constructor" << endl;}
- 284 -
~Rectangle() {cout << endl << "Rectangle Destructor" << endl;} double Area() {return height * width;} }; class Circle : public Shape { protected: double radius; public: Circle(double r) : Shape("Circle"), radius(r) {cout << endl << "Circle Constructor" << endl;} ~Circle() {cout << endl << "Circle Destructor" << endl;} double Area() {return 3.1416 * radius * radius;} }; class Trapezoid : public Shape { protected: double base1, base2, height; public: Trapezoid(double b1, double b2, double h) : Shape("Trapezoid"), base1(b1), base2(b2), height(h) {cout << endl << "Trapezoid Constructor" << endl;} ~Trapezoid() {cout << endl << "Trapezoid Destructor" << endl;} double Area() {return 0.5 * height * (base1 + base2);} }; int main() { cout << setprecision(4) << setiosflags(ios::fixed) << setiosflags(ios::showpoint); Shape* s_p1; Circle* c_p1; Circle c1(5); s_p1 = &c1;
//Shape pointer pokazuje na objekat Circle
c_p1 = &c1;
//Circle pointer pokazuje na objekat Circle
cout << endl; cout << "Area() applied through Circle pointer: " << c_p1 -> Area() << endl << endl; cout << "Area() applied through Shape pointer: "
- 285 -
<< s_p1 -> Area() << endl << endl; cout << endl; return 0; }
Ovoga puta, druga cout naredba izvršava Area() metod cilja Shape pointera s_p1. Ona radi ovo zato što smo deklarisali Area() metod u osnovnoj klasi Shape kao virtuelni metod. Polimorfizam dozvoljava da izbor metoda zavisi od tipa podatka cilja pointera radije nego od tipa podatka pointera. Da bi polimorfizam radio, objektima u hijerarhiji klasa mora se pristupati kroz pokazivae. Samo metodi klase mogu biti virtuelni. Da bi metod u izvedenoj klasi nadjaao virtuelni metod u osnovnoj klasi, metod u izvedenoj klasi mora da ima isto ime i potpis (broj i tip argumenata) kao metod osnovne klase. Metod u izvedenoj klasi sa istim imenom i potpisom kao i virtuelni metod u osnovnoj klasi je takoe virtuelan, bez obzira da li se ili ne virtual kljuna re pojavljuje u njegovoj deklaraciji (Zato su, Area() metodi u izvedenim klasama iz prethodnog programa takoe virtuelni) Funkcije lanice osnovne klase koje se u izvedenim klasama mogu realizovati specifino za svaku izvedenu klasu, nazivaju se virtuelne funkcije. Virtuelni destruktori Sada razmatramo program u kome je zamenjen statiki deklarisan objekat c1 iz prethodnog programa, dinamiki alociranim objektom na koji pokazuje s_p1.
- 286 -
//Program prikazuje nekorektno koriscenje destruktora u hijerarhiji klasa #include #include #include using namespace std; class Shape { protected: string figure_type; public: Shape(string ft = "Default Figure") : figure_type(ft) {cout << endl << "Shape Constructor" << endl;} string Get_Type() {return figure_type;} ~Shape() {cout << endl << "Shape Destructor" << endl;} virtual double Area() {return 0.0;} }; class Rectangle : public Shape { protected: double height, width; public: Rectangle(double h, double w): Shape("Rectangle"), height(h),width(w) {cout << endl << "Rectangle Constructor" << endl;} ~Rectangle() {cout << endl << "Rectangle Destructor" << endl;} double Area() {return height * width;} }; class Circle : public Shape { protected: double radius; public: Circle(double r) : Shape("Circle"), radius(r) {cout << endl << "Circle Constructor" << endl;} ~Circle() {cout << endl << "Circle Destructor" << endl;} double Area() {return 3.1416 * radius * radius;} }; class Trapezoid : public Shape { protected: double base1, base2, height;
- 287 -
public: Trapezoid(double b1, double b2, double h) : Shape("Trapezoid"), base1(b1), base2(b2), height(h) {cout << endl << "Trapezoid Constructor" << endl;} ~Trapezoid() {cout << endl << "Trapezoid Destructor" << endl;} double Area() {return 0.5 * height * (base1 + base2);} }; int main() { cout << setprecision(4) << setiosflags(ios::fixed) << setiosflags(ios::showpoint); Shape* s_p1 = new Circle (5); cout << endl; cout << "Area() applied through Shape pointer: " << s_p1 -> Area() << endl; delete s_p1; cout << endl; return 0; }
Kada se delete naredba izvršava za s_p1, koji pokazuje na Circle objekat, samo se destruktor za osnovnu klasu izvršava. Ovo je zbog toga što se destruktor primenjuje na objekat kroz pokaziva. Kako destruktor osnovne klase nije deklarisan kao virtual, primena destruktora na cilj pointera s_p1 izvršava destruktor osnovne klase a ne destruktor izvedene klase. Da biste propisno izvršili destruktore, tj. izvršili destruktor za izvedenu klasu, a zatim izvršili destruktor za osnovnu klasu, uinite da destruktor osnovne klase bude virtuelni metod.
- 288 -
Napomena: Pošto se konstruktor poziva pre nego što je objekat nastao, nema smisla da bude virtuelan, jezik C++ to ne dozvoljava. Sledei program koristi virtual destruktore. //Program prikazuje korektno koriscenje destruktora u hijerarhiji klasa. #include #include #include using namespace std; class Shape { protected: string figure_type; public: Shape(string ft = "Default Figure") : figure_type(ft) {cout << endl << "Shape Constructor" << endl;} string Get_Type() {return figure_type;} virtual ~Shape() {cout << endl << "Shape Destructor" << endl;} virtual double Area() {return 0.0;} }; class Rectangle : public Shape { protected: double height, width; public: Rectangle(double h, double w): Shape("Rectangle"), height(h),width(w) {cout << endl << "Rectangle Constructor" << endl;} virtual ~Rectangle() {cout << endl << "Rectangle Destructor" << endl;} double Area() {return height * width;} }; class Circle : public Shape { protected: double radius; public: Circle(double r) : Shape("Circle"), radius(r) {cout << endl << "Circle Constructor" << endl;} virtual ~Circle() {cout << endl << "Circle Destructor" << endl;} double Area() {return 3.1416 * radius * radius;} };
- 289 -
class Trapezoid : public Shape { protected: double base1, base2, height; public: Trapezoid(double b1, double b2, double h) : Shape("Trapezoid"), base1(b1), base2(b2), height(h) {cout << endl << "Trapezoid Constructor" << endl;} virtual ~Trapezoid() {cout << endl << "Trapezoid Destructor" << endl;} double Area() {return 0.5 * height * (base1 + base2);} }; int main() { cout << setprecision(4) << setiosflags(ios::fixed) << setiosflags(ios::showpoint); Shape* s_p1 = new Circle (5); cout << endl; cout << "Area() for the " << s_p1 -> Get_Type() << " applied through Shape pointer: " << s_p1 -> Area() << endl; delete s_p1; cout << endl; return 0; }
- 290 -
Sada se destruktori za target pointer s_p1 izvršavaju korektno. Prvo se destruktor za izvedenu klasu izvršava a onda destruktor osnovne klase. Obratite pažnju da smo takoe koristili aksesor metod Get_Type(), koji je takoe primenjen kroz pokaziva. Primer u kome se koristi polimorfizam Sledei program rešava problem koji smo postavili na poetku ove sekcije: omoguiti korisniku da kreira niz oblika geometrijskih slika po izboru. Korisnik može prvo da kreira na primer pravougaonik odreenih dimenzija, zatim krug odreenog poluprenika itd. Nakon toga želimo da program prikaže površine slika. Kako emo ovo da uradimo? Odgovor leži u kreiranju niza Shape pokazivaa i korišenju polimorfizma sa metodom Area(), kao u sledeem programu: //Ovaj program prikazuje koriscenje polimorfizma #include #include #include using namespace std; class Shape { protected: string figure_type; public: Shape(string ft = "Default Figure") : figure_type(ft) {} string Get_Type() {return figure_type;} virtual ~Shape() {} virtual double Area() {return 0.0;} }; class Rectangle : public Shape { protected: double height, width; public: Rectangle(double h, double w): Shape("Rectangle"), height(h),width(w) {} virtual ~Rectangle() {} double Area() {return height * width;} };
- 291 -
class Circle : public Shape { protected: double radius; public: Circle(double r) : Shape("Circle"), radius(r) {} virtual ~Circle() {} double Area() {return 3.1416 * radius * radius;} }; class Trapezoid : public Shape { protected: double base1, base2, height; public: Trapezoid(double b1, double b2, double h) : Shape("Trapezoid"), base1(b1), base2(b2), height(h) {} virtual ~Trapezoid() {} double Area() {return 0.5 * height * (base1 + base2);} }; Shape* Get_Shape(); int main() { cout << setprecision(4) << setiosflags(ios::fixed) << setiosflags(ios::showpoint); const int num_shapes = 5; Shape* shapes[num_shapes]; for (int i = 0; i < num_shapes; ++i) shapes[i] = Get_Shape(); cout << endl; for (i = 0; i < num_shapes; ++i) cout << "\nThe area of the " << shapes[i] -> Get_Type() << " is " << shapes[i] -> Area(); cout << endl; for (i = 0; i < num_shapes; ++i) delete shapes[i];
- 292 -
cout << endl; return 0; } Shape* Get_Shape() { Shape* s_p; //funkcija vraca pointer s_p double height, width, radius, base1, base2; cout << endl; cout << "Enter the number of the shape you want to create:" << endl << endl; cout << "For a Rectangle, enter 1" << endl; cout << "For a Circle, enter 2" << endl; cout << "For a Trapezoid, enter 3" << endl << endl; cout << "Please make your selection: "; int response; cin >> response; switch (response) { case 1: cout << endl << endl; cout << "Enter the height of the rectangle: "; cin >> height; cout << endl << endl; cout << "Enter the width of the rectangle: "; cin >> width; s_p = new Rectangle(height, width); break; case 2: cout << endl << endl; cout << "Enter the radius of the circle: "; cin >> radius;
- 293 -
s_p = new Circle(radius); break; case 3: cout << endl << endl; cout << "Enter the first base of the trapezoid: "; cin >> base1; cout << endl << endl; cout << "Enter the second base of the trapezoid: "; cin >> base2; cout << endl << endl; cout << "Enter the height of the trapezoid: "; cin >> height; s_p = new Trapezoid(base1, base2, height); break; default: cout << endl << endl; cout << "Invalid selection. Creating default object."; s_p = new Shape(); break; } return s_p; }
- 294 -
Svi destruktori su deklarisani kao virtual metodi. Takoe metod Area() u klasi Shape je deklarisan kao virtual. Ovo dozvoljava da se odgovarajui
- 295 -
metod Area() primeni kroz Shape pokaziva. U glavnoj funkciji main(), deklarisali smo niz shapes[] Shape pokazivaa. Prva for petlja dodeljuje svakom elementu niza shapes[] Shape pokaziva koji vraa funkcija Get_Shape(). Kada se Get_Shape() izvršava, prikazuje se korisniku meni sa opcijama Rectangle, Circle, ili Trapezoid kreiranja geometrijskih slika. Naredba switch odreuje akcije nakon korisnikove odluke. Ako, na primer, korisnik želi da kreira objekat pravougaonik Rectangle, funkcija pita za visinu i širinu pravougaonika. Zatim se kreira novi objekat Rectangle, dinamiki korišenjem operatora new. Mada ovo vraa pokaziva na objekat Rectangle, ispravno je dodeliti ga s_p, koji je Shape pokaziva. Ako korisnik ukuca broj koji nije 1, 2 ili 3, default sluaj iz naredbe switch kreira default Shape objekat. Prva for petlja inicijalizuje Shape pointere u nizu shapes[] da pokazuju na neku kombinaciju Rectangle, Circle, Trapezoid i default objekata. Svi elementi niza mora da budu istog tipa, kao što su elementi niza shapes[] - oni su svi pointeri tipa Shape. Meutim, elementi niza shapes[] pokazuju na objekte razliitog tipa. Zbog ovog razloga takvi nizovi se ponekad zovu heterogeni nizovi. Druga for petlja koristi polimorfizam. U svakoj iteraciji ove for petlje, metod Area() se primenjuje kroz pointer shapes[i]. Metod Area() koji petlja koristi zavisi potpuno od tipa oblika shape na koji pokaziva pokazuje (polimorfizam). Suprotno, metod Get_Type() nije primenjen preko polimorfizma. Postoji samo jedan metod Get_Type(), koji je lan klase Shape i koji druge klase nasleuju. Veoma je važno shvatiti da kada se program kompajlira, kompajler ne zna koji Area() metod e se u petlji koristi kada se program bude izvršavao. U stvari, u svakoj iteraciji, razliit Area() metod se može primeniti. C++ odluuje koji metod da koristi kada se petlja izvršava, a ne kada se program kompajlira. Ovo je kasno (late ili dynamic binding) ili dinamiko vezivanje: koji metod koristiti pri pozivu shapes[i] -> Area() se ne odluuje sve dok se kod ne izvršava. Ovo je suprotno u odnosu na rano (early ili static binding) ili statiko vezivanje, compiler zna koja e funkcija biti izvršena u compile time. Konano, trea for petlja u glavnoj funkciji main() "isti" memoriju brisanjem objekata koji su kreirani u prvoj for petlji.
- 296 -
10.3 Apstraktne osnovne klase Hijerarhija klasa koju smo predstavili u prethodnoj sekciji ima osnovnu klasu Shape za tri preostale klase. Nain na koji definišemo klasu Shape ini moguim deklarisanje objekta Shape mada takav objekat nema dimenzije. isti virtuelni metodi i apstraktne osnovne klase U C++, možemo da definišemo klasu na takav nain da je nemogue da deklarišemo objekat toga tipa, inei klasu da je apstraktna osnovna klasa - abstract base class ili ABC. Da biste napravili ABC klasu deklarišite bilo koji od njenih metoda kao ist virtuelni metod, treba da uradite sledee: -Smestite = 0 nakon liste argumenata metoda u deklaraciji metoda u klasi. -Nemojte da definišete metod. Kako ist virtuelni metod nema definiciju, nema smisla deklarisati objekat koji e da koristi takav metod. Zato se takva klasa zove apstraktna: ne možete kreirati bilo koji konkretan objekat tog tipa. Obezbeujui definicije svih istih virtuelnih metoda u izvedenoj klasi, specificiramo interfejs klase. Zato je mogue kreirati objekte u toj izvedenoj klasi. Napraviemo Shape klasu kao apstraktnu osnovnu klasu na sledei nain: class Shape { protected: string figure_type; public: Shape(string ft = "Default Figure") : figure_type(ft) {} const char* Get_Type() {return figure_type;} virtual ~Shape() {} virtual double Area() = 0; };
Ako je metod Area() ist virtuelni metod, sledi treba za izvedene klase obezbediti sopstvene definicije metoda Area(). Sledee deklaracije u glavnoj funkciji main() sada su neispravne: Shape s;
//neispravan objekat
- 297 -
Shape Func();
//neispravna povratna vrednost
double Func(Shape s); //neispravna vrednost parametra
Kako je Shape apstraktna osnovna klasa, ne možete kreirati objekat tipa Shape. Zato je prva deklaracija neispravna. Druga deklaracija je neispravna zato što ona implicira da funkcija Func() sadrži return naredbu koja vraa Shape objekat. Ovo implicira da se Shape objekat kreira mehanizmom return, što je nesipravno. Trea naredba je neispravna zato što korišenje funkcije zahteva prosleivanje Shape objekta po vrednosti, što zahteva da je Shape objekat kreiran. Meutim, zato što pokazivai i reference ne zahtevaju kreiranje objekta, sledee deklaracije su ispravne. Rectangle r(3, 5); Shape& s_ref = r; Shape* s_ptr = &r; double Func(Shape*);
Podsetimo se da je Shape referenca drugo ime za Shape objekat. Kako Rectangle objekat nasleuje Shape objekat, možemo koristiti Shape referencu na ovaj objekat. Prisustvo samo jednog istog virtuelnog metoda ini da klasa bude apstraktna osnovna klasa. Klasa može da sadrži druge iste virtuelne metode, obine virtuelne metode, ili ne-virtuelne metode. Ako sada pokušate da deklarišete Shape objekat, kompajler e prikazati poruku sa greškom.
- 298 -
11. Fajlovi 11.1 Ulazno/izlazni tokovi Kao i jezik C, ni C++ ne sadrži ulazno/izlazne (I/O) operacije, ve se one realizuju standardnim bibliotekama. Na raspolaganju su i stare C biblioteke sa funkcijama scanf i printf, ali njihovo korišenje nije u duhu jezika C++. U C++ fajl se tretira kao tok karaktera. Karakteri iz fajla su na raspolaganju programu u jednom trenutku jedan karakter u nizu (sekvencijalno). Ulaz i izlaz u C++ jeziku su poznati kao tokovi (stream I/O). C++ jezik ne pretpostavlja bilo koju drugu organizaciju fajla osim njegove strukture kao toka. Da bi dao fajlu dodatnu logiku strukturu, programer mora da napiše programske instrukcije koje to rade. Od prvog poglavlja koristili smo standardni izlazni tok cout i standardni ulazni tok cin. Kasnije smo uveli tok standardne greške cerr. Po default, standardni ulazni tok je "prilepljen" za tastaturu. Tok cin prima svoj ulaz sa tastature. Standardni izlazni tokovi, cout i cerr, su "prilepljeni" displeju monitora. Bilo koji podatak ubaen u izlazne tokove cout i cerr pojavljuje se na monitoru. Standardni ulazni i izlazni tokovi automatski su na raspolaganju svakom C++ programu koji ima pretprocesorsku direktivu #include . Sada emo objasniti prirodu cin, cout i cerr. Ranije smo napomenuli da je cin objekat klase istream, a cout i cerr su objekti klase ostream. Ove dve klase su ustvari deo kompleksne hijerarhije klasa ulaza i izlaza koje su deo C++ jezika (donja slika).
Heder sadrži definiciju klase iostream, koja je izvedena iz istream i ostream. Klasa kao što je iostream, koja je izvedena iz dve ili više
- 299 -
„roditelj“ klasa, je primer višestrukog nasleivanja (multiple inheritance). Kod višestrukog nasleivanja, izvedena klasa nasleuje sve lanove iz svih klasa iz kojih je izvedena. Na taj nain klasa iostream nasleuje sve lanove iz istream, ostream i takoe, indirektno, iz klase ios, iz koje su i istream i ostream izvedene. Klasa istream rukuje ulazom i ukljuuje definiciju operatora extraction >> (koji je preklopljen). Objekat cin je lan klase istream. Metodi get() i getline() su lanovi klase istream. Zbog toga se mogu primeniti na istream objekat kao što je cin. Na sledei nain smo koristili ove metode: ch = cin.get(); cin.getline(buffer, 81);
Klasa ostream rukuje izlazom i ukljuuje definiciju insertion operatora << (koji je preklopljen). Objekat cout je lan klase ostream. I/O manipulatori koje smo koristili da bismo oblikovali izlaz iz naših programa su ustvari metodi koji koriste ostream i ios metode za rad sa izlaznim tokom. Na primer, metod setprecision(), kada se pošalje na cout, odreuje preciznost decimalnih brojeva koji se prikazuju od strane cout. Slino, setiosflags(ios::showpoint), kada se pošalje na cout, setuje jednobitni flag u primerku promenljive klase ios koji odreuje da izlazni tok prikaže decimalnu taku kada je decimalni broj izlaz. Operator razrešenja dosega :: je neophodan da bi se obezbedilo upuivanje na lana roditelj klase. Tekstualni fajlovi Fajlovi na diskovima mogu biti binarni (koriste se za kompaktno skladištenje podataka) i tekstualni (služe za skladištenje podataka u obliku itljivom za oveka). Za sada, pretpostavimo da radimo sa tekstualnim fajlovima. Tekstualni fajl se sastoji od slova alfabeta, brojeva i specijalnih znakova kao što su zapeta, crtica i taka. Na kraju svake linije tekstualnog fajla je znak za novi red ('\n'). Tekst fajlove proizvode takozvani ASCII tekst editori ili samo tekst editori (Notepad, Windows i VI editor u UNIX-u, Visual C++ text editor). Bilo koji od ovih tekst editora se može koristiti za primere u ovom poglavlju. Napomena: fajlovi koje proizvode word procesori, kao npr. Microsoft Word, nisu tekstualni.
- 300 -
Korisniki deklarisani fajlovi C++ dozvoljava programeru da deklariše I/O strimove, tj. fajlove drugaije od standardnih. Da biste odradili input ili output na imenovanim fajlovima zahteva se da napravite objekte u klasama koje su dizajnirane za izvoenje operacija nad fajlovima. Da biste radili sa fajlom u C++ mora da odradite sledee korake: -Deklarišite fajl objekat odgovarajueg moda (npr. ulaz ili izlaz ili oba). -Otvorite file object i pridružite tom objektu ime fajla iz vašeg raunarskog sistema. -Izvršite operacije na fajlu (npr. read data ili write data). -Zatvorite fajl. Deklarisanje fajl objekta Pri deklarisanju objekta file, posmatraemo klase koje podržavaju rad sa ulazno/izlaznim fajlovima. -Koristite klasu ifstream za kreiranje ulaznih fajlova. Klasa ifstream je izvedena iz klase istream i klase zvane fstreambase. Klasa fstreambase, koja je izvedena iz klase ios, obezbeuje mogunosti za rad sa fajlovima sa imenima. -Koristite klasu ofstream da biste kreirali izlazne fajlove. Ova klasa je izvedena iz ostream i fstreambase. -Konano, koristite klasu fstream da biste kreirali fajlove koji mogu biti i izlazni i ulazni fajlovi. Izvedena je iz iostream i fstreambase. Na slici, klase iznad isprekidane linije deklarisane su u heder fajlu a klase ispod nje u heder fajlu .
- 301 -
Da biste koristili fajl deklarišite objekat file odgovarajueg tipa, kao u sledeim deklaracijama: ofstream out_file; ifstream in_file; fstream io_file;
//deklariše output file objekat nazvan out_file //deklariše input file objekat nazvan in_file //deklariše file objekat io_file ili za izlaz ili za ulaz
Prva naredba deklariše out_file kao ofstream objekat, koji je tok izlaznog fajla. Ovo znai da naš program može da smesti podatke u out_file tok na skoro isti nain kao što smeštamo podatke u standardni izlazni tok, cout. Druga naredba deklariše in_file kao ifstream objekat. Zbog toga, naš program može da uzima podatke iz in_file toka na isti nain kao što uzima podatke iz standardnog ulaznog toka, cin. Trea naredba deklariše io_file kao objekat klase fstream. Naš program može da koristi io_file kao ulazni ili izlazni tok, zavisno od okolnosti u programu i kako želimo da otvorimo fajl. Otvaranje fajla Nakon deklarisanja fajl objekta, mora da otvorimo fajl i pridružimo fajl objekat stvarnom fizikom fajlu koji se nalazi u raunarskom sistemu. Prva od prethodnih deklaracija, na primer, deklariše out_file kao jedan ofstream objekat. Mautim, izlazni strim out_file još uvek nije pridružen ili dodeljen bilo kom stvarnom fajlu. Ovo je slino deklarisanju celobrojne varijable bez dodele poetne vrednosti. Da bismo koristili varijablu svrsishodno mora da joj dodelimo vrednost. Sledi, jednom kada deklarišemo fajl objekat, mora da pridružimo taj objekat fajlu. Uradiemo ovo otvarajui fajl koristei open() metod. Sledea naredba otvara out_file strim i pridružuje ga fajlu outdata.dat. out_file.open("outdata.dat");
Od ove take u programu, sve operacije na fajl objektu out_file bie izvršene na fajlu outdata.dat. Treba obratiti pažnju da argument metoda open() mora biti string. Zbog toga, ime fajla mora biti ukljueno sa navodnicima. U odsustvu direktorijumske putanje fajl e biti otvoren u katalogu gde se
- 302 -
program izvršava. Ime fajla može da ukljui putanju do fajla. Na primer, sledea naredba otvara fajl outdata.dat u root direktorijumu C: drajva. out_file.open("C:\outdata.dat");
Drugi nain za kreiranje i otvaranje fajla je korišenje konstruktora sa jednim argumentom ofstream. Sledea deklaracija kreira u jednom koraku ofstream objekat out_file i pridružuje ga fajlu outdata.dat. ofstream out_file("outdata.dat");
Sledei koraci prilikom otvaranja fajla su važni: -Otvoriti fajl (koristei open() metod ili konstruktor sa jednim argumentom kada deklarišete fajl objekat). -Pridružiti stvaran fajl iz raunarskog sistema fajl objektu koji se otvara. -Otvoriti fajl prema modu koji odgovara tipu objekta. -Kreirati promenljivu koja je deo fajl objekta, nazvanu file position indicator, ili FPI, koja vodi rauna o poziciji u fajlu. Vrednost FPI je programov displacement u fajlu, tj. broj bajtova od pozicije prvog bajta u fajlu. Kada se otvori fajl objekat ofstream, ako fajl koji ste pridružili objektu ne postoji, sistem ga kreira automatski. Ako fajl ve postoji otvara se za izlaz. U oba sluaja FPI se postavlja na 0, što je pozicija prvog bajta u fajlu. Prvi podatak koji program upiše u fajl je na toj poziciji. Ako prva operacija write smešta sedam znakova u fajl, sistem automatski poveava vrednost FPI za 7, kao na slici.
Kada otvorite fajl objekat ifstream, što je ulazni fajl, fajl koji ste pridružili objektu mora ve da postoji. Ako ne postoji javlja se greška. Kako da rukujemo sa ovom greškom?
- 303 -
Pretpostavimo da fajl koji se otvara postoji, njegov FPI se postavlja na 0. Prvi podatak koji išitavamo iz fajla je na poziciji 0. Ako proitamo 5 karaktera iz fajla, FPI se povea za 5. Sledi, sledee itanje podataka iz fajla poinje sa pomerajem 5.
Procesiranje fajla Jednom kada je ofstream objekat kreiran i otvoren, možemo da koristimo bilo koji operator koji radi sa izlaznim fajlom, ukljuujui i insertion operator <<. Podsetimo se da je insertion operator deklarisan u klasi ostream, iz koje je izvedena klasa ofstream. Operatori su u stvari metodi (funkcije) i tako su tretirani u jeziku C++. Zbog toga, klasa ofstream nasleuje insertion operator. Ovo dozvoljava da se uradi sledee da bi se upisao string "Hello, World!" u fajl outdata.dat za kojim sledi karakter za novi red. Zapamtite da fajl objekat out_file predstavlja fajl outdata.dat. out_file << "Hello, World!" << endl;
Zatvaranje fajla Nakon završetka procesiranja fajla, treba da se zatvori fajl. C++ sistem automatski zatvara bilo koji otvoren fajl kada se program završi. Meutim, dobra je praksa zatvoriti fajlove koristei metod close(). Na primer, sledee naredba zatvara out_file out_file.close();
Sledei program ilustruje prosto korišenje izlaznog fajla: //Ovaj program prikazuje fajl kao obican izlaz #include #include
- 304 -
using namespace std; int main() { char buffer[81]; ofstream out_file("outdata.dat"); cout << "Enter your name: "; cin.getline(buffer, 81); out_file << buffer << endl; cout << endl; cout << "Enter the first line of your address: "; cin.getline(buffer, 81); out_file << buffer << endl; out_file.close(); cout << endl; cout << "Program Terminated" << endl; return 0; }
Program ne prikazuje bilo kakav rezultat na displeju monitora zato što program smešta ime korisnika i adresu u fajl outdata.dat. Sledi listing izlaznog fajla.
- 305 -
Podsetimo se da je insertion operator nasleen od ofstream klase. Znai, da biste primenili operator na ofstream objekat kao što je out_file, koristite insertion operator << da prosledite podatke u fajl. Smeštamo podatke u out_file tok na isti nain kao što smeštamo podatke u standardni izlazni tok, cout. Treba obratiti pažnju da koristimo C-stringove (tj. nizove karaktera) u ovom i u sledeim programima u ovom poglavlju, a ne string objekte. Možete u prethodnom primeru da deklarišete bafer kao string objekat i program e raditi na isti nain. Meutim, uzdržaemo se od korišenja objekata sa cout zato što ne želimo da stvorimo utisak da možete da uradite tako sa proizvoljnim objektima. Na primer, ne možete da napišete kod za Savings_Account objekat acc1: cout << acc1;
Kompajler prijavljuje grešku kao rezultat ove naredbe. Jedini nain da se napravi da ovakva naredba radi je preklapanje operatora << koje smo definisali ranije za string objekte. Provera grešaka kada se otvara fajl Poslednji program ne proverava greške kada se fajl otvara. Ako se pojavi greška kada se fajl otvara, vrednost fajl objekta je 0. Sledei program prikazuje kako se proverava takva vrsta greške. Prvo izvršavanje programa daje izlaz u fajl, outdata.dat, koji je kreiran u folderu u kom se program izvršava. Drugi pokušaj izvršenja programa daje izlaz u fajl na disku M, koji ne postoji u sistemu gde se program izvršava. //Ovaj program prikazuje fajl kao obican izlaz //Program proverava da li je otvaranje fajla sa greskom ili bez #include #include #include using namespace std; int main() { char buffer[81]; char file_name[81];
- 306 -
cout << "Enter the name of the file you want to write to: "; cin.getline(file_name, 81); ofstream out_file(file_name); if (!out_file) { cerr << endl; cerr << "ERROR: File could not be opened." << endl; cerr << "Program Terminated" << endl; exit(1); } cout << endl; cout << "Enter your name: "; cin.getline(buffer, 81); out_file << buffer << endl; cout << endl; cout << "Enter the first line of your address: "; cin.getline(buffer, 81); out_file << buffer << endl; out_file.close(); cout << endl; cout << "Program Terminated" << endl; return 0; }
- 307 -
U ovom programu, dozvoljavamo korisniku da ukuca ime fajla u koji e ime i adresa da budu upisani. Program dobija ime fajla od korisnika i smešta ga u polje file_name[]. Kada je fajl objekat out_file deklarisan, koristimo kao argument konstruktora polje sa imenom file_name, koje je character pointer, ili string. Kada se fajl otvara provera grešaka se izvodi na sledei nain: if (!out_file) { cerr << endl; cerr << "ERROR: File could not be opened."; cerr << "Program Terminated" << endl; exit(1); }
Ako fajl nije otvoren propisno, vrednost out_file je 0. Zbog toga, testiranja !out_file je ustvari, "ako je out_file sa greškom pri otvaranju". U ovom sluaju, poruka o grešci se šalje na standardni tok error stream i program se završava exit(1) naredbom. Kreiranje tekstualnog fajla sa zapisima Mada C++ tretira sve fajlove kao tokove karaktera, nametnuemo logiku strukturu fajla. Zapis (record) je skup podataka, ili injenica (fakta), koji se odnose na odreeni entitet. Svaki fakt unutar zapisa je polje. Na primer, ako treba da napišemo program koji procesira inventar male kompanije, možemo da projektujemo part zapis. Svaki takav zapis može da se sastoji od tri polja: identifikacionog broja, koliine i cene. Kompletan skup part zapisa je inventarski fajl. Postoji nekoliko naina konstrukcije zapisa u C++. Kako za sada razmatramo samo tekstualne fajlove konstruisaemo zapise na sledei nain. Svaki zapis u fajlu je linija teksta. Zbog toga, u toku karaktera koji ini fajl, znak za novi red odvaja zapise. Polja u svakom zapisu su odvojena sa jednim ili više razmaka (spaces). Pozicija unutar zapisa identifikuje polje. Inventarski fajl sa delovima sa tri zapisa, koristei tekst editor izgleda ovako: 23 145 24.95 15 46 67.99 65 230 11.95
- 308 -
Prethodni fajl je primer sekvencijalnog fajla, koji je fajl iji su zapisi snimljeni sekvencijalno jedan za drugim. Sledei program kreira sekvencijalni tekstualni parts inventory fajl. On pita korisnika da unese podatke za zapise u fajl. Onda program upisuje zapis u delove fajla. //Ovaj program prikazuje kreiranje fajla sa obicnim tekstualnim podacima //inventara u kome su podaci odvojeni praznim prostorom. #include #include #include #include using namespace std; int main() { char file_name[81]; int id_no; int qoh; double price; int response; cout << "Enter the name of the new inventory file: "; cin.getline(file_name, 81); ofstream inventory_file(file_name); if (!inventory_file) { cerr << endl; cerr << "ERROR: File could not be opened." << endl; cerr << "Program Terminated" << endl; exit(1); } inventory_file << setprecision(2) << setiosflags(ios::fixed) << setiosflags(ios::showpoint); cout << endl; cout << "Create an inventory record? (1 for Yes/0 for No): "; cin >> response; while (response)
- 309 -
{ // Uzima podatke za inventarski zapis cout << endl; cout << "ID Number: "; cin >> id_no; cout << endl; cout << "Quantity On Hand: "; cin >> qoh; cout << endl; cout << "Price: "; cin >> price; //Upisuje inventarski zapis inventory_file << id_no << " " << qoh << " " << price << endl; cout << endl; cout << "Create an inventory record? (1 for Yes/0 for No): "; cin >> response; } cout << endl << endl; cout << "Inventory File " << file_name << " created." << endl; inventory_file.close(); return 0; }
- 310 -
Program prvo pita korisnika da ukuca ime inventar fajla. Nakon dobijanja imena, program otvara fajl kao ofstream fajl objekat inventory_file i testira ga da vidi da li je fajl otvoren propisno. Sledee, program šalje u inventory_file setprecision() i setiosflags() naredbe koje obino šalje u cout. Ovo obezbeuje da svaka vrednost za polje cena zadržava decimalnu taku i ima dve cifre sa desne strane decimalne take kada se upisuje u output fajl.
- 311 -
Program zatim izvršava while petlju koja kreira output fajl. U telu petlje, program pita redom za identifikacioni broj, koliinu i cenu svakog uzorka. Zatim se upisuje inventarski zapis u fajl. inventory_file << id_no << " " << qoh << " " << price << endl;
Obratite pažnju da program smešta razmak izmeu svakog polja, i završava zapis znakom za novi red. Zatim program pita korisnika da li želi da kreira novi zapis. Nakon napuštanja petlje, program prikazuje poruku i zatvara fajl. Izlazni fajl Kada završimo sa kreiranjem nekoliko fajlova, kako možemo da koristimo ove fajlove kao ulaz u program i išitavanje njihovog sadržaja? Kao što je napomenuto prethodno, za kreiranje ulaznog fajla, deklarišemo ifstream fajl objekat i zatim otvaramo fajl. Na primer, da bismo otvorili fajl outdata.dat kao ulazni fajl, možemo da izvršimo sledee naredbe: ifstream in_file; in_file.open("outdata.dat");
Alternativno, možemo da kreiramo i otvorimo fajl u isto vreme, koristei konstruktor sa jednim argumentom na sledei nain: ifstream in_file("outdata.dat");
Kada itamo podatke iz fajla, mora uvek da proverimo uslov za kraj fajla (end-of-file). Uslov za kraj znai da program, pri procesiranju fajla, dolazi do kraja fajla. Sledi nema više podataka za itanje iz fajla. Metod eof() vraa 1 (true) ako je FPI na kraju fajla, i vraa nulu ako nije. Znai, ako je za in_file objekat klase ifstream koji je otvoren, vrednost koju vraa in_file.eof() jednaka 1, uslov za kraj fajla je ispunjen. Sledei program ilustruje kako možemo da itamo i prikažemo podatke koje program smešta u fajl outdata.dat. //Ovaj program prikazuje rad sa prostim ulaznim fajlom #include #include
- 312 -
#include using namespace std; int main() { char buffer[81]; char file_name[81]; cout << "Enter the name of the file you want to display: "; cin.getline(file_name, 81); ifstream in_file(file_name); if (!in_file) { cerr << endl; cerr << "ERROR: File could not be opened." << endl; cerr << "Program Terminated" << endl; exit(1); } cout << endl; while (!in_file.eof()) { in_file.getline(buffer, 81); cout << buffer << endl; } in_file.close(); cout << endl << endl; cout << "Program Terminated" << endl; return 0; }
- 313 -
Proveru greške kada otvaramo fajl radimo na isti nain kao što smo radili za izlazni fajl, proveravajui vrednost 0 za objekat klase ifstream, tj. in_file. Kopija i displej fajla su dati u while petlji. Uslov petlje proverava uslov za kraj ulaznog fajla. Ako nije kraj fajla, tj. ako je !in_file.eof() uslov ispunjen (true), program izvršava telo petlje. U telu petlje getline() metod ita liniju iz ulaznog fajla na potpuno isti nain kao što ita linije ubaene sa tastature koristei standardni ulazni strim cin. Podsetimo se da je metod getline() nasleen iz klase istream. Naredba cout zatim prikazuje liniju na monitoru. Procesiranje tekstualnih fajlova sa zapisima Sledei program prikazuje kako se procesira sekvencijalni tekstualni fajl koji radi sa zapisima. Program ita (prolazi) kroz fajl sa delovima inventara i treba da prikaže samo one zapise delova za koje ukupna vrednost dela (koliina pomnožena sa cenom) prelazi 3000.00€. //Ovaj program prikazuje citanje zapisa iz tekstualnog fajla //ciji su podaci odvojeni praznim pozicijama. #include #include #include #include using namespace std; int main() { char file_name[81]; int id_no; int qoh; double price; double total; cout << setprecision(2) << setiosflags(ios::fixed) << setiosflags(ios::showpoint); cout << "Enter the name of the inventory file: "; cin.getline(file_name, 81); ifstream inventory_file(file_name);
- 314 -
if (!inventory_file) { cerr << endl; cerr << "ERROR: File could not be opened." << endl; cerr << "Program Terminated" << endl; exit(1); } cout << endl << endl; cout << setw(8) << "ID No." << setw(10) << "Quantity" << setw(10) << "Price" << setw(12) << "Total" << endl << endl; //Dobijanje prvog zapisa inventara inventory_file >> id_no >> qoh >> price; while (!inventory_file.eof()) { total = qoh * price; if (total > 3000.00) { cout << setw(8) << id_no << setw(10) << qoh << setw(10) << price << setw(12)<< total << endl; } //Dobijanje sledeceg zapisa inventara inventory_file >> id_no >> qoh >> price; } inventory_file.close(); cout << endl; return 0; }
- 315 -
Program poinje dobijanjem imena fajla sa inventarom od korisnika i otvaranjem fajla kao fajl objekta inventory_file klase ifstream. Zatim, program prikazuje liniju zaglavlja po kolonama. Kada program ita iz fajla zapise sekvencijalno, tj. u jednom trenutku jedan karakter, mora da vodite rauna da se procesira poslednji zapis u fajlu i da se zapis procesira samo jednom. Sledi opis koraka za itanje svih zapisa u sekvencijalnom ulaznom fajlu: 1. Uitaj prvi zapis fajla odmah nakon otvaranja fajla. 2. Uitaj ulazni fajl ponovi odmah nakon što program kompletira procesiranje ulaznih podataka. Tako, tipian program koji procesira takav fajl i koristi eof() da bi odredio kraj fajl treba da ima sledei format napisan u pseudokodu: otvoriti ulazni fajl input_file iscitati prvi zapis while (!input_file.eof()) obradi zapis uitaj sledei zapis endwhile
Ovo je uraeno u programu, nakon otvaranja fajla za inventar, program ita prvi zapis izvršavajui naredbu inventory_file >> id_no >> qoh >> price;
koja ita prva tri broja u fajlu, identifikacioni broj, koliinu i cenu i smešta ih u tri varijable. Zatim, program ulazi u petlju za procesiranje ... Ulazno/izlazni fajl Možemo da koristimo fajl i kao ulaz i kao izlaz u istom programu. Da bismo uradili ovo, treba da imamo fajl objekat koji može da služi i kao ulazni i kao izlazni tok. Klasa fstream, nasleena iz iostream, koja redom nasleuje i ostream i istream, je upravo ono što nam treba. Zato što lan klase fstream može da se koristi i kao ulaz i kao izlaz, kada se fajl otvara, mora da specificirate mod otvaranja kao drugi argument metoda open() ili konstruktorov drugi argument. (open() metod i fajl konstruktori su preklopljeni - oni mogu da uzmu ili jedan ili dva argumenta.) Indicirate mod
- 316 -
otvaranja koristei konstante moda pristupa koje su definisane u klasi ios i zbog toga su na raspolaganju fstream, ifstream i ofstream. Konstante moda pristupa: ios::in Otvara fajl za ulaz (ili itanje). Ovaj mod može takoe da se koristi i sa ifstream fajl objektima. ios::out Otvara fajl za izlaz (ili upisivanje). Ovaj mod može takoe da se koristi i sa ofstream fajl objektima. ios::app Otvara fajl za izlaz i poinje na kraju fajla (dodavanje). Ovaj mod se može koristiti samo sa ofstream objektima. Da bismo otvorili fajl outdata.dat za ulaz, treba da napišemo kôd: fstream file("outdata.dat", ios::in);
Kada se otvara fajl u ios::in modu ili u ios::out modu, FPI se postavlja na 0. Kada se otvara izlazni fajl u ios::app, ili modu dodavanja, FPI se postavlja na broj bajtova u fajlu. Sledei program dozvoljava korisniku da ukuca ime i adresu i smesti ih u tekstualni fajl. Program zatim prikazuje sadržaj fajla. //Ovaj program prikazuje jednostavan rad sa fajlom (ulaz i izlaz). //Fajl je otvoren u ios::in modu i ios::out modu. #include #include #include using namespace std; int main() { char buffer[81]; char file_name[81]; cout << "Enter the name of the file you want to write to: "; cin.getline(file_name, 81); fstream file(file_name, ios::out); if (!file) { cerr << endl; cerr << "ERROR: File could not be opened." << endl; cerr << "Program terminated" << endl;
- 317 -
exit(1); } cout << endl; cout << "Enter your name: "; cin.getline(buffer, 81); file << buffer << endl; cout << endl; cout << "Enter the first line of your address: "; cin.getline(buffer, 81); file << buffer << endl; file.close(); cout << endl; cout << "The file you created is the following:" << endl << endl; file.open(file_name, ios::in); if (!file) { cerr << endl; cerr << "ERROR: File could not be opened." << endl; cerr << "Program Terminated" << endl; exit(1); } while (!file.eof()) { file.getline(buffer, 81); cout << buffer << endl; } file.close(); cout << "Program Terminated." << endl; return 0; }
- 318 -
Program prvo pita za ime fajla koji korisnik želi da kreira. Prvi put kada otvorimo fajl, kreiramo fstream fajl objekat u deklaraciji i otvaramo fajl u modu ios::out. Program zatim pita za korisnikovo ime i adresu, koje program upisuje u fajl. Program zatim zatvara fajl i otvara isti fajl u ios::in modu. Naredba while zatim prikazuje sadržaj fajla. Sledei program otvara fajl kreiran ranije i dodaje jednu liniju fajlu. Da bismo otvorili fajl u ios::app modu, fajl objekat koji predstavlja fajl file_app u programu, treba da bude ofstream objekat. Nakon dodavanja linije fajlu, program zatvara fajl a zatim ga otvara ponovo kao ifstream fajl, file_in u programu, tako da se može sadržaj fajla prikazati. //Ovaj program prikazuje jednostavan fajl kao ulaz i izlaz. //Fajl je otvoren u in, out i app modu. #include #include #include using namespace std; int main() { char buffer[81]; char file_name[81]; cout << "Enter the name of the file you want to append to: "; cin.getline(file_name, 81); cout << endl; cout << "Enter the city, state, and zip code in which you live: "; cin.getline(buffer, 81); cout << endl;
- 319 -
cout << "The information will be appended to your file." << endl; ofstream file_app(file_name, ios::app); if (!file_app) { cerr << endl; cerr << "ERROR: File could not be opened in append mode." << endl; cerr << "Program terminated" << endl; exit(1); } file_app << buffer << endl; file_app.close(); cout << endl; cout << "Your complete name and address is the following:" << endl << endl; ifstream file_in(file_name); if (!file_in) { cerr << endl; cerr << "ERROR: File could not be opened." << endl; cerr << "Program terminated" << endl; exit(1); } while (!file_in.eof()) { file_in.getline(buffer, 81); cout << buffer << endl; } file_in.close(); cout << endl; cout << "Program Terminated" << endl; return 0; }
- 320 -
11.2 Procesiranje fajla karakter po karakter U prethodnoj sekciji koristili smo insertion operator za smeštanje podataka u tekstualni fajl i extraction operator i metod getline() za uzimanje podataka iz tekstualnog fajla. U nekim sluajevima, ili je neophodno ili je efikasnije koristiti karakter po karakter za tekstualne fajlove. Metodi get() i put() Da biste uitali ili upisali jedan karakter u fajl, možete koristiti metode get() i put(). Ovi metodi su brži od korišenja insertion i extraction operatora. Metod get() vraa jedan karakter iz ulaznog fajla. Ako je in_file otvoren ifstream objekat, in_file.get() vraa sledei iskoristljiv objekat iz in_file toka. Metod get() uzima karakter na koji pokazuje FPI. Npr. ako je FPI 6, in_file.get() uzima karakter koji je 6 karaktera od poetka fajla (tj. 7 karakter u fajlu). Zatim get() metod poveava FPI za 1 (7).
- 321 -
Uz to, get() metod uvek detektuje uslov za kraj fajla, dok extraction operator >> ne. Podsetimo se da smo koristili eof() metod za detekciju uslova za kraj fajla. Metod get() vraa EOF, konstanta definisana u iostream header fajlu, ako je program došao do kraja fajla u ulaznom fajlu. Ako je out_file otvoren, onda out_file.put(ch) smešta kopiju karaktera uskladištenog u varijabli ch na poziciju koju odreuje FPI, i tada put() metod poveava FPI za jedan. Sledei program kopira jedan tekstualni fajl u drugi karakter po karakter. //Ovaj program kopira jedan fajl u drugi koristeci get() i put() #include #include #include using namespace std; int main() { char file_name[81]; char ch; cout << "Enter the name of the source file: "; cin.getline(file_name, 81); ifstream source_file(file_name); if (!source_file) { cout << endl; cout << "ERROR: File cannot be opened."; exit(1); } cout << endl; cout << "Enter the name of the target file: "; cin.getline(file_name, 81); ofstream target_file(file_name); if (!target_file) { cout << endl; cout << "ERROR: File cannot be opened."; exit(1); }
- 322 -
while ( (ch = source_file.get()) != EOF ) target_file.put(ch); source_file.close(); target_file.close(); cout << endl << endl; cout << "Program Terminated." << endl; return 0; }
Na donjoj slici je dat listing fajla primer2.
Treba voditi rauna o tome kako testiramo end-of-file u uslovu petlje while. Izraz ch = source_file.get()
nije jednak EOF ako get() metod nije stigao do kraja fajla. Kada je stigao do kraja fajla izraz je jednak EOF i petlja se završava. while ( (ch = source_file.get()) != EOF ) target_file.put(ch);
Izlaz na printer Ako znate ime pridruženo u vašem sistemu štampau, npr. "prn" u Windows okruženju, možete da tretirate printer kao output stream. Da biste - 323 -
otvorili printer za izlaz, deklarišite ofstream objekat i pridružite objekat printeru. Na primer, sledea naredba deklariše ofstream objekat printer_file i dodeljuje ga printeru: ofstream printer_file("prn");
Svi metodi koje smo koristili za ofstream objekte radie i za printer_file, kao što bi i insertion operator. Zbog toga sledea naredba e odštampati re "Hello" na printeru. printer_file << "Hello" << endl;
Sledea naredba e odštampati karakter 'A' na printeru. printer_file.put('A');
Sledei program štampa sadržaje fajla kreiranog ranije sa dvostrukim proredom na printeru: //Ovaj program stampa na stampacu sadrzaje fajla sa dvostrukim proredom #include #include #include using namespace std; int main() { char file_name[81]; char ch; cout << "Enter the name of the source file: "; cin.getline(file_name, 81); ifstream source_file(file_name); if (!source_file) { cout << endl; cout << "ERROR: File cannot be opened."; exit(1); } ofstream printer_file("prn");
- 324 -
if (!printer_file) { cout << endl; cout << "ERROR: Printer could not be opened."; exit(1); } printer_file << "Contents of the Source File - Double Spaced." << endl << endl; while ((ch = source_file.get()) != EOF) { printer_file.put(ch); if (ch == '\n') printer_file.put(ch); } source_file.close(); printer_file.close(); cout << endl << endl; cout << "Program Terminated." << endl; return 0; }
Nakon otvaranja sors fajla i printer fajla, program insertuje poruku (Contents of the Source File - Double Spaced.) u printer_file strim. Zatim while petlja uspešno ita karaktere iz sors fajla i štampa ih na printeru. If naredba u petlji testira karakter koji ita get() da bi se videlo da li je znak za novi red, a ako jeste karakter se štampa ponovo, što stvara dvostruki prored. 11.3 Sluajni pristup fajlu U prethodnim sekcijama procesirali smo fajlove sekvencijalno, jedan karakter ili zapis u jednom trenutku. Mogue je procesirati karaktere u fajlu i sluajno, odnosno program može da procesira fajl na bilo kojoj željenoj lokaciji unutar fajla. Tekstualni i binarni fajlovi Tekstualni fajl, na primer u C++ izvornom kodu, je niz karaktera koji povremeno ukljuuju znak za novi red. U nekim operativnim sistemima (Windows), kada program smešta newline karakter u fajl, newline karakter
- 325 -
se fiziki skladišti kao dva karaktera: carriage return i line feed (CR+LF). Slino, kada program proita CRLF par iz tekstualnog fajla, sistem ih konvertuje u jedan newline karakter. Mada program "vidi" samo jedan znak, newline znak, operativni sistem ustvari procesira CRLF par. Kada procesiramo fajl na sluajan nain, program mora da zna njegovu tanu poziciju u fajlu. Ako pokušamo da procesiramo sluajno fajl koji je otvoren kao tekstualni fajl (što je po difoltu kada koristimo mod otvaranja) program može da izgubi poziciju u fajlu. Ovo može da nastane zbog konverzije newline karaktera u par CRLF. Zbog toga kada procesiramo fajl sluajno, ne treba da otvorimo fajl kao tekstualni. Kada program otvori fajl kao binarni fajl, ni jedan karakter se ne menja kada se ita ili upisuje u fajl. Program e procesirati newline karakter koji je memorisan kao par CRLF, kao par karaktera umesto jednog karaktera. Za otvaranje fajla binarno, mora da koristite mod otvaranja ios::binary zajedno sa jednim od modova koje smo ranije objasnili. Da biste ovo uradili zahteva se korišenje operatora ili |, bitwise OR operatora. Nemojte da ga zamenite sa logikim operatorom OR, ||. Bitwise OR radi na nivou bitova izmeu operanada. Ako je jedan od dva bita 1, onda bitwise OR daje 1. Ako su oba bita 0, bitwise OR kao rezultat daje 0. Na primer: 1010 1010 0010 0111 ------------1010 1111
Prvi operand Drugi operand Bitwise OR
Bitwise OR se koristi da postavi (na 1) odgovarajue bitove. Napomena, u prethodnom primeru, ako je bit prvog operanda 0, rezultat bitwise OR je kopiranje odgovarajueg bita drugog operanda u rezultat. Sa druge strane, ako je bit prvog operanda 1, rezultat bitwise OR je 1 na odgovarajuoj poziciji rezultata, bez obzira koji je bit drugog operanda. Znai, da bi setovali bit na 1, treba primeniti bitwise OR sa 1. Primena bitwise OR sa 0 ostavlja bit nepromenjen. Na primer, primenimo bitwise OR kada ne znamo drugi operand: 0010 0000 ???? ???? -----------??1? ????
Prvi operand Drugi operand Bitwise OR
- 326 -
Bez obzira koja je bit vrednost drugog operanda, trei bit sa leve strane mora biti 1 u rezultatu. Preostalih sedam bitova se kopira u rezultat. Modovi otvaranja za fajlove, na primer ios::in i ios::binary, ustvari ukazuju na specifine bitove stanja varijable definisane u klasi ios. Ilustracije radi, pretpostavimo da otvaranje fajla u ios:: in modu kao rezultat daje postavljanje drugog bita varijable na 1. 0100 0000
Takoe pretpostavimo da otvaranje fajla u ios::binary modu kao rezultat daje postavljanje petog bita na 1. 0000 1000
Sada, ako otvorimo fajl u ios::in | ios::binary modu, primena bitwise OR na dva moda dae: 0100 0000 0000 1000 -----------0100 1000
ios::in ios::binary ios::in | ios::binary
Fajl e biti otvoren i u ulaznom i u binarnom modu. Sledea naradba e zbog toga otvoriti fajl bindata.dat kao binarni ulazni fajl: fstream in_file ("bindata.dat", ios::in | ios::binary);
Mogue je takoe otvoriti fajl koristei tri moda otvaranja: fstream iofile("bindata.dat", ios::in | ios::out | ios::binary);
Fajl bindata.dat je otvoren u binarnom modu i kao ulazni i kao izlazni fajl. Zbog toga, program može da ita i upisuje podatke u fajl bez potrebe da zatvori i otvori fajl izmeu operacija. Funkcije lanice sa sluajnim pristupom C++ I/O klase sadrže nekoliko metoda koji omoguavaju programu da pristupi fajlu sluajno. Svaki od ovih metoda radi sa fajlovim File Position
- 327 -
Indicator, FPI. Podsetimo se da metodi getc() i putc() odreuju gde da pristupe fajlu koristei FPI. Zbog toga, ako radimo sa FPI, možemo da itamo ili
upisujemo karaktere na bilo kojoj željenoj lokaciji u fajlu. Sledei metodi koji rade sa strim objektima su na raspolaganju za sluajan pristup fajlu: seekg(offset, mode)
// za ulazne fajlove – pomeraj za vrednost offset-a kako // je definisano modom. seekp(offset, mode) // za izlazne fajlove - pomeraj za vrednost offset-a kako // je definisano modom. tellg() // za ulazne fajlove – vraca tekucu vrednost za FPI (long). tellp() // za izlazne fajlove - vraca tekucu vrednost za FPI (long).
Sufiks "p" je od "put" a sufiks "g" od "get." Pomeraj-offset mora biti long integer (pozitivan ili negativan). Mod može biti: ios::beg ios::cur ios::end
//smesta FPI na pocetak fajla. // smesta FPI na tekucu poziciju u fajlu. // smesta FPI na kraj fajla.
Nekoliko primera ilustruju korišenje ovih metoda. Slika prikazuje fajl sa osam karaktera "fpitest.dat", koji je otvoren kao binarni fajl: fstream in_file("fpitest.dat", ios::in | ios::binary);
- 328 -
Otvaranje fajla u ios::in modu postavlja njegov FPI na 0 (slika a). Karet je iznad znaka na koji FPI pokazuje. Slika b prikazuje FPI nakon izvršenja in_file.seekg(3L, ios::cur). Sufiks L prouzrokuje da raunar uskladišti integer 3 kao long umesto default tip int. Kako je drugi argument seekg() - ios::cur, metod inicijalno ne menja vrednost FPI. Pošto je prvi argument 3L, seekg() dodaje 3 vrednosti FPI. Tako da je vrednost FPI = 3 i karakter na koji pokazuje je "d". Slika c prikazuje kako pomeriti FPI na kraj fajla izvršavajui in_file.seekg(0L, ios::end).
Slika d prikazuje da prvi argument u seekg() može biti negativan. Naredba in_file.seekg(-2L, ios::cur) oduzima 2 od trenutne vrednosti FPI. Zato, naredba "vraa" FPI na karakter 'g'. Konano, slika e, naredba in_file.seekg (0L, ios::beg) postavlja FPI nazad na 0, što ini da FPI pokazuje na prvi karakter u fajlu. Možete da koristite metod tellg() da naete vrednost FPI u bilo kojoj taki programa. Na primer, sledee naredbe izraunavaju veliinu fajla u bajtovima:
- 329 -
long file_size; in_file.seekg(0L, ios::end); file_size = in_file.tellg();
Sledei program ilustruje ove koncepte. Program pita korisnika za ime fajla. Program otvara fajl, menja u velika slova njegove karaktere i zatvara fajl. #include #include #include #include #include using namespace std; int main() { char file_name [51]; char ch; cout << "Enter the file you want to uppercase: "; cin.getline(file_name, 51); fstream file(file_name, ios::in | ios::out | ios::binary); if (!file) { cout << endl; cout << "ERROR: Could not open file."; exit(1); } while ( (ch = file.get()) != EOF) { ch = toupper(ch); file.seekg(-1L, ios::cur); file.put(ch); cout << file.tellg() << setw(6) << ch << endl; } cout << endl; cout << "Program Terminated." << endl; cout << endl; file.close();
- 330 -
return 0; }
Program poinje porukom koja je upuena korisniku da ukuca ime fajla na koji se primenjuje promena malih u velika slova. Program skladišti ime fajla u niz file_name[]. Program zatim kreira fstream objekat nazvan file, koji je otvoren kao binarni fajl i za ulaz i za izlaz. Nakon provere da li je fajl otvoren korektno, program ulazi u while petlju. Petlja while testira (gets) karakter iz fajla i testira uslov za kraj fajla. Ako se karakter uita, prva naredba u telu petlje skladišti uppercase verziju karaktera u varijablu ch. Zato što file.get() poveava FPI za jedan, sledea naredba u telu petlje oduzima jedan od FPI. Ovo omoguuje da sledea fajl operacija, file.put(ch), - 331 -
smešta karakter nazad na njegovu originalnu poziciju u fajlu. Napomena, izvršenje file.put(ch) ponovo poveava FPI za jedan, tako sledei file.get() e vratiti sledei karakter u fajl. Poslednja naredba u telu petlje prikazuje trenutnu vrednost FPI koristei file.tellg() i trenutnu vrednost ch. 11.4 Procesiranje binarnog fajla sekvencijalno U jeziku C++ možemo da skladištimo i procesiramo sve podatke u zapis kao jedinicu koristei strukturu. Na primer, možemo koristiti sledeu strukturu part record fajla za inventar, gde se svaki zapis u fajlu sastoji od tri polja: identifikacionog broja, koliine i cene. lanovi strukture su polja zapisa: struct Part_Record { char id_no[3]; int qoh; double price; }; Part_Record struktura je u binarnoj formi.
Zato što je svako polje u strukturi Part_Record fiksne veliine (3 bajta za id_no, 4 bajta za qoh, i 8 bajtova za price), nema potrebe za odvajanjem polja razmakom. Takoe, kada upisujemo zapise u binarni sekvencijalni fajl, newline karakter nee da odvaja jedan zapis od drugog. Umesto toga zapisi se razlikuju po dužini zapisa. Ovo je mogue zato što su svi zapisi u fajlu iste veliine. U ovoj sekciji prodiskutovaemo kako da kreiramo i procesiramo binarne sekvencijalne fajlove koji su sastavljeni od niza struktura, odnosno kako da kreiramo i procesiramo sekvencijalni binarni fajl zapisa. Kreiranje binarnog sekvencijalnog fajla zapisa Prvo posmatrajmo binarne fajlove koji su kreirani i kojima se pristupa sekvencijalno. Pretpostavimo da imamo fajl sa podacima koji su zapisi inventara koji su kreirani ranije. Svaki zapis je linija u polju. Svaka linija se sastoji od broja dela iz dva bita, od koliine u formatu celog broja i jedinine cene predstavljene u formatu decimalne vrednosti. Blanko prostor odvaja jedno polje od drugog. Sledi primer fajla sa popisom inventara.
- 332 -
23 15 65 56 59 12 84 03 44
145 46 230 37 1074 26 19 81 39
24.95 67.99 11.95 73.95 3.95 104.99 55.95 18.95 31.95
Želimo da napišemo program koji ita zapise iz ovog fajla i upisuje ih u binarni sekvencijalni fajl. Pretpostavimo da su zapisi iz binarnog sekvencijalnog fajla Part_Record strukture, kao što je opisano ranije. Jedan nain da išitamo zapise iz ulaznog tekst fajla je korišenje operatora ekstrakcije <<. Kako treba da dobijemo tri polja iz fajla za svaki zapis, koristimo funkciju Read_Part_Record() da bismo proitali zapis iz fajla. Definicija funkcije je sledea: void Read_Part_Record(ifstream& ifs, Part_Record& pr) { ifs >> pr.id_no; ifs >> pr.qoh; ifs >> pr.price; }
Funkcija ima dva argumenta. Prvi je referenca na ifstream objekat. Zato, možemo da prosledimo input file object name kao prvi argument. Drugi argument je referenca na strukturu Part_Record. Funkcija ita tri uzorka podataka iz ifstream objekta, ifs, i smešta ih u strukturu sa tri lana. Program može zatim da radi sa part strukturom. Pretpostavimo sledee deklaracije: Part_Record part; ifstream input_file(input_file_name);
Da bismo itali podatke iz ulaznog fajla, možemo da izvršimo sledeu naredbu, koja ita zapis iz input_file i smešta kopiju zapisa u strukturu part. Read_Part_Record(input_file, part);
- 333 -
Sada kada možemo da itamo podatke iz ulaznog fajla, želimo da ih upišemo u binarni fajl kao strukturu. Da bismo ovo uradili zahteva se metod write(). Kastujemo pokaziva na strukturu kao (char*) iz sledeeg razloga. Programeri koji su pisali kod za metod write() nisu mogli da znaju tip podatka prvog argumenta. Prvi argument može da bude pokaziva na bilo koju strukturu koju izaberete. Da biste dozvolili da metod write() bude korišen sa bilo kojim pokazivaem, metod pretpostavlja da njegov prvi argument bude karakter pointer. Onda, da bi koristio metod, programer prosto kastuje prvi argument kao karakter pointer. Operator sizeof() (nije funkcija) vraa broj bajtova koji su potrebni za skladištenje promenljive tipa koji je njegov argument. Koristite operator sizeof() na isti nain kao što koristite funkciju. Smestite ime tipa podatka (kao jedan od ugraenih C++ tipova ili korisniki definisanih tipova) u zagrade nakon sizeof(). Vrednost koju vraa operator je broj bajtova potrebnih za skladištenje varijable tog tipa. Na primer, sizeof(int) je broj bajtova potrebnih da uskladišti ceo broj u sistem u kome je funkcija odreena. Na Windows ili UNIX/Linux sistemu, sizeof(int) je 4. Metod write(), koji može da se primeni na bilo koji objekat izlaznog fajla otvoren u binarnom modu, ima sledeu sintaksu: write( (char*) ptr, item_size)
U prethodnoj sintaksi, ptr je pokaziva na podatke koji treba da budu upisani. Pokaziva mora da se kastuje kao karakter pointer zato što e u opštem sluaju on pokazivati na istu vrstu strukture. Drugi argument item_size je broj bajtova koji treba da se upišu, koji je obino veliina strukture koja se upisuje u fajl. Koristite operator sizeof(). Da bi se upisala kopija promenljive part strukture u fajl input_file, treba da se izvrši sledea naredba: input_file.write( (char*) &part, sizeof(Part_Record) );
Prvi argument, &part je adresa prostora u memoriji koji treba da se kopira u fajl. Kao što se traži od metoda, (char*) kastuje Part_Record pokaziva kao karakter pointer. Drugi argument je broj bajtova koji se kopiraju. Sledei program ita zapise iz tekstualnog fajla i upisuje strukture u binarni sekvencijalni fajl zapisa.
- 334 -
//Ovaj program kreira sekvencijalni fajl od struktura iz tekstualnog fajla podataka //On koristi operator >> za dobijanje podataka iz tekstualnog fajla i koristi write() //metod za upis struktura u izlazni fajl. #include #include #include using namespace std; struct Part_Record { char id_no[3]; int qoh; double price; }; void Read_Part_Record(ifstream&, Part_Record&); int main() { int record_count = 0; char input_file_name[51]; char output_file_name[51]; Part_Record part; cout << "Enter the name of the text file: "; cin.getline(input_file_name, 51); ifstream input_file(input_file_name); if (!input_file) { cout << endl; cout << "ERROR: Could not open text file."; exit(1); } cout << endl; cout << "Enter the name of the sequential file: "; cin.getline(output_file_name, 51); ofstream output_file(output_file_name, ios::binary); if (!output_file) {
- 335 -
cout << endl; cout << "ERROR: Could not open sequential file: "; exit(1); } //Cita prvi zapis Read_Part_Record(input_file, part); while (!input_file.eof()) { output_file.write( (char *)&part, sizeof(Part_Record) ); ++record_count; Read_Part_Record(input_file, part); } cout << endl << endl << record_count << " records written."; input_file.close(); output_file.close(); cout << endl; return 0; } void Read_Part_Record(ifstream& ifs, Part_Record& pr) { ifs >> pr.id_no; ifs >> pr.qoh; ifs >> pr.price; }
- 336 -
U programu prvo deklarišemo broja record_count, koji broji zapise koje program procesira. Dva niza karaktera memorišu sistemska imena ulaznog i izlaznog fajla. Deo part strukture Part_Record je deo gde program smešta podatke. Program zatim dobija imena ulaznog i izlaznog fajla i otvara pridružene fajl objekte. Obratite pažnju da se ulazni fajl otvara, po default-u, kao tekstualni fajl, a izlazni se otvara kao binarni fajl. Kada se ita fajl sekvencijalno, morate da vodite rauna da vaš program procesira poslednji ulazni zapis, i da ga procesira samo jednom. Programski kôd prethodnog primera sledi ove napomene. Nakon otvaranja ulaznog fajla, program ita prvi zapis koristei funkciju Read_Part_Record(). Program prosleuje kao reference argumente funkciji ime fajla i deo part strukture Part_Record. U telu funkcije, operator ekstrakcije dobija tri polja i smešta svako u odgovarajui podatak lan strukture. Petlja while zatim testira uslov za kraj fajla. Ako nije kraj fajla, telo petlje izvršava i procesira zapis. Procesiranje je prosto upis kopije zapisa u sekvencijalni izlazni fajl i poveanje brojaa zapisa. Zatim se fajl ita ponovo. Program napušta petlju kada se ispuni uslov za kraj fajla. Program na kraju prikazuje broj zapisa koji su procesirani i zatvara fajlove.
- 337 -
12. Specijalne teme: Prijateljske funkcije, preklapanje operatora, makroi i inline funkcije 12.1 Prijateljske (friend) funkcije Do sada smo videli da su metodi klasa jedine funkcije koje imaju pristup privatnim instancama promenljivih te klase. Meutim, ponekad je poželjno da funkcija koja nije metod te klase ima pristup privatnim instancama promenljivih date klase. Definisanje prijateljske funkcije Pretpostavimo da u sistemu koji koristi Savings_Account klasu želimo da primenimo funkciju koja prebacuje novac sa jednog štednog rauna na drugi. Mogue rešenje bi bilo da se napiše Savings_Account metod, Transfer_Method. Metod bi imao dva argumenta: prvi bi bio raun sa koga prebacujemo odreenu koliinu, a drugi argument bi bio koliina para za transfer. Raun na koji primenjujemo metod bi bio raun na koji prebacujemo sredstva. Na primer, ako su acc1 i acc2 štedni rauni, sledea naredba bi izvršila transfer 100.00 sa acc2 na acc1 acc1.Transfer_Method(acc2, 100.00);
Drugi pristup bio bi definisanje funkcije koja nije lan Transfer1() koja ima tri argumenta: prvi je prijemna sredstva, drugi sredstva koja se predaju i trei sredstva za transfer. Tako bismo za transfer 100.00 sa acc2 na acc1, napisali sledeu naredbu: Transfer1(acc1, acc2, 100.00);
Koristiemo metode klase Savings_Account da bismo napisali kod za takvu funkciju. Funkcija vraa true ako je transfer uspešan i false ako nije. bool Transfer1(Savings_Account acc1, Savings_Account acc2, double amount) { if (!acc2.Withdraw(amount)) return false; acc1.Deposit(amount);
- 338 -
return true; }
Podsetimo se da metod Withdraw() vraa true ako je podizanje sa rauna mogue. Naredba if u funkciji transfer1() vraa false ako podizanje nije izvršeno. Smetnja za primenu funkcije za transfer je da funkcija zahteva izvršenje dve druge funkcije Withdraw() i Deposit(). Funkcija bi bila efikasnija kada bi mogla direktno da pristupi instancama varijabli parametara acc1 i acc2. Rešenje je kreirati „prijateljsku“ friend funkciju. Prijateljska funkcija klase ima ista prava pristupa kao metodi klase, ali sama nije metod. Sledi, prijateljska funkcija klase ima pristup svim privatnim lanovima klase kao da je metod te klase. Važno je znati da se u klasi mora deklarisati funkcija da bude prijateljska. Ovo narušava princip skrivanja podataka ako bilo koja funkcija može da deklariše sebe kao friend funkciju te klase! Da bismo deklarisali funkciju da bude prijateljska funkcija klase treba uraditi sledee: -Deklarisati funkciju unutar deklaracije klase, gde prethodi kljuna re friend povratnom tipu funkcije. Nije važno u kojoj kategoriji pristupa je definisana funkcija (public ili private). -Kada se definiše funkcija izvan klase, ne treba ponoviti rezervisanu re friend. Rezervisana re friend se može pojaviti u deklaraciji klase. U deklaraciji klase Savings_Account napisaemo sledei kod: class Savings_Account { friend bool Transfer(Savings_Account&, Savings_Account&, double); private: . . . public: . . . };
- 339 -
Treba obratiti pažnju da smeštamo deklaraciju friend funkcije pre svakog specifikatora pristupa. Prosleujemo dva štedna rauna funkciji po referenci zato što funkcija mora da promeni oba Account objekta koji su prosleeni kao argumenti. Ako prosledimo Savings_Account objekte po vrednosti, promene koje funkcija napravi bie uraene na parametrima funkcije (to su kopije argumenata) a ne na samim argumentima. Sledi kod za funkciju: bool Transfer(Savings_Account& acc_r1, Savings_Account& acc_r2, double amount) { //Ako iznos prelazi stanje na racunu „acc_r2“, ne radi nista i vrati „false“ if (amount > acc_r2.balance) return false; //U suprotnom, izvrsi transfer i vrati "true" acc_r2.balance = amount; //smanji „acc_r2 balance“ prema iznosu acc_r1.balance += amount; //povecaj „acc_r1 balance“ prema iznosu return true; }
Ova funkcija je nešto duža od funkcije transfer1(), ali je efikasnija jer ne mora da izvršava funkcije kako bi izvršila svoj zadatak. Napomena, možemo direktno da pristupimo private podacima lanovima sa oba rauna zato što je transfer() friend funkcija klase Savings_Account. Mora da koristimo operator taka (dot .) kako bi pristupili lanovima podacima oba parametra zato što Transfer() nije metod klase. Sledi kompletan program koji koristi transfer() funkciju. Da bismo uprostili program koji smo ranije napravili, treba da uklonimo Calc_Interest(), Deposit(), i Withdraw() metode. //Ovaj program prikazuje rad sa friend funkcijama. //Da bismo uprostili program uklanjamo funkcijeCalc_Interest(), Deposit() i Withdraw(). #include #include #include
- 340 -
using namespace std; class Savings_Account { friend bool Transfer(Savings_Account&, Savings_Account&, double); private: char id_no[5]; char* name; double balance; double rate; public: Savings_Account(char id[], char* n_p, double bal = 0.00, double rt = 0.04); ~Savings_Account(); const char* Get_Id() const; const char* Get_Name() const; double Get_Balance(); }; Savings_Account::Savings_Account(char id[], char* n_p, double bal, double rt) { strcpy(id_no, id); //kopira prvi argument u id_no[] name = new char[strlen(n_p) + 1]; //kreira prostor za name strcpy(name, n_p); //kopira drugi argument u novi prostor balance = bal; rate = rt; } Savings_Account::~Savings_Account() { cout << endl << endl; cout << "Account " << id_no << " terminated." << endl; delete [] name; } const char* Savings_Account::Get_Id() const { return id_no; } const char* Savings_Account::Get_Name() const { return name; } double Savings_Account::Get_Balance() {
- 341 -
return balance; } bool Transfer(Savings_Account& acc_r1, Savings_Account& acc_r2, double amount) { //Ako iznos prelazi stanje na racunu acc_r2, ne radi nista i vrati 0 if (amount > acc_r2.balance) return false; //U suprotnom, prenesi sredstva i vrati 1 acc_r2.balance = amount; //umanjuje stanje acc_r2 za odredjeni iznos acc_r1.balance += amount; //uveava stanje na acc_r1 za odredjenu kolicinu return true; } void Display_Account(Savings_Account&);
//Prototip funkcije
int main() { cout << setprecision(2) << setiosflags(ios::fixed) << setiosflags(ios::showpoint); double amount; Savings_Account acc1("1111", "Adam Zapple", 100.00, 0.08); Savings_Account acc2("2222", "Poly Ester", 200.00, 0.06); Display_Account(acc1); Display_Account(acc2); cout << endl; cout << "Enter an amount to transfer from the second account " << "to the first: "; cin >> amount; if (Transfer(acc1, acc2, amount)) { cout << endl; cout << "Transfer made. Updated Account Information:" << endl; Display_Account(acc1); Display_Account(acc2); } else {
- 342 -
cout << endl; cout << "Transfer could not be made." << endl; } return 0; } void Display_Account(Savings_Account& acc) { cout << endl; cout << "Data for Account# " << acc.Get_Id() << endl << endl; cout << "Owner's Name: " << acc.Get_Name() << endl << endl; cout << "Account Balance: " << acc.Get_Balance() << endl << endl; }
Obratite pažnju na nain kako glavna funkcija main() koristi funkciju Transfer(). Naredba if testira uslov da li je transfer bio uspešan. Ako jeste program prikazuje na displeju poruku i nove informacije o štednom raunu. Ako transfer nije uspešan, program prikazuje odgovarajuu poruku. Sledi
- 343 -
izvršenje programa u kome tražimo transfer više novca sa prvog rauna nego što je na raunu.
Nasleivanje i prijateljske funkcije Prijateljske funkcije se ne nasleuju u hijerarhiji klasa. Ako je funkcija "prijatelj" osnovne klase u hijerarhiji klasa, ona nije "prijatelj" bilo kojoj izvedenoj klasi. Ako želite da takva funkcija bude prijatelj izvedenoj klasi, mora da je deklarišete kao takvu u izvedenoj klasi. 12.2 Preklapanje osnovnih aritmetikih operatora Videli smo u poglavlju da C++ dozvoljava preklapanje konstruktora. C++ takoe dozvoljava programeru preklapanje operatora. Možemo da proširimo znaenje operatora sabiranja +, operatora insertovanja <<, i veine drugih C++ operatora. Prikazaemo sada kako se preklapaju osnovni aritmetiki operatori, drugi operatori dodele, insertovanja i ekstrakcije, kao i relacioni operatori. Sabiranje dva objekta Razmotrimo klasu Test_Class, koju smo koristili u prethodnom poglavlju.
- 344 -
class Test_Class { private: int n; public: Test_Class(int i = 0); //Konstruktor sa jednim argumentom Test_Class(Test_Class&); //Konstruktor kopije ~Test_Class(); int Get_Value(); }; Test_Class::Test_Class(int i) { n = i; cout << endl; cout << "Constructor Executed: Data member initialized to " << n << endl; } Test_Class::Test_Class(Test_Class& tc_r) { n = tc_r.n; cout << endl << endl; cout << "Copy constructor executed: " << "Data member initialized to " << n << endl; } Test_Class::~Test_Class() { cout << endl << endl; cout << "Destructor Executed for object with data member " << n << endl; } int Test_Class::Get_Value() { return n; }
Pretpostavimo da smo napravili sledee deklaracije u glavnoj funkciji main(). Test_Class tc_object1(4); Test_Class tc_object2(7);
- 345 -
Test_Class tc_object3; Test_Class objekat ima samo jedan podatak lan, ako želimo da
napravimo sledeu dodelu: tc_object3 = tc_object1 + tc_object2;
operacija dodele treba da se proširi tako da ukljuuje i dodelu dva objekta tipa Test_Class drugom objektu tipa Test_Class. Trebalo bi da operator dodeli vrednost 11 (što je suma vrednosti podataka lanova objekata tc_object1 i tc_object2) podatku lanu tc_object3. Možemo usvari proširiti znaenje sabiranja kao u ovom primeru preklapanjem + operatora. Operator može biti preklopljen kao metod klase ili kao friend funkcija. Jedan preklopljen operator koji menja jedan od svojih operanada treba da bude definisan kao metod klase. Svi drugi preklopljeni operatori treba da budu definisani kao prijateljske funkcije. Meutim, sledei operatori mora da budu preklopljeni kao metodi klase: dodela (=), funkcijski poziv (()), indeksi nizova ([]), operator indirekcije lana (->).
Sledi, operatori kao što su: sabiranje, oduzimanje, proizvod i deljenje, kao i operatori insertovanja i brisanja, treba da budu deklarisani kao prijateljske funkcije. Operatori kao što su složena dodela (+=, - =, i tako dalje) treba da budu deklarisani kao metodi klase. Poeemo od operatora koji su definisani kao prijateljske funkcije. Takvi operatori ukljuuju aritmetike operatore i insertion i extraction operatore. Da biste deklarisali preklopljen friend operator, koristite sledeu sintaksu: friend povratni-type operator simbol-operatora (lista_argumenata);
Kljuna re operator je obavezna i mora da bude pre simbola operatora. Na primer, ovako izgleda deklaracija preklopljenog operatora sabiranja za klasu Test_Class, koja mora da se pojavi u deklaraciji klase: friend Test_Class operator + (const Test_Class&, const Test_Class&);
- 346 -
Dva argumenta u funkciji predstavljaju dva operanda (respektivno) u binarnoj operaciji sabiranja. Kod preklapanja binarnog operatora kao friend funkcije, prvi argument preklapanja uvek predstavlja levi operand a drugi argument uvek predstavlja desni operand. Sledi kôd preklopljenog operatora sabiranja: Test_Class operator + (const Test_Class& left_op, const Test_Class& right_op) { Test_Class temp_obj; // Uzima „default“ vrednost 0 za n temp_obj.n = left_op.n + right_op.n; return temp_obj; }
koristimo imena left_op i right_op za prvi i drugi argument zato što oni predstavljaju levi i desni operand operatora. Ako pišemo kôd za izraz tc_object1 + tc_object2, tc_object1 je vrednost left_op zato što je on levo od operatora, i tc_object2 je vrednost right_op zato što je on desno od operatora. Preklopljen operator sabiranja vraa Test_Class objekat. Zato, prva naredba u funkciji deklariše privremeni objekat Test_Class, temp_obj, iju vrednost funkcija vraa pozivajuem programu. Sledea naredba u funkciji dodeljuje vrednosti instance varijable n privremenog objekta temp_obj, zbir instanci varijable n left_op i right_op. Konano, funkcija vraa kopiju temp_obj pozivajuem programu. Sabiranje objekta i celog broja Posmatrajmo primer sabiranja obine celobrojne konstante i Test_Class objekta: Test_Class tc_object1(4); Test_Class tc_object2; tc_object2 = tc_object1 + 15;
Bilo bi razumno da se dodeli 19 (zbir n instance varijable objekta tc_object1 i celobrojne konstante 15) instanci promenljive n objekta tc_object2. Sledi deklaracija i kod preklopljenog operatora sabiranja: friend Test_Class operator + (const Test_Class&, const int);
- 347 -
Test_Class operator + (const Test_Class& left_op, const int right_op) { Test_Class temp_obj; temp_obj.n = left_op.n + right_op; return temp_obj; }
Na osnovu prethodnog koda nije ispravno pisati: tc_object2 = 7 + tc_object1;
Sledi kompletan program koji koristi dva preklapanja operatora sabiranja. Treba obratiti pažnju da smo dali komentare cout naredbe u konstruktoru, konstruktoru kopije i destruktoru kako bi izlaz bio jednostavniji. //Ovaj program ilustruje preklapanje operatora sabiranja #include using namespace std; class Test_Class { friend Test_Class operator + (const Test_Class&, const Test_Class&); friend Test_Class operator + (const Test_Class&, const int); private: int n; public: Test_Class(int i = 0); //Konstruktor sa jednim argumentom Test_Class(Test_Class&); //Konstruktor kopije ~Test_Class(); int Get_Value(); }; Test_Class::Test_Class(int i) { n = i;
- 348 -
//cout << endl; //cout << "Constructor Executed: Data member initialized to " // << n << endl; } Test_Class::Test_Class(Test_Class& tc_r) { n = tc_r.n; //cout << endl << endl; //cout << "Copy constructor executed: " // << "Data member initialized to " << n << endl; } Test_Class::~Test_Class() { //cout << endl << endl; //cout << "Destructor Executed for object with data member " // << n <
- 349 -
Test_Class tc_object1(4); Test_Class tc_object2(7); Test_Class tc_object; cout << endl << endl; cout << "Prior to adding the objects, the value of tc_object is " << tc_object.Get_Value() << endl; tc_object = tc_object1 + tc_object2; cout << endl << endl; cout << "After adding the objects, the value of tc_object is " << tc_object.Get_Value() << endl; tc_object = tc_object1 + 15; cout << endl << endl; cout << "After adding 15 to tc_object1, the value of tc_object is " << tc_object.Get_Value() << endl; return 0; }
Program Output Prior to adding the objects, the value of tc_object is 0 After adding the objects, the value of tc_object is 11 After adding 15 to tc_object1, the value of tc_object is 19
Objekat tc_object poinje time da instanca promenljive n ima default vrednost 0. Nakon sabiranja objekata tc_object1 (vrednost instance promenljive je 4) i tc_object2 (vrednost instance promenljive je 7) i dodele rezultata objektu tc_object, vrednost instance promenljive objekta tc_object je 11. Konano, nakon dodavanja celobrojne vrednosti 15 objektu tc_object1 (ija je vrednost instance promenljive 4) i dodele rezultata objektu tc_object, instanca varijable objekta tc_object ima vrednost 19. Treba obratiti pažnju da preklapanje operatora sabiranja kao rezultat daje da su naredbe kao što je sledea mogue: tc_object = tc_object1 + tc_object2 + tc_object3 + 6;
- 350 -
Prvo sabiranje kao rezultat daje privremeni objekat Test_Class, koji se onda dodaje objektu tc_object3, gde se opet stvara objekat Test_Class. Tree sabiranje onda dodaje ovaj privremeni objekat celom broju 6 i kao rezultat daje novi privremeni objekat, koji se dodeljuje objektu tc_object. Pravila preklapanja operatora Sledea pravila mora da se uzmu u obzir pri preklapanju operatora. x Svi operatori se mogu preklopiti osim sledeih: . pristup lanu (dot operator) :: razrešenje dosega ?: condicional sizeof operator veliine new dinamika alokacija delete dealokacija .* pristup lanu x Sledei operatori moraju biti metodi klasa: = dodela () funkcijski poziv [] lanovi niza -> indirektan pristup lanu x Ne možete da menjate unarnu/binarnu prirodu operatora. Sledi, deljenje mora da ostane binarni operator. Ako je jedan operator i unarni i binarni (na primer +), onda on mora da bude preklopljen ili na jedan ili na drugi ili na oba naina. x Ne možete da preklopite unapred definisana pravila prioriteta. Preklapanje operatora dodele i this pokazivaa U ovoj sekciji, objasniemo kako da preklopite operator dodele. Da bismo preklopili operator dodele, na isti nain kao i dodelu ugraenih tipova, mora da koristimo specijalan pokaziva this, koji je na raspolaganju svakom metodu klase. Preklapanje operatora dodele Spomenuli smo više puta da možemo da dodelimo jedan objekat drugom objektu iste klase. Pri tome se dodela izvodi lan-po-lan (member- 351 -
by-member). Ovaj tip dodele je odgovarajui za objekte Test_Class, koji imaju jednu celobrojnu instancu promenljive. Meutim member-by-member kopiranje nije odgovarajue za klasu koja ima jedan ili više pokazivaa kao instance promenljivih. Na primer, neka su acc1 i acc2 objekti klase Savings_Account, koji imaju name instancu promenljive koja pokazuje na ime osobe koja je vlasnik štednog rauna. Pretpostavimo da je dodela acc1 = acc2. Kako je kopija nainjena na osnovu member-by-member, ime lanova oba objekta pokazuju sada na ime pridruženo objektu acc2. Na taj nain oba pokazuju na isti fiziki prostor u hip memoriji. Sledi da promena imena ili štednog rauna e prouzrokovati da se ta promena pojavi u oba. Da bismo izbegli ovo mora da preklopimo operator dodele. Treba da napišete kod za preklapanje operatora na takav nain da se preklopljeni operator ponaša kao odgovarajui tipovi podataka. Za preklopljen operator dodele, ovo znai da sledee dodele imaju smisla za objekte klase Savings_Account. acc1 = acc2 = acc3;
Podsetimo se da u C++, svaki izraz ima vrednost. Vrednost dodele je leva strana operatora dodele. Kako se dodela izvršava sa desne strane na levu vrednost prve dodele acc2 = acc3, je objekat acc2. Zatim druga dodela pridružuje objekat acc2 objektu acc1. Kako bismo nainili da se preklopljeni operator dodele ponaša kao obian operator dodele, želimo da i sledei izraz radi korektno: (acc1 = acc2) = acc3;
U ovom sluaju leva dodela se prvo izvršava. Rezultat je objekat acc1, kome se onda dodeljuje vrednost objekta acc3.
Da bismo uinili da višestruke dodele rade na nain koji je nama pogodan, naša preklapanja mora da vrate objekat na koji je operator primenjen. Zato, operator mora da vrati reference na prvi argument, a ne kopiju prvog argumenta. Dodela je binarni operator, ima levi i desni operand. Za razliku od sluaja kada preklapamo operator sabiranja, operacija dodele menja levi operand. Zato, najbolje je razmišljati o dodeli kao operaciji na levom operandu.
- 352 -
Kada preklapamo binarni operator kao metod klase, objekat na koji se funkcija primenjuje predstavlja levi operand i jedan argument operatora predstavlja desni operand. Sledi deklaracija operatora. Jedan argument preklopljenog operatora je desna strana operatora dodele. Leva strana operatora dodele je objekat na koji je dodela primenjena. Savings_Account& operator = (const Savings_Account&);
Pokaziva this Svaki objekat ima svoje sopstvene kopije instanci promenljivih date klase, ali postoji samo jedna kopija svakog metoda klase za sve objekte koje program može da kreira. Metod zna na koji objekat se primenjuje u smislu specijalnog pokazivaa koji sistem automatski obezbeuje i koji možete da koristite kako vama odgovara. Unutar koda bilo kog metoda klase, pokaziva this, koji je rezervisana re, uvek upuuje na objekat na koji je metod primenjen. Kada C++ kompajler prevodi kôd metoda, this -> prethodi svakoj referenci na instancu varijable. Mada nije neophodno, možete da smestite izraz this -> pre svake instance promenljive name u metodu i program e se kompajlirati i izvršiti korektno. Na primer, za konstruktor klase Test_Class: Test_Class::Test_Class(int i) { n = i; //cout << "\nConstructor Executed: Data member initialized to " << n; }
možemo da zamenimo prethodni kôd sledeim ekvivalentnim kodom: Test_Class::Test_Class(int i) { this -> n = i; //cout << "\nConstructor Executed: Data member initialized to " << n; }
Unutar koda metoda klase, *this predstavlja objekat na koji se metod primenjuje.
- 353 -
Sledi kôd za preklopljeni operator dodele. Savings_Account& Savings_Account::operator = (const Savings_Account& right_op) { if (&right_op == this) ; //ne radi nista else { strcpy(id_no, right_op.id_no); //kopira id desnog operanda right_op u id_no[] delete [] name; name = new char[strlen(right_op.name) + 1]; //kreira prostor za name strcpy(name, right_op.name); //kopira drugi argument u novi prostor balance = right_op.balance; rate = right_op.rate; } return *this; }
Uslov u if naredbi testira da li je desni operand u dodeli jednak prvom operandu. Na taj nain, proveravamo takozvano samo dodeljivanje kao što je acc1 = acc1. Ako je ovaj uslov true, ništa se ne radi, pa se null naredba izvršava. Inae, lanovi sa desne strane operanda su kopije leve strane operanda na isti nain kao što je dato u kodu konstruktora i konstruktora kopije. Treba da obratite pažnju da je neophodno da dealocirate prostor na koji pokazuje ime name instance promenljive levog operanda. Ako ovo ne uradite ostaje alociran prostor koji nije na raspolaganju programu. Program koji sledi testira preklapanje operatora dodele. //Ovaj program prikazuje overloading operatora dodele. #include #include #include using namespace std; class Savings_Account { private: char id_no[5]; char* name;
- 354 -
double balance; double rate; public: Savings_Account(char id[], char* n_p, double bal = 0.00, double rt = 0.04); Savings_Account(const Savings_Account &); ~Savings_Account(); double Calc_Interest(); double Get_Balance(); const char* Get_Id() const; const char* Get_Name() const; void Deposit(double); bool Withdraw(double); Savings_Account& operator = (const Savings_Account&); }; Savings_Account::Savings_Account(char id[], char* n_p, double bal, double rt) { strcpy(id_no, id); //kopira prvi argument u id_no[] name = new char[strlen(n_p) + 1]; //kreira prostor za name strcpy(name, n_p); //kopira drugi argument u novi prostor balance = bal; rate = rt; } Savings_Account::Savings_Account(const Savings_Account& acc_r) { strcpy(id_no, acc_r.id_no); //kopira prvi argument u id_no[] name = new char[strlen(acc_r.name) + 1]; //kreira prostor za name strcpy(name, acc_r.name); //kopira drugi argument u novi prostor balance = acc_r.balance; rate = acc_r.rate; } Savings_Account::~Savings_Account() { delete [] name; } double Savings_Account::Get_Balance() { return balance; }
- 355 -
double Savings_Account::Calc_Interest() { double interest; interest = balance * rate; balance += interest; return interest; } const char* Savings_Account::Get_Name() const { return name; } const char* Savings_Account::Get_Id() const { return id_no; } void Savings_Account::Deposit(double amount) { balance += amount; } bool Savings_Account::Withdraw(double amount) { bool result; if (amount <= balance) { balance = amount; result = true; } else result = false; return result; } Savings_Account & Savings_Account::operator = (const Savings_Account & right_op) { if (&right_op == this) ; //ne radi nista else { strcpy(id_no, right_op.id_no); //kopira id desnog operanda right_op u id_no[] delete [] name; name = new char[strlen(right_op.name) + 1]; //kreira prostor za name
- 356 -
strcpy(name, right_op.name); //kopira drugi argument u novi prostor balance = right_op.balance; rate = right_op.rate; } return *this; } Savings_Account Get_Account(); //Prototip za funkciju Get_Account() void Display_Account(Savings_Account&);
//Prototip za funkciju //Display_Account()
int main() { cout << setprecision(2) << setiosflags(ios::fixed) << setiosflags(ios::showpoint); Savings_Account acc1 = Get_Account(); cout << endl; Display_Account(acc1); Savings_Account acc2 = Get_Account(); cout << endl; Display_Account(acc2); acc1 = acc2; cout << endl << endl; cout << "After the assignment:" << endl << endl; Display_Account(acc1); Display_Account(acc2); return 0; } Savings_Account Get_Account() { char id[5]; char buffer[81]; double bal; double rt;
- 357 -
cout << endl; cout << "Enter Account ID: "; cin.getline(id, 5); cout << endl; cout << "Enter Account Holder's Name: "; cin.getline(buffer, 81); cout << endl; cout << "Enter Balance: "; cin >> bal; cout << endl; cout << "Enter Interest Rate: "; cin >> rt; cin.get(); //brise karakter za novi red iz bafera Savings_Account acc(id, buffer, bal, rt); return acc; } void Display_Account(Savings_Account& acc_r) { cout << endl; cout << "Data for Account# " << acc_r.Get_Id() << endl << endl; cout << "Owner's Name: " << acc_r.Get_Name() << endl << endl; cout << "Account Balance: " << acc_r.Get_Balance() << endl; }
- 358 -
Program kreira dva štedna rauna koristei funkciju Get_Account() i prikazuje sadržaje oba rauna koristei Display_Account(). Zatim program dodeljuje objekat acc2 objektu acc1 i prikazuje sadržaje oba tekua rauna da bi pokazao da su tekui rauni zaista isti. Nasleivanje i preklopljeni operatori Kao i prijateljske funkcije, preklopljeni operatori se ne nasleuju u hijerarhiji klasa. Zbog toga, ako se preklopi operator u osnovnoj klasi, mora da ga preklopite ponovo i u izvedenoj klasi. 12.3 Makroi i inline funkcije Do sada smo definisali simbolike konstante kao const varijable. Takoe, mogue je definisati simbolike konstante koristei pretprocesorsku
- 359 -
direktivu #define. Možete koristiti pretprocesorsku direktivu #define da biste definisali makroe, koji mogu ponekad da zamene funkcije. Simbolike konstante koristei pretprocesorsku direktivu #define Podsetimo se da C++ pretprocesor koristi mehanizam zamene teksta. Pretprocesorska direktiva #define dozvoljava da zamenimo bilo koji izraz definisanim imenom. Na primer deklaraciju const double COMMISSION_RATE = 0.050;
možemo da zamenimo po definiciji sa #define COMMISSION_RATE 0.050
Ova direktiva definiše da simbolika konstanta COMMISSION_RATE ima vrednost 0.050. Kada pretprocesor skenira kod datog programa on zamenjuje svako pojavljivanje simbola COMMISSION_RATE vrednošu 0.050. Sledi, kada pretprocesor skenira liniju straight_commission = sales * COMMISSION_RATE;
on zamenjuje simbol COMMISSION_RATE njegovom unapred definisanom vrednošu 0.050. Pretprocesorske direktive se ne završavaju sa ; , zato što to može da prouzrokuje da taka zarez bude deo definicije, odnosno to prouzrokuje sintaksnu ili logiku grešku. Mada možete da koristite #define za definisanje simbolikih konstanti u bilo kom C++ programu više se koristi definicija simbolike konstante koristei const. Definicija makroa Direktiva #define se takoe može koristiti da definiše makroe sa parametrima. Makro je ime za naredbe i izraze. Na primer: #define SQ(x) x * x
- 360 -
Makro koji se definiše je SQ(x), a njegova definicija je x * x. Kada C++ pretrocesor vidi ovakav #define, on pretražuje program da bi pronašao sva pojavljivanja makroa sa imenom SQ. Pretpostavimo, na primer, da pretprocesor pronae SQ(count) u programu. Pretprocesor tada zamenjuje makro SQ(count) izrazom dobijenim zamenom parametra x u definiciji makroa sa count. Tako e pretprocesor zameniti izraz s = SQ(count);
sa s = count * count;
Zbog toga što pretprocesor koristi mehanizam zamene teksta, on ne proverava korektnost u sintaksi ili znaenju. Na primer, ne možete da stavite razmak nakon imena makroa i pre leve zagrade. Ako ovo uradite pretprocesor e sve što sledi nakon imena makroa da interpretira kao deo definicije, ak i zagrade. Na taj nain, nekorektno definisanje SQ kao #define SQ (x) x * x
kao rezultat pretprocesiranja naredbe s = SQ(count);
daje izraz bez znaenja s = (x) x * x(count);
Data definicija SQ takoe može da prouzrokuje neželjene rezultate (takozvane bone efekte) odnosno promenu u znaenju. Pretpostavimo da imamo sledee definicije i dodelu: int i = 2, j = 4, k; k = SQ(i + j);
- 361 -
Operator dodele ne dodeljuje vrednost 36 promenljivoj k kako prvo može da se pomisli. Pretprocesor ekspanduje makro u dodeli, zamenjujui svaku pojavu parametra x stringom i + j, na sledei nain. k = i + j * i + j;
Kako raunar izvršava operaciju množenja pre operacije sabiranja, desna strana operacije dodele ima vrednost 14. Da biste izbegli ovakav boni efekat razvoja makroa stavite u male zagrade parametre u definiciji makroa na sledei nain: #define SQ(x) (x) * (x)
sledi: k = (i + j) * (i + j);
Daemo sada pregled pravila za pisanje makroa: x Ne stavljajte u kôd razmak izmeu imena makroa i leve zagrade koje slede nakon imena. x Ne završavajte definiciju makroa sa ;. x Stavite svaki parametar u definiciji makroa u zagrade. x Stavite u definiciji makroa ceo makro u zagrade. Makroi mogu imati više parametara. Makroi koji su definisani u programu, mogu da se koriste u definiciji drugih makroa. Poreenje funkcija i makroa Postoji više prednosti korišenja makroa umesto funkcija. Prvo, kako korišenje makroa ne ukljuuje poziv funkcije, ili prosleivanje parametara, makro se izvršava brže od funkcije. Drugo, parametri u makrou nemaju tip. Postoje i loše osobine korišenja makroa umesto funkcija. Prvo, makroi mogu imati bone efekte koji dovode do pogrešnih rezultata. Kod funkcija nema ovakvih bonih efekata. Drugo, mada postoje opšti troškovi overhead pri pozivu funkcije i prosleivanju parametara, mehanizam funkcije je sigurniji za korišenje. Zapamtite da kompajler koristi prototip funkcije da bi obezbedio korektno korišenje funkcijskih parametara i povratnog tipa. Kompajler nema takve provere za makroe.
- 362 -
Inline funkcije U C++, postoji nain da se iskombinuju efikasnost makroa sa bezbednošu funkcija koristei inline funkcije (neposredno ugraivanje u kod). Ako se funkcija insertuje sa inline, kompajler smešta kopiju koda te funkcije u svakoj taki gde se poziva funkcija. Zato, kratke funkcije (jedna ili dve linije koda) su idealne za korišenje inline. Zato što kompajler zamenjuje pozive inline funkcije kodom funkcije, sledi da kompajler mora da zna definiciju funkcije pre bilo kog poziva u programskom kodu. Da bi se ubacila funkcija, treba da se smesti rezervisana re inline pre imena funkcije i definiše funkcija pre bilo kog poziva funkcije. Ovo znai da treba da smestite definiciju funkcije gde obino smeštate prototip funkcije. U našim programima ovo znai da su definicije inline funkcija smeštene pre funkcije main(). Na primer, za sledei makro: #define MAX(x, y) ( ((x) > (y))? (x): (y) )
ekvivalentna inline funkcija je: inline double Max(double x, double y) {return (x > y)? x : y;}
Treba obratiti pažnju da ne treba da koristimo previše zagrada, kao što je bilo neophodno u definiciji makroa zbog izbegavanja bonih efekata. Pretpostavimo da funkcija main() sadrži sledee deklaracije i funkcijske pozive: double d1 = 4.8, d2 = 9.6 d; d = Max(d1, d2);
Kada kompajler realizuje funkcijski poziv Max(), on zamenjuje funkcijski poziv kodom inline funkcije koristei vrednosti argumenata kao vrednosti parametara. Zato, dodela je ekvivalentna sledeem d = (d1 > d2)? d1 : d2;
- 363 -
Inline funkcije takoe igraju važnu ulogu kada su metodi definisani u deklaraciji klase. Razlika izmeu definisanja metoda unutar ili izvan deklaracije klase je da je metod klase koji je definisan unutar deklaracije klase, po default, inline. Ako definišete metod izvan deklaracije klase, tada inline metod, mora da smestite da prethodi definiciji odnosno kljunoj rei inline.
- 364 -
Dodatak A: Integrisano razvojno okruženje Microsoft Visual C++ 1.1 Uvod U ovom delu bie dat kratak uvod u terminologiju okruženja Microsoft Visual C++, odnosno paketa Developer Studio, koji predstavlja zajedniko integrisano razvojno okruženje grupe Microsoft-ovih prevodilaca razliitih programskih jezika.
Slika 1.1.1: Microsoft Visual Studio logo 1.2 Pojmovi U okruženju Microsoft Visual C++ (u daljem tekstu MSVC) razvija se jedan programski paket pomou radnog prostora (eng. workspace) koji sadrži jedan ili više projekata. Projekat (eng. project) se sastoji iz: Ͳ Ͳ Ͳ Ͳ
izvornih (eng. source) fajlova zaglavlja (eng. header) fajlova resursnih (engl. resource) fajlova fajlova koji sadrže informacije o podešavanjima i konfiguraciji
Programski kôd definisan unutar jednog projekta prevodi se u jedan nezavisni izvršni program ili biblioteku. Unutar jednog radnog prostora može postojati više projekata, recimo za razliite aplikacije unutar jednog programskog paketa ili za razliite uslužne programe koji ine paket, za razliite verzije programa, biblioteke itd. Fajl zaglavlje (eng. header file) predstavlja interfejs jedne programske celine (modula) koji sadrži deklaracije elemenata definisanih u tom modulu koje koriste drugi moduli (deklaracije klasa, funkcija, objekata, tipova, konstanti itd.).
- 365 -
Izvorni fajl (eng. source file) sadrži implementaciju programskog modula. Resursni fajl (eng. resource file) sadrži definicije elemenata grafikog interfejsa koje koristi Windows kada izvršava dati program (bit mape, meniji, dijalozi itd.). Pravljenje novog programa poinje stvaranjem novog radnog prostora i projekta. Otvaranje prethodno kreiranog projekta (nastavak rada sa zapoetim projektom) omogueno je otvaranjem fajla sa nastavkom dsw. 1.3 Pokretanje Visual C++ okruženja Okruženje Microsoft Visual C++ se može otvoriti klikom na taster Start i izborom stavke Microsoft Visual Studio 6.0/Microsoft Visual C++ 6.0 iz liste programa (grupa All Programs ili Programs kod starijih verzija MS Windows operativnog sistema). Na slici 1.3.1 je ilustrovan ovaj postupak. Nakon startovanja otvorie se novi prozor prikazan na slici 1.4.1.
Slika 1.3.1: Pokretanje Microsoft Visual C++
- 366 -
1.4 Radno okruženje Radno okruženje Microsoft Visual C++ sastoji se iz sledeeg (slika 1.4.1): Ͳ Ͳ Ͳ Ͳ
Na vrhu su glavni meni i kutija sa alatkama. Sa leve strane nalazi se prozor radnog prostora (engl. workspace). Ovaj deo je klju za kretanje kroz razne delove projekta. Sa desne strane je glavna radna površina na kojoj se ureuju fajlovi. Na dnu su izlazni pano (engl. output panel) i statusna linija (engl. status bar). Izlazni pano možda nee biti vidljiv kada se program startuje prvi put, ali se pojavljuje pri prvom prevoenju programa. Na izlaznom panou vide se poruke koje prevodilac šalje (npr. greške) pri prevoenju i povezivanju.
Slika 1.4.1: Radno okruženje Microsoft Visual C++
- 367 -
1.4.1 Prozor radnog prostora Prozor radnog prostora omoguava kretanje kroz delove projekta na tri razliita naina (slika 1.4.1.1): - Class View (1) omoguava kretanje i manipulaciju izvornim C++ kodom na nivou klasa. On koristi razliite ikone za predstavljanje privatnih, zaštienih i javnih funkcija lanica i atributa. Ako se dvaput pritisne mišem bilo koja stavka, otvara se odgovarajui fajl pri emu je kursor automatski postavljen na odgovarajue mesto. Npr. dvostruko pritiskanje mišem imena klase postavlja kursor na njenu deklaraciju, a dvostruko pritiskanje imena funkcije postavlja kursor na poetak njene definicije. Dvostruko pritiskanje imena atributa postavlja kursor na mesto gde je on deklarisan. Pritiskanje imena klase desnim tasterom miša otvara kontekstni meni koji omoguava brzo nalaženje mesta gde je klasa definisana, dodavanje funkcije ili podataka toj klasi, pregled liste svih mesta gde je klasa referisana, njene odnose sa drugim klasama itd. Slino tome, pritiskanje imena funkcije desnim tasterom miša otvara kontekstni meni koji omoguava da nalaženje mesta gde je funkcija deklarisana odnosno definisana, brisanje, postavljanje take prekida (eng. breakpoint), pregled liste svih mesta u kodu odakle se funkcija poziva itd. Pritiskanje imena atributa desnim tasterom otvara manji meni slian opisanima. - Resource View (2) omoguava pretraživanje i ureivanje raznih resursa aplikacije, kao što su dijalozi, ikone i meniji. - File View (3) omoguava kretanje kroz fajlove od kojih se sastoji aplikacija i njihovo otvaranje. Željeni fajl se otvara dvostrukim pritiskom njegovog imena.
- 368 -
2. OPŠTE MANIPULACIJE PROJEKTIMA 2.1 Kreiranje novog projekta Novi projekat (slika 2.1.1) u Microsoft Visual C++ kreira se na sledei nain. Odabirom opcije File->New otvara se dijalog sa sledeim stranama (slika 2.1.2): x Files x Projects x Workspaces x Other Documents
Slika 2.1.1: Kreiranje novog projekta Na strani Projects bira se vrsta projekta koji se želi napraviti. U ovom trenutku znaajni su Win32 Console Application, Win32 DynamicLink Library i Win32 Static Library. Unesite ime projekta u polje Project name. U polje Location upišite putanju do direktorijuma na disku gde želite da bude upisan novi projekat. Na strani Workspaces u poetku mogue je pravljenje samo praznog radnog prostora. Ako se ne napravi radni prostor pri zapoinjanju projekta, MSVC e ponuditi da napravi podrazumevani radni prostor za vas.
- 369 -
Slika 2.1.2: Project: 1. Project name 2. Location Kada se pritisne OK pojavljuje se dijalog u kome se može odabrati vrsta aplikacije koja se želi napraviti: - Prazan projekat znai upravo to - bie napravljen projekat koji nee sadržati ni jedan fajl niti klasu. - Ako se odabere jednostavna aplikacija, bie napravljen projekat koji sadrži neke poetne fajlove, odnosno kostur aplikacije u koji se dodaje kod. - Ako se odabere tip aplikacije „Hello, world!", MSVC e napraviti program koji, kada se startuje, štampa „Hello, world!".
- 370 -
Slika 2.1.3: Files: 1. Project name 2. Location Kada se odabere tip aplikacije i pritisne Finish, prikazae se prozor koji sadrži informacije o projektu koji e biti napravljen. Potrebno je izabrati OK i zapaziti šta je MSVC napravio.
Slika 2.1.4: Workspaces
- 371 -
Kreiranje novog projekta (korak-po-korak) vrši se na sledei nain: - Odabrati File->New - Odabrati stranu Projects - Odabrati Win 32 Dynamic-Link Library - U polje Projects upisati Figure - Pritisnuti dugme pored polja Location da be se izabralo gde e se smestiti novi projekat ili se lokacija može direktno upisati u polje predvieno za to - Pritisnuti OK - U dijalogu koji se pojavi odabrati An empty DLL project i pritisnuti Finish - Pritisnuti OK u dijalogu koji prikazuje informacije o projektu koji e biti napravljen 2.2 Rad sa više projekata MSVC nije ogranien na rad samo sa jednim projektom. Biranjem komande Insert Project into Workspace menija Project može se dodati postojei projekat u trenutno otvoren radni prostor. Projekti se mogu dodati kao projekti najvišeg nivoa (eng. top-level) ili kao potprojekti (eng. subprojects). Glavna razlika je u tome što potprojekat uestvuje u procesu izgradnje (eng. build) svog natprojekta (njemu nadreenog) - kada se gradi top-level projekat, prvo se izgrade njegovi potprojekti. Rad sa više projekata (korak-po-korak) vrši se na sledei nain: - Odabrati File->Close Workspace ako je prethodno formirani radni prostor još otvoren - Odabrati File->New - U dijalogu New odabrati stranu Project, a potom opciju Win32 Console Application - U polje Project upisati „MojProgram“ - Odabrati lokaciju i pritisnuti OK - U dijalogu koji se pojavi odabrati opciju A simple application i pritisnuti Finish - U sledeem dijalogu pritisnuti OK - Odabrati Project->Insert Project into Workspace (slika 2.2.1) i pronai prethodni projekat (fajl Figure, dsp)
- 372 -
Slika 2.2.1: Ubacivanje novog projekta 2.3 Osnovna podešavanja Konfiguracija projekta definiše kako e izvršni program ili biblioteka koje projekat predstavlja biti sagraeni (eng. build). Kada se pravi projekat pomou nekog od arobnjaka (eng. wizard), njemu e biti dodeljen skup podrazumevanih konfiguracija. Podrazumevane konfiguracije su: - Debug: služi za pravljenje programa u radnoj fazi. - Release: služi za konano pravljenje programa (kada se smatra da je spreman za isporuku).
Slika 2.3.1: Putanja za podešavanje konfiguracija
- 373 -
Konfiguracije se mogu dodati ili obrisati biranjem komande Configurations iz menija Build. Odreena konfiguracija se podešava biranjem komande Settings iz menija Project. Podešavanje konfiguracija vrši se na sledei nain: - Odabrati Build->Cofigurations (slika 2.3.1) - Izabrati konfiguraciju (slika 2.3.2) Win32 Debug projekta „MojProgram“ i pritisnuti Remove
Slika 2.3.2: Odabir Win32 Debug - Potvrditi uklanjanje konfiguracije - Pritisnuti ime projekta („MojProgram“) - Pritisnuti Add - U polje Configuration uneti Debug. Naravno, da bi konfiguracija služila za debagovanje ona ne mora da se zove Debug – može se nazvati po želji (slika 2.3.3) - U listi Copy settings from izabrati „MojProgram“ - Win32 Release (koji je jedini u listi, ali u opštem sluaju e postojati prilika da se izabere konfiguracija ija e se podešavanja kopirati). To znai da se ne kree iz poetka kada se pravi konfiguracija. - U opštem sluaju, u listi Platform nalazie se samo Win32 - Pritisnuti OK u dijalogu Add Project Configuration, a zatim Close u dijalogu Configurations
- 374 -
Slika 2.3.3: Add Project Configuration
3. UREIVANJE PROGRAMA 3.1 Dodavanje fajlova u projekat Dodavanje postojeeg fajla u aktuelan projekat se može uraditi biranjem Projects -> Add to Project -> Files. Novi fajl se dodaje biranjem Project -> Add to Project -> New i biranjem vrste fajla. Fajlovi se mogu hijerarhijski organizovati unutar projekta, prema logikoj organizaciji programa. Novi header fajl se dodaje na sledei nain: - Zatvoriti trenutno otvoren radni prostor (ako je otvoren) biranjem File->Close Workspace - Odabrati File->New - Odabrati stranu Files i C/C++ Header File - U polje File name uneti „Pravougaonik“ - U polje Location upisati putanju projekta Figure ili pritisnuti odgovarajue dugme i pronai direktorijum Figure - Pritisnuti OK - Uneti sledei kôd u fajl „Pravougaonik.h“: typedef unsigned int UINT; class CPravougaonik { public:
- 375 -
CPravougaonik(); virtual -CPravougaonik(); private: UINT visina; UINT sirina; };
- Odabrati File->Save i zatvoriti fajl biranjem File->Close - Otvoriti radni prostor „MojProgram“ biranjem File->Recent Workspaces - Odabrati Project->Add to Project->Files (slika 3.1.1)
Slika 3.1.1: Putanja za dodavanje fajlova u projekat - U dijalogu Insert Files into Project (slika 3.1.2) pronai fajl „Pravougaonik.h“ i pritisnuti OK. Ako radni prostor sadrži više projekata, izabrani fajl e biti dodat u trenutno aktivan projekat (njegovo ime je prikazano crnim slovima u prozoru radnog prostora). Ako se želi da drugi projekat bude aktivan, pritisne se desnim tasterom miša njegovo ime i u kontekstnom meniju odabere Set as Active Project. Da bi projekat bio dodat u nov fajl upotrebiti putanju File->New.
- 376 -
Slika 3.1.2: Ubacivanje fajlova u projekat Novi source fajl se dodaje na sledei nain: - Odabrati File->New - Odabrati stranu Files i C+ + Source File (slika 3.1.3) - U polje File name uneti „Pravougaonik“ i odabrati istu lokaciju kao za „Pravougaonik.h“ - Potvrditi Add to project i u listi ispod, odabrati projekat Figure - Uneti sledei kod u „Pravougaonik.cpp“: #include "Pravougaonik.h" CPravougaonik::CPravougaonik() { sirina=8; visina=5; } CPravougaonik:: ~CPravougaonik() { sirina=0; visina=0; }
- 377 -
Slika 3.1.3: Dijalog za dodavanje novog fajla 3.2 Osnovni alati ClassWizard predstavlja jednu od najmonjih alata MSVC okruženja. Njegove najvažnije funkcije tiu se rada sa MFC projektima, ali i u radu sa konzolnim aplikacijama bie od koristi (mada neuporedivo manje). WizardBar omoguava brz pristup mnogim funkcijama ClassWizard - a. Iz prve liste možete odabrati bilo koju klasu iz aktuelnog projekta, iz druge birate filter, a iz tree funkciju klase koja se želi modifikovati. Dugme WizardBar Actions omoguava brz pristup brojnim komandama (spisak tih komandi zavisi od tipa projekta, kao i od toga da li je trenutno odabrana klasa ili globalna funkcija itd.). SourceBrowser omoguava brzo nalaženje definicije i reference simbola i traženje veza meu simbolima. Ovaj alat zahteva prisustvo fajla koji sadrži potrebne informacije. Za pristup ovom fajlu potrebno je ponovno podešavanje projekta. Najlakši nain je da, kada se signalizira da taj fajl ne postoji (dešava se kada se odabere neka od komandi koja pokree SourceBrowser, npr. References iz kontekstnog menija podatka lana), dozvoli MSVC-u da ga automatski napravi. Drugi nain je runo podešavanje uz pomo odabira komande Settings iz menija Project, pa odabrati stranu Browse Info i potvrditi Build browse info file.
- 378 -
3.2.1 Class Wizard U osnovi, ClassWizard je alat za automatsko generisanje klasa. Pokree se biranjem komande New Class bilo iz WizardBar Actions ili iz menija Insert. Takoe se može pokrenuti biranjem komande ClassWizard iz menija View (ako je komanda omoguena). Kada se otvori dijalog New Class, potrebno je uneti ime klase i odabrati njenu osnovnu klasu iz spiska. Ukoliko se klasa iz koje se želi izvesti nova klasa ne nalazi na spisku, to e se rešiti runim menjanjem koda. Kada se pritisne OK, ClassWizard e generisati željenu klasu i automatski dodati konstruktor i destruktor. Prethodno opisano, korak-po-korak, izgledalo bi na sledei nain: - U prikazu Class View pritisnuti desnim tasterom miša projekat Figure - U kontekstnom meniju odabrati New Class (slika 3.2.1.1)
Slika 3.2.1.1: Dodavanje nove klase - U dijalogu New Class, u polje Name uneti „CKvadrat“ - Pritisnuti mišem ispod Derived From i uneti „CPravougaonik“ (slika 3.2.1.2) - Ispod As e se pojaviti re public, što je podrazumevan nain izvoenja. Neka ostane tako - Pritisnuti OK - U prikazu Class View pritisnuti desnim tasterom miša ime klase „CPravougaonik“ i odabrati Add Member Function (slika 3.2.1.3)
- 379 -
- U dijalogu Add Member Function (slika 3.2.1.4) uneti void u polje Function Type, a u polje Function Declaration uneti: setVelicina(UINT a, UINT b)
Slika 3.2.1.2: Navoenje odakle je klasa izvedena
Slika 3.2.1.3: Dodavanje funkcije
- 380 -
Slika 3.2.1.4: Tip i deklaracija funkcije - U opcijama Access odabrati public - Pritisnuti OK - Ako projekat Figure nije trenutno aktivan, aktivirati ga - Iz prve liste WizardBar-a odabrati klasu „CPravougaonik“ - Iz druge liste odabrati All class members - Iz tree liste odabrati „setVelicina“. Otvorie se odgovarajui fajl („Pravougaonik.cpp“), sa kursorom postavljenim na poetak definicije funkcije i obeleženim potpisom (eng. signature) funkcije - Odabrati komandu Project->Settings (slika 3.2.1.5)
Slika 3.2.1.5: Putanja za podešavanje parametara - Otvorie se dijalog Project Settings sa izabrana oba projekta sa leve strane (slika 3.2.1.6) - Iz liste sa leve strane odabrati Win32 Debug. Kako su oba projekta izabrana i oba imaju konfiguraciju koja se zove Win32 Debug, sva - 381 -
podešavanja koja budu promenjena sa desne strane odrazie se na oba projekta: - Odabrati stranu C/C++, zatim General iz liste Category i potvrditi Generate browse info - Odabrati stranu Browse Info i potvrditi Build browse info file - Da be se mogao koristiti SourceBrowser, mora se odabrati komanda Build->Rebuild All, koja e iz poetka prevesti sve fajlove i povezati projekte sa novim podešavanjima
Slika 3.2.1.6: Project Settings - U prikazu ClassView pritisnuti desnim tasterom miša ime funkcije lanice setSize klase CKvadrat i odabrati opciju References, Calls ili Called by iz kontekstnog menija. Pri tom treba imati u vidu da se SourceBrowser može koristiti samo za trenutno aktivan projekat - Prozor koji se pojavio sadrži sa leve strane informacije o tome odakle se poziva funkcija CKvadrat::setVelicina ili o funkcijama koje ona poziva, u zavisnosti od toga koja je komanda menija izabrana. Sa desne strane nalazi se ime fajla u kome je funkcija definisana, a ispod toga spisak fajlova u kojima se ona spominje. Pritisnuti dvaput bilo koji fajl sa spiska (sa desne strane) ili bilo koju funkciju (sa leve strane)
- 382 -
3.2.2 Ureivanje koda Unošenje, izmena, brisanje, kopiranje teksta itd. isti su kao u drugim editorima teksta, npr. Microsoft Word-u. Meutim, kako je MSVC okruženje za programiranje, ima i neke specifine mogunosti. Ako se odabere desnim tasterom miša bilo gde u okviru fajla koji se menja, otvorie se kontekstni meni koji sadrži sledee komande: - Cut iseca odabrani tekst i kopira ga na Clipboard -Copy kopira odabrani tekst na Clipboard -Paste zamenjuje odabrani tekst tekstom koji je trenutno na Clipboard-u. Ako nije odabran nikakav tekst, ubacuje sadržaj Clipboard-a na mesto gde se trenutno nalazi kursor -Insert File Into Project dodaje fajl koji se menja u trenutno otvoren projekat -Open otvara fajl iznad ijeg imena se nalazi kursor miša. Ovo je posebno korisno za otvaranje zaglavlja -List Members prikazuje listu podataka i funkcija lanica objekta iznad ijeg imena se nalazi kursor miša -Type Info prikazuje mali prozor koji podsea na tip podatka iznad ijeg imena se nalazi kursor miša -Parameter Info podsea na parametre koje prima funkcija iznad ijeg imena se nalazi kursor miša -Complete Word pomaže u vezi s imenom promenljive ili funkcije koje je delimino otkucano -Go To Definition otvara fajl u kome je definisano ime iznad kojeg se nalazi kursor -Go To Reference postavlja kursor na mesto gde se sledei put referiše ime iznad kojeg se nalazi kursor -Insert/Remove Breakpoints postavlja taku prekida na mesto gde se nalazi kursor ili je uklanja ako ona ve postoji -Enable Breakpoint omoguava taku prekida -ClassWizard otvara dijalog ClassWizard -Properties otvara listu svojstava Sve ove komande imaju ekvivalente u meniju i kutiji sa alatkama.
- 383 -
3.2.3 Sintaksno bojenje MSVC oznaava elemente Podrazumevane boje su: crna za kod koji plava za rezervisane rei. Stringovima, druga boja tako što se odabere komanda odabere strana Format.
koda sintaksnim bojenjem. se prevodi, zelena za komentare i brojevima itd. može se dodeliti Options iz menija Tools, a zatim
3.2.4 Vežba Koristei što više ClassWizard, uraditi sve što treba da bi klase CPravougaonik i CKvadrat i funkcija main projekta „MojProgram“ izgledale ovako: //Pravougaonik.h typedel unsigned int UINT; class CPravougaonik { public: CPravougaonik{}; virtual -CPravougaonik(); UINT getObim(); UINT getPovrsina(); void setVelicina(UINT a, UINT b); private: UIXT visina; UTNT sirina; }; //Pravougaonik.cpp ((include "Pravougaonik. h" CPravougaonik::CPravougaonik() { sirina = 8 ; visina = 5; } CPravougaonik::~CPravougaonik () { sirina = 0; visina = 0; }
- 384 -
void CPravougaonik::setVelicina(UINT a, UINT b) { sirina = a; visina = b; } UINT CPravougaonik::getPovisina() { return sirina*visina; } UINT CPravougaonik::getObim() { return 2*(sirina+visina); } // Kvadrat.h class CKvadrat:public CPravougaonik { public: CKvadrat(); virtual CKvadrat0; void setVelicina(UINT a); }; // Kvadrat.cpp #include "Kvadrat.h" CKvadrat::CKvadrat() setVelicina(5); CKvadrat::~CKvadrat() { }; void CKvadrat::setVelicina(UINT a); CPravougaonik::setVelicina(a,a); // MojProgram.cpp int main(int argc, char* argv[]) { CPravougaonik pravougaonik; CKvadrat kvadrat; UINT a; UINT b; cout << endl;
- 385 -
cout << "Obim pravougaonika: "<
4. PREVOENJE PROGRAMA Svaki izvorni fajl u projektu mora biti najpre preveden (eng. compiled) da bi se potom moglo prei na povezivanje (eng. linking). Kada se radi na veem projektu postaje zamorno da, svaki put kada se promeni kod, da se sve prevodi iz poetka. Najbrži nain je da se ponovo prevedu samo fajlovi u kojima su unete promene. Fajl e se prevesti biranjem komande Compile “nekiFajl.cpp” iz menija Build. Ovde “nekiFajl.cpp” predstavlja fajl koji je trenutno otvoren u editoru. U toku prevoenja, MSVC šalje poruke o greškama i upozorenjima na ve pomenuti izlazni pano (eng. output panel). Pod greškom (eng. error) se podrazumeva nešto što nije moglo da se prevede, jer nije ispravno sa stanovišta sintakse ili semantike jezika C++. Upozorenje (eng. varning) se odnosi na nešto što nije greška sa stanovišta samog jezika, tj. može da se prevede, ali MSVC smatra da tu postoji mogunost semantike greške u programu. Na primer, deklarisana je promenljiva, ali nakon toga nije korišena - to nije greška, ali MSVC na to upozorava, jer sumnja da se možda nešto zaboravilo. Nakon izlistavanja postojeih grešaka i upozorenja (ukoliko broj grešaka ne prelazi odreenu granicu posle koje prevodilac
- 386 -
prekida prevoenje), na izlaznom panou se pojavljuje broj grešaka i upozorenja. Ako je program sintaksno ispravan, a MSVC ga smatra i semantiki korektnim, javie: 0 grešaka, 0 upozorenja. Program se prevodi na sledei nain: Ͳ Pritisnuti desnim tasterom miša ime projekta Figure i odabrati Set as Actilve Project Ͳ Otvoriti fajl “Pravougaonik.cpp” pritiskanjem dvaput njegovog imena u prikazu File View Ͳ Odabrati Build->Compile “Pravougaonik.cpp”. 4.1 Vežba Prevesti na isti nain i “Kvadrat.cpp” i “MojProgram.cpp”. Zašto MSVC prijavljuje greške? Šta nedostaje? 4.2 Pravljenje projekta Pravljenje projekta znai prevoenje i povezivanje svih njegovih komponenti da bi se proizvela ciljna verzija izvršnog programa ili biblioteke. Svaki projekat ima svoj make fajl, koji sadrži podatke o zavisnostima izmeu pojedinih fajlova. Kada se neki fajl promeni, onda svi fajlovi koji zavise od njega moraju ponovo da se prevedu i povežu. U procesu kreiranja projekta, potrebno je odabrati komandu Build “nekiProjekat” iz menija Build, gde “nekiProjekat” predstavlja trenutno aktivan projekat. Biranjem ove komande, MSVC e prevesti samo one fajlove koji su promenjeni posle prethodnog prevoenja, zatim fajlove koji su od njih zavisni i uradie povezivanje. Ako je potrebno da se svi fajlovi bezuslovno prevedu i povežu, potrebno je odabrti komandu Rebuild All iz menija Build. Ovo je potrebno uraditi kada se promene neke opcije prevoenja od kojih zavise svi delovi programa, pa ne bi bilo dobro da neki fajlovi budu prevedeni sa starim, a neki sa novim podešavanjima.
- 387 -
4.3 Pomo u radu Dok je aktivan prozor editora, postaviti kursor na mesto gde se nalazi željena re, a zatim pritisnuti taster F1. Automatski e se pokrenuti MSDN (Microsoft Developer Network, kolekcija lanaka koji se tiu MSVC) sa spiskom lanaka u kojima se spominje odabrana re. Drugi nain da se dobije pomo jeste tzv. Info View, koji je deo prozora Workspace. Ako se odabere prikaz Info View, u ovom prozoru e se prikazati kolekcija lanaka vezanih za MSVC i Developer Studio. 4.4 Podešavanja MSVC obezbeuje podešavanje mnoštva opcija prevoenja i debagovanja. Odabrati kamandu Settings menija Project. Na levoj strani dijaloga Project Settings videe se lista svih konfiguracija projekta. Na desnoj strani može se izabrati odreena stranica i tako pristupiti mnogim opcijama projekta. Podešavanje konfiguracije se može izabrati sa leve strane. Ako se želi definicija podešavanja za odreeni faji projekta, potrebno je odabrati ga na levoj strani tako što e se raširiti stablo pritiskom znaka plus pored imena konfiguracije. Prva strana je strana General. Ovde se može definisati da Ii program koristi MFC i kako. Takoe, na ovoj strani mogu se izabrati direktorijumi u kojima e biti smešteni tzv. meu-fajlovi kao i krajnji fajlovi projekta. Druga strana, Debug, definiše opcije debagovanja. Biranjem kategorije General ili Additional DLLs ustanovie se da ova strana ima dve podstrane. Od znaaja je polje Executable for debug session. Ako je projekat standardni izvršni program, onda nema razloga da se sadržaj ovog polja razlikuje od imena programa. Ali, na primer, ako se radi na DLL projektu, definisanjem izvršnog programa, postojae mogunost da se i on debaguje. Trea strana, C/C++, omoguava podešavanja opcija prevodioca. Ova strana ima više podstrana koje se menjaju biranjem Category. etvrta strana, Link, omoguava pristup raznim opcijama povezivanja. Strana Browse info se koristi kada se želi upotreba mogunosti pretraživanja koda (eng. browse).
- 388 -
5. DEBAGOVANJE MSVC debager se aktivira kada se izvršava program u režimu debagovanja (eng. debug mode). To se postiže biranjem neke od komandi podmenija Start debug koji se nalazi u meniju Build. Komande su: Go, Step Into, Run to Cursor. Ali, pre nego što se pokrene debager, aplikacija mora biti prevedena tako da sadrži informacije potrebne za debagovanje (eng. debug info). 5.1 Pripremanje aplikacije za debagovanje Ako je projekat napravljen pomou nekog od arobnjaka, verovatno nee biti neophodne promene konfiguracija Debug je jedna od podrazumevanih. Ali, ako postoji potreba za pravljenjem ove konfiguracije, to e se uraditi podešavanjem u dijalogu Project settings. Ovaj dijalog se otvara biranjem komande Settings menija Project. Kada je pokrenut dijalog, potebno je odabrati stranu C/C++. Izabrati kategoriju General i sa leve strane konfiguraciju za koju se želi da bude debug konfiguracija. Zatim, uraditi sledee: - U polju Debug info odabrati Program Database - U polju Optimizations odabrati Disable (Debug). Još je bitno da projekat bude povezan sa debug verzijom biblioteke C Run-time Library. Odabrati kategoriju Code Generation, a zatim željenu debug biblioteku. Treba još podesiti povezivanje. Odabrati stranu Link i u polju Category odabrati General. Potvrditi Generate debug info. Korak po korak: Ͳ Odabrati komandu Project->Settings Ͳ Pošto je odabrana samo konfiguracija Debug za projekat “MojProgram”, izabrati na desnoj strani samo taj projekat. Ͳ Odabrati stranu C/C++ i kategoriju General. Iz liste Optimizations odabrati Disable (Debug), a iz liste Debug info stavku Program Database for Edit and Continu, a zatim kategoriju Code Generation i iz liste Use run-time library stavku Debug Single-Threaded.
- 389 -
Ͳ Odabrati stranu Link i potvditi Generate debug info i Link incrementally Ͳ Pritisnuti OK U cilju osiguranja da e sledei put biti izgraena Debug konfiguracija projekta, odabrati komandu Build->Set Active Configuration. U dijalogu Set Active Project Configuration odabrati konfiguraciju “MojProgram” - Win32 Debug i pritisnuti OK. Da bi projekat bio kompletno spreman za debagovanje, treba ga ponovo izgraditi sa novim podešavanjima. Ako projekat “MojProgram” nije trenutno aktivan, potrebno je aktivirati ga i odabrati komandu Build>Rebuild All. 5.2 Pokretanje aplikacije u režimu debagovanja Pošto se ponovo prevede cela aplikacija nakon svih podešavanja, može se pokrenuti biranjem bilo koje komande iz podmenija Start Debug menija Build. Kada se zapone debagovanje, pojavie se neki od prozora debagera. Takoe e nestati neki prozori koji su inae vidljivi. Glavni meni e se promeniti i meni Build e biti zamenjen menijem Debug. Aplikacija koja se pokree u režimu debagovanja izvršava se dok ne stigne do take prekida ili se ne prekine u izvršavanju biranjem Stop debugging ili Break. Tokom debagovanja, MSVC prikazuje informacije u nizu prozora. Ako neki od njih nisu vidljivi, mogu se prikazati biranjem odgovarajue komande podmenija Debug Windows menija View. 5.3 Prozori debagera i pregled objekata Prozor Variables prikazuje vrednosti objekata u tekuoj funkciji. Ovaj prozor ima tri strane: Ͳ Strana Auto prikazuje objekte koji se koriste u tekuem i prethodnom redu programskog koda. Ͳ Strana Locals prikazuje objekte koji su lokalni u tekuoj funkciji, ukljuujui i argumente funkcije.
- 390 -
Ͳ Strana This prikazuje podatke lanove objekta na koji pokazuje this pokaziva tekue funkcije lanice. Prozor Variables takoe može da prikaže objekte u oblasti važenja funkcija koje su pozvale tekuu funkciju. Ovaj prozor može da se koristi i za modifikovanje vrednosti prostih objekata ugraenog tipa. Da bi se promenila takva vrednost, potrebno je pritisnuti je dvaput u prozoru Variables. Ako je modifikacija mogua, pojavie se kursor tastature. Prozor Watch se koristi za proveru vrednosti izraza. Izraz uneti u polje Name. Ovaj prozor ima etiri iste strane, tako da u isto vreme se mogu pratiti vrednosti etiri razliita izraza. Isto kao i prozor Variables i on se može koristiti za modifikovanje vrednosti. Postoje još dva naina pregleda promenljivih: QuickWatch i DataTips. DataTips Iii na ToolTips. Za vreme debagovanja, postaviti i zadržati par sekundi kursor miša iznad imena objekta, i njegova vrednost e se prikazati (ako ta vrednost može da se odredi). Za izraunavanje vrednosti izraza koristiti dijalog QuickWatch koji e se otvoriti komandom QuickWatch menija Debug. Ako se kursor trenutno nalazi iznad imena objekta, njegova vrednost e se automatski pojaviti u dijalogu QuickWatch. Ako je obelezen izraz, pojavie se njegova vrednost. Prozor Registers prikazuje trenutne vrednosti u registrima procesora. Prozor Memory ornoguava praenje sadržaja memorije u adresnorn prostoru procesa koji se trenutno debaguje. Prozor Call Stack prikazuje istoriju poziva funkcija koja je dovela do poziva tekue funkcije. Višestruko pritiskanje funkcije u ovorn prozoru promenie sadržaj ostalih debug prozora, tako da odgovaraju toj funkciji. Prozor Disassembly obezbeuje pogled na generisani asemblerski kod. Dok ovaj prozor ima fokus, izvršavanje korak po korak drugaije funkcioniše: umesto da prolazi kroz redove C++ koda, prolazi kroz zasebne asemblerske instrukcije.
- 391 -
5.4 Take prekida Najjednostavniji nain da se postavi taka prekida jeste da se postavi kursor na željeno mesto u kodu i pritisne F9. Pojavie se kruzi sa leve strane reda. Mnogo bolja kontrola postiže se biranjern Edit->Breakpoints. Biranjem ove komande pojavljuje se dijalog Breakpoints, gde se mogu postaviti tri razliite vrste taaka prekida: Ͳ Location breakpoints prekidaju izvršavanje programa na odreenoj lokaciji. Ovo su take prekida koje se postavljaju sa F9. Može se dodati i provera uslova na taki prekida, tako da se izvršavanje programa ne prekida svaki put, ve samo kada je ispunjen taj uslov. Ͳ Data breakpoints prekidaju izvršavanje programa kada se promeni vrednost odreenog izraza. Ͳ Message breakpoints prekidaju izvršavanje programa kada neka od procedura dobije odreenu poruku. Komande za izvršavanje su sledee: Ͳ Komanda Step Into izvršava sledei red koda ili sledeu instrukciju u prozoru Disassembly. Ako je u tom redu poziv funkcije, ovom komandom se ulazi u telo te funkcije. Ͳ Komanda Step Into Specific Function koristi se radi kontrole u koju se funkciju ulazi u sluaju ugneždenih poziva funkcija u jednom redu koda. Ͳ Komanda Step Over je slina komandi Step into, osim što se ne ulazi u telo funkcije ako je u tom redu koda poziv funkcije, ve se samo izvrši poziv kao jedinstvena akcija. Ͳ Komanda Step Out nastavlja izvršavanje programa do kraja tekue funkcije, izlazi iz nje i prekida izvršavanje iza reda u kome je ta funkcija pozvana. Ͳ Kornanda Run to Cursor nastavlja izvršavanje programa do reda gde se trenutno nalazi kursor tastature ili dok se ne naie na taku prekida. Ͳ Dok izvršavanje programa stoji, može se pomou komande Set Next Statement zadati naredba gde izvršavanje treba da se nastavi.
- 392 -
Korak po korak: Ͳ Otvoriti fajI “MojProgram.cpp”. Ͳ Postaviti kursor tastature na prvi red koda u funkciji main. Ͳ Pritisnuti F9. Ͳ Odabrati komandu Build->Start Debug->Go. Ͳ Kada se program pokrene u režimu debagovanja i stane kod take prekida koja je postavljena, pritisne se F11 (ili odabere Debug->Step Into). Potrebno je pritiskati F11 i pratiti kuda prolazi izvršavanje programa. Kada se želi sa nastavkom izvršavanja u telu funkcije koja se poziva u tekuem redu koda, pritisnuti F10. Dok tee izvršavanje programa, pratiti šta se dešava u vidljivim prozorima. Postaviti kursor miša iznad imena objekta za iju trenutnu vrednost postoji interesovanje. Ͳ Kada izvršavanje programa stigne do drugog reda koda funkcije main, pa se nakon lananih poziva funkcija nae u funkciji lanici CPravougaonik::setVelicina(), odabrati komandu View->Debug Windows->Call Stack. Prouiti sadržaj tog prozora i ukloniti ga. Zatim pritisnuti SHIFT + F11 da bi se izvršavanje programa nastavilo izvan tekue funkcije. Ͳ Kada izvršavanje programa stane nakon postavljanja promenljivih a i b u funkciji main, proveriti vrednost izraza a*a-2*a*b+b*b koristei prozor Watch. Ͳ Kada izvršavanje programa stane na kvadrat.setVelicina(a), potrebno je promeniti vrednost promenljive a, tako što e se pritisnuti polje Value u prozoru Variables i uneti željena vrednost. Potrebno je imati u vidu da je a neoznaen ceo broj, pa i vrednost koja se zadaje mora biti odgovarajueg tipa.
- 393 -
Dodatak B: Integrisano razvojno okruženje Microsoft Visual C++ 2008
Slika 1.1.1: Microsoft Visual Studio 2008 logo 1. Uvod Prvo izdanje programa Visual Studio pojavilo se na tržištu 1997. godine i sadržao je odvojene IDE-eve (eng. Integrated Development Environment) za programe Visual C++, Visual Basic, J++ i alatku poznatu kao InterDev. Program Visual Studio 6.0 imao je drastina poboljšanja koja su oznaila roenje programa Visual Basic 6 i koja su oslikavala ideju skupa jedinstvenih usluga za sve jezike. Visual Studio .NET 2002 i Visual Studio .NET 2003 su tu ideju sproveli u delo sa aplikacijom .NET Framework. Po prvi put programer je mogao da napiše aplikaciju na jeziku po svom izboru korišenjem mogunosti opšteg skupa alatki ukljuujui dizajnere, kontrole Drag&Drop i IntelliSense (intelliSense je Microsoft-ov mehanizam automatskog dopunjavanja kôda). Zajedno sa porastom produktivnosti, došlo je i do porasta u veliini i kompleksnosti razvojnih projekata i timova. Visual Studio 2008 je napravio revoluciju u nainu na koji se rukuje podacima. Uz novi alat Language Integrated Query (LINQ), može se raditi sa svim vrstama podataka sa konzistentnim pristupom i pristupati podacima sa novim dizajnerom za podatke. LINQ omoguava programerima lakši pristup podacima kroz skup oznaka tipa datoteke u programu C# i Visual Basic programskim jezicima, kao i u aplikaciji Microsoft .NET Framework. Ove oznake tipa datoteke omoguavaju integrisane upite za objekte, baze podataka i XML podatke. Koristei LINQ, mogu se napisati upiti u svom jeziku u programu C# ili programu Visual Basic bez korišenja posebnih jezika, kao što su SQL i Xpath. Pored površina za dizajn, u programu Visual Studio, dizajneri korisnikih interfejsa mogu koristiti poznate alatke kao što su Microsoft Expression Suite kako bi upravljali prikazima, kontrolama i povezivanjem
- 394 -
podataka. Datoteke sa rešenjima koje su generisane alatom Expression mogu se otvoriti i ureivati u programu Visual Studio. Dizajneri i programeri su u mogunosti da izgrade biblioteke opšteg dizajna korisnikog interfejsa, formata i elemenata kojima se može lako upravljati i koji se mogu ponovo koristiti. Visual Studio 2008 je jedinstven skup alata koji omoguava pravljenje kvalitetnih aplikacija na Microsoft-ovim platformama. Podrška za razvoj operativnog sistema Windows Vista i sistema Microsoft Office pomaže kreiranju efektne i bogate aplikacije. Uz ukljuenu podršku za ASP.NET AJAX i programski dodatak Silverlight za Visual Studio 2008, mogua je izgradnja velikog broja bogatih interaktivnih aplikacija za Web. Visual Studio omoguava razvoj WPF aplikacija (za programiranje u C#) u cilju direktnog ureivanja XAML (sa IntelliSense podrškom) ili kreiranja korisnikog interfejsa kroz nove vizuelne dizajnere. Promena koja je nainjena u prikazu aplikacije jednom od ovih alatki odmah se oslikava na drugoj. Pored toga, program Visual Studio nudi podršku za više od 8.000 novih osnovnih API-ja u operativnom sistemu Windows Vista. Lako korišenje znai da Visual Studio u velikoj meri asistira korisniku i umesto njega radi mnoštvo poslova koji su dobro definisani. U prevodu, umesto korisnika pravi kostur aplikacije i time oslobaa korisnika od tog posla, kao i od uenja kako se to radi. 1.1
Razvojno okruženje
Visual Studio 2008 razvijan je više od tri godine pod kodnim imenom Orcas. Zamišljen je kao razvojno okruženje koje bi trebalo da omogui programerima da u potpunosti iskoriste mogunosti operativnog sistema Windows Vista. Kod prvog pokretanja Visual Studio 2008, uoie se da je izgled radnog okruženja identian okruženju verzije 2005. Na poetku, korisniku se nudi mogunost da izabere u kom programskom jeziku želi da radi kako bi u skladu s’tim bilo podešeno radno okruženje prilagoeno njegovim potrebama (slika 1.1.1).
- 395 -
Slika 1.1.1 Odabir programskog jezika Naravno, ukoliko se naknadno javi potreba za radom u drugom okruženju, aktivno okruženje se veoma lako menja korišenjem opcije Import and Exports settings koja se nalazi u meniju Tools (slika 1.1.2).
- 396 -
Slika 1.1.2 Import i Export Settings Ispod glavnog menija, nalazi se toolbar sa ikonama za manipulaciju projektima i fajlovima (slika 1.1.3), izbor aktivnih prozora koji se prikazuju u okruženju, rad sa tekstom i manipulisanje aplikacijom na kojoj se radi i još mnogo drugih opcija.
- 397 -
Slika 1.1.3 Import i Export Settings Sa leve strane prozora je inicijalno prikazan Solution Explorer (pregled fajlova u aktivnom projektu), Class View (prikaz klasa u aktivnom projektu) i Resource Explorer (prikaz resursa aktivnog projekta). Centralni deo aplikacije zauzima prozor u kome se modifikuje programski kod ili resursi koji se u programu koriste, uz desnu ivicu prozora su prikaeni Server Explorer i Toolbox koji se otvaraju na klik korisnika. Dno prozora je rezervisano za sekciju Output (slika 1.1.4).
Slika 1.1.4 Okruženje
- 398 -
Naravno, ovu inicijalnu konfiguraciju radnog okruženja mogue je proizvoljno menjati prema željama korisnika. Iako je izgled radnog okruženja identian, unapreeni IDE navigator omoguava lakše kretanje izmeu delova okruženja, doking prozora u okruženju je unapreen i olakšan, kao i mogunost podešavanja default fonta za okruženje.
Slika 1.1.5 Test meni U promene spada novododati Test meni, kao i odsustvo menija Community, koji je postojao u prethodnoj verziji (Visual Studio 2005), a ije su preostale opcije premeštene u Help meni. Opcije Test menija (slika 1.1.5) nude programerima mogunost lakšeg kreiranja unit testova za aplikacije koje razvijaju, kao i bolju kontrolu nad njihovim izvršavanjem, što doprinosi razvoju kvalitetnijih, aplikacija koje su bolje testirane. U odnosu na prethodnu verziju Visual Studio-a, kod verzije 2008, znaajnih noviteta po pitanju korisnikog okruženja - nema. Noviteti Visual Studio-a 2008, u odnosu na ranije verzije su sledee: Ͳ Novi template-i za Visual Basic i Visual C# Ͳ Kod C++ javlja se podrška svih funkcionalnosti i API-ja koje nudi Windows Vista (više od 150 funkcija i 18 klasa, preko 8000 API-ja) Ͳ Class Designer, alat koji je u prethodnoj verziji Visual Studio-a omoguavao vizuelno dizajniranje i dokumentovanje klasa samo za Visual Basic i Visual C#, ovoga puta postoji i za Visual C++ U Visual Studio 2008, posebna pažnja posveena je Web aplikacijama. Tako je meu template-ove za Visual Basic i Visual C# dodata posebna potkategorija template-ove nazvana Web u kojoj su ponueni tipini kosturi nekoliko vrsta Web aplikacija (slika 1.1.6). Jedna od mogunosti jeste ugraena podrška za JavaScript intelliSense. Takoe,
- 399 -
unapreeno je debagovanje – postavljanje breakpoint-a u JavaScript pre izvršavanja ASP.NET stranica, reorganizovanje breakpoint-a dok se stranice još izvršavaju, poboljšan prikaz sadržaja objekata i još mnogo detalja koji u svakodnevnom radu puno znae. Kada je rad sa podacima u pitanju, Visual Basic i Visual C# nude mogunost dobijanje podataka iz baza, XML fajlova ili ak objekata, korišenjem LINQ, specijalnih query operatora koji su integrisani u ove jezike.
Slika 1.1.6 Web templates Još jedna nova kategorija template-ova koja je dodata skupu VB i C# template-ova je Office, koja nudi kreiranje Office 2003/2007 projekata, od kojih su (slika 1.1.7): Ͳ Ͳ Ͳ Ͳ Ͳ
Excell Add-in Workbook Word Add-in Document Visio Add-in
- 400 -
Tehnologija koja stoji iza ovih template-ova je Visual Studio Tools for Office (VSTO) i ona omoguava korišenje otvorenih funkcija bilo koje od Office aplikacija za kreiranje samostalnih aplikacija ili dokumenata zasnovanih na Office aplikacijama.
Slika 1.1.7 Office templates
1.2 IntelliSence ikone IntelliSense je Microsoft-ov mehanizam automatskog dopunjavanja kôda. Kada se ukuca taka nakon imena klase, Visual Studio e ponuditi listu svih lanova te klase. Ovo smanjuje broj grešaka nastalih prilikom unošenja imena promenljivih. Pored svakog imena sa liste lanova, nalazi se ikonica koja asocira na tip (da li je metod, klasa, struktura i sl.). Pomenute ikonice su prikazane na slici 1.2.1. IntelliSense ikonice nisu vezane samo za klase. Postoji još mnogo drugih koji e se javljati u rezliitim delovima programa.
- 401 -
Slika 1.2.1 IntelliSence ikonice
2. Kreiranje grafikih aplikacija Korišenjem Visual Studio 2008 veoma jednostavno se mogu kreirati grafike aplikacije koje se baziraju na formi. Visual Studio 2008 omoguava kreiranje dva razliita tipa grafikih aplikacija kroz dve razliite vrste projekata – Windows forms applications i MFC application. Pomenuto se iskljuivo odnosi na programiranje u Visual C++ (jezik C# za kreiranje grafikih aplikacija koristi WPF application). Izborom jednog ili drugog tipa projekta Visual Studio kreira potreban kostur aplikacije i omoguava interaktivno kreiranje grafikog korisnikog okruženja. Ispratiti putanju File -> New Project za kreiranje novog projekta. Kreiranje kompletnog kostura mogue je odabirom template-a MFC Application (slika 2.1).
- 402 -
Slika 2.1 MFC Application Nakon unosa imena i lokacije na kojoj e projekat biti sauvan, kliknuti OK. Pokrenue se MFC Application Wizard koji upuuje na trenutno podešene parametre, koji e izgraditi kostur samo klikom na dugme Finish. Ukoliko su potrebna dalja podešavanja, potrebno je kliknuti na dugme Next (slika 2.2).
- 403 -
Slika 2.2 MFC Application Wizard Pritiskom na dugme Next, otvara se prozor za odabir tipa aplikacije. Savet je, na poetku, da se odabere Dialog based applcation (slika 2.3).
- 404 -
Slika 2.3 Application Type Sledea dva prozora nude mogunosti dodavanja delova funkcionalnosti prozora aplikacije, raznih dugmia novog dijaloga, ActiveX kontrola, kao i unošenje naslova koji e se nalaziti na vrhu novog prozora (slike 2.4 i 2.5).
- 405 -
Slika 2.4 User Interface Features
Slika 2.5 Advanced Features
- 406 -
Na kraju MFC Application Wizard generiše klase i daje prikaz njihovih imena (slika 2.6). Klikom na Finish otvara se novo radno okruženje sa podešenim opcijama i praznim dijalogom za dalje kreiranje aplikacije (slika 2.7).
Slika 2.6 Generated Classes
- 407 -
Slika 2.7 Radno okruženje nakon kreiranja kostura grafike aplikacije
3. Kreiranje konzolnih aplikacija Ispratiti putanju File -> New Project za kreiranje novog projekta. Kreiranje konzolih aplikacija poinje odabirom Win32 Console Application, iz liste template-ova (slika 3.1). Nakon unošenja imena i lokacije na kojoj e se aplikacija nalaziti, kliknuti na dugme OK.
- 408 -
Slika 3.1 Kreiranje kostura konzolne aplikacije Za razliku od procesa kreiranja grafikih aplikacija, kostur konzolne aplikacije se definiše daleko jednostavnije. Ve sledei prozor nudi opciju kreiranja praznog projekta ili projekta sa prekompajliranim zaglavljem. Potrebno je selektovati opciju Empty project (slika 3.2) kako bi se kreirao prazan projekat, iju bi izgradnju korisnik mogao da kontroliše.
- 409 -
Slika 3.2 Kreiranje praznog projekta
- 410 -
3.1 Dodatak – MSDN Subscriptions Comparison Chart
- 411 -
Reference: 1. Laslo Kraus, Programski jezik C++ sa rešenim zadacima, Akademska misao, Beograd, 2004. 2. John C. Molluzzo, "C++ for Business Programmers", Prentice Hall, 2005. 3. Dragan Miliev, Objektno orijentisano programiranje na jeziku C++, skripta sa praktikumom, Mikro knjiga, 2001. 4. Stanley B. Lippman, Josee Lajoie, C++ izvornik, prevod treeg izdanja, CET, 2000. 5. Tony Gaddis, Starting out with C++, Scott/Jones, 2001. 6. Cay Horstmann, Timothy Budd, Big C++, John Wiley, 2005. 7. William Roetzheim, Borland, C++ 4.5, programiranje za Windows, Mikro knjiga, 1995 8. Julian Templeman, Andy Olsen, Microsoft, Visual C++ .NET, CET, 2002.
- 412 -
Odlukom Senata Univerziteta “Singidunum”, Beogrаd, broj 636/08 od 12.06.2008, ovaj udžbenik je odobren kao osnovno nastavno sredstvo na studijskim programima koji se realizuju na integrisanim studijama Univerziteta “Singidunum”.
CIP - Каталогизација у публикацији Народна библиотека Србије, Београд 004.432.2C++ ПОПОВИЋ, Ранко, 1956Programski jezik C++ : sa rešenim zadacima / Ranko Popović, Zona Kostić. Beograd : Univerzitet Singidunum, 2010 (Loznica : Mladost grup). - 412 str. : ilustr. ; 25 cm Tiraž 250. - Bibliografija: str. 412. ISBN 978-86-7912-286-5 1. Костић, Зона, 1983- [аутор] a) Програмски језик “C++” COBISS.SR-ID 178203916 © 2010. Sva prava zadržana. Ni jedan deo ove publikacije ne može biti reprodukovan u bilo kom vidu i putem bilo kog medija, u delovima ili celini bez prethodne pismene saglasnosti izdavača.
