1

Olio-ohjelmoinnin perusteetluento 7: C++ mallit, Standard Template Library (STL)

Jani Rönkkönenjani.ronkkonen@lut.fi

Luennot muokattu Sami Jantusen ja Kari Smolanderin aikaisempien vuosien luennoista

2

Sisältö C++ mallit

Yleiskäyttöisyydestä C++ mallit Funktiomallit Luokkamallit

Standard Template Library (STL) Taustaa Säiliöt Iteraattorit Algoritmit

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 Periytyminen on tyypillinen yleiskäyttöisyyteen

liittyvä mekanismi Luokkien yhteiset ominaisuudet voidaan toteuttaa

kertalleen kantaluokassa. Vaihtuvat asiat toteutetaan lapsiluokissa Periytymisen käytöllä on kuitenkin rajansa!

4

Periytymisen 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();

};

nextprevdata

nextprevdata

nextprevdata

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

periytymisen käyttö ei kovin kätevää!

Useat rajapinnoista ovat 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 periytymisen 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 <int> Deque <double>

Auki jätetyt asiat siis selviävät jo käännösaikana, mutta kuitenkin vasta käyttötilanteessa

Deque

12

C++ mallin syntaksi

template<typename tyyppiparam1, typename tyyppiparam2, ...>//Tähän normaali funktion tai luokan määrittely

TAI VAIHTOEHTOISESTI

template<class tyyppiparam1, class tyyppiparam2, ...>//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<float>(3.2,6)

Jäsenfunktiomalli on funktiomalli, joka on määritelty luokan jäsenfunktioksi

template <typename T> //Tai template <class T>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 voivat 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<int,double> p(1, 3.2);

template <typename T1, typename T2>class Pari{public:Pari(T1 eka, T2 toka);T1 annaEka() const;T2 annaToka() const;...Private: T1 mEka;T2 mToka;

};

template <typename T1, typename T2>Pari<T1, T2>::Pari(T1 eka, T2 toka) :mEka(eka), mToka(toka) //muodostaja{}

template <typename T1, typename T2>T1 Pari<T1, T2>::annaEka() const{return mEka;

}

15

Ajattelumalli, joka toivottavasti helpottaa luokkamallin käyttöä:

Pari<int,double> p(1, 3.2); Yllä olevassa esimerkissä Pari<int,double> voidaan käsittää

luokan tyyppinä (aivan kuin luokan tyypit myString tai myVeryOwnClass)

void f(Pari<int,int> &i, Pari<float, int*> d); ihan tavallinen funktio jolla on kaksi täysin eri tyyppistä luokkaa

parametrina1. int,int -pari2. float, int* -pari

luokan tyyppi luotava olio

luokan tyyppi luokan tyyppi

16

Jäsenfunktiomalli malliluokan jäsenenä

template <typename T1, typename T2>class Pari{ . . .template <typename T3, T4>void summaa(const pari<T3, T4>& toinenPari)...

};

template <typename T1, typename T2>template <typename T3, typename T4>Void Pari<T1, T2>::summaa(const Pari<T3,T2>& toinenPari){ mEka += toinenPari.annaEka(); mToka += toinenPari.annaToka();}

Luokkamallissa ja sen sisällä jäsenfunktiomallissa on nyt molemmissa aukijätettyjä parametreja:

Malli mallin sisällä Mihin tahansa pariin voi

nyt summata minkä tahansa tyyppisen toisen parin, kunhan parien alkiot voi laskea yhteen keskenään

17

Tyyppiparametreille asetetut vaatimukset C++ mallin koodin on käännyttävä, kun

tyyppiparametrien tilalle sijoitetaan todelliset tyypit Esimerkiksi aiemmin määrittelemämme min –

funktiomallin parametrien 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

18

Tyyppiparametreille asetetut vaatimukset

Koska tyyppiparametrien vaatimukset on siroteltu mallin koodin sekaan, tyyppiparametreihin kohdistuvat vaatimukset olisi hyvä dokumentoida ja kerätä yhteen paikkaan, josta mallin käyttäjä voi helposti ne tarkistaa

