Dr. Željko Jurić: Tehnike programiranja /kroz programski jezik C++/

Transcription

1 Razmotrimo malo pažljivije generičku funkciju IspisiNiz čiji je cilj podrška ispisa na ekran elemenata niza proizvoljnog tipa elemenata (pod uvjetom da se ti elementi mogu ispisivati na ekran), a koju smo prikazali na kraju prethodnog predavanja: template <typename IspisiviObjekat> void IspisiNiz(IspisiviObjekat niz[], int broj_elemenata) { for(int i = 0; i < broj_elemenata; i++) std::cout << niz[i] << " "; U ovoj funkciji imamo takozvanu djelimičnu (parcijalnu) dedukciju tipa. Naime, za formalni parametar niz se na osnovu njegove deklaracije (preciznije, na osnovu prisustva uglastih zagrada) zna da on nije u potpunosti bilo kakav tip: on mora biti niz, a tip elemenata tog niza će biti određen dedukcijom (o djelimičnoj dedukciji govorimo uvijek kad se o tipu parametra na osnovu deklaracije znaju barem neke informacije, poput informacije da je on niz). To automatski znači da će poziv poput IspisiNiz(5, 3); // GREŠKA PRI KOMPAJLIRANJU! biti odbijen i prije nego što se pokuša instantacija funkcije, jer se stvarni parametar 5 ne može interpretirati kao niz. Drugim riječima, ovakav stvarni parametar je nemoguće uklopiti u šablon. Ovo je, naravno, poželjno svojstvo, jer ovakav poziv i ne smije biti dozvoljen. Međutim, ovaj pristup posjeduje i ozbiljan nedostatak. Zamislimo da funkciju IspisiNiz želimo iskoristiti da ispišemo elemente nekog vektora, kao u sljedećoj sekvenci naredbi: std::vector<double> a{3, 4, 0, 8, 1, -6, 1, 4, 2, -7; IspisiNiz(a, 10); // OPET GREŠKA! Ovaj poziv će ponovo biti odbijen. Naime, bez obzira što vektori liče na nizove i ponašaju se slično kao nizovi, oni nisu nizovi, dok generička funkcija IspisiNiz zahtijeva da prvi parametar bude niz. Ukoliko želimo da funkcija koja se zove isto i koja se poziva na isti način može raditi i sa vektorima, jedna mogućnost je da napišemo preklopljenu verziju generičke funkcije IspisiNiz koja bi kao prvi parametar primala vektore (čiji su elementi neodređenog tipa), koja bi mogla izgledati ovako: template <typename IspisiviObjekat> void IspisiNiz(std::vector<IspisiviObjekat> v, int broj_elemenata) { for(int i = 0; i < broj_elemenata; i++) std::cout << v[i] << " "; Prethodni poziv sada ispravno radi, pri čemu dedukcija tipa zaključuje da je značenje parametra šablona IspisiviObjekat tip double, s obzirom da je stvarni parametar a tipa vector<double>. Sada se prirodno nameće pitanje da li je moguće napraviti generičku funkciju IspisiKolekciju koja bi radila i sa nizovima i sa vektorima, bez potrebe da ručno definiramo posebne preklopljene verzije za nizove i vektore. Odgovor je potvrdan ukoliko umjesto djelimične upotrijebimo potpunu dedukciju tipa. Naime, nećemo kompajleru dati nikakvu uputu šta bi prvi parametar trebao da predstavlja, nego ćemo pustiti da prilikom poziva funkcije sam izvuče kompletnu informaciju. Definicija bi, stoga, trebala izgledati poput sljedeće (primijetimo odsustvo uglastih zagrada pri deklaraciji parametra c, kojem smo usput promijenili ime da ne bi imali pogrešnu asocijaciju da on mora biti niz): template <typename NekiTip> void IspisiKolekciju(NekiTip c, int broj_elemenata) { for(int i = 0; i < broj_elemenata; i++) std::cout << c[i] << " "; Razmotrimo sada kako izgleda dedukcija tipa u slučaju sekvence naredbi: int a[10]{3, 4, 0, 8, 1, -6, 1, 4, 2, -7; IspisiKolekciju(a, 10); Kompajler će zaključiti da se može uklopiti u šablon jedino ukoliko pretpostavi da parametar šablona NekiTip predstavlja ne tip int, već tip niza cijelih brojeva. Tako će kompajler ispravno zaključiti da NekiTip predstavlja nizovni tip i ispravno će deklarirati formalni parametar c kao niz cijelih brojeva. Slično, u sekvenci naredbi std::vector<double> a{3, 4, 0, 8, 1, -6, 1, 4, 2, -7; IspisiKolekciju(a, 10); 1

2 kompajler zaključuje da u ovom slučaju parametar šablona NekiTip predstavlja vektor realnih brojeva, odnosno tip vector<double>. Slijedi da će formalni parametar c ponovo biti deklariran ispravno (kao vektor realnih brojeva), tako da će funkcija raditi ispravno kako sa nizovima, tako i sa vektorima. Potpuna dedukcija tipa ipak ima i jedan neželjeni propratni efekat. Uz potpunu dedukciju tipa, u slučaju besmislenog poziva poput IspisiKolekciju(5, 3) kompajler će ipak pokušati instantaciju, jer se ovakav poziv može uklopiti u šablon, ukoliko se pretpostavi da parametar šablona NekiTip predstavlja tip int. Formalni parametar niz će, prema tome, biti deklariran sa tipom int. Greška će biti uočena kada se pokuša izvršiti pristup nekom elementu parametra niz, jer on nije niz, pa se na njega ne može primijeniti indeksiranje. Dakle, greška će biti uočena tek kada se sa parametrom pokuša izvesti operacija koja na njega nije primjenljiva (u ovom primjeru, indeksiranje). Zbog toga, potpunu dedukciju treba koristiti samo u slučaju kada je zaista potrebna izuzetno velika općenitost generičke funkcije, o čemu ćemo detaljnije govoriti nešto kasnije. U slučaju posjedovanja dijela informacije o očekivanom tipu (npr. da je on niz), poželjno je koristiti djelimičnu dedukciju. Napisana generička funkcija IspisiKolekciju će kao prvi parametar prihvatiti bilo koji objekat na koji se može primijeniti indeksiranje (za sada znamo da je to moguće za nizove, vektore, dekove i stringove). Možemo reći da ova funkcija kao prvi parametar zahtijeva objekat koji zadovoljava koncept objekata koji se mogu indeksirati. Kako se objekti koji se mogu indeksirati također nazivaju i kontejneri sa direktnim (slučajnim) pristupom (engl. random access containers), prvi parametar ove funkcije mora zadovoljavati koncept kontejnera sa direktnim pristupom. Na primjer, nizovi, vektori, dekovi i stringovi predstavljaju modele koncepta kontejnera sa direktnim pristupom. Pomoću generičkih funkcija moguće je postići zaista veliku univerzalnost. Na primjer, u sljedećem primjeru definiraćemo funkciju NadjiElement koja pronalazi i vraća kao rezultat indeks traženog elementa u nizu, odnosno vrijednost 1 u slučaju da traženi element nije nađen. Generički mehanizam će nam omogućiti da napišemo takvu funkciju koja traži vrijednosti proizvoljnog tipa u nizu elemenata istog takvog tipa (s obzirom da je korištena djelimična dedukcija, funkcija radi samo sa nizovima). S obzirom da ništa ne znamo o prirodi tipa elemenata, parametar element je deklariran kao referenca na konstantni objekat, da izbjegnemo nepotrebno kopiranje koje može biti neefikasno u slučaju da se radi o nekom masivnom tipu): template <typename TipElemenata> int NadjiElement(TipElemenata niz[], const TipElemenata &element, int broj_elemenata) { for(int i = 0; i < broj_elemenata; i++) if(niz[i] == element) return i; return -1; Nije teško korištenjem potpune dedukcije prepraviti ovu funkciju da radi sa proizvoljnim kontejnerom sa slučajnim pristupom (npr. vektorom ili dekom). Primijetimo da ovdje imamo dva neovisna metatipa, jedan za tip samog kontejnera, a drugi za tip njegovih elemenata: template <typename Kontejner, typename TipElemenata> int NadjiElement(const Kontejner &c, const TipElemenata &element, int broj_elemenata) { for(int i = 0; i < broj_elemenata; i++) if(c[i] == element) return i; return -1; Naredni primjer demonstrira generičku funkciju koja vraća referencu na najveći element u nizu elemenata proizvoljnog tipa (odnosno na prvi najveći element u slučaju da takvih elemenata ima više), za koje se samo pretpostavlja da se mogu porediti po veličini (što isključuje, recimo, nizove kompleksnih brojeva). Primjer je posebno interesantan, jer se kao rezultat ne vraća prosto najveći element niza nego referenca na njega: template <typename UporediviTip> UporediviTip &MaxElement(UporediviTip niz[], int broj_elemenata) { int indeks_max(0); for(int i = 1; i < broj_elemenata; i++) if(niz[i] > niz[indeks_max]) indeks_max = i; return niz[indeks_max]; 2

3 Vraćanje reference umjesto same vrijednosti povećava mogućnosti primjene ove funkcije. Na primjer, ukoliko želimo na mjesto najvećeg elementa u nizu a od 10 elemenata upisati vrijednost 0, možemo koristiti poziv poput sljedećeg (da nismo vratili referencu, poziv funkcije ne bi bio l-vrijednost pa se, prema tome, ne bi mogao naći sa lijeve strane znaka jednakosti): MaxElement(a, 10) = 0; Veoma je bitno da ovu funkciju nismo mogli napisati na sljedeći način (koji bi bio sasvim legalan da želimo prosto vratiti kao rezultat najveći element niza, a ne referencu na njega). Naime, već smo rekli da ne smijemo vratiti iz funkcije referencu na objekat koji prestaje postojati po završetku funkcije, a lokalna promjenljiva max je upravo takva, tako da ova funkcija ima fatalnu logičku grešku: template <typename UporediviTip> UporediviTip &MaxElement(UporediviTip niz[], int broj_elemenata) { UporediviTip max(niz[0]); for(int i = 1; i < broj_elemenata; i++) if(niz[i] > max) max = niz[i]; return max; // VISEĆA REFERENCA!!! Razmotrimo sada probleme koji nastaju ukoliko želimo funkciju MaxElement izvesti tako da koristi potpunu dedukciju, tako da se može primijeniti na proizvoljan kontejner sa direktnim pristupom, a ne samo na nizove. Jasno je da ćemo za parametar niz izostaviti uglaste zagrade (da uklonimo implikaciju da se radi o nizu), ali šta ćemo tada staviti da bude tip rezultata funkcije? Jasno je da rezultat treba biti onog tipa kakvi su elementi kontejnera, ali javlja se problem kako taj tip dobiti iz tipa kontejnera: template <typename Kontejner>??? &MaxElement(const Kontejner &c, int broj_elemenata) // ŠTA SAD??? Ovdje, za razliku od funkcije NadjiElement, nemamo neki parametar iz kojeg bismo mogli izvući informaciju o tipu elemenata kontejnera (kao što je tamo bio parametar element ). Sve do pojave standarda C++11 ovakvi problemi su bili u općem slučaju nerješivi, mada su se u dosta specijalnih slučajeva uspijevali riješiti pomoću raznih prljavih i nezgrapnih trikova. Srećom, C++11 je uveo dvije nove konstrukcije, decltype operator i naknadno specificiranje tipa funkcije, koje kombinirane zajedno rješavaju opisani probem. Kasnije je standard C++14 ponudio znatno jednostavnije rješenje, koje ćemo nešto kasnije ukratko spomenuti. Opišimo prvo decltype operator. Ovaj operator je jedinstven u jeziku C++ po tome što on kao rezultat daje tip a ne vrijednost. Ukoliko se ovaj operator primijeni na ime neke promjenljive, on kao rezultat daje tip kako je ta varijabla deklarirana (odatle potiče i ime decltype). S druge strane, ukoliko se ovaj operator primijeni na proizvoljan izraz, tada operator decltype kao rezultat daje kojeg je tipa taj izraz, pri čemu se taj tip tretira kao tip reference kad god izraz ima status l-vrijednosti (npr. kad izraz predstavlja pristup elementu niza, dereferencirani pokazivač, itd.). Rezultat operatora decltype može se iskoristiti bilo gdje gdje se očekuje ime nekog tipa (npr. u deklaracijama promjenljivih, parametara i povratnih vrijednosti funkcija, u eksplicitnim konverzijama tipova, itd.). Slijedi jedan primjer: int a, *p; decltype(a) b; // Isto što i int b; decltype(3.15 *a - 2) c(5); // Isto što i double c(5); decltype(*p) d(a); // Isto što i int &d(a); Na prvi pogled, izgleda da nam je decltype operator dovoljan da riješimo problem na koji smo naišli. Naime, izgleda da je dovoljno zaglavlje funkcije započeti ovako: template <typename Kontejner> // MOŽE LI decltype(c[0]) MaxElement(const Kontejner &c, int broj_elemenata) // OVO??? Nažalost, ovdje ima još jedan problem. Kompajler analizira definicije funkcija slijeva nadesno, tako da u trenutku kada kompajler naiđe na konstrukciju decltype(c[0]), on će prijaviti grešku, jer mu u tom trenutku ime c još nije ni uvedeno (tj. kompajleru još uvijek nije poznato da postoji takav identifikator, a pogotovo ne šta on predstavlja). Da bismo riješili ovaj problem, potrebna nam je još jedna C++11 inovacija. Naime C++11 omogućava da se za povratni tip funkcije stavi oznaka auto, pri čemu to auto ovaj put ne znači da se povratni tip funkcije određuje automatski (mada je baš takva inovacija uvedena nedavno u C++14), nego da će se povratni tip funkcije zadati naknadno, iza spiska parametara. U tom slučaju, iza spiska parametara se stavlja znak ->, nakon kojeg slijedi željeni povratni tip. Tako se, na primjer, funkcija 3

4 int ZbirBrojeva(int x, int y) { return x + y; u C++11 može napisati i ovako: auto ZbirBrojeva(int x, int y) -> int { return x + y; // C++11 alternativa Rijetko ko će normalne funkcije pisati na ovakav način (osim možda ljubitelja tzv. funkcionalnih programskih jezika, jer je ova sintaksa prilično u duhu takvih jezika). Međutim, činjenica je da upravo ova inovacija u kombinaciji sa decltype operatorom rješava naš problem. Konačno ispravno rješenje za generičku funkciju NadjiElement sa potpunom dedukcijom sad može izgledati ovako: template <typename Kontejner> auto MaxElement(const Kontejner &c, int broj_elemenata) -> decltype(c[0]) { int indeks(0); for(int i = 1; i < broj_elemenata; i++) if(c[i] > c[indeks]) indeks = i; return c[indeks]; Operator decltype uopće ne izračunava svoj argument, nego ga samo analizira sa ciljem da mu odredi tip, tako da on neće napraviti problem zbog indeksiranja c[0] čak i ako je c prazna kolekcija (ipak, sama funkcija hoće napraviti problem ponudi li joj se prazna kolekcija, zbog indeksiranja koje se javlja u samom tijelu funkcije, tako da bi u tom slučaju najbolje bilo baciti izuzetak, jer tad funkcija nema ništa smisleno što bi mogla vratiti). Treba još ukazati i na činjenicu da će povratni tip ove funkcije zapravo biti referenca, jer je izraz c[0] l-vrijednost. U ovom konkretnom slučaju to nam ne smeta, ali postoje slučajevi gdje to može i da smeta. Često se primjenom raznih trikova može izbjeći da decltype vrati referencu. Na primjer, ukoliko znamo da su elementi niza numeričke prirode, možemo umjesto decltype(c[0]) pisati decltype(0 + c[0]), što neće biti referenca s obzirom da izraz 0 + c[0] nije l-vrijednost. Postoji i univerzalno rješenje za ovaj problem, ali je prilično nezgrapno. Ukoliko želimo izbjeći da decltype vrati referencu, umjesto standardne konstrukcije decltype(neki_izraz) treba koristiti (rogobatnu) konstrukciju std::remove_reference<decltype(neki_izraz)>::type Ova konstrukcija nažalost zahtijeva uključenje biblioteke type_traits koja, između ostalog, definira i metafunkciju remove_reference koja tip koji eventualno može biti i tip reference pretvara u odgovarajući tip koji nije referenca. Inače, metafunkcije su tvorevine slične funkcijama, ali koje kao svoje parametre prihvataju tipove (a ne objekte) i mogu kao rezultat dati ponovo tipove (npr. neki drugi tip). Prostor na ovom kursu nam ne dozvoljava da ulazimo u dublje detalje vezane za metafunkcije. Kao što je već nagoviješteno, u najnovijem standardu C++14 omogućeno je da se povratni tip funkcije određuje potpuno automatski, uz jedino ograničenje da ukoliko unutar funkcije postoji više return naredbi, iza svake od njih mora biti izraz istog tipa. Stoga bi se prethodna funkcija u C++14 mogla vrlo elegantno napisati prosto ovako: template <typename Kontejner> auto &MaxElement(const Kontejner &c, int broj_elemenata) { // Samo u C++14! int indeks(0); for(int i = 1; i < broj_elemenata; i++) if(c[i] > c[indeks]) indeks = i; return c[indeks]; Da bismo uvidjeli punu snagu generičkih funkcija i potpune dedukcije, moramo se upoznati sa još nekim tipovima podataka za čuvanje kolekcije elemenata pored nizova, vektora i dekova, kao i sa jednim poopćenjem pokazivača uvedenom u jezik C++ (u odnosu na C-ovske pokazivače) nazvanim iteratori. Kao motivaciju, prikazaćemo prvo nešto drugačiju verziju funkcije IspisiKolekciju koja umjesto same kolekcije i broja elemenata u kolekciji prima kao parametre pokazivač na prvi element kolekcije i pokazivač koji pokazuje tačno iza posljednjeg elementa kolekcije (vidjećemo nešto kasnije zašto ne na posljednji element kolekcije). Takva funkcija mogla bi izgledati recimo ovako: template <typename NekiTip> void IspisiKolekciju(NekiTip *pocetak, NekiTip *iza_kraja) { while(pocetak!= iza_kraja) std::cout << *pocetak++ << " "; 4

5 Primijetimo prvo da je u ovoj funkciji korištena djelimična dedukcija, s obzirom da je za parametre pocetak i iza_kraja specificirano da se radi o pokazivačima, jedino nije precizirano na koji tip podataka oni pokazuju. Bez obzira na to, ova funkcija se može primijeniti na ispis bilo nizova, bilo vektora, upravo zahvaljujući činjenici da ona kao parametre prima pokazivače, čime smo se donekle oslobodili ovisnosti od toga u kakvoj se kolekciji nalaze elementi (mada ćemo uskoro vidjeti da se ipak nismo u potpunosti oslobodili te ovisnosti). Treba istaći, da bi mnogi vjerovatno umjesto operatora!= u uvjetu petlje radije upotrijebili operator <. Funkcija bi i tada ispravno radila, ali uskoro ćemo vidjeti da ima razloga zbog kojih je bolje uvjet napisati preko operatora!=. Sljedeći isječak pokazuje da ovu funkciju zaista možemo uspješno koristiti kako sa nizovima, tako i sa vektorima: int a[10]{3, 4, 0, 8, 1, -6, 1, 4, 2, -7; IspisiKolekciju(&a[0], &a[10]); std::vector<double> v{3, 4, 0, 8, 1, -6, 1, 4, 2, -7; IspisiKolekciju(&v[0], &v[10]); Ovako napisana funkcija je znatno fleksibilnija nego ranije napisana verzija funkcije IspisiKolekciju, s obzirom da je pomoću nje lako ispisati proizvoljan blok uzastopnih elemenata niza/vektora (u daljem tekstu ćemo prosto govoriti blok), a ne samo čitav niz/vektor. Naime, dovoljno je da kao parametre proslijedimo pokazivač na prvi element bloka i pokazivač koji pokazuje na element iza posljednjeg elementa bloka (za takva dva pokazivača kažemo da omeđuju taj blok). U slučaju kada je u pitanju niz, zahvaljujući automatskoj konverziji nizova u pokazivače i pokazivačkoj aritmetici, mogli smo umjesto gore navedenog poziva koristiti i jednostavniji poziv IspisiKolekciju(a, a + 10); Zaista, imena nizova upotrijebljena sama za sebe (bez indeksiranja) automatski se konvertiraju u pokazivače na prve elemente nizova. Tako se izraz a automatski interpretira kao izraz &a[0], dok se izraz a + 10 interpretira kao &a[0] + 10, što je, zahvaljujući pokazivačkoj aritmetici, isto što i &a[10]. Ipak, zasada radi jednoobraznosti nećemo koristiti ovu konvenciju (tj. da bismo imali istu sintaksu za nizove i za vektore). Prije nego što ukažemo na probleme sa ovom funkcijom, razmotrimo i zbog čega smo se odlučili da drugi parametar bude pokazivač koji pokazuje na element iza posljednjeg elementa bloka, a ne tačno na posljednji element. Razlozi za ovo su praktične prirode. Recimo, uz ovakvu konvenciju, broj elemenata bloka prosto možemo dobiti kao razliku ova dva pokazivača (tj. kao iza_kraja - pocetak ), dok bi uz konvenciju pokazivanja na posljednji element ova razlika bila za jedinicu manja od broja elemenata bloka. Dalje, ukoliko niz a ima n elemenata, adresa koja slijedi iza posljednjeg elementa niza je &a[n] odnosno a + n, što je svakako praktičnije od adrese posljednjeg elementa &a[n - 1] odnosno a + n - 1. Još jedna prednost ovakve konvencije je što kod nje uvijek mora vrijediti uvjet iza_kraja > pocetak kad god blok ima makar jedan element, tako da se prazan blok (tj. blok bez elemenata) može modelirati kao blok kod kojeg vrijedi uvjet iza_kraja == pocetak, što se također pokazuje kao korisno u nekim primjenama. Konačno, konvencijom da se koristi pokazivač koji pokazuje tačno iza kraja bloka omogućeno je da se u uvjetima koji kontroliraju kada će se petlja koja prolazi kroz elemente bloka završiti mogu koristiti operatori poređenja!= i == umjesto operatora <=, >=, < i >, što će se kasnije pokazati kao vrlo značajno. Napisana funkcija lijepo radi sa nizovima i vektorima, pa čak i stringovima (koji se u dosta aspekata ponašaju poput vektora čiji su elementi znakovi). Razmotrimo međutim šta će se dogoditi ukoliko ovu funkciju probamo iskoristiti da ispišemo elemente nekog deka pozivom poput sljedećeg: std::deque<double> d{3, 4, 0, 8, 1, -6, 1, 4, 2, -7; IspisiKolekciju(&d[0], &d[10]); // PROBLEMATIČNO!!! Ovo će sintaksno proći, ali da li će raditi? Postoji mogućnost da hoće, ali postoji i da neće, tako da se ne smijemo osloniti da hoće. U čemu je problem? Funkcija IspisiKolekciju oslanja se na pokazivačku aritmetiku, a ona se opet zasniva na pretpostavci da su elementi kolekcije smješteni u memoriju jedan za drugim. Ta pretpostavka je za nizove, vektore i stringove garantirano ispunjena, ali za dekove ne mora biti. Susjedni elementi deka ne moraju biti susjedni u memoriji (u većini implementacija dekova, elementi dekova su grupirani u blokove pri čemu elementi koji čine jedan blok jesu susjedni u memoriji, ali različiti blokovi nisu susjedni u memoriji). To je učinjeno da bi se dobila garancija da umetanje novih elemenata u dek pomoću operacija push_back i push_front nikada neće pomjeriti adresu niti jednog elementa u deku, dok takva garancija ne postoji recimo za vektore i stringove. Uglavnom, kako susjedni elementi deka nisu nužno susjedni u memoriji, prethodni primjer može dati posve nepredvidljive rezultate. 5

6 C++ nudi elegantno rješenje ovog problema uvođenjem tzv. iteratora. Iteratori predstavljaju poopćenje pokazivača koje omogućava da se manipulacije slične korištenju pokazivačke aritmetike mogu koristiti i sa kolekcijama podataka čiji elementi ne moraju biti smješteni u memoriji jedan za drugim, nego mogu biti i razbacani po memoriji (kasnije ćemo vidjeti da u jeziku C++ pored dekova ima još takvih kolekcija). Za razliku od pokazivača, iteratori znaju kako je interno građena kolekcija podataka po kojoj se kreću i mogu iskoristiti ta znanja za uspješno kretanje kroz kolekciju. Konkretno, ukoliko je it neki iterator koji pokazuje na neki element neke kolekcije, tada će nakon konstrukcije poput it++ taj iterator pokazivati na sljedeći element te kolekcije, bez obzira gdje se on nalazio u memoriji (iterator će iskoristiti znanje o građi kolekcije podataka na čiji element pokazuje da sazna gdje se zaista nalazi sljedeći element). Iteratori su podržani za vektore, dekove, stringove i još mnoge kolekcije koje postoje u jeziku C++ sa kojima se još nismo susreli. Zapravo, za vektore i stringove iteratori su funkcionalno potpuno ekvivalentni pokazivačima, dok za druge vrste kolekcija koje ne garantiraju kontinuitet njihovih elemenata u memoriji nisu. Stoga se, u načelu, za vektore i stringove iteratori i nisu morali podržavati (obični pokazivači bi bili sasvim dovoljni), ali su podržani čisto radi jednoobraznosti (da bi se na isti način moglo raditi sa različitim vrstama kolekcija). Bilo bi lijepo da su iteratori (ponovo radi jednoobraznosti) podržani i za klasične nizove, ali to tehnički nije bilo izvodljivo (iteratori se mogu podržati samo za tipove koji predstavljaju tzv. klase, a nizovi to nisu). Stoga pri radu sa nizovima moramo koristiti klasične pokazivače. Iteratorski tip se dobija tako što se na tip kolekcije kroz koju se iterator kreće doda nastavak ::iterator. Slijedi nekoliko primjera deklaracija iteratora: std::vector<int>::iterator it1; std::string::iterator it2; std::deque<double>::iterator it3; // Iterator za vektor cijelih brojeva // Iterator za string // Iterator za dek realnih brojeva Nisu iteratori za sve kolekcije jednako moćni po svojim mogućnostima, o čemu ćemo detaljnije govoriti kasnije. Zasad ćemo samo reći da iteratori za vektore, stringove i dekove spadaju u tzv. iteratore sa direktnim (slučajnim) pristupom (engl. random access iterators), što praktično znači da su jednako moćni kao i pokazivači. Konkretno, ukoliko je it neki iterator sa direktnim pristupom, valjani su izrazi poput *it (dereferenciranje), it + n, it - n, it += n, it -= n (gdje je n cjelobrojna vrijednost), it++, it-- i it[n] (ovo je ekvivalentno sa *(it + n) ). Također, ako su it1 i it2 dva iteratora sa direktnim pristupom istog tipa, valjan je i izraz it1 - it2 kao i sva moguća poređenja ova dva iteratora. Ipak, iteratorima se ne može neposredno dodijeliti adresa nekog elementa niti se mogu inicijalizirati adresom. Umjesto toga, svaka kolekcija koja podržava iteratore podržava i funkcije begin i end bez parametara, koje primijenjene na neku kolekciju vraćaju respektivno iterator koji ukazuje na prvi element kolekcije i iterator koji ukazuje tačno iza posljednjeg elementa kolekcije. Stoga sve elemente nekog vektora v možemo ispisati i na sljedeći način: for(std::vector<int>::iterator i = v.begin(); i!= v.end(); i++) std::cout << *i << " "; Ovo može i kraće pomoću auto deklaracija, koje su ko stvorene baš za ovakve stvari: for(auto i = v.begin(); i!= v.end(); i++) std::cout << *i << " "; Ovakve konstrukcije (sa auto deklaracijom) će raditi za bilo koju kolekciju koja podržava iteratore. Nažalost, one neće raditi za obične nizove, jer oni ne podržavaju iteratore. Da bi se još više povećala jednoobraznost pri radu sa različitim kolekcijama, u verziji C++11 je kao alternativa za konstrukcije poput v.begin() i v.end() omogućeno da se piše std::begin(v) odnosno std::end(v) sa posve istim značenjem (prefiks std:: može se izostaviti ukoliko smo koristili odgovarajuću using deklaraciju). Smisao ove alternative je da se, iz nekih tehničkih razloga, ova druga sintaksa može podržati i za neke tipove za koje se prva sintaksa ne može podržati. Recimo, ova druga sintaksa radi čak i sa klasičnim nizovima. Konkretno, ukoliko je a neki klasični niz, tada std::begin(a) i std::end(a) vraćaju respektivno pokazivač na prvi element, odnosno pokazivač na mjesto iza posljednjeg elementa niza (dakle, pokazivač, a ne iterator). U svakom slučaju, ukoliko prethodnu konstrukciju napišemo kao for(auto i = std::begin(a); i!= std::end(a); i++) std::cout << *i << " "; ona će raditi čak i sa klasičnim nizovima, ali pravim nizovima. Tačnije, ona neće raditi sa nizovima koji su formalni parametri funkcija, jer oni zapravo i nisu nizovi nego pokazivači, o čemu smo već govorili (tehnički, ovo ne može raditi sa takvim nizovima jer je prilikom konverzije niza u pokazivač izgubljena informacija o veličini niza). 6

7 Bitno je napomenuti da su iteratori za različite vrste kolekcija međusobno nekompatibilni i ne mogu se međusobno dodjeljivati. Isto tako, iteratori i pokazivači su međusobno nekompatibilni. Treba još istaći da kako između iteratora za vektore i stringove i običnih pokazivača nema apsolutno nikakve efektivne razlike, standard C++ jezika dozvoljava da ovi iteratori budu implementirani kao obični pokazivači (tj. da oni bukvalno budu pokazivači), ali ne zahtijeva da bude tako. Stoga se ne smijemo osloniti na mogućnost da iteratoru za vektor dodijelimo pokazivač (bez obzira što se može desiti da ta dodjela uspije u nekim kompajlerima). Nakon ovih objašnjenja, sad imamo dovoljno informacija da možemo shvatiti smisao konstrukcija kao što su recimo v.insert(v.begin() + n, x) i v.erase(v.begin() + n). Poenta je u tome da funkcije insert i erase kao prvi parametar traže iterator na element gdje se vrši umetanje, odnosno element koji se briše. Kako je v.begin() iterator koji ukazuje na prvi element vektora, to je v.begin() + n iterator koji ukazuje na n -ti element vektora. Vratimo se ponovo na generičku funkciju IspisiKolekciju koju smo ranije pisali, a koja je kao parametre prihvatala pokazivače. Upravo zbog činjenice da smo eksplicitno naglasili da su parametri pokazivači, tako napisana funkcija neće prihvatati iteratore kao parametre. Drugim riječima, ukoliko je v neki vektor, sljedeći poziv (zasada) neće raditi: IspisiKolekciju(v.begin(), v.end()); // NE RADI (ZA SADA)! Ovaj problem je veoma lako riješiti tako što ćemo umjesto djelimične dedukcije koristiti potpunu dedukciju, odnosno uklonićemo pretpostavku da su parametri pokazivači. Na taj način dobićemo generičku funkciju koja će kao parametre primati bilo pokazivače bilo iteratore (odnosno bilo šta na šta se može primijeniti derefenrenciranje, operator ++, te poređenje na različitost pomoću!= ): template <typename IterTip> void IspisiKolekciju(IterTip pocetak, IterTip iza_kraja) { while(pocetak!= iza_kraja) std::cout << *pocetak++ << " "; Slijedi primjer nekoliko ispravnih poziva ove funkcije, uz pretpostavku da je a neki niz od 10 elemenata, v neki vektor, a d neki dek: IspisiKolekciju(a, a + 10); IspisiKolekciju(&a[0], &a[10]); // Kao prethodno IspisiKolekciju(std::begin(a), std::end(a)); // Kao prethodno (C++11) IspisiKolekciju(a + 3, a + 7); IspisiKolekciju(&v[0], &v[v.size()]); IspisiKolekciju(v.begin(), v.end()); // Kao prethodno IspisiKolekciju(std::begin(v), std::end(v)); // Kao prethodno (C++11) IspisiKolekciju(v.begin() + 3, v.begin() + 5); IspisiKolekciju(v.begin() + 3, v.end() - 2); IspisiKolekciju(d.begin(), d.end()); IspisiKolekciju(d.begin() + 3, d.end() - 2); Pretpostavimo sada da zbog nekih razloga želimo napraviti generičku funkciju IspisiDek sličnu kao funkcija IspisiKolekciju, ali koja radi samo sa dekovima (proizvoljnog tipa elemenata) i koja zahtijeva isključivo iteratore za dekove kao parametre. Jasno je da ovdje moramo koristiti djelimičnu dedukciju, odnosno moramo reći da su parametri iteratori za dekove, jedino što ostaje nespecificirano je kakav je tip elemenata tog deka. Prirodan pokušaj da napravimo takvu funkciju izgleda ovako: template <typename TipElemenata> void IspisiDek(std::deque<TipElemenata>::iterator pocetak, std::deque<tipelemenata>::iterator iza_kraja) { while(pocetak!= iza_kraja) std::cout << *pocetak++ << " "; // NE RADI! Nažalost, na ovakvu funkciju, kompajler prijavljuje vrlo čudne i nejasne greške. Problem je u tome što zbog činjenice da postoje tzv. djelimične specijalizacije šablona (u šta se nećemo upuštati), kompajler ne može da zaključi da konstrukcija poput std::deque<tipelemenata>::iterator uopće predstavlja naziv nekog tipa. Tačnije, on (pogrešno) zaključi da to uopće nije tip i eto problema. Da ne ulazimo u tehničke detalje, daćemo jedno pravilo. Kad god imamo konstrukciju oblika x :: y u kojoj x ovisi od parametara šablona (poput std::deque<tipelemenata> u našem slučaju), kompajler ne može zaključiti da je to zaista naziv nekog tipa, i moramo mu pomoći dodavanjem ključne riječi typename ispred ove konstrukcije (tj. pisanjem typename x :: y ). Stoga ispravna verzija gore napisane funkcije glasi ovako: 7

8 template <typename TipElemenata> void IspisiVektor(typename std::vector<tipelemenata>::iterator pocetak, typename std::vector<tipelemenata>::iterator iza_kraja) { while(pocetak!= iza_kraja) std::cout << *pocetak++ << " "; Razvoj programa u jeziku C++ osjetno je olakšan uvođenjem standardne biblioteke algorithm. Ova biblioteka sadrži veliki broj korisnih funkcija (85 u verziji C++11, pri čemu većina funkcija dolazi u više varijanti sa različitim parametrima) za kojima se u svakodnevnom programiranju često javlja potreba. Veliki broj ovih funkcija su posve jednostavne, i ne bi ih bilo nikakav problem samostalno napisati, mada među njima ima i dosta složenih funkcija. Međutim, kako se radi o operacijama koje se izuzetno često koriste u praktičnim primjenama, lijepo je znati da takve funkcije već postoje napisane, tako da ih možemo koristiti bez potrebe da svaki put ponovo otkrivamo toplu vodu. Također, sve spomenute funkcije napisane su veoma efikasno, tako da će vjerovatno raditi efikasnije nego analogne funkcije koje bismo eventualno napisali sami. Većina funkcija iz biblioteke algorithm predviđena je za razne manipulacije sa nizovima, vektorima, stringovima, dekovima i drugim kontejnerskim strukturama (kolekcijama) koje posjeduje jezik C++. Štaviše, one mogu raditi čak i sa kontejnerskim strukturama podataka koje definira sam programer, pod uvjetom da one zadovoljavaju određene uvjete (odnosno, da predstavljaju modele odgovarajućeg koncepta). Ove funkcije su zasnovane na potpunoj dedukciji i uglavnom prihvataju kao parametre pokazivače i iteratore, pri čemu se pokazivači mogu (i moraju) koristiti ukoliko koristimo nizove, dok za sve druge kolekcije moramo koristiti iteratore (eventualno, dozvoljeno je da se pokazivači koriste i u slučaju vektora odnosno stringova, mada se radi jednoobraznosti preporučuje da se i tada koriste iteratori). Prikazaćemo sada neke od najjednostavnijih i najčešće korištenih funkcija iz ove biblioteke. U svim opisanim funkcijama, kada govorimo o bloku elemenata između i, mislimo da pokazivač ili iterator pokazuje na prvi element bloka, a pokazivač ili iterator pokazuje tačno iza posljednjeg elementa bloka, u skladu sa konvencijom koju smo već usvojili: copy(,, ) Kopira blok elemenata između i na lokaciju koja je određena pokazivačem/iteratorom (usput vraća kao rezultat pokazivač/ iterator na poziciju tačno iza odredišnog bloka). copy backward(,, ) Kao copy, ali kopira elemente unazad, odnosno redom od posljednjeg elementa ka prvom. Pri tome, treba da pokazuje tačno iza kraja odredišnog bloka, a ne na njegov početak. Razlika između ove funkcije i funkcije copy može biti važna ukoliko se izvorni i odredišni blok preklapaju. fill(,, ) Popunjava sve elemente između i sa vrijednošću. fill_n(,, ) Popunjava uzastopnih elemenata počev od pokazivača/iteratora nadalje sa vrijednošću. swap_ranges(,, ) Razmjenjuje blok elemenata između i sa blokom elemenata na koji pokazuje (usput vraća kao rezultat pokazivač/iterator na poziciju tačno iza bloka na koji pokazuje ). reverse(, ) Izvrće blok elemenata između i u obrnuti poredak, tako da prvi element postane posljednji, itd. reverse_copy(,, ) Kopira blok elemenata između i u obrnutom poretku na lokaciju određenu pokazivačem/iteratorom (tako da će nakon toga posljednji element u izvornom bloku biti prvi element u odredišnom bloku, itd.). Sam izvorni blok ostaje neizmijenjen. replace(,,, ) Zamjenjuje sve elemente između i koji imaju vrijednost sa elementima sa vrijednošću. replace_copy(,,,, ) Kopira blok elemenata između i na lokaciju koja je određena pokazivačem/iteratorom uz zamjenu svakog elementa koji ima vrijednost sa elementom koji ima vrijednost. count(,, ) Vraća kao rezultat broj elemenata u bloku između i koji imaju vrijednost. 8

9 rotate(,, ) Rotira blok elemenata između i ulijevo onoliko puta koliko je potrebno da element na koji pokazuje dođe na mjesto elementa na koji pokazuje (jedan korak rotacije se obavlja tako da krajnji lijevi element prelazi na posljednju poziciju, a svi ostali se pomjeraju za jedno mjesto ulijevo). rotate_copy(,,, ) equal(,, ) min_element(, ) max_element(, ) find(,, ) Isto kao rotate, ali kopira rotiranu verziju bloka elemenata na poziciju određenu pokazivačem/iteratorom, dok sam izvorni blok ostaje neizmijenjen. Vraća kao rezultat logičku vrijednost true ukoliko je blok elemenata između i identičan po sadržaju bloku elemenata na koji pokazuje (podrazumijeva se da su blokovi iste dužine) a u suprotnom vraća logičku vrijednost false. Vraća kao rezultat pokazivač/iterator na najmanji element u bloku između i. Vraća kao rezultat pokazivač/iterator na najveći element u bloku između i. Vraća kao rezultat pokazivač/iterator na prvi element u bloku između i koji ima vrijednost. Ukoliko takav element ne postoji, vraća kao rezultat. remove(,, ) Reorganizira elemente bloka između i tako što uklanja sve elemente koji imaju vrijednost v. Kao rezultat vraća pokazivač/ iterator p takav da u bloku između i niti jedan element neće imati vrijednost v. Ukoliko niti jedan element nije imao vrijednost, funkcija vraća kao rezultat. Ova funkcija ne mijenja sam broj elemenata niza niti vektora (broj elemenata niza nije ni moguće mijenjati), nego samo premješta elemente da obezbijedi traženo svojstvo. Sadržaj bloka između vraćenog pokazivača/iteratora i na kraju je nedefiniran. remove copy(,,, ) Kopira blok elemenata između i na lokaciju koja je određena pokazivačem/iteratorom, uz izbacivanje elemenata koji imaju vrijednost. Kao rezultat, funkcija vraća pokazivač/iterator koji pokazuje tačno iza posljednjeg elementa odredišnog bloka. unique(, ) Reorganizira elemente bloka između i tako što uklanja sve elemente koji su jednaki elementima koji im prethode. Kao rezultat vraća pokazivač/iterator takav da u bloku između i neće biti susjednih elemenata koji su međusobno jednaki. Ukoliko u nizu nije bilo susjednih elemenata koji su međusobno jednaki, funkcija vraća kao rezultat. Bitno je naglasiti da ova funkcija neće ukloniti nesusjedne elemente koji su međusobno jednaki, već samo susjedne. Također, ova funkcija ne mijenja sam broj elemenata niza niti vektora nego samo premješta elemente da obezbijedi traženo svojstvo. Sadržaj bloka između vraćenog pokazivača/iteratora i na kraju je nedefiniran. unique copy(,, ) Kopira blok elemenata između i na lokaciju koja je određena pokazivačem/iteratorom p 3, uz izbacivanje elemenata koji su jednaki elementu koji im prethodi. Kao rezultat, funkcija vraća pokazivač/ iterator koji pokazuje tačno iza posljednjeg elementa odredišnog bloka. Razmotrimo nekoliko jednostavnih primjera primjene ovih funkcija. Pretpostavimo prvo da imamo dva niza a i b od po 10 realnih elemenata, i da je potrebno iskopirati sve elemente niza a u niz b. Umjesto da vršimo kopiranje element po element pomoću for-petlje, možemo prosto iskoristiti funkciju copy, na neki od sljedećih načina (uključujući i jednoobraznu varijantu iz C++11 koja koristi funkcije std::begin i std::end ): std::copy(&a[0], &a[10], &b[0]); std::copy(a, a + 10, b); std::copy(std::begin(a), std::end(a), std::begin(b)); // Kraća varijanta... // Samo u C++11 9

10 Radi boljeg razumijevanja funkcije copy, navedimo da je ona implementirana prinicipijelno ovako, samo često na efikasniji način, uz pozivanje izvjesnih mašinskih potprograma za potrebe kopiranja nekih standardnih tipova: template <typename IterTip1, typename IterTip2> IterTip2 copy(itertip1 pocetak, IterTip1 iza_kraja, IterTip2 odrediste) { while(pocetak!= iza_kraja) *odrediste++ = *pocetak++; return odrediste; Primijetimo da je u ovoj funkciji korištena potpuna dedukcija, odnosno nisu navedeni nikakvi detalji o tome šta parametri pocetak, iza_kraja i odrediste predstavljaju, pa čak nije naglašeno ni da su oni pokazivači (nema zvjezdice u deklaraciji). Time je postignuto da ovi parametri i ne moraju biti pokazivači. Zaista, oni će moći biti i recimo iteratori, odnosno bilo kakvi objekti na koje je moguće primijeniti dereferenciranje i operacije ++ te!= (možemo reći objekti koji pripadaju konceptu iteratorskih tipova, odakle i ime metatipova IterTip1 i IterTip2 ). Primijetimo da tip parametara pocetak i iza_kraja mora biti isti, ali parametar odrediste može biti drugačijeg tipa. Recimo, legalno je da pocetak i iza_kraja budu neki pokazivači, a odrediste neki iterator. Uzmimo sada da je elemente niza a sa indeksima u opsegu od 4 do 9 potrebno pomjeriti za jedno mjesto naniže, tako da element sa indeksom 4 dođe na mjesto elementa sa indeksom 3 (recimo, sa ciljem brisanja elementa sa indeksom 3). To možemo uraditi sljedećim pozivom: std::copy(a + 4, a + 10, a + 3); S druge strane, želimo li sve elemente niza a sa indeksima u opsegu od 5 do 8 pomjeriti za jedno mjesto naviše, tako da element sa indeksom 5 dođe na mjesto elementa sa indeksom 6 (recimo, sa ciljem umetanja novog elementa na mjesto elementa sa indeksom 5), to možemo uraditi sljedećim pozivom (razmislite zbog čega je ovdje potrebno koristiti funkciju copy_backward umjesto copy ): std::copy_backward(a + 5, a + 9, a + 10); U slučaju da umjesto nizova koristimo vektore, stringove ili dekove, prethodne konstrukcije neće raditi, s obzirom da se imena vektora, stringova ili dekova upotrijebljena bez indeksiranja ne konvertiraju automatski u adresu prvog elementa kolekcije. Stoga, ukoliko je c neki vektor, string ili dek, prethodne konstrukcije mogli bismo realizirati ovako: std::copy(c.begin() + 4, c.begin() + 10, c.begin() + 3); std::copy_backward(c.begin() + 5, c.begin() + 9, c.begin() + 10); Alternativno, za slučaj vektora ili stringova (ali ne i dekova) mogli bismo eksplicitno koristiti i operator uzimanja adrese. Ipak, ovu praksu treba izbjegavati, jer ne radi ispravno sa kolekcijama kod kojih ne postoji kontinuitet elemenata u memoriji (za razliku od verzije sa iteratorima koja uvijek radi ispravno); std::copy(&c[4], &c[10], &c[3]); // Ovo radi, ali bi std::copy_backward(&c[5], &c[9], &c[10]); // trebalo izbjegavati... Neka je sada potrebno ispisati najveći element u nizu a. To možemo uraditi recimo ovako: std::cout << *std::max_element(a, a + 10); Naravno, u verziji C++11 možemo koristiti i funkcije begin i end : std::cout << *std::max_element(std::begin(a), std::end(a)); U svakom slučaju, zvjezdica je potrebna zbog činjenice da funkcija max_element ne vraća sam maksimalni element, nego pokazivač ili iterator na njega (iterator se vraća ako su parametri bili također iteratori) tako da je potrebno primijeniti dereferenciranje. Ova konvencija je uvedena s obzirom da se tako ostvaruje povećana fleksibilnost. Na primjer, ukoliko sad hoćemo na mjesto najvećeg elementa upisati nulu, možemo prosto pisati: *std::max_element(a, a + 10) = 0; Ranije smo vidjeli da se sličan efekat može izvesti bez upotrebe dereferenciranja, ukoliko se umjesto pokazivača (ili iteratora) upotrijebe reference. Autori biblioteke algorithm ipak su se odlučili za pokazivače odnosno iteratore a ne za reference, s obzirom da su pokazivači i iteratori generalniji od referenci. Ukoliko istu stvar želimo uraditi sa vektorom ili dekom, najbolje bi bilo koristiti konstrukcije u kojima se koriste iteratori poput 10

11 std::cout << *std::max_element(v.begin(), v.end()); Zapravo, iteratori su nužnost ukoliko radimo sa dekom. Pokazivači i pokazivačka aritmetika su validni samo kada se primjenjuju na elemente nizova, vektora i stringova. Oni se nikada ne smiju koristiti sa dekovima i drugim složenijim strukturama podataka. Ilustrirajmo još i funkciju remove. Pretpostavimo da niz a sadrži redom elemente 3, 7, 2, 5, 7, 4, 7, 1, 7 i 3. Dalje, neka je p neki pokazivač na tip elemenata niza (recimo double ). Nakon poziva p = std::remove(a, a + 10, 7); elementi niza a sa indeksima od 0 do 5 biće redom 3, 2, 5, 4, 1 i 3, dok će elementi niza sa indeksima od 6 do 9 biti nedefinirani (u većini implementacija, biće onakvi kakvi su bili i ranije, odnosno 7, 1, 7 i 3, ali se na tu osobinu ne treba oslanjati). Pokazivač p će pokazivati na element sa indeksom 6, tako da će, zahvaljujući pokazivačkoj aritmetici, izraz p - a sadržavati broj elemenata u bloku koji više ne sadrži element 7. Stoga, elemente nakon obavljenog odstranjivanja, možemo ispisati ovako: for(int i = 0; i < p - a; i++) std::cout << a[i] << std::endl; Alternativno smo mogli neposredno koristiti pokazivačku aritmetiku: for(double *p1 = a; p1!= p; p1++) std::cout << *p1 << std::endl; Treba imati na umu da funkcija remove ne uklanja fizički elemente sa navedenom vrijednošću, nego samo premješta elemente niza tako da u navedenom bloku više ne bude elemenata sa navedenom vrijednošću, dok međusobni poredak ostalih elemenata ostaje netaknut (slično vrijedi i za funkciju unique ). Za slučaj nizova, fizičko uklanjanje elemenata nije ni moguće izvesti (s obzirom da je broj njihovih elemenata fiksan), dok je u slučaju vektora fizičko uklanjanje nakon obavljene reorganizacije moguće izvesti (recimo, pozivom funkcije resize nad vektorom). U vezi sa funkcijama iz biblioteke algorithm koje vraćaju kao rezultat pokazivače ili iteratore, kao što su unique, remove, find i slične, treba paziti na jednu bitnu činjenicu. Naime, ove funkcije će kao rezultat vratiti pokazivač ili iterator ovisno od toga da li su im kao argumenti proslijeđeni pokazivači ili iteratori. U mnogim kontekstima ovo nije bitno, jer se iteratori u većini slučajeva mogu koristiti na isti način kao i pokazivači. Na primjer, iteratori se mogu dereferencirati na isti način kao i pokazivači. Međutim, iteratori se ne mogu dodjeljivati pokazivačima niti obratno. Ukoliko o ovome ne vodimo računa, mogu nastupiti problemi. Neka je, na primjer, v neki vektor cijelih brojeva. Mada je konstrukcija poput int *p(std::find(&v[0], &v[v.size()], 5)); posve korektna, to ne vrijedi za konstrukciju poput int *p(std::find(v.begin(), v.end(), 5)); // OVO NE RADI!!! Naime, kako su izrazi v.begin() i v.end() po tipu iteratori (a ne pokazivači), funkcija find će kao rezultat vratiti također iterator, koji se ne može dodijeliti pokazivaču p. Da bi ova posljednja konstrukcija bila ispravna, p bi trebalo deklarirati kao iterator za vektor cijelih brojeva, a ne kao pokazivač na cijeli broj: std::vector<int>::iterator p(std::find(v.begin(), v.end(), 5)); Ukoliko koristimo C++11, auto deklaracije nam mogu dvostruko pomoći, ne samo što nećemo morati kucati rogobatne deklaracije, nego najčešće nećemo uopće ni morati misliti o tome kakav je tačno tip vraćene vrijednosti. Naime, prethodna konstrukcija se u C++11 mogla napisati prosto ovako: auto p(std::find(v.begin(), v.end(), 5)); Kod svih opisanih funkcija koje kopiraju elemente na neko odredište (takve su sve navedene funkcije koje u svom imenu imaju riječ copy ), isključiva je odgovornost programera da odredište sadrži dovoljno prostora da može primiti elemente koji se kopiraju. Ukoliko ovo nije ispunjeno, posljedice su nepredvidljive i obično fatalne po program. Još treba napomenuti da su sve opisane funkcije napisane u izrazito generičkom stilu, tako da prihvataju parametre izrazito različitih tipova. Stoga je potrebno voditi računa da parametri koje prosljeđujemo ovim funkcijama imaju smisla. U protivnom, moguće su prijave vrlo čudnih grešaka od strane kompajlera, a može se desiti i da ne bude prijavljena nikakva greška, ali da funkcija ne radi u skladu sa očekivanjima. 11

12 Pokažimo u kojoj mjeri uvođenje auto deklaracija olakšava kreriranje generičkih funkcija, posebno onih koje koriste potpunu dedukciju. Pretpostavimo da želimo sami napisati funkciju koja radi isti zadatak kao funkcija reverse iz biblioteke algorithm. Ova funkcija, mogla bi izgledati recimo ovako (nazvali smo je Izvrni ): template <typename IterTip> void Izvrni(IterTip pocetak, IterTip iza_kraja) { while(pocetak < iza_kraja) { auto pomocna(*pocetak); *pocetak++ = *--iza_kraja; *iza_kraja = pomocna; U ovoj funkciji smo iskoristili auto deklaraciju za potrebe deklaracije promjenljve pomocna. Sad se postavlja pitanje kako bismo deklarirali ovu promjenljivu da nemamo auto deklaracije, odnosno šta bismo stavili da je njen tip. Očigledno, njen tip mora biti tip onoga na šta pokazuje pokazivač ili iterator pocetak, ali kako dobiti informaciju koji je to tip? Dedukcija nam samo govori šta je tip pokazivača ili iteratora pocetak, ali ne i tip onoga na šta on pokazuje. Jasno je da taj tip možemo dobiti pomoću konstrukcije decltype(*pocetak), ali i to je C++11 inovacija. Prije pojave C++11 standarda, jedini način je bio da se napiše pomoćna generička funkcija nazvana recimo Razmijeni (upravo takvu funkciju smo nešto ranije napisali) kojoj ćemo proslijediti dereferencirane pokazivače ili iteratore, tako da će se u novom procesu dedukcije odrediti tip na koji oni pokazuju. To bi izgledalo praktično ovako: template <typename IterTip> void Izvrni(IterTip pocetak, IterTip iza_kraja) { while(pocetak < iza_kraja) Razmijeni(*pocetak++, *--iza_kraja); Prije pojave C++11 standarda, ovakvi (i još mnogo gori) trikovi su se intenzivno morali koristiti da bi se podržala potpuna dedukcija, ali često ni oni nisu uspijevali riješiti problem (neke stvari se jednostavno nisu mogle izvesti). U standardu C++11, takvi problemi su definitivno nestali. Na kraju, treba reći da u jeziku C također postoje neke općenite funkcije koje obavljaju zadatke srodne pojedinim funkcijama iz biblioteke algorithm. Ove funkcije se uglavnom nalaze u biblioteci cstdlib. Tako se, na primjer, funkcije memcpy i memset u jeziku C koriste umjesto funkcija copy i fill, na dosta sličan način, ali uz nešto komplikovanije parametre. Programeri u jeziku C intenzivno koriste ovakve funkcije. Mada se one, u načelu, mogu koristiti i u jeziku C++, postoje veoma jaki razlozi da u jeziku C++ ove funkcije ne koristimo (ova napomena namijenjena je najviše onima koji imaju prethodno programersko iskustvo u jeziku C). Naime, ove funkcije svoj rad baziraju na pretpostavci da je manipulacije sa svim tipovima podataka moguće izvoditi bajt po bajt. Ta pretpostavka je tačna za sve tipove podataka koji postoje u jeziku C, ali ne i za neke novije tipove podataka koji su uvedeni u jeziku C++ (kao što su svi tipovi podataka koji koriste tzv. vlastiti konstruktor kopije). Na primjer, mada će funkcija memcpy besprijekorno raditi za kopiranje nizova čiji su elementi tipa double, njena primjena na nizove čiji su elementi tipa string može imati fatalne posljedice. Tipovi podataka sa kojima se može sigurno manipulirati pristupanjem individualnim bajtima koje tvore njihovu strukturu nazivaju se POD tipovi (od engl. Plain Old Data). Na primjer, prosti tipovi kao što su int, double i klasični nizovi jesu POD tipovi, dok vektori i dinamički stringovi nisu. Opisani problemi sa korištenjem pojedinih funkcija naslijeđenih iz jezika C ne treba mnogo da nas zabrinjavaju, jer za svaku takvu funkciju u jeziku C++ postoje bolje alternative, koje garantirano rade u svim slučajevima. Tako, na primjer, u jeziku C++ umjesto funkcije memcpy treba koristiti već opisanu funkciju copy. Ove funkcije, ne samo da su univerzalnije od srodnih funkcija naslijeđenih iz jezika C, već su i jednostavnije za upotrebu. Činjenica je da se programeri koji posjeduju veće iskustvo u jeziku C teško odriču upotrebe funkcija poput memcpy i memset, jer im je poznato da su one, zahvaljujući raznim trikovima na kojima su zasnovane, vrlo efikasne (mnogo efikasnije nego upotreba obične for-petlje). Međutim, bitno je znati da odgovarajuće funkcije iz biblioteke algorithm, poput copy ili fill tipično nisu ništa manje efikasne. Zapravo, u mnogim implementacijama biblioteke algorithm, poziv funkcija poput copy automatski se prevodi u poziv funkcija poput memcpy ukoliko se ustanovi da je takav poziv siguran, odnosno da tipovi podataka sa kojima se barata predstavljaju POD tipove. Stoga, programeri koji sa jezika C prelaze na C++ ne trebaju osjećati nelagodu prilikom prelaska sa upotrebe funkcija poput memcpy na funkcije poput copy. Jednostavno, treba prihvatiti činjenicu: funkcije poput memcpy i memset zaista više ne treba koristiti u C++ programima. One su zadržane pretežno sa ciljem da omoguće kompatibilnost sa već napisanim programima koji su bili na njima zasnovani! 12