Olio-ohjelmoinnin perusteet luento 7: C++ mallit, Standard Template Library (STL) Sami Jantunen LTY/Tietotekniikan osasto.

Esitys aiheesta: "Olio-ohjelmoinnin perusteet luento 7: C++ mallit, Standard Template Library (STL) Sami Jantunen LTY/Tietotekniikan osasto."— Esityksen transkriptio:

1 Olio-ohjelmoinnin perusteet luento 7: C++ mallit, Standard Template Library (STL) Sami Jantunen LTY/Tietotekniikan osasto

2 Sisältö C++ mallit Yleiskäyttöisyydestä C++ mallit Funktiomallit Luokkamallit Standard Template Library (STL) Taustaa Säiliöt Iteraattorit Yhteenveto

3 Yleiskäyttöisestä suunnittelusta Oleellista on pystyä erottamaan pysyvät ja vaihtelevat asiat toisistaan! Halutaan uudelleenkäyttää pysyvät asiat ja johtaa uusia luokkia toteuttamalla erikseen vaihtelevat asiat Tavoitteelle löytyy oliopohjaisista kielista erilaisia mekanismeja Perintä on tyypillinen yleiskäyttöisyyteen liittyvä mekanismi Luokkien yhteiset ominaisuudet voidaan toteuttaa kertalleen kantaluokassa. Vaihtuvat asiat toteutetaan lapsiluokissa Perinnän käytöllä on kuitenkin rajansa!

4 Perinnän rajoituksia yleiskäytettävyydessä Aliluokat perivät kantaluokkansa rajapinnan ja toteutuksen kokonaisuudessaan ja täsmälleen samanlaisena! Pysyvään osuuteen kuuluu siis kokonaisia palveluita (jäsenfunktioita) parametreineen ja paluuvarvoineen. Todellinen tarve ei kuitenkaan aina ole tällainen!

5 Muistatko vielä? (IntDeque) Otetaanpa Deque luokka hyötykäyttöön! Luodaan Int-pohjainen lista class IntDeque: public Deque { public: IntDeque(); void insert (int); void remove(); int current () const; ~IntDeque(); }; next prev data next prev data next prev data IntDeque void goBeforeFirst(); void goAfterLast(); void forth(); void back(); int isBeforeFirst() const; int isAfterLast() const; IntDeque(); void insert (int); void remove(); int current () const; ~IntDeque(); Deque- luokasta peritty Uusi toiminnallisuus

6 Esimerkki: 2-suuntainen lista Pysyvä osa: Listan toteutus (alkioiden käsittely) Vaihtuva osa: Alkioiden tyyppi  Perinnän käyttö ei kovin kätevää! Useat rajapinnoista on kuitenkin riippuvaisia alkion tyypistä.  Uudelleenkäytettävyyden taso heikkenee Deque IntDeque DoubleDeque Muistathan vielä 2-suuntaisen listaesimerkkimme?

7 Entäpä jos? Mitä jos vaatisimme, että eri tyyppiset alkiot perittäisiin samasta kantaluokasta? Sama 2-suuntainen listatoteutus toimisi riippumatta alkion todellisesta tyypistä Alkio IntAlkio DoubleAlkio Deque

8 Ratkaisun huonoja puolia Tyyppitietoisuus häviää Listaan on mahdollista tallettaa eri tyyppejä sekaisin Kääntäjä ei pysty tekemään tyyppitarkistuksia Taulukon käyttäjän tulee itse tietää mitä tyyppiä alkiot oikeasti on (ja tehdä tarvittaessa osoittimen muunnostyöt) Alkio IntAlkio DoubleAlkio Deque

9 Johtopäätös Erityyppisillä taulukoilla on todella paljon yhteistä Yhteiset asiat on kuitenkin sen luonteisia, että niitä on vaikea toteuttaa yleiskäyttöiseksi kantaluokkaan Taulukon alkioiden tyyppi vaikuttaa taulukon rajapintaan ja toteutukseen kauttaaltaan Alkioiden tyyppien erilaisuuden merkitystä ei voi eliminoida ilman, että tingitään tyyppiturvallisuudesta ja käyttömukavuudesta Olisi kiva jos olisi muitakin mekanismeja pysyvyyden ja vaihtelevuuden hallintaan