Jotta malli pysyisi mahdollisimman yleiskäyttöisenä, tulisi se suunnitella vaatimaan tyyppiparametreiltaan mahdollisimman vähän

19

Esimerkki Aiemmin esitelty min-

malli vaatii kopiomuodostimen ja sijoitusoperaattorin olemassaolon tyyppiparametreiltaan Rajoittaa mallin käyttöä,

koska kaikilla luokilla ei näitä ole

Alla on parempi versio min-mallista Turhat sijoitukset on

jätetty pois ja parametrit välitetään viitteinä, joten vaaditaan vain vertailuoperaattori

template <typename T> T min(T p1, T p2){T tulos;if (p1 < p2){

tulos = p1;} else {

tulos = p2;}return tulos

}

template <typename T> const T& min(const T& p1, const T& p2){if (p1 < p2){

return p1;} else {

return p2;}

}

20

Mallien oletusparametrit Malleilla voi olla oletustyyppiparametreja, samaan

tapaan kuin normaaleilla funktiolla oletusarvoja, esimerkiksi:template<typename T1=int, typename T2=T1>class Pari2{…};

Liukuluku-merkkijono yhdistelmä:Pari2<double,string>

Molemmat arvot liukulukuja:Pari2<double>

Molemmat arvot kokonaislukuja:Pari2<>

21

Mallien vakioparametrit Malleissa voi jättää auki tiettyjä

käännösaikaisia vakioita, jotka jäävät mallin parametreiksi, kelvollisia ovat:

Kokonaislukuvakiot ja enum tyyppiset arvot

Osoitin tai viite globaaliin olioon tai funktioon

Osoitin jäsenfunktioon tai muuttujaan

Jokainen eri vakioparametrin arvolla luotu luokka on oma erillinen luokkansa

Esimerkin eripituiset merkkijono-oliot (s1 ja s2) eivät siis kuulu samaan luokkaan, eikä niitä voi esimerkiksi sijoittaa toisiinsa

template<unsigned long SIZE>class Mjono{public: Mjono(const char *arvo); const char* annaArvo() const;private: char taulukko[SIZE+1];};

Mjono<12> s1(“Tuli täyteen”);Mjono<7> s2(”Lyhempi”);

22

Malliparametrit Mallissa voi jättää auki myös

toisen mallin Esimerkissä on funktiomalli,

jossa on jätetty auki yksi kaksi tyyppiparametria saava malli ja yksi tavallinen tyyppiparametri

Mallin summaa avulla voi nyt summata mistä tahansa kaksiparametrisesta luokkamallista instantuoituja olioita, kunhan tyyppiparametrit ovat samat ja se tarjoaa metodit annaEka ja annaToka

template<template<typename T1, typename T2> class X, typename S>S summaa(const X<S, S>& x){ return x.annaEka() + x.annaToka();}

void kayta(){ Pari<int, int> p(1,2); int tulos=summaa(p);}

23

Mallien erikoistus

On mahdollista määrittää erityinen versio (juuri tietyille tyypeille) mallista

Käyttäjän kannalta kaikki säilyy ennallaan, kääntäjä valitsee erikoistus koodin tarvittaessa

Esimerkissä on ideana vähentää muistinkulutusta tallentamalla bool tyyliset arvot yhteen char muuttujaan ekaJaToka, jota sitten käsitellään bittioperaattoreilla

Luokkamalleille on mahdollista tehdä myös osittaiserikoistus, jolloin vain osa tyypeistä sidotaan

template <>class Pari<bool, bool>{public:Pari(bool eka, bool toka);bool annaEka() const;bool annaToka() const;...private: unsigned char ekaJaToka;

};

bool Pari<bool, bool>::annaEka() const{return (ekaJaToka & 1) != 0;

}

Tyhjät kulmasulkeet merkiksi siitä, että erikoistumisessa ei ole enää auki jääneitä tyyppejä

Kirjoitettu auki ne tyypit mitä erikoistumiinen koskee

24

Mallin koodin sijoittelu Koska mallin koodin on oltava kääntäjän

tiedossa mallia käytettäessä, on mallin koodi kirjoitettava kokonaisuudessaan otsikkotiedostoon

Lisäämällä avainsana export ennen template sanaa sekä esittelyn että toteutuksen yhteyteen on periaatteessa mahdollista siirtää mallin koodi erilliseen .cpp tiedostoon Valitettavasti suurin osa kääntäjistä ei tue

tätä ominaisuutta ja siksi sitä ei tulisi käyttää

25

Missä mennään? C++ mallit

Yleiskäyttöisyydestä C++ mallit Funktiomallit Luokkamallit

Standard Template Library (STL) Taustaa Säiliöt Iteraattorit Algoritmit

Yhteenveto

26

STL (Standard Template Library)

Hyvä esimerkki C++ mallien käytöstä ja geneerisestä 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”

27

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) ovat olioita säiliöiden 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

28

STLAlgoritmien 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)

29

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

30

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

kohtaa yhtä aikaa.

Edellä ehdotetun ratkaisumallin ongelmat ovat:

31

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)

32

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 Syntaksi vastaa osoitinaritmetiikkaa

33

Iteraattorikategoriat 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.

34

Iteraattorit ja säiliöt Iteraattorit liittyvät kiinteästi säiliöihin,

joten STL:ssä iteraattoriluokat ja iteraattoreiden luominen on siirretty säiliöluokkien sisälle

Jokainen STL säiliöluokka määrittelee kaksi luokan sisäistä tyyppiä: iterator ja const_iterator deque ja vector käyttävät hajasaanti iteraattoria list, set, multiset, map ja multimap käyttävät

kaksisuuntaista iteraattoria

35

Esimerkki, säiliön läpikäynti iteraattoreilla

void nollaaAlkiot(vector<int>& vektori){

vector<int>::iterator i=vektori.begin(); //alkuunwhile (i!=vektori.end()) //toistetaan, kunnes ollaan lopussa{

*i=0; //alkion arvoksi nolla++i; //siirrytään seuraavaan alkioon

}}void tulostaAlkiot(const vector<int>& vektori){

for(vector<int>::const_iterator i=vektori.begin(); i!=vektori.end(); ++i) //const_iterator, koska ei muuteta arvoa{

cout << *i << ” ”;}cout << endl;

}

36

Iteraattoreiden kelvollisuus

Jos säiliöön lisätään tai siitä poistetaan alkioita, osa olemassa olevista iteraattoreista (tai osoittimista/viitteistä) voi muuttua kelvottomiksi

Kelvotomalle iteraattorille ainoat sallitut operaatiot ovat tuhoaminen ja uuden arvon sijoitus

Vector: Lisäys voi mitätöidä kaikki iteraattorit, osoittimet ja viitteet, jos joudutaan

tekemään uusi muistinvaraus, muuten lisäyspaikan jälkeiset (jos vektorille on varattu riittävästi tilaa ennakkoon reserve jäsenfunktiolla)

Poisto mitätöi kaikki poistopaikan jälkeiset Deque:

Lisäys alkuun tai loppuun mitätöi kaikki iteraattorit. Osoittimet ja viittaukset säilyvät. Lisäys keskelle mitätöi kaikki.

Poisto alusta tai lopusta mitätöi alkioon itseensä osoittavat osoittimet ja viitteet ja poistetun vasemmalla puolella olevan iteraattorin. Poisto keskeltä mitätöi kaikki.

List ja assosiatiiviset säiliöt: Lisääminen ei mitätöi mitään Poisto mitätöi alkioon itseensä osoittavat osoittimet ja viitteet ja

poistetun vasemmalla puolella olevan iteraattorin.

37

Iteraattorisovittimet Iteraattorisovittimet ovat erikoisiteraattoreita,

jotka toimivat hieman eri tavalla kuin perusiteraattorit:

Käänteisiteraattorit (reverse iterator) Tavallisen iteraattorin peilikuva, kaikki operaatiot

toimivat nurinkurisesti, esim. ++ menee taaksepäin ja -- eteenpäin.