10 C++ Mallit (Templates) Käännösaikaisesti tyypitetyissä kielissä (kuten C++) täytyy kaikkien parametrien ja muuttujien tyyppien olla selvillä jo ohjelmaa käännettäessä. Tyyppien geneerisyys ei onnistu ilman lisäkikkoja Mallit (template) ovat C++:n tapa kirjoittaa yleiskäyttöisiä: funktioita (funktiomallit, function templates) luokkia (Luokkamallit, class templates) Malleissa tyyppejä ja joitain muitakin asioita voidaan jättää määrämäättä Auki jätetyt asiat “sidotaan” vasta myöhemmin käytön yhteydessä. Näin saadaan säilytettyä C++:n vahva käännösaikainen tyypitys, mutta annetaan silti mahdollisuus kirjoittaa geneeristä koodia

11 Esimerkki C++ mallista Otetaan esimerkiksi meidän 2-suuntainen lista Muutetaan olemassa olevaa toteutusta ja käytetään perinnän sijasta luokkamallia Toteutetaan Deque-malliin yleinen toiminnallisuus Jätetään alkioiden tyyppi vielä määrittelemättä Kun lista otetaan käyttöön, määritellään samalla alkioiden tyyppi tyyliin: Deque Auki jätetyt asiat siis selviävät jo käännösaikana, mutta kuitenkin vasta vektoreiden käyttötilanteessa Deque

12 C++ mallin syntaksi template //Tähän normaali funktion tai luokan määrittely TAI template //Tähän normaali funktion tai luokan määrittely Malli alkaa avainsanalla template Seuraavaksi esitellään kulmasulkeiden sisällä kaikki auki jätetyt tyyppiparametrit Tämän jälkeen seuraa itse mallin koodi (normaalin funktion tai luokan tapaan) Tyyppiparametreja voi käyttää koodissa aivan kuin normaaleja C++ tyyppejä.

13 Funktiomallit (function template) Geneerisiä malleja, joista kääntäjä voi generoida eri tyypeillä toimivia funktioita Kääntäjä osaa automaattisesti päätellä kutsusta tyyppiparametrien arvot Voidaan kutsua aivan kuin mitä tahansa muuta funktiota: min(1,2); //int min(2.3, 5.7); //double On myös mahdollista eksplisiittesesti määrätä tyyppiparametreille arvot: float f = min (3.2,6) template //Tai template T min(T p1, T p2) { T tulos; if (p1 < p2) { tulos = p1; } else { tulos = p2; } return tulos }

14 Luokkamallit (class template) Toimii mallina luokille, jotka ovat muuten samanlaisia, mutta joissa jotkin tyypit voit erota toisistaan Esimerkkinä vieressä oleva malli Pari: Ei oma luokkansa vaan malli kokonaiselle “perheelle” luokkia Kaksi auki jätettyä tyyppiä T1 ja T2 Luokat saadaan luotua määräämällä tyyppiparametreille arvot. Esimerkki: Pari p(1, 3.2); template class Pari { public: Pari(T1 eka, T2 toka); T1 annaEka() const; T2 annaToka() const;. private T1 eka_; T2 toka_; }; template Pari ::Pari(T1 eka, T2 toka) :eka_(eka), toka_(toka) { } template T1 Pari ::annaEka() const { return eka_; }

15 Ajattelumalli, joka toivottavasti helpottaa luokkamallin käyttöä: Pari p(1, 3.2); Yllä olevassa esimerkissä Pari voidaan käsittää luokan tyyppinä (aivan kuin luokan tyypit myString tai myVeryOwnClass ) void f(Pari &i, Pari d); ihan tavallinen funktio jolla on kaksi täysin eri tyyppistä luokkaa parametrina 1. int,int -pari 2. float, int* -pari luokan tyyppi luotava olio luokan tyyppi