Jäsenfunktio rbegin palauttaa käänteisiteraattorin säiliön loppuun ja rend säiliön alkuun

Lisäysiteraattorit (insert iterator/inserter) Voidaan käyttää lisäämään alkioita säiliöön

Virtaiteraattorit (stream iterator) Lukevat ja kirjoittavat tiedostovirtoihin säiliöiden sijasta

38

STL:n säiliöt STL:n säiliöt muistuttavat suuresti toisiaan

Rajapinnat ovat yhtenäisiä, eli suurin osa yhden säiliön jäsenfunktioista löytyy myös muista STL säiliöistä

Kun oppii käyttämään yhtä muiden käytön oppiminen on helppoa

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

39

Säiliöiden käyttöohjeetEsim. Visual C++ online help

40

STL:n alkioista Alkioiden tyypeillä tulee olla:

Kopiomuodostin, 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

41

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 Kaikissa sarjoissa annetaan sarjan

alkioiden tyyppi mallin tyyppiparametrina. Esim: vector<float>, deque<int> ja list<string>

42

Sarjat-”peräkkäissäiliöt” STL:n sarjasäiliöt: vector

STL vastine taulukoille. Tehokas jos tietorakennetta indeksoidaan paljon ja alkioita poistetaan tai lisätään vain loppuun.

deque Kaksipäinen taulukko (pakka). Tehokkaampi kuin

vektori, jos alkioiden lisäyksiä tai poistoja halutaan tehdä myös alkuun. Indeksointi hieman vektoria hitaampaa.

list Kaksisuuntainen linkitetty lista. Nopea poistaa tai

lisätä alkioita minne tahansa, indeksointi hidasta.

43

Sample Code:

////////////////////////////////////////////////////////////////////////// front.cpp: Illustrates the vector::front and vector::back methods.//// Functions://// front - Returns reference to first element.//// back - Returns reference to last element.//// push_back - Appends (inserts) an element to the end of a// container, allocating memory for it if necessary.// pop_back - Deletes the last element.//// size - Returns number of elements.//// begin - Returns an iterator to start traversal.//// end - Returns an iterator for the last element.//// erase - Deletes elements (single & range).////////////////////////////////////////////////////////////////////////

Vector esimerkki (1/3)

44

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);

//Erase the last element with pop_back()

theVector.pop_back();

cout << endl << "After erasing 2 last elements, 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;

}

#include <iostream>#include <vector>

using namespace std ;

typedef vector<int> 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)

45

Program Output is:=====================

First element: 100Last element: 400Elements in vector: 4

After erasing 2 last element, new last element is: 200After erasing first element, new first element is: 200Elements in vector: 1

Vector esimerkki (3/3)

46

Deque esimerkki (1/3)

Sample Code:

////////////////////////////////////////////////////////////////////// // deque.cpp ://// Functions://// operator[] - Indexing// at – Same as above.// empty – Is the container empty// push_front – Inserts a new element at the beginning// pop_front – Removes the first element//////////////////////////////////////////////////////////////////////

47

//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;

//remove the first element

a.pop_front();//print out the contents print_contents (a,"a");

}

//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;

}

#include <iostream>#include <deque>

using namespace std;

typedef deque<char > 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(‘C’); a.push_front(‘B’); a.push_front(‘A’); 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)

48

Deque esimerkki (3/3)Program Output is:===============a is emptya is not emptyThe contents of a : A B C DThe first element of a is AThe first element of a is AThe last element of a is DThe last element of a is DThe contents of a : B C D

49

list esimerkki (1/3)

Sample Code:

////////////////////////////////////////////////////////////////////////// assign.cpp : Shows the various ways to assign and erase elements// from a list<T>.//// Functions://// assign(p1,p2) – Replaces the contents of container with // p1 elements of p2 / or from p1 to p2 // clear – Empties the container// insert - Inserts an element ////////////////////////////////////////////////////////////////////////

50

list esimerkki (2/3)#include <list>#include <iostream>

using namespace std ;

typedef list<int> 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); //replace contents of listAnother with contents of

listOne 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; //1 2 1 1 1 i=listAnother.begin(); i++; listAnother.insert(i,2);

for (i = listAnother.begin(); i != listAnother.end(); ++i) cout << *i << " "; cout << endl; //empty the whole list listAnother.clear(); if (listAnother.empty()) cout << "All gone” << endl;}

51

list esimerkki (3/3)

Program Output is:

1 2 31 1 1 11 2 1 1 1All gone

52

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

WorkDesk ReturnedItemJobID : IntegerJobID : Integer

53

Assosiatiiviset säiliötyypit set (Joukko)

Yksinkertaisin säiliötyyppi, missä avaimena on alkio itsessään

Vain yksi samanarvoinen alkio Käytännöllinen, jos ohjelmassa pidetään yllä rekisteriä,

johon lisätään alkioita sekalaisessa järjestyksessä ja pitää nopeasti tietää, löytyykö tietty alkio rekisteristä.

multiset (monijoukko) Eroaa setistä siten, että samanarvoisia alkioita voi olla

useita ja joukolta voi kysyä montako annetun arvoista alkiota joukossa on

map (assosiaatiotaulu) Tietorakenne, missä avain ja alkio ovat erillisiä ja jossa

avaimen perusteella voidaan hakea haluttu alkio. Voidaan myös ajatella eräänlaisena taulukkona

Kutakin avainta vastaa yksi alkio multimap (assosiaatiomonitaulu)

Eroaa mapista siten, että yhtä avainta kohden voi olla useita alkioita

54

set esimerkki (1/3)//////////////////////////////////////////////////////////////////////////// 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().// insert Inserts only, if the element was not in the set before//////////////////////////////////////////////////////////////////////

55

set esimerkki (2/3)

// 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 <set>#include <iostream>

using namespace std ;

typedef set<int> SET_INT;

void truefalse(int x){ cout << (x?"True":"False") << endl;}