16 Tyyppiparametreille asetetut vaatimukset C++ mallin koodin on käännyttävä, kun tyyppiparametrien tilalle sijoitetaan todelliset tyypit esimerkiksi aiemmin määrittelemämme min – funktiomallin parametrit pitää olla sellaisia, että niiden arvoja voi vertailla < operaattorilla Jos mallin koodi kutsuu auki jätetyn tyypin kautta esim. olion jäsenfunktiota, voi mallia käyttää vain sellaisten tyyppien kanssa, mistä kyseinen jäsenfunktio löytyy

17 Mallien parametreista Malleilla voi olla oletusparametreja template Malleilla voi olla vakioparametreja template class Mjono { public: Mjono(const char *arvo); const char* annaArvo() const; private: char taulukko[SIZE+1]; }; Mjono s1(“Tuli täyteen”);

18 Mallien erikoistus On mahdollista määrittää erityinen versio (juuri tietyille tyypeille) mallista: template <> class Pari { public: Pari(bool eka, bool toka); bool annaEka() const; bool annaToka() const;. private: unsigned char ekaJaToka_; }; bool Pari ::annaEka() const { return (ekaJaToka_ & 1) != 0; } Tyhjät kulmasulkeet merkiksi siitä, että erikoistumisessa ei ole enään auki jääneitä tyyppejä Kirjoitettu auki ne tyypit mitä erikoistumiinen koskee

19 Missä mennään? C++ mallit Yleiskäyttöisyydestä C++ mallit Funktiomallit Luokkamallit Standard Template Library (STL) Taustaa Säiliöt Iteraattorit Yhteenveto

20 STL (Standard Template Library) Hyvä esimerkki C++ mallien käytöstä ja geeneerisestä ohjelmoinnista Määrittelee joukon tavallisimpia tietorakenteita ja niiden käyttöön tarkoitettuja algoritmeja Tarkoituksena on uudelleenkäyttää STL:n optimoituja tietorakenteita sen sijaan, että “keksittäisiin pyörä uudelleen”

21 STL:n rakenne Säiliöt (container) ovat STL:n tarjoamia tietorakenteita Iteraattorit (iterator) ovat “kirjanmerkkejä” säiliöiden läpikäymiseen Geneeriset algoritmit (generic algorithm) käsittelevät säiliöitä iteraattoreiden avulla Säiliösovittimet (container adaptor) ovat säiliömalleja, jotka toteutetaan halutun toisen säilion avulla. Niillä voi muuntaa säiliön rajapinnan toisenlaiseksi Funktio-oliot (function object) ovat olioita, jotka käyttäytyvät kuten funktiot ja joita voi käyttää muun muassa algoritmien toiminnan säätämiseen Varaimet (allocator) oava olioita säiliöivien muistinhallinnan räätälöintiin. Lyhyesti selitettynä varaimet ovat olioita, jotka osaavat varata ja vapauttaa muistia. Normaalisti STL:n säiliöt varaavat muistinsa new’llä ja vapauttavat deletellä. Jos niille annetaan ylimääräisenä tyyppiparametrina varainluokka, ne käyttävät ko.luokan palveluita tarvitsemansa muistin varaamiseen ja vapauttamiseen

22 STL Algoritmien geneerisyys Olemme olio-ohjelmoijina tottuneet siihen, että halutut tiedot ja toiminnallisuudet kirjoitetaan luokan jäsenfunktioihin. Tuntuisi siis loogiselta, että STL:n tarjoamat algoritmit olisi myös toteutettu säiliöiden jäsenfunktiona STL:ssä lähes kaikki algoritmit on kuitenkin kirjoitettu irrallisina funktioina. Miksi? algoritmien geneerisyys on laajempaa kuin pelkkä tyypin auki jättäminen tyypin lisäksi STL:n algoritmit jättävät mm. auki sen minkä tietorakenteen kanssa ne toimivat. näin samaa geneeristä find-algoritmia voidaan käyttää niin listan, vektorin kuin joukonkin kanssa. algoritmiä ei myöskään tarvitse kirjoittaa erikseen jokaiselle säiliölle vaan yksi geneerinen funktiomalli toimii kaikkien säiliöiden kanssa geneerisyydestä seuraa myös se, että STL:n algoritmeja voi käyttää myös omien tietorakenteiden kanssa (kunhan ne vain toteuttavat STL:n algoritmien asettamat vaatimukset)