void main() { SET_INT s1; //insert some data 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}

56

set esimerkki (3/3)

Program Output is:=============s1.insert(5)s1.insert(8)s1.insert(12)it=find(8)it!=s1.end() returned Trueit=find(6)it!=s1.end() returned False

57

map esimerkki (1/3)

//////////////////////////////////////////////////////////////////////// Asks numbers from the user and prints them as words// // value_type is a definition of Pair type for map, with // elements first and second, defined as follows:// typedef pair<const Key, T> value_type;//// template<class T, class U> // struct pair { // typedef T first_type;// typedef U second_type // T first; // U second; // pair(); // pair(const T& x, const U& y); // template<class V, class W> // pair(const pair<V, W>& pr); // }; //////////////////////////////////////////////////////////////////////

58

map esimerkki (2/3)#pragma warning(disable:4786)

#include <iostream>#include <string>#include <map>

using namespace std;//the key is type int, value is type stringtypedef map<int, string > 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// value_type descripes an element of the controlled sequence... 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; }}

59

map esimerkki (3/3)

Program Output is:==============Enter "q" to quit, or enter a Number: 22Two TwoEnter "q" to quit, or enter a Number: 33Three ThreeEnter "q" to quit, or enter a Number: 456Four Five SixEnter "q" to quit, or enter a Number: q

60

Muita säiliöitä vector<bool> (totuusarvovektori)

Vektorin erikoistapaus boolean arvoille, säästää muistia

bitset (bittivektori) Tarkoitettu binääristen bittisarjojen

käsittelyyn Säiliösovittimet

stack (Pino) queue (Jono) priority_queue (prioriteettijono)

jono, jossa alkiot suuruusjärjestyksessä

61

STL algoritmit STL tarjoaa monenlaisia algoritmeja säiliöiden

käsittelyyn Näille annetaan parametreina iteraattoreita:

Iteraattoreiden avulla algoritmi voi toimia vain osalle säiliötä. Väli määrätään antamalla parametrina kaksi iteraattoria (jos halutaan tehdä toiminto koko säiliölle voi välinä antaa begin ja end kutsujen palauttamat iteraattorit)

Sama algoritmi toimii erilaisten säiliöiden kesken, koska itse säiliöiden tyyppiä ei tarvitse kertoa algoritmille

Iteraatorisovittimien avulla voi vaikuttaa algoritmin toimintaan. Esimerkiksi find-algoritmi etsii normaalisti ensimmäisen halutunarvoisen alkion, mutta käänteisiteraattorilla viimeisen

Ohjelmoija voi kirjoittaa omia iteraattorityyppejä, joilla STL algoritmit voi sovittaa lähes mihin tahansa tietorakenteeseen

62

STL algoritmit Algoritmit saa käyttöön: #include <algorithm> copy (alku, loppu, kohde)

Kopioi välillä alku-loppu olevat alkiot iteraattorin kohde päähän. Normaaleilla iteraattoreilla korvaa vanhat arvot, lisäysiteraattorilla lisää uusia.

find (alku, loppu, arvo) Etsii väliltä alku-loppu ensimmäisen alkion, jonka

arvo on arvo, jos sopivaa ei löydy, palautetaan loppu sort (alku, loppu)

Järjestää välillä alku-loppu olevat alkiot suuruusjärjestykseen. Parametrien tulee olla hajasaanti iteraattoreita (list säiliöllä on sort jäsenfunktiona)

63

STL algoritmit merge (alku1, loppu1, alku2, loppu2, kohde)

Yhdistää välien alku1-loppu1 ja alku2-loppu2 alkiot ja kopioi ne suuruusjärjestyksessä iteraattorin kohde päähän, kuten copy. lähtötietojen pitää olla valmiiksi suuruusjärjestyksessä.

for_each (alku, loppu, funktio) Antaa jokaisen väliltä alku-loppu olevan alkion vuorollaan

funktion parametriksi ja kutsuu funktiota partition (alku, loppu, ehtofunktio)

järjestää välillä alku-loppu olevat alkiot niin, että ensin tulevat ne alkiot, joille ehtofunkio palauttaa true ja sitten ne joilla se palautta false

random_shuffle (alku, loppu) Sekoittaa välillä alku-loppu olevat alkiot satunnaiseen

järjestykseen. Algoritmille voi ylimääräisenä parametrina antaa satunnaislukugeneraattorin.

64

Esimerkki#include <iostream>#include <algorithm>#include <vector>using namespace std;

//aliohjelma vektorien tulostukseenvoid printVector( vector<int> vektori){ vector<int>::iterator iter; for(iter = vektori.begin(); iter != vektori.end(); iter++) { cout << *iter <<" " ; } cout<<endl;}

void main (){ vector<int> vektori; for (int i=0;i<12;i++) //lisätään alkioita vektoriin vektori.push_back(i);

printVector(vektori); //tulostetaan vektori //satunnainen järjestys random_shuffle(vektori.begin(), vektori.end()); printVector(vektori);

int eka = vektori.front(); //ensimmäinen alkio talteen int vika = vektori.back(); //viimeinen alkio talteen sort(vektori.begin(), vektori.end()); //järjestetään vektori printVector(vektori); vector<int>::iterator ekanpaikka = find(vektori.begin(), vektori.end(),eka); //etsitään eka vector<int>::iterator vikanpaikka = find(vektori.begin(), vektori.end(),vika); //etsitään toka //poistetaan alkiot eka <= alkio < vika vektori.erase(ekanpaikka,vikanpaikka); printVector(vektori); }

Tulostus esimerkiksi:0 1 2 3 4 5 6 7 8 9 10 114 3 0 2 10 7 8 11 5 1 6 90 1 2 3 4 5 6 7 8 9 10 110 1 2 3 9 10 11

65

Mitä tänään opimme? Haluamme tehdä geneeristä koodia.

Valitettavasti periytyminen 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:n tarjoamista palveluista opeteltiin käyttämään

Säiliötä Iteraattoreita Algoritmeja

66

Tentti + palaute

Tentti keskiviikkona 5.3.2008

Kurssista tulee palautekysely, josta ilmoitan sähköpostilla.