23 Iteraattorit On hyvin tavallista, että tietorakenteen alkioita käydään läpi järjestyksessä yksi kerrallaan Tyypillinen ratkaisuyritys ongelmaan on lisätä läpikäymiseen tarvittavat operaatiot itse tietorakenteeseen annaEnsimmainen annaSeuraava onkoLoppu … Tällöin säiliö muistaisi itse, missä alkiossa läpikäyminen on sillä hetkellä menossa

24 Iteraattorit säiliön tila koostuisi sekä listan alkioista että läpikäyntipaikasta.  operaatiot kuten annaEnsimmainen() ja annaSeuraavat() muuttaisivat väistämättä säiliön tilaa  kyseiset operaatiot eivät voisi olla vakiojäsenfunktioita  vakioviitteen päässä olevaa listaa ei voisi täten selata läpi Usein on tarve lukea listaa kahdesta kohtaan yhtä aikaa. Edellä ehdotetun ratkaisumallin ongelmat ovat:

25 Iterator Luodaan kaksi eri luokkaa varsinainen säiliö, joka ei sisällä mitään paikkatietoa “kirjanmerkki”, joka vaan muistaa, missä kohtaa säiliötä ollaan läpikäymässä Kyseessä on tunnettu Design Pattern (Iterator)

26 Iteraattorit Erittäin tärkeä käsite STL:ssä Jokaista säiliötyyppiä kohden on olemassa myös iteraattorityyppi, jonka avulla säiliön alkiot voi käydä läpi Iteraatorin voi käsittää kirjainmerkkinä, joka muistaa tietyn paikan tietyssä säiliössä. iteraattoria voi siirrellä säiliön sisällä iteraattorin läpi voi lukea ja muuttaa säiliön alkioita

27 Iteraattorikategorioita syöttöiteraattori (input iterator) voi vain lukea alkioita tulostusiteraattori (output iterator) voi vain muuttaa alkioita (ei lukea) eteenpäin-iteraattori (forward iterator) voi lukea ja muuttaa alkioita ja lisäksi iteraattoria voi siirtää yhdellä eteenpäin. kaksisuuntainen iteraattori (bidirectional iterator) voi lukea, muuttaa ja liikkua kumpaakin suuntaan hajasaanti-iteraattori (random access iterator) on kuin kaksisuuntainen iteraattori, mutta se voi harpata mielivaltaisia askelia.

28 iteraattoreiden kelvollisuus jos säiliöön lisätään tai siitä poistetaan alkioita, olemassa olevat iteraattorit muuttuvat käkyttökelvottomaksi tällöin iteraattori tulee määritellä uudestaan

29 STL:n säiliöt STL:n säiliöt muistuttavat suuresti toisiaan Säiliöt jakautuvat pääpiirteittään kahteen kategoriaan: Sarjat (sequence) ovat säiliöitä, joiden alkioita pystyy hakemaan niiden järjestysnumeron perusteella. Samoin alkioita voi lisätä haluttuun paikkaan ja poistaa siitä. Esimerkki: vector Assosiatiiviset säiliöt (associative container) puolestaan perustuvat siihen, että alkioita haetaan säiliöstä avaimen (key) perusteella. Esimerkiksi puhelinluettelo muistuttaa assosiatiivista säiliötä– siinä numeron pystyy etsimään nopeasti nimen perusteella

30 Säiliöiden käyttöohjeet Esim. Visual C++ online help

31 STL:n alkioista Alkioiden tyypeillä tulee olla: kopiorakentaja, joka luo alkuperäisen olion kanssa samanlaisen olion sijoitusoperaattori, jonka tuloksena sijoituksen kohteena olevasta oliosta tulee samanlainen sijoitetun olion kanssa STL:n assosiatiiviset säiliöt vaativat, että alkioiden avaimia voi myös kopioida ja sijoitaa ja lisäksi kahta avainta täytyy pystyä vertailemaan Viitteet eivät kelpaa alkioiksi

32 Sarjat-”peräkkäissäiliöt” Sarjat ovat säiliöitä, joissa alkiot sijaitsevat “peräkkäin” ja joissa jokaisella alkiolla on järjestysnumero Alkioita voi selata järjestyksessä Halutun alkion voi hakea järjestysnumeron perusteella Uusia alkioita voi lisätä säiliössä haluttuun paikkaan ja vanhoja voi poistaa STL:n sarjasäiliöt: vector deque list Kaikissa sarjoissa annetaan sarjan alkioiden tyyppi mallin tyyppiparametrina. Esim: vector, deque ja list

33 Sample Code: ////////////////////////////////////////////////////////////////////// // // Compile options needed: /GX // // front.cpp: Illustrates the vector::front and vector::back methods. // // Functions: // // vector::front - Returns reference to first element of vector. // // vector::back - Returns reference to last element of vector. // // vector::push_back - Appends (inserts) an element to the end of a // vector, allocating memory for it if necessary. // // vector::size - Returns number of elements in the vector. // // vector::begin - Returns an iterator to start traversal of the vector. // // vector::end - Returns an iterator for the last element of the vector. // // vector::erase - Deletes elements from a vector (single & range). // ////////////////////////////////////////////////////////////////////// Vector esimerkki (1/3)

34 cout << "First element: " << theVector.front() << endl; cout << "Last element: " << theVector.back() << endl; cout << "Elements in vector: " << theVector.size() << endl; // Delete the last element of the vector. Remember that the vector // is 0-based, so theVector.end() actually points 1 element beyond // the end. theVector.erase(theVector.end() - 1); cout << endl << "After erasing last element, new last element is: " << theVector.back() << endl; // Delete the first element of the vector. theVector.erase(theVector.begin()); cout << "After erasing first element, new first element is: " << theVector.front() << endl; cout << "Elements in vector: " << theVector.size() << endl; } // The debugger can't handle symbols more than 255 characters // long. STL often creates symbols longer than that. When //symbols are longer than 255 characters, the warning is issued. #pragma warning(disable:4786) #include using namespace std ; typedef vector INTVECTOR; const ARRAY_SIZE = 4; void main() { // Dynamically allocated vector begins with 0 elements. INTVECTOR theVector; // Intialize the array to contain the members [100, 200, 300, 400] for (int cEachItem = 0; cEachItem < ARRAY_SIZE; cEachItem++) theVector.push_back((cEachItem + 1) * 100); Vector esimerkki (2/3)

35 Program Output is: ===================== First element: 100 Last element: 400 Elements in vector: 4 After erasing last element, new last element is: 300 After erasing first element, new first element is: 200 Elements in vector: 2 Vector esimerkki (3/3)

36 Deque esimerkki (1/3) Sample Code: ////////////////////////////////////////////////////////////////////// // // Compile options needed: -GX // // deque.cpp : // // Functions: // // operator[] // at // empty // push_back // begin // end //////////////////////////////////////////////////////////////////////

37 //print out the contents print_contents (a,"a"); cout <<"The first element of a is " <<a[0] <<endl; cout <<"The first element of a is " <<a.at(0) <<endl; cout <<"The last element of a is " <<a[a.size()-1] <<endl; cout <<"The last element of a is " <<a.at(a.size()-1) <<endl; } //function to print the contents of deque void print_contents (CHARDEQUE deque, char *name) { CHARDEQUE::iterator pdeque; cout <<"The contents of "<< name <<" : "; for(pdeque = deque.begin(); pdeque != deque.end(); pdeque++) { cout << *pdeque <<" " ; } cout<<endl; } /* Compile options needed:-GX */ #include using namespace std; typedef deque CHARDEQUE; void print_contents (CHARDEQUE deque, char*); void main() { //create an empty deque a CHARDEQUE a; //check whether it is empty if(a.empty()) cout<<"a is empty"<<endl; else cout<<"a is not empty"<<endl; //inset A, B, C and D to a a.push_back('A'); a.push_back('B'); a.push_back('C'); a.push_back('D'); //check again whether a is empty if(a.empty()) cout<<"a is empty"<<endl; else cout<<"a is not empty"<<endl; Deque esimerkki (2/3)

38 Deque esimerkki (3/3) Program Output is: =============== a is empty a is not empty The contents of a : A B C D The first element of a is A The last element of a is D

39 list esimerkki (1/3) Sample Code: ////////////////////////////////////////////////////////////////////// // // Compile options needed: -GX // // assign.cpp : Shows the various ways to assign and erase elements // from a list. // // Functions: // // list::assign // list::empty // list::erase //////////////////////////////////////////////////////////////////////

40 list esimerkki (2/3) #include using namespace std ; typedef list LISTINT; void main() { LISTINT listOne; LISTINT listAnother; LISTINT::iterator i; // Add some data listOne.push_front (2); listOne.push_front (1); listOne.push_back (3); listAnother.push_front(4); listAnother.assign(listOne.begin(), listOne.end()); // 1 2 3 for (i = listAnother.begin(); i != listAnother.end(); ++i) cout << *i << " "; cout << endl; listAnother.assign(4, 1); // 1 1 1 1 for (i = listAnother.begin(); i != listAnother.end(); ++i) cout << *i << " "; cout << endl; listAnother.erase(listAnother.begin()); // 1 1 1 for (i = listAnother.begin(); i != listAnother.end(); ++i) cout << *i << " "; cout << endl; listAnother.erase(listAnother.begin(), listAnother.end()); if (listAnother.empty()) cout << "All gone\n"; }

41 list esimerkki (3/3) Program Output is: 1 2 3 1 1 1 1 1 All gone

42 Assosiatiiviset säiliöt (associative container) Eroavat sarjoista siinä, että alkioita ei lueta, lisätä tai poisteta niiden “sijainnin” tai järjestysnumeron perusteella Jokaiseen alkioon liittyy avain (key), jonka perusteella alkion voi myöhemmin hakea

43 Assosiatiiviset säiliötyypit set Yksinkertaisin säiliötyyppi, missä avaimena on alkio itsessään multiset Eroaa setistä siten, että samanarvoisia alkioita voi olla useita map Tietorakenne, missä avain ja alkio ovat erillisiä ja jossa avaimen perusteella voidaan hakea haluttu alkio. Voidaan myös ajatella eräänlaisena taulukkona multimap Eroaa mapista siten, että yhtä avainta kohde voi olla useita alkioita

44 set esimerkki (1/3) ////////////////////////////////////////////////////////////////////// // // Compile options needed: -GX // // SetFind.cpp: // Illustrates how to use the find function to get an iterator // that points to the first element in the controlled sequence // that has a particular sort key. // // Functions: // // find Returns an iterator that points to the first element // in the controlled sequence that has the same sort key // as the value passed to the find function. If no such // element exists, the iterator equals end(). //////////////////////////////////////////////////////////////////////

45 set esimerkki (2/3) #pragma warning(disable:4786) #include using namespace std ; typedef set SET_INT; void truefalse(int x) { cout << (x?"True":"False") << endl; } void main() { SET_INT s1; cout << "s1.insert(5)" << endl; s1.insert(5); cout << "s1.insert(8)" << endl; s1.insert(8); cout << "s1.insert(12)" << endl; s1.insert(12); SET_INT::iterator it; cout << "it=find(8)" << endl; it=s1.find(8); cout << "it!=s1.end() returned "; truefalse(it!=s1.end()); // True cout << "it=find(6)" << endl; it=s1.find(6); cout << "it!=s1.end() returned "; truefalse(it!=s1.end()); // False }

46 set esimerkki (3/3) Program Output is: ============= s1.insert(5) s1.insert(8) s1.insert(12) it=find(8) it!=s1.end() returned True it=find(6) it!=s1.end() returned False

47 map esimerkki (1/3) Sample Code: ////////////////////////////////////////////////////////////////////// // // Compile options needed: None // // : main.cpp // // Functions: // // end // find // insert //////////////////////////////////////////////////////////////////////

48 map esimerkki (2/3) #pragma warning(disable:4786) #include using namespace std; typedef map > INT2STRING; void main() { // 1. Create a map of ints to strings INT2STRING theMap; INT2STRING::iterator theIterator; string theString = ""; int index; // Fill it with the digits 0 - 9, each mapped to its string counterpart // Note: value_type is a pair for maps... theMap.insert(INT2STRING::value_type(0,"Zero")); theMap.insert(INT2STRING::value_type(1,"One")); theMap.insert(INT2STRING::value_type(2,"Two")); theMap.insert(INT2STRING::value_type(3,"Three")); theMap.insert(INT2STRING::value_type(4,"Four")); theMap.insert(INT2STRING::value_type(5,"Five")); theMap.insert(INT2STRING::value_type(6,"Six")); theMap.insert(INT2STRING::value_type(7,"Seven")); theMap.insert(INT2STRING::value_type(8,"Eight")); theMap.insert(INT2STRING::value_type(9,"Nine")); // Read a Number from the user and print it back as words for( ; ; ) { cout << "Enter \"q\" to quit, or enter a Number: "; cin >> theString; if(theString == "q") break; // extract each digit from the string, find its corresponding // entry in the map (the word equivalent) and print it for(index = 0; index < theString.length(); index++){ theIterator = theMap.find(theString[index] - '0'); if(theIterator != theMap.end() ) // is 0 - 9 cout << (*theIterator).second << " "; else // some character other than 0 - 9 cout << "[err] "; } cout << endl; }

49 map esimerkki (3/3) Program Output is: ============== Enter "q" to quit, or enter a Number: 22 Two Enter "q" to quit, or enter a Number: 33 Three Enter "q" to quit, or enter a Number: 456 Four Five Six Enter "q" to quit, or enter a Number: q

50 iterator & map esimerkki #pragma warning(disable:4786) #include using namespace std ; typedef map STRING2INT; void main() { STRING2INT MyMap; STRING2INT::iterator MyIterator; string MyBuffer; // Fill in MyMap with the months of the year, mapped to their number // January - 1, February - 2, etc. using operator[]. MyMap["January"] = 1; MyMap["February"] = 2;. // Ask the user for a month of the year and print the number // that corresponds to the month entered //MyIterator = MyMap.end(); while(MyIterator == MyMap.end()){ cout << "Enter a Month :"; cin >> MyBuffer; if((MyIterator = MyMap.find(MyBuffer)) != MyMap.end()) cout << (*MyIterator).first << " is Month Number " << (*MyIterator).second << endl; else cout << "Enter a Valid Month (example: March)" << endl; }

51 STL algoritmit & funktio-oliot STL algoritmit ja funktio-oliot ovat vielä käsittelemättä ne suljetaan tällä kertaa kurssin ulkopuolelle.

52 Mitä tänään opimme? Haluamme tehdä geneeristä koodia. Valitettavasti perintä ei aina ratkaise pulmiamme. Joissain tilanteissa C++ mallien käyttö on hyvä työkalu geneerisyyteen C++ malleja on sekä luokka- että funktiomallit Standard Template Library (STL) Hyvä esimerkki siitä miten C++ mallien avulla saadaan geneeristä koodia STL sisältää Säiliötä Iteraattoreita Algoritmeja Funktio-oliota

53 Tentistä Pyritään kattamaan koko tenttialue Paljon kysymyksiä Oleellista ei ole “muistaa” pikkudetaljeja Pyritään varmistamaan, että oleellisimmat asiat on YMMÄRRETTY!