Periytyminen. Luokat ja olio-ohjelmointi

Transkriptio

1 Periytyminen 15 Periytyminen Tässä luvussa käsittelemme aihetta, joka on olio-ohjelmoinnin kaikkein tärkein osa - periytyvyys. Periytyvyyden avulla voimme luoda uusia luokkia uudelleenkäyttämällä ja laajentamalla jo olemassa olevia luokkia. On muitakin tapoja luoda uusia luokkien määrityksiä olemassa olevista luokista - näimme esimerkiksi luvussa 13, kuinka luokkia kirjoitetaan sisäkkäin. Periytyvyys on kuitenkin huomattavasti monipuolisempi kuin sisäkkäiset luokat - ja kuten näemme seuraavasta luvusta, periytyvyys on keskeisessä asemassa polymorfismin toteuttamisessa. Periytyvyys on aivan olioohjelmoinnin ytimessä, eikä tässä luvussa käsitellä kaikkia siihen liittyviä asioita. Myös seuraavan luvun voidaan ajatella olevan osa periytyvyyden käsittelyä. Tässä luvussa käsittelemme: Miten periytyvyys sopii olio-ohjelmoinnin ideaan Mitä ovat kantaluokat ja periytetyt luokat ja miten ne liittyvät toisiinsa Uuden luokan määrittely olemassa olevan luokan pohjalta protected-avainsanan käyttö uutena luokan jäsenten saantitavan hallintakomentona Miten muodostinfunktiot toimivat periytetyssä luokassa ja mitä tapahtuu, kun niitä kutsutaan Mitä tapahtuu periytetyn luokan tuhoajafunktiota käytettäessä Moniperintä ja kuinka se toimii Muunnokset luokkahierarkian luokkien välillä Luokat ja olio-ohjelmointi Aloitetaan siitä, mitä olemme edellisissä luvuissa käsitelleet ja katsotaan, kuinka pääsemme niistä tämän luvun aiheisiin. Luvussa 12 esittelimme luokan käsitteen. Luokka on tietotyyppi, jonka määrittelet sopivaksi sovelluksesi tarpeisiin. Kun käytät olio-ohjelmointia ongelman ratkaisemiseen, ensimmäinen tehtävä on ohjelmaan liittyvien oliotyyppien suunnittelu. Tämän jälkeen tyypit ohjelmoidaan 577

2 C++ Ohjelmoijan käsikirja kirjoittamalla luokan määrittelyt. Lopuksi ongelma ratkaistaan kirjoittamalla ohjelma olioiden avulla (määrittelemiesi luokkien ilmentymien avulla) ja käyttämällä operaatioita, jotka käyttävät näitä olioita suoraan. Luokkana voidaan toteuttaa millainen tyyppi tahansa - täysin abstraktisesta (kuten kompleksiluvut matematiikassa) hyvinkin fyysiseen, kuten puu tai kuorma-auto. Luokan määrittelyn tulee kuvata joukkoa asioita, joihin liittyy tiettyjä ominaisuuksia. Eli luokka voi tyypin lisäksi olla elävän elämän olion määrittely (tai ainakin tarpeeksi tarkka ongelman ratkaisemiseksi). Monissa elävän elämän ongelmissa olioiden tyypit liittyvät toisiinsa. Esimerkiksi koira on eläimen erikoismuoto, jolla on kaikki eläimen ominaisuudet ja joitakin omia ominaisuuksia. Näin ollen Elain ja Koira -olioiden luokkien määrittelyjen tulisi olla jollain tavalla yhteydessä toisiinsa. Toinen esimerkki voisi olla sellainen, että autolla on moottori, joten Moottori-luokkaa tulisi voida jotenkin käyttää, kun määrittelemme Auto-luokkaa. Tässä luvussa näemme, miten nämä kaksi varsin erilaista suhdetta toteutetaan C++:ssa. Hierarkiat Edellisissä luvuissa olemme käyttäneet Laatikko-luokkaa kuvaamaan suorakaiteen muotoista laatikkoa - Laatikko-luokan määrittelymme koostui vain kolmesta erisuuntaisesta mitasta. Voimme käyttää tätä perusmäärittelyä elävän elämän erilaisiin suorakulmaisiin laatikoihin - pahvilaatikoihin, puulaatikoihin, karkkilaatikoihin, viljalaatikoihin ja niin edelleen. Jokaisella näistä laatikoista on kolme erisuuntaista mittaa, joten ne ovat aivan kuin yleiset Laatikkooliotkin. Niillä jokaisella on lisäksi muita ominaisuuksia - esimerkiksi mitä niissä on tarkoitus säilyttää tai materiaali, josta ne on tehty. Eli voit kuvata ne Laatikko-olion erikoismuotoina. Voimme esimerkiksi kuvata PahviLaatikko-luokan, jolla on samat ominaisuudet kuin Laatikko-luokallakin - eli kolme mittaa - ja lisäominaisuutena laatikon rakenne. Tämän jälkeen voisimme erikoistaa sitä vielä enemmän ja määritellä RuokaPahviLtk-luokan, joka on erikoinen PahviLaatikko, jossa on tarkoitus säilyttää ruokaa. Sillä on kaikki PahviLaatikko-luokan ominaisuudet, ja lisäominaisuudet, jotka kuvaavat laatikon käyttötarkoitusta. Tällaisen luokkahierarkian suhteet näytetään viereisessä kaaviossa. Yleisempi Laatikko-luokka pituus syvyys korkeus perityt jäsenet PahviLaatikko pituus syvyys korkeus materiaali Jokaisella luokalla on sen luokan ominaisuudet, josta se on periytetty, sekä lisäominaisuuksia, jotka erikoistavat sen. Erikoistuneempi RuokaPahviLtk pituus korkeus materiaali sisalto perityt jäsenet 578

3 Periytyminen PahviLaatikko-luokka on Laatikko-luokan laajennus - voit sanoa, että PahviLaatikkoluokka on periytetty Laatikko-luokasta. Samaan tapaan RuokaPahviLtk-luokka on periytetty PahviLaatikko-luokasta. Tätä suhdetta kuvataan kaavioissa yleensä nuolella, joka osoittaa yleisempään luokkaan hierarkiassa - olemme käyttäneet tätä merkintätapaa edellä olevassa kaaviossa. Näemme myöhemmin, että voimme myös yhdistää olemassa olevien luokkien määrittelyt uudeksi luokaksi. Uusi luokka sisältää tällöin kaikki alkuperäisten luokkien ominaisuudet. Voimme esimerkiksi luoda Pakattu_leipa-tyypin yhdistämällä RuokaPahviLtk-luokan ja Leipa-luokan määrittelyt. Leipa-luokka kuvaa leipään liittyvät ominaisuudet. Tämän prosessin avulla kuvaamme keskenään suhteessa olevien luokkien hierarkian, jossa yksi luokka on periytetty toisesta luokasta lisäämällä uusia ominaisuuksia - toisin sanoen erikoistamalla se. Edellisessä kaaviossa olevilla kaikilla luokilla on kaikki Laatikko-luokan ominaisuudet ja se kuvaa tarkalleen C++:n luokkien periytymismekanismin. Voisimme myös määritellä Laatikko, PahviLaatikko ja RuokaPahviLtk -luokat toisistaan riippumatta, mutta määrittelemällä ne toisiinsa liittyviksi saamme runsaasti lisäarvoa. Katsotaan kuinka tämän toimii käytännössä. Luokkien periytyvyys Aloitetaan keskenään suhteessa olevien luokkien terminologialla. Oletetaan, että meillä on luokka A ja luomme uuden, erikoistuneen luokan B. Luokkaa A kutsutaan kantaluokaksi ja luokka B on perillinen. Voit myös ajatella, että A on isä ja B on lapsi. Periytetty luokka sisältää kaikki kantaluokkansa jäsenmuuttujat ja (joillakin rajoituksilla, joihin palaamme myöhemmin) kaikki jäsenfunktiot. Periytetyn luokan sanotaan perivän kantaluokkansa jäsenmuuttujat ja jäsenfunktiot. Jos luokka B on luokasta A suoraan periytetty luokka, sanomme, että A on B:n suora kantaluokka. Sanomme myös, että B on periytetty luokasta A. Edellisessä esimerkissä luokka PahviLaatikko on luokan RuokaPahviLtk suora kantaluokka. Koska PahviLaatikko on määritelty Laatikko-luokan pohjalta, sanomme, että Laatikko-luokka on RuokaPahviLtk-luokan epäsuora kantaluokka. RuokaPahviLtk-luokan oliolla on PahviLaatikko-luokasta perityt jäsenet - mukaan lukien jäsenet, jotka PahviLaatikko-luokka on perinyt Laatikko-luokalta. Tapa, jolla periytetty luokka perii kantaluokkansa jäsenet, kuvataan viereisessä kaaviossa. Kantaluokka Jäsenmuuttujat Jäsenfunktiot Periytetty luokka Kantaluokan ali-olio Jäsenmuuttujat Jäsenfunktiot Omat jäsenmuuttujat Omat jäsenfunktiot Kantaluokalta perityt jäsenet 579

4 C++ Ohjelmoijan käsikirja Kuten huomaat, periytetty luokka sisältää kaikki kantaluokkansa jäsenmuuttujat ja jäsenfunktiot sekä lisäksi sen omat jäsenmuuttujat ja jäsenfunktiot. Eli jokainen periytetty luokka sisältää kantaluokan alioliona sekä muita jäseniä. 580 Periytyminen vs. kerääminen Periytymisen tarkoituksena ei ole pelkästään saada yhden luokan jäsenet mukaan toiseen luokkaan. Koko ajatuksen pohjalla on tärkeä idea: periytettyjen luokkien tulee kuvata järkeviä kantaluokan olioita. Jotta ymmärrät tarkasti, mitä tämä tarkoittaa, voit suorittaa useita yksinkertaisia testejä. Ensimmäinen on on eräänlainen -testi: periytetyn luokan olio on eräänlainen kantaluokan olio. Toisin sanoen periytetyn luokan tulee kuvata kantaluokan kuvaamien olioiden alijoukkoa. Esimerkiksi: Koira-luokka voidaan periyttää Elain-luokasta. Tässä on järkeä, koska koira on eräänlainen eläin - tai pikemminkin, Koira-olio edustaa järkevää Elain-luokan oliota. Toisaalta Poyta-luokkaa ei tule periyttää Koira-luokasta: vaikka Poyta-olioilla ja Koira-olioilla on yleensä neljä jalkaa, Poyta-oliota ei voida mitenkään pitää Koira-olioon liittyvänä. On eräänlainen -testi on erinomainen ensimmäinen testi, mutta se ei ole vedenpitävä. Oletetaan, että olemme määritelleet luokan Lintu, joka (muiden ominaisuuksien lisäksi) kuvaa sitä, että useimmat linnut osaavat lentää. Strutsi on eräänlainen lintu, mutta luokkaa Strutsi ei ole järkevää periyttää Lintu-luokasta, koska strutsit eivät osaa lentää! Jos luokkasi läpäisee on eräänlainen -testin, sinun tulee varmistaa asia vielä kysymällä: voidaanko kantaluokasta sanoa (tai vaatia) jotain, joka ei päde periytetylle luokalle? Jos tällaista löytyy, periytyvyyssuhde ei välttämättä ole oikein hyvä. Eli Koira-luokan periyttäminen Elain-luokasta on järkevää, mutta Strutsi-luokan periyttäminen Lintu-luokasta ei ole - sinun tulisi ehkä määritellä luokat Lentavat_linnut ja Ei_lentavat_linnut. Jos luokkasi ei läpäise on eräänlainen -testiä, sinun ei yleensä tulisi tehdä kyseistä periyttämistä. Tällöin voit käyttää omistaa-testiä. Luokan olio läpäisee omistaa-testin, jos se sisältää toisen olion ilmentymän. Tämä tilanne voidaan toteuttaa lisäämällä luokka toisen luokan jäsenmuuttujaksi. Tällaista riippuvuutta kutsutaan keräämiseksi. Tarkastellaan esimerkiksi luokkaa Auto. Se sisältää varmastikin auton pääkomponentit jäsenmuuttujina. Luonnollisestikin, auto omistaa moottorin, omistaa vaihteiston, omistaa korin ja omistaa jousituksen - joten Auto-luokka sisältää luokat Moottori, Vaihteisto, Kori ja Jousitus. Huomaa, että et voi sanoa, että moottori on eräänlainen auto. Eli luokat eivät läpäise on eräänlainen -testiä, joten Auto-luokkaa ei voi periä Moottori-luokasta. Käyttämämme kolme testiä olivat siis: On eräänlainen -testi on ensimmäinen testi, jota käytetään tarkistamaan, onko periyttäminen oikea tapa toteuttaa luokkasi. Jos luokat läpäisevät on eräänlainen -testin, varmista tulos vielä kysymällä: voidaanko kantaluokasta sanoa (tai vaatia) jotain, joka ei päde periytetylle luokalle? Jos vastaus on ei, periyttäminen yleensä käy. Jos luokat eivät läpäise on eräänlainen -testiä, kokeile omistaa-testiä. Jos ne läpäisevät omistaa-testin, kerääminen on yleensä vastaus.

5 Periytyminen Sopiva toteutustapa riippuu tietysti sovelluksestasi ja nämä testit on tarkoitettu vain suuntaa antaviksi, ei tarkkaan noudatettaviksi. Joskus luokan periyttämistä käytetään yksinkertaisesti kokoamaan halutut ominaisuudet yhteen, eli periytetty luokka rakentaa kuoren haluttujen ominaisuuksien ympärille. Tällöinkin periytetty luokka kuvaa ominaisuuksia, jotka liittyvät toisiinsa jollakin tavoin. Nyt on aika katsoa, miltä koodi näyttää, kun periytämme luokan toisesta luokasta. Luokkien periyttäminen kantaluokasta Palataan takaisin Laatikko-luokkamme yksinkertaiseen versioon, jossa oli kolme yksityistä jäsenmuuttujaa ja julkinen muodostinfunktio: // Laatikko.h - määrittelee Laatikko-luokan #ifndef LAATIKKO_H #define LAATIKKO_H class Laatikko public: Laatikko(double lv=1.0, double bv=1.0, double hv=1.0); private: double pituus; double syvyys; double korkeus; ; #endif Koska olemme määritelleet muodostinfunktion parametreille oletusarvot, se toimii myös oletusmuodostinfunktiona. Talleta tämä määrittely otsikkotiedostoon Laatikko.h ja lisää se esimerkkiin #include-esikääntäjäkomennolla. Laatikko-luokan muodostinfunktion määrittely kirjoitetaan Laatikko.cpp-tiedostoon: // Laatikko.cpp #include "Laatikko.h" // Muodostinfunktio Laatikko::Laatikko(double lv, double bv, double hv) : pituus(lv), syvyys(bv), korkeus(hv) Nyt määrittelemme toisen luokan PahviLaatikko. PahviLaatikko-olio on samanlainen kuin aikaisemmin jo näimme - muuten samanlainen kuin Laatikko-olio, mutta siihen on lisätty jäsenmuuttuja, joka kertoo laatikon materiaalin. Voimme esitellä uuden jäsenmuuttujan nullmerkkiin päättyväksi merkkijonoksi, joka kuvaa materiaalia, josta laatikko on tehty. (Käytännössä käyttäisimme string-oliota, mutta käyttämällä null-merkkiin päättyvää merkkijonoa voimme havainnollistaa joitakin dynaamisen muistinvarauksen vaikutuksia). Määrittelemme PahviLaatikko-luokan periytetyksi luokaksi, jonka kantaluokka on Laatikko: // PahviL.h - määrittelee PahviLaatikko-luokan Laatikko-luokasta #ifndef PAHVILAATIKKO_H #define PAHVILAATIKKO_H #include "Laatikko.h" // Kantaluokan määrittelyt #include <cstring> 581

6 C++ Ohjelmoijan käsikirja class PahviLaatikko : public Laatikko public: PahviLaatikko(const char* pstr = "Pahvi"); ~PahviLaatikko(); // Muodostinfunktio // Tuhoajafunktio private: char* pmateriaali; ; #endif Meidän täytyy sisällyttää Laatikko-luokan määrittely tähän tiedostoon, koska se on PahviLaatikko-luokan kantaluokka. Määrittelyt sijoitetaan tiedostoon PahviL.cpp: // PahviL.cpp #include PahviL.h" #include <cstring> // Muodostinfunktio PahviLaatikko::PahviLaatikko(const char* pstr) pmateriaali = new char[strlen(pstr)+1]; strcpy( pmateriaali, pstr); // Varataan muisti merkkijonolle // Kopioidaan se // Tuhoajafunktio PahviLaatikko::~PahviLaatikko() delete[] pmateriaali; PahviLaatikko-luokan määrittelyn ensimmäinen rivi kertoo, että PahviLaatikko-luokka on suoraan periytetty Laatikko-luokasta: class PahviLaatikko : public Laatikko 582 Avainsana public on kantaluokan saantitavan hallintakomento, joka kertoo, miten Laatikkoluokan jäseniin päästään käsiksi PahviLaatikko-luokasta. Palaamme tähän myöhemmin. Muuten PahviLaatikko-luokan määrittely näyttää samanlaiselta kuin muutkin luokan määrittelyt. Se sisältää uuden jäsenen, pmateriaali, joka on osoitin null-merkkiin päättyvään merkkijonoon. Se alustetaan muodostinfunktiossa vapaasta muistista varattuun osoitteeseen sijoitetulla merkkijonolla. Tämä varmistaa, että oliolla on oma materiaalin kertova merkkijono. Meidän tulee määritellä myöskin tuhoajafunktio, joka vapauttaa pmateriaali-osoittimen osoittaman muistialueen. Huomaa, että muodostinfunktiossa on määritelty materiaalin oletusarvo, joten sitä voidaan käyttää myös PahviLaatikko-luokan oletusmuodostinfunktiona. PahviLaatikko-luokan olio sisältää kaikki Laatikko-kantaluokan jäsenmuuttujat sekä uuden jäsenmuuttujan pmateriaali. Katsotaan nyt, miten tämä kaikki toimii käytännössä.

7 Periytyminen Kokeile itse - Periytetyn luokan käyttö Tässä on periytettyä luokkaa käyttävän ensimmäisen esimerkin koodi: // Esimerkki Periytetyn luokan määrittely ja käyttö #include <iostream> #include "Laatikko.h" // Laatikko-luokka #include "PahviL.h" // PahviLaatikko-luokka using namespace std; int main() // Luodaan laatikko ja kaksi pahvilaatikkoa Laatikko omaltk(40.0, 30.0, 20.0); PahviLaatikko omapahviltk; PahviLaatikko karkkiltk("ohut pahvi"); // Tarkistetaan ne - varsinkin koot cout << endl << "omaltk vie tilaa " << sizeof omaltk << " tavua" << endl; cout << "omapahviltk vie tilaa " << sizeof omapahviltk << " tavua" << endl; cout << "karkkiltk vie tilaa " << sizeof karkkiltk << " tavua" << endl; // omaltk.pituus = 10.0; // Poista kommentti ja saat virheen // karkkiltk.pituus = 10.0; // Poista kommentti ja saat virheen return 0; Minun koneessani ohjelma tulostaa seuraavaa: omaltk vie tilaa 24 tavua omapahviltk vie tilaa 28 tavua karkkiltk vie tilaa 28 tavua Kuinka se toimii Aluksi sisällytämme otsikkotiedostot, jotka sisältävät luokkien Laatikko ja PahviLaatikko määrittelyt. Tiedosto, joka sisältää PahviLaatikko-luokan määrittelyn, sisällyttää myös otsikkotiedoston Laatikko.h, mutta #ifndef/#endif -esikääntäjäkomennot estävät Laatikkoluokan määrittelyn kahteen kertaan. Esittelemme main()-funktiossa Laatikko-olion ja kaksi PahviLaatikko-oliota ja tulostamme kunkin olion koon tavuissa. Tulostus todistaa sen mitä odotimmekin - eli että PahviLaatikko-olio on suurempi kuin Laatikko-olio. Laatikko-oliolla on kolme double-tyyppistä jäsenmuuttujaa, joista jokainen vie 8 tavua, eli yhteensä 24 tavua. Molemmat PahviLaatikko-oliot ovat saman kokoisia: 32 tavua. PahviLaatikko-olion viemä lisätila johtuu jäsenmuuttujasta pmateriaali (merkkijonon pituus ei vaikuta PahviLaatikko-olion kokoon, koska pmateriaali on osoitin). 583

8 C++ Ohjelmoijan käsikirja Jos poistamme kommentoinnin jommasta kummasta kommentoidusta rivistä, ohjelma ei enää käänny. Ensimmäinen näistä riveistä on: // omaltk.pituus = 10.0; // Poista kommentti ja saat virheen Tämän lauseen pitäisikin tuottaa virheilmoitus. Laatikko-olion omaltk jäsenmuuttuja pituus on esitelty yksityiseksi, joten se ei ole tällä tavoin käytettävissä. Poistamalla kommentoinnin seuraavastakin lauseesta näemme, että myöskään PahviLaatikko-olion jäsenmuuttujaa pituus ei voida käsitellä suoraan: // karkkiltk.pituus = 10.0; // Poista kommentti ja saat virheen Kääntäjä antaa virheilmoituksen, että kantaluokan jäsen pituus ei ole käytettävissä. Tämä kuulostaa ehkä hieman odottamattomalta - määrittelimmehän PahviLaatikko-luokan periyttämällä Laatikko-luokan jäsenet julkisiksi. Virheen syy on siinä, että pituus on kantaluokassa yksityinen. Periytetyssä PahviLaatikkoluokassa jäsen pituus on julkisesti peritty yksityinen jäsenmuuttuja. Kääntäjä tulkitsee tämän siten, että se tekee jäsenestä pituus PahviLaatikko-luokan yksityisen jäsenen. Eli kun yritämme käsitellä jäsentä karkkiltk.pituus, kääntäjä antaa virheilmoituksen. Jos todellakin haluaisit käsitellä näitä yksityisiä jäsenmuuttujia, käytä julkisia funktioita, kuten luvussa 12 käsittelemämme luepituus(). Periytetyn luokan jäsenmuuttujien saantiin vaikuttaa sekä kantaluokan jäsenmuuttujan saantitavan hallintakomento että periytetyn luokan saantitavan hallintakomento periytetyssä luokassa. Periytetyn luokan jäsenmuuttujien saantitapaa tulee tarkastella tarkemmin. Kolmannen saantitavan hallintakomennon, protected, käsittelemme hetken päästä. Katsotaan ensin esimerkkejä; myöhemmin teemme yhteenvedon, miten kantaluokan saantitavan hallintakomennot vaikuttavat periytetyn luokan jäsenten saantitapaan. Jäsenten saantitapa perinnässä Kantaluokan yksityiset jäsenmuuttujat ovat myös periytetyn luokan jäseniä, mutta ne säilyvät yksityisinä kantaluokkaan nähden. Tämä tarkoittaa sitä, että perittyjä jäsenmuuttujia voidaan käsitellä kantaluokalta perityissä jäsenfunktioissa, mutta ei periytetyn luokan jäsenfunktioissa. Lisätään esimerkiksi funktio tilavuus() periytettyyn luokkaan PahviLaatikko. Tiedosto PahviL.h muuttuu seuraavasti: 584 // PahviL.h - määrittelee PahviLaatikko-luokan Laatikko-luokasta #ifndef PAHVILAATIKKO_H #define PAHVILAATIKKO_H #include "Laatikko.h" // Kantaluokan määrittelyt #include <cstring>

9 Periytyminen class PahviLaatikko : public Laatikko public: PahviLaatikko(const char* pstr = "Pahvi"); ~PahviLaatikko(); double tilavuus() const; // Muodostinfunktio // Tuhoajafunktio //Virhe - jäseniä ei voi käsitellä private: char* pmateriaali; ; #endif Ja PahviL.cpp -tiedosto muuttuu seuraavasti: // PahviL.cpp #include PahviL.h" #include <cstring> // Muodostinfunktio PahviLaatikko::PahviLaatikko(const char* pstr) pmateriaali = new char[strlen(pstr)+1]; strcpy( pmateriaali, pstr); // Varataan muisti merkkijonolle // Kopioidaan se // Tuhoajafunktio PahviLaatikko::~PahviLaatikko() delete[] pmateriaali; //Funktio, joka laskee PahviLaatikko-olion tilavuuden double PahviLaatikko::tilavuus() const return pituus*syvyys*korkeus; Oletetaan, että yritämme suorittaa ohjelman tällä luokalla ja esimerkin 15.1 mukaisella Laatikko-luokan määrittelyllä. Kaikki ohjelmat, jotka käyttävät tätä luokkaa, eivät käänny. PahviLaatikko-luokan tilavuus()-funktio yrittää käsitellä kantaluokan yksityisiä jäseniä - sehän ei ole sallittua, vaikka ne ovatkin periytetyn luokan jäseniä. On kuitenkin sallittua käyttää tilavuus()-funktiota, jos se on kantaluokan jäsen. Joten jos siirrät funktion tilavuus() määrittelyn Laatikko-kantaluokan public-osaan, ohjelma kääntyy ja voit käyttää funktiota PahviLaatikko-olion tilavuuden laskentaan. Katsotaan tätä käytännössä. 585

10 C++ Ohjelmoijan käsikirja Kokeile itse - Kantaluokan jäsenfunktiot Muuta ensin luokan määrittelyä Laatikko.h-tiedostossa: class Laatikko public: Laatikko(double lv=1.0, double bv=1.0, double hv=1.0); //Funktio, joka laskee Laatikko-olion tilavuuden double tilavuus() const; private: double pituus; double syvyys; double korkeus; ; Voimme esitellä tilavuus()-funktion const-tyyppiseksi, koska se ei muuta luokan jäsenmuuttujia - se vain käyttää niitä olion tilavuuden laskentaan. Lisää funktion määrittely Laatikko.cpptiedostoon: // Laatikko.cpp #include "Laatikko.h" // Muodostinfunktio Laatikko::Laatikko(double lv, double bv, double hv) : pituus(lv), syvyys(bv), korkeus(hv) //Funktio, joka laskee Laatikko-olion tilavuuden double Laatikko::tilavuus() const return pituus*syvyys*korkeus; Tässä ohjelmassa käytämme esimerkin 15.1 tiedostoja PahviL.h ja PahviL.cpp. Eli PahviLaatikkoluokka perii Laatikko-luokan julkisesti ja luokalla on muodostinfunktio, tuhoajafunktio ja yksityinen jäsenmuuttuja pmateriaali. Voimme nyt laskea esimerkissä 15.1 luomiemme Laatikko- ja PahviLaatikko-olioiden tilavuudet: // Esimerkki Kantaluokasta perityn funktion käyttö #include <iostream> #include "Laatikko.h" // Laatikko-luokka #include "PahviL.h" // Pahvilaatikko-luokka using namespace std; 586 int main() // Luodaan laatikko ja kaksi pahvilaatikkoa Laatikko omaltk(40.0, 30.0, 20.0); PahviLaatikko omapahviltk; PahviLaatikko karkkiltk("ohut pahvi");

11 Periytyminen cout << endl; cout << "omaltk:n tilavuus on " << omaltk.tilavuus() << endl; cout << "omapahviltk:n tilavuus on " << omapahviltk.tilavuus() << endl; cout << "karkkiltk:n tilavuus on " << karkkiltk.tilavuus() << endl; return 0; Ohjelma tulostaa seuraavaa: omaltk:n tilavuus on omapahviltk:n tilavuus on 1 karkkiltk:n tilavuus on 1 Kuinka se toimii Tämä esimerkki havainnollistaa, että Laatikko-luokassa määritelty tilavuus()-funktio toimii aivan yhtä hyvin PahviLaatikko-luokan olioiden kanssa. Se pystyy käsittelemään kantaluokan jäsenmuuttujia, vaikka ne ovat yksityisiä, eikä niitä voida käsitellä periytetyn luokan funktioista. Molempien PahviLaatikko-olioiden tilavuus on 1, joten niiden mitat ovat kantaluokan muodostinfunktiossa asetetut oletusarvot. PahviLaatikko-luokan muodostinfunktiota kutsutaan, kun luomme luokan olion; mutta selvästikin kantaluokan muodostinfunktiota täytyy myöskin kutsua jollain tavalla, koska periytetyn luokan muodostinfunktio ei voi mitenkään alustaa kantaluokalta perittyjä jäsenmuuttujia. Voit varmistua, että kantaluokan muodostinfunktiota kutsutaan, jos lisäät tulostuslauseita kertomaan mitä muodostinfunktiota kulloinkin on kutsuttu. Laatikko-luokan muodostinfunktion runkoon voit lisätä seuraavan lauseen: cout << Laatikon muodostinfunktio << endl; Voit lisätä vastaavan tulostuslauseen myös PahviLaatikko-luokan muodostinfunktioon. Älä unohda sisällyttää iostream-otsikkotiedostoa ja using-komentoa jokaiseen.cpp-tiedostoon. Jos suoritat ohjelman uudelleen, saat seuraavanlaisen tulostuksen: Laatikon muodostinfunktio Laatikon muodostinfunktio PahviLaatikon muodostinfunktio Laatikon muodostinfunktio PahviLaatikon muodostinfunktio omaltk:n tilavuus on omapahviltk:n tilavuus on 1 karkkiltk:n tilavuus on 1! Tulostuksen ensimmäinen rivi johtuu Laatikko-olion omaltk luonnista. Seuraavat kaksi riviä muodostuvat PahviLaatikko-olion omapahviltk luonnista. Kuten huomaat, PahviLaatikko-olion luonnissa kutsutaan automaattisesti Laatikko-luokan muodostinfunktiota (itse asiassa oletusmuodostinfunktiota) ennen kuin PahviLaatikko-luokan muodostinfunktio suoritetaan. Tällöin alustetaan kantaluokan jäsenmuuttujat. Myöhemmin tässä luvussa tarkastelemme tarkemmin kantaluokan muodostinfunktiota. Erityisesti meitä kiinnostaa, miten voimme tarkemmin kontrolloida kantaluokan jäsenmuuttujien alustusta. 587

12 C++ Ohjelmoijan käsikirja Luokan jäsenten esittely suojatuiksi Kantaluokan yksityisiin jäsenmuuttujiin pääsee käsiksi ainoastaan kantaluokan jäsenfunktioista. Tämä ei ole aina hyvä tilanne. Eteen tulee varmastikin tilanteita, joissa haluamme päästä käsiksi kantaluokan jäsenmuuttujiin myös periytetystä luokasta, mutta ei luokan ulkopuolelta. Kuten varmasti jo aavistatkin, C++:ssa on tapa, jolla tämä voidaan tehdä. public- ja private-saantitavan hallintakomentojen lisäksi voit esitellä luokan jäsenen suojatuksi protected-avainsanalla. Luokan sisällä protected-avainsanalla on täsmälleen sama vaikutus kuin private-avainsanallakin. Luokan jäsentä, joka on suojattu protected-avainsanalla, voivat käsitellä vain luokan jäsenfunktiot, ystäväluokat ja luokan ystäväfunktiot. Suojattuihin jäseniin ei pääse käsiksi luokan ulkopuolelta, joten ne toimivat kuten yksityisetkin jäsenet. Suojattujen ja yksityisten jäsenten ero tulee esille periytetyssä luokassa. Suojatuiksi esitellyt kantaluokan jäsenet ovat vapaasti käytettävissä periytetyn luokan jäsenfunktioissa, kun taas kantaluokan yksityiset jäsenet eivät ole. Voimme määritellä Laatikko-luokkamme uudelleen suojatuilla jäsenmuuttujilla: class Laatikko public: Laatikko(double lv=1.0, double bv=1.0, double hv=1.0); ; protected: double pituus; double syvyys; double korkeus; Nyt Laatikko-luokan jäsenmuuttujat ovat itse asiassa yksityisiä, koska niihin ei pääse käsiksi tavallisista globaalisista funktioista, mutta periytetyn luokan jäsenfunktiot pääsevät niihin käsiksi. Katsotaan tätä havainnollistavaa esimerkkiä. 588 Kokeile itse - Perittyjen suojattujen jäsenten käyttö Käytämme tässä esimerkissä edellä esitettyä Laatikko-luokkaa ja teemme uuden version PahviLaatikko-luokasta, joka käsittelee kantaluokan jäsenmuuttujia omassa tilavuus()- jäsenfunktiossaan. Meidän tulee poistaa tilavuus()-funktion prototyyppi Laatikko-luokan määrittelystä (kuten edellä) sekä myöskin tilavuus()-funktion määrittely tiedostosta Laatikko.cpp. Tämän jälkeen lisäämme tilavuus()-funktion prototyypin PahviLaatikko-luokan määrittelyyn ja tilavuus()-funktion määrittelyn PahviL.cpp-tiedostoon. Esittelemme myöskin PahviLaatikko-luokan jäsenmuuttujan protected-avainsanalla, jotta se on saman tyyppinen kuin Laatikko-luokalta perimämme jäsenmuuttujatkin. Seuraavassa on luokan määrittely:

13 Periytyminen class PahviLaatikko : public Laatikko public: PahviLaatikko(const char* pstr = "Pahvi"); ~PahviLaatikko(); // Muodostinfunktio // Tuhoajafunktio //Funktio, joka laskee PahviLaatikko-olion tilavuuden double tilavuus() const; protected: char* pmateriaali; ; Seuraavassa on funktion määrittely, joka tulee lisätä PahviL.cpp-tiedostoon: //Funktio, joka laskee PahviLaatikko-olion tilavuuden double PahviLaatikko::tilavuus() const return pituus*syvyys*korkeus; Voimme kokeilla uutta PahviLaatikko-luokkaamme seuraavalla ohjelmalla: // Esimerkki Perityn suojatun jäsenen käyttö #include <iostream> #include "Laatikko.h" // Laatikko-luokka #include "PahviL.h" // Pahvilaatikko-luokka using namespace std; int main() // Luodaan laatikko ja kaksi pahvilaatikkoa Laatikko omaltk(40.0, 30.0, 20.0); PahviLaatikko omapahviltk; cout << endl; //cout << "omaltk:n tilavuus on " << omaltk.tilavuus() << endl; //Poista kommentointi niin saat virheen cout << "omapahviltk:n tilavuus on " << omapahviltk.tilavuus() << endl; //cout << "omapahviltk:n pituus on " << omapahviltk.pituus << endl; //Poista kommentointi niin saat virheen return 0; Nämä kommentoinnit ovat vain uusien Laatikko- ja PahviLaatikko-luokkiemme esittelyä varten. Ohjelma tulostaa seuraavaa: Laatikon muodostinfunktio Laatikon muodostinfunktio PahviLaatikon muodostinfunktio omapahviltk:n tilavuus on 1 589

14 C++ Ohjelmoijan käsikirja Kuinka se toimii Jos poistat kommentoinnin tulostuslauseesta, joka väittää laskevan omaltk:n tilavuuden, ohjelma ei enää käänny: //cout << "omaltk:n tilavuus on " << omaltk.tilavuus() << endl; //Poista kommentointi niin saat virheen Näin tapahtuu, koska Laatikko-luokalle ei ole määritelty funktiota tilavuus(). Voit laskea vain PahviLaatikko-olion tilavuuden. PahviLaatikko-olion omapahviltk tilavuus lasketaan kutsumalla periytetyssä luokassa määriteltyä tilavuus()-funktiota: cout << "omapahviltk:n tilavuus on " << omapahviltk.tilavuus() << endl; Tämä funktio käyttää perittyjä jäseniä pituus, syvyys ja korkeus tuloksen laskennassa. Nämä jäsenet on esitelty suojatuiksi kantaluokassa ja säilyvät suojattuina periytetyssä luokassakin. Tulostuksesta näemme, että omapahviltk:n tilavuus lasketaan oikein. Sen tilavuudeksi saadaan arvo 1, koska Laatikko-oliosta perittyihin jäseniin asetetaan oletusarvot. Koska olemme määritelleet PahviLaatikko-luokan jäsenen pmateriaali suojatuksi, tämän luokan kaikki jäsenet ovat nyt suojattuja ja niitä voidaan käsitellä PahviLaatikko-luokasta periytettävistä luokista. Voit havainnollistaa, että kantaluokan suojatut jäsenet säilyvät suojattuina myöskin periytetyssä luokassa, jos poistat kommentoinnin seuraavasta lauseesta: //cout << "omapahviltk:n pituus on " << omapahviltk.pituus << endl; //Poista kommentointi niin saat virheen Jos poistat kommentoinnin, kääntäjä antaa virheilmoituksen, että jäsen pituus on suojattu, joten sitä ei voida käsitellä periytetyn luokan ulkopuolelta. Perittyjen jäsenten saantitavat! Kuten olemme jo huomanneet, jos periytät luokan kantaluokasta, sinun tulee valita kantaluokan saantitapa. Käytössä on kolme vaihtoehtoa: public, protected ja private. Itse asiassa, oletusarvoinen kantaluokan saantitapa on private. Joten jos jätät saantitavan määrittelemättä - esimerkiksi kirjoittamalla class PahviLaatikko: Laatikko esimerkin 15.1 PahviLaatikko-luokan määrittelyyn - oletuksena käytetään private-saantitapaa. 590 Tiedämme myöskin, että kantaluokan jäsenmuuttujien esittelyssä voidaan käyttää kolmea saantitavan hallintakomentoa - eli jälleen samat vaihtoehdot: public, protected ja private.

15 Periytyminen Kun periytämme luokan kantaluokasta, kantaluokan saantitavan hallintakomento vaikuttaa perittyjen jäsenten saantitapaan. Tässä kohdassa on yhdeksän erilaista yhdistelmää; olemme nähneet jo muutamia tämän luvun aikaisemmissa esimerkeissä. Käymme nämä kaikki vaihtoehdot läpi seuraavaksi, vaikka joidenkin hyödyllisyys tulee esille vasta seuraavassa luvussa käsitellessämme polymorfismia. Ensiksi tarkastelemme, kuinka kantaluokan yksityiset jäsenet periytyvät. Riippumatta kantaluokan saantitavasta (public, protected tai private), kantaluokan yksityinen jäsen säilyy aina yksityisenä kantaluokkaan nähden. Tästä seuraa kaksi asiaa. Ensinnäkin, perityt yksityiset jäsenet ovat yksityisiä myös periytetyssä luokassa (eli niitä ei voida käsitellä luokan ulkopuolelta). Toiseksi, periytetyn luokan jäsenfunktiotkaan eivät pääse niihin käsiksi (koska ne ovat yksityisiä kantaluokkaan nähden). Nyt tarkastelemme, miten kantaluokan julkiset ja suojatut jäsenet periytyvät. Kaikissa tapauksissa perittyjä jäseniä pystyy käsittelemään myös periytetyn luokan jäsenfunktioista. Katsotaan, miten jäsenet periytyvät. Kaikkein yleisin periytymisen muoto on julkinen periytyminen. Tällöin perittyjen jäsenten saantitapa ei muutu. Eli perityt julkiset jäsenet ovat julkisia ja perityt suojatut jäsenet ovat suojattuja. Kun kantaluokka peritään suojattuna, perityt julkiset jäsenet muuttuvat periytetyssä luokassa suojatuiksi. Suojatut jäsenet pysyvät suojattuina myös periytetyssä luokassa. Kun kantaluokka peritään yksityisenä, perityt julkiset ja suojatut jäsenet muuttuvat periytetyssä luokassa yksityisiksi - eli periytetyn luokan jäsenfunktiot voivat käsitellä niitä, mutta tästä luokasta perittyjen luokkien jäsenmuuttujat eivät voi. Tämä kaikki on esitetty alla olevassa kaaviossa: public-kantaluokka public -jäsenet protected -jäsenet private -jäsenet periytyy periytetty luokka public protected Periytyy, mutta ei käytettäv. protected-kantaluokka public -jäsenet protected -jäsenet private -jäsenet periytyy periytetty luokka protected protected Periytyy, mutta ei käytettäv. private-kantaluokka public -jäsenet protected -jäsenet private -jäsenet periytyy periytetty luokka private private Periytyy, mutta ei käytettäv. 591

16 C++ Ohjelmoijan käsikirja Mahdollisuus muuttaa periytetyn luokan saantitapaa antaa lisää joustavuutta, mutta muista, että voit vain tiukentaa saantitapaa - et voi löysentää kantaluokassa määriteltyä saantitapaa. Saantitavan hallintakomentojen käyttö luokkien hierarkiassa Kuten olemme juuri nähneet, luokkien hierarkiassa on kaksi asiaa, jotka tulee ottaa huomioon - luokan jäsenten saantitapa ja kantaluokan saantitapa. Kuten näimme luvussa 12, luokan julkiset jäsenet määrittelevät luokan rajapinnan - johon ei yleensä kuulu jäsenmuuttujia. Luokan jäsenten, jotka eivät ole osa luokan rajapintaa, ei tulisi olla käsiteltävissä luokan ulkopuolelta suoraan. Tämä tarkoittaa sitä, että niiden tulisi olla yksityisiä tai suojattuja. Se kumman valitset tietylle luokalle riippuu siitä, haluatko rajoittaa saantia periytetyissä luokissa. Jos haluat rajoittaa, käytä yksityistä, muutoin käytä suojattua. On yleensä järkevää pitää asiat mahdollisimman piilossa. periytetty luokka aina käytettävissä käytettävissä vain, jos kantaluokka on public ei koskaan käytettävissä kantaluokka public -jäsenet protected private -jäsenet ei koskaan käytettävissä Kantaluokan jäsenten saantitavan vaikutus Kuten yllä oleva kaavio havainnollistaa, perittyjen jäsenten saantitapaan vaikuttaa ainoastaan näiden jäsenten saantitapa kantaluokan määrittelyssä. Periytetyssä luokassa kantaluokan julkiset ja suojatut jäsenet ovat aina käytettävissä ja kantaluokan yksityiset jäsenet eivät koskaan ole käytettävissä. Ainoastaan kantaluokan julkiset jäsenet ovat käytettävissä periytetyn luokan ulkopuolelta - ja tällöinkin vain, jos kantaluokka on periytetty julkisesti. Kuten olemme nähneet, jos kantaluokan saantitapa on julkinen, perittyjen jäsenten saantitapa säilyy muuttumattomana. Käyttämällä kantaluokan yhteydessä protected ja private saantitavan hallintakomentoa, voit tehdä kaksi asiaa. Ensinnäkin, voit estää kantaluokan julkisen jäsenen käsittelyn periytetyn luokan ulkopuolelta - molemmat komennot tekevät tämän. Jos kantaluokalla on julkisia jäsenfunktioita, tämä on varsin suuri asia - koska luokan rajapinta poistetaan periytetyltä luokalta. Toiseksi, voit vaikuttaa siihen, miten periytetyn luokan jäsenet periytyvät edelleen. 592

17 Periytyminen class Periytetty:protected Kanta class Periytetty:private kanta class Kanta public -jäsenet protected -jäsenet private -jäsenet class Kanta public -jäsenet protected -jäsenet private -jäsenet Periytetystä peritty luokka Peritty, mutta ei käsiteltävissä Peritty ja voi olla käsiteltävissä Periytetystä peritty luokka Peritty, mutta ei käsiteltävissä Kuten kaaviosta näemme, kantaluokan julkiset ja suojatut jäsenet voidaan periyttää suojattuina. Yksityisesti periytetystä kantaluokasta perityissä luokissa jäseniä ei enää voi käsitellä. Useimmissa tapauksissa kaikkein sopivin kantaluokan saantitapa on public, kun kantaluokan jäsenmuuttujat on esitelty yksityiseksi tai suojatuksi. Jos käytät kantaluokan saantitapana protected tai private, kantaluokka on periytetyn luokan sisällä siten, että se ei ole osa periytetyn luokan julkista rajapintaa. Koska käytännössä periytetyn luokan olio on eräänlainen kantaluokan olio, haluat varmastikin, että kantaluokan rajapinta on käytettävissä myös periytetyssä luokassa. Eli tällöin kantaluokka tulee määritellä julkiseksi. Perittyjen jäsenten saantitavan muuttaminen Haluat varmastikin kokeilla kantaluokan saantitavan muuttamista suojatuksi tai yksityiseksi. Katsotaanpa esimerkkiä. Oletetaan, että määrittelemme Laatikko-luokan, jolla on publictyyppinen jäsenfunktio tilavuus(): class Laatikko public: //Muodostinfunktio Laatikko(double lv=1.0, double bv=1.0, double hv=1.0); //Funktio, joka laskee Laatikko-olion tilavuuden double tilavuus() const; ; protected: double pituus; double syvyys; double korkeus; 593

18 C++ Ohjelmoijan käsikirja Seuraavassa ovat luokan jäsenfunktioiden määrittelyt: // Muodostinfunktio Laatikko::Laatikko(double lv, double bv, double hv) : pituus(lv), syvyys(bv), korkeus(hv) cout << "Laatikon muodostinfunktio" << endl; //Funktio, joka laskee Laatikko-olion tilavuuden double Laatikko::tilavuus() const; return pituus*syvyys*korkeus; Haluamme nyt periyttää Laatikko-luokasta uuden luokan Paketti, käyttämällä Laatikko-luokkaa private-tyyppisenä kantaluokkana - mutta haluaisimme tilavuus()-funktion olevan julkisen myös periytetyssä luokassa. Yksityisen perinnän tuloksena kaikki public- ja protected-tyyppiset jäsenet ovat tietysti private-tyyppisiä periytetyssä luokassa. Voimme muuttaa tietyn perityn jäsenen saantitapaa using-esittelyllä. Tämä on periaatteessa aivan sama kuin luvussa 10 nimiavaruuksien yhteydessä näkemämme using-esittely. Voimme pakottaa tilavuus()-funktion julkiseksi periytetyssä luokassa kirjoittamalla luokan määrittelyn seuraavasti: class Paketti : private Laatikko public: using Laatikko::tilavuus; // Loput luokan määrittelystä ; // Peritään julkisena 594! Luokan määrittely määrittelee näkyvyysalueen - ja using-esittely esittelee kyseiseen luokan näkyvyysalueeseen uuden nimen. Tässä using-esittely korvaa kantaluokan private-saantitavan ainoastaan kantaluokan funktiolle tilavuus(). Funktio peritään Paketti-luokkaan julkisena, ei yksityisenä. Syntaksissa on tässä kaksi erikseen huomioitavaa kohtaa. Ensiksi, kun käytät unsing-esittelyä kantaluokan jäsenelle, täytyy sinun kirjoittaa jäsenen nimi kantaluokan nimen kanssa, kuten olemme edellä tehneetkin. Toiseksi, huomaa, että et kirjoita funktion parametrilistaa tai paluuarvon tyyppiä - ainoastaan jäsenen nimi. Tässä olemme käyttäneet using-esittelyä korvaamaan kantaluokan saantitavan hallintakomennon perityn jäsenfunktion yhteydessä - mutta sama tekniikka toimii myös perityn jäsenmuuttujan yhteydessä. Käytä yksinkertaisesti kantaluokan nimeä ja näkyvyysalueoperaattoria jäsenen nimen edellä. On mahdollista käyttää using-esittelyä myös korvaamaan alkuperäiset public- ja protectedsaantitavan hallintakomennot. Eli näin voit väljentää luokan jäsenen saantitapaa periytetyssä luokassa - tai tiukentaa. Jos esimerkiksi tilavuus()-funktio olisi suojattu Laatikko-luokassa, voisit tehdä sen julkiseksi periytetyssä Paketti-luokassa vastaavanlaisella using-esittelyllä kuin edellä esitettiin.

19 Periytyminen Huomaa, että et voi käyttää using-esittelyä tällä tavalla kantaluokan yksityiselle jäsenelle, koska yksityisiä jäseniä ei voi käsitellä periytetyssä luokassa. Kun nyt tiedämme, miten kantaluokan jäseniä piilotetaan ja niihin päästään silti käsiksi periytetystä luokasta, palataan muodostinfunktioihin. Muodostinfunktioiden toiminta periytetyssä luokassa Vaikka esimerkeissämme 15.2 ja 15.3 kantaluokan oletusmuodostinfunktiota kutsuttiin automaattisesti, näin ei aina tarvitse olla. Voimme järjestää kutsun siten, että periytetyn luokan muodostinfunktiosta kutsutaan jotain tiettyä kantaluokan muodostinfunktiota. Näin voimme alustaa kantaluokan jäsenmuuttujat jollain muulla kuin oletusarvoilla. Näin voimme myös valita haluamamme kantaluokan muodostinfunktion, riippuen periytetyn luokan muodostinfunktiolle välitetystä datasta. Kokeile itse - Kantaluokan muodostinfunktio Voimme havainnollistaa tätä muuntamalla hieman esimerkin 15.3 ohjelmaa. Annamme tulostuslausekkeiden olla edelleen muodostinfunktioissa. Lisäämme PahviLaatikko-luokkaan toisen muodostinfunktion, jonka avulla voit määritellä olion mitat. Tämän funktion avulla havainnollistamme, kuinka voimme kutsua kantaluokan muodostinfunktiota eksplisiittisesti. Muuta PahviLaatikko-luokan määrittely seuraavanlaiseksi: class PahviLaatikko : public Laatikko public: // Muodostinfunktio, joka voi toimia myös oletusmuodostinfunktiona - // kutsuu kantaluokan oletusmuodostinfunktiota automaattisesti PahviLaatikko(const char* pstr = "Pahvi"); // Muodostinfunktio, joka eksplisiittisesti kutsuu kantaluokan // muodostinfunktiota PahviLaatikko(double lv, double bv, double hv, const char* pstr = "Pahvi"); ~PahviLaatikko(); // Tuhoajafunktio //Funktio, joka laskee PahviLaatikko-olion tilavuuden double tilavuus() const; protected: char* pmateriaali; ; Kuten aina, funktioiden määrittelyt ovat PahviL.cpp-tiedostossa: // PahviL.cpp #include "PahviL.h" #include <cstring> #include <iostream> using namespace std; 595

20 C++ Ohjelmoijan käsikirja // Muodostinfunktio, joka voi toimia myös oletusmuodostinfunktiona - // kutsuu kantaluokan oletusmuodostinfunktiota automaattisesti PahviLaatikko::PahviLaatikko(const char* pstr) pmateriaali = new char[strlen(pstr)+1]; // Varataan muisti merkkijonolle strcpy( pmateriaali, pstr); // Kopioidaan se cout << "PahviLaatikon muodostinfunktio 1" << endl; // Muodostinfunktio, joka eksplisiittisesti kutsuu kantaluokan // muodostinfunktiota PahviLaatikko::PahviLaatikko(double lv, double bv, double hv, const char* pstr) : Laatikko(lv, bv, hv) pmateriaali = new char[strlen(pstr)+1]; // Varataan muisti merkkijonolle strcpy( pmateriaali, pstr); // Kopioidaan se cout << "PahviLaatikon muodostinfunktio 2" << endl; // Tuhoajafunktio PahviLaatikko::~PahviLaatikko() delete[] pmateriaali; //Funktio, joka laskee PahviLaatikko-olion tilavuuden double PahviLaatikko::tilavuus() const return pituus*syvyys*korkeus; Jotta voimme seurata, milloin Laatikko-luokan oletusmuodostinfunktiota kutsutaan, muutamme määrittelyä lisäämällä erillisen oletusmuodostinfunktion: class Laatikko public: Laatikko(); Laatikko(double lv, double bv, double hv); //Oletusmuodostinfunktio // Muodostinfunktio protected: double pituus; double syvyys; double korkeus; ; Funktioiden määrittelyt sijoitetaan jälleen Laatikko.cpp-tiedostoon: // Laatikko.cpp #include "Laatikko.h" #include <iostream> using namespace std; 596 // Oletusmuodostinfunktio Laatikko::Laatikko() : pituus(1.0), syvyys(1.0), korkeus(1.0) cout << "Laatikon oletusmuodostinfunktio" << endl;

21 Periytyminen // Muodostinfunktio Laatikko::Laatikko(double lv, double bv, double hv) : pituus(lv), syvyys(bv), korkeus(hv) cout << "Laatikon muodostinfunktio" << endl; Kirjoitamme uuden version main()-funktiosta, jossa kutsutaan molempia PahviLaatikko-luokan muodostinfunktioita: // Esimerkki 15.4 kantaluokan muodostinfunktion kutsuminen periytetystä luokasta #include <iostream> #include "Laatikko.h" // Laatikko-luokka #include "PahviL.h" // PahviLaatikko-luokka using namespace std; int main() // Luodaan kaksi PahviLaatikko-oliota PahviLaatikko omapahviltk; PahviLaatikko karkkiltk(50.0, 30.0, 20.0, "Ohut pahvi"); cout << endl << "omapahviltk:n tilavuus on " << omapahviltk.tilavuus(); cout << endl << "karkkiltk:n tilavuus on " << karkkiltk.tilavuus() << endl; return 0; Ohjelman kääntäminen ja suorittaminen saa aikaan seuraavanlaisen tulostuksen: Laatikon oletusmuodostinfunktio PahviLaatikon muodostinfunktio 1 Laatikon muodostinfunktio PahviLaatikon muodostinfunktio 2 omapahviltk:n tilavuus on 1 karkkiltk:n tilavuus on Kuinka se toimii Muodostinfunktioissa olevat tulostuslauseet kertovat meille selkeästi tapahtumien järjestyksen. PahviLaatikko-olion omapahviltk kohdalla kääntäjä kutsuu ensin Laatikko-luokan oletusmuodostinfunktiota, jonka perään kutsutaan ensimmäistä PahviLaatikko-luokan muodostinfunktiota. Laatikko-luokan oletusmuodostinfunktion kutsu on automaattinen kutsu, joita olemme nähneet jo aikaisemminkin. Toisen PahviLaatikko-olion kohdalla Laatikko-luokan muodostinfunktiota kutsutaan PahviLaatikko-luokan toisen muodostinfunktion otsikossa olevan eksplisiittisen muodostinfunktion kutsun seurauksena: PahviLaatikko::PahviLaatikko(double lv, double bv, double hv, const char* pstr) : Laatikko(lv, bv, hv) Laatikko-luokan muodostinfunktion eksplisiittinen kutsu on periytetyn luokan otsikossa kaksoispisteen perässä. Kutsu kirjoitetaan vain muodostinfunktion määrittelyyn, ei prototyyppiin. PahviLaatikko-luokan muodostinfunktiolle välitetyt parametrit välitetään parametreinä myös kantaluokan muodostinfunktiolle. 597

22 C++ Ohjelmoijan käsikirja Olet jo saattanut huomatakin, että kantaluokan muodostinfunktion kutsun syntaksi on aivan sama kuin jäsenmuuttujien alustus muodostinfunktiossa. Olemme käyttäneet tätä syntaksia Laatikko-luokan muodostinfunktioissa. Se on täysin yhdenmukaista tässä tekemämme kanssa, koska olemme itse asiassa alustamassa PahviLaatikko-olion aliolion Laatikko käyttämällä PahviLaatikko-olion muodostinfunktiolle välitettyjä parametrejä. Alla oleva taulukko selventää, mitä kukin tulostuksen muodostinfunktion kutsu tarkoittaa: Ohjelman tulostus Laatikon oletusmuodostinfunktio PahviLaatikon muodostinfunktio 1 Laatikon muodostinfunktio PahviLaatikon muodostinfunktio 2 Luotu olio omaltk:n Laatikko -aliolio Loput omaltk-oliosta karkkiltk:n Laatikko -aliolio Loput karkkiltk-oliosta Kun periytetyn luokan olio luodaan, kantaluokan muodostinfunktiota tulee kutsua ennen periytetyn luokan muodostinfunktiota. Tämä on varsin yleinen sääntö. Kun luokkia on periytetty toisistaan useita peräkkäin, kaikkein yleisimmän kantaluokan muodostinfunktiota tulee kutsua ensin; muut muodostinfunktiot kutsutaan perimisjärjestyksessä, kunnes lopulta kutsutaan periytetyn luokan muodostinfunktiota. Vaikka kantaluokan jäsenmuuttujia, jotka eivät ole yksityisiä kantaluokkaan nähden, voidaan käsitellä periytetyssä luokassa, niitä ei voi alustaa periytetyn luokan alkuarvolistassa. Yritä esimerkiksi korvata toinen PahviLaatikko-luokan muodostinfunktio seuraavalla koodilla (sinun täytyy muuttaa vain tiedostoa PahviL.cpp): // muodostinfunktio, joka ei käänny PahviLaatikko::PahviLaatikko(double lv, double bv, double hv, const char* pstr) : pituus(lv), syvyys(bv), korkeus(hv) pmateriaali = new char[strlen(pstr)+1]; // Varataan muisti merkkijonolle strcpy( pmateriaali, pstr); // Kopioidaan se cout << "PahviLaatikon muodostinfunktio 2" << endl; Ensisilmäyksellä näyttää, että tämän tulisi toimia, koska pituus, syvyys ja korkeus ovat kantaluokan suojattuja jäseniä, jotka on peritty julkisesti - joten PahviLaatikko-luokan muodostinfunktion tulisi pystyä käsittelemään niitä. Kääntäjä kuitenkin valittaa, että pituus, syvyys ja korkeus eivät kuulu PahviLaatikko-luokkaan. Eli mitä tässä oikein tapahtuu? Vastaus on, että periytetyn luokan muodostinfunktio voi viitata kantaluokan suojattuihin jäseniin, mutta ei alkuarvolistassa - koska tässä kohtaa niitä ei ole vielä olemassa. Alkuarvolista käsitellään ennen kantaluokan muodostinfunktion kutsua, eli ennen kuin olion kantaosa on luotu. Jos haluat alustaa perityt jäsenmuuttujat eksplisiittisesti, sinun täytyy tehdä se muodostinfunktion rungossa. Eli voisit käyttää seuraavanlaista muodostinfunktion määrittelyä PahviL.cpp-tiedostossa: 598

23 Periytyminen // Tämä muodostinfunktio ei aiheuta ongelmia kääntäjässä PahviLaatikko::PahviLaatikko(double lv, double bv, double hv, const char* pstr) pituus = lv; syvyys = bv; korkeus = hv; pmateriaali = new char[strlen(pstr)+1]; // Varataan muisti merkkijonolle strcpy( pmateriaali, pstr); // Kopioidaan se cout << "PahviLaatikon muodostinfunktio 2" << endl; Kun muodostinfunktion runkoa suoritetaan, olion kantaosa on jo luotu. Tässä PahviLaatikkoolion kantaosa luodaan kantaluokan oletusmuodostinfunktion automaattisella kutsulla. Voimme viitata kantaluokan ei-yksityisen jäsenen nimeen ilman ongelmia. Periytetyn luokan kopiomuodostin Olemme jo nähneet mitä tapahtuu, kun käyttäjän määrittelemän luokan olio esitellään ja alustetaan toisella saman luokan oliolla. Tarkastellaan nyt seuraavia lauseita: Laatikko omaltk(2.0, 3.0, 4.0); Laatikko kopioltk(omaltk); //Kutsuu muodostinfunktiota //Kutsuu kopiomuodostinta Tässä esittelemme Laatikko-olion omaltk, mutta kiinnostavampi lause on jälkimmäinen lause, jossa olio kopioltk esitellään ja alustetaan. Luvussa 13 näimme, kuinka tällaisessa tapauksessa kääntäjä kutsuu automaattisesti kopiomuodostinta. Esimerkissä 12.5 näimme myös, että jos et ole määritellyt Laatikko-luokalle omaa kopiomuodostinta, kääntäjä muodostaa oletuskopiomuodostimen, joka luo uuden olion kopioimalla alkuperäisen olion jäsen jäseneltä. Tarkastellaan kopiomuodostimia nyt periytetyn luokan kohdalla. Teemme tässä lisäyksiä esimerkin 15.4 luokkiin. Ensiksi lisäämme Laatikko-kantaluokkaan kopiomuodostimen lisäämällä seuraavan koodin Laatikko.cpp-tiedostoon: // Kopiomuodostin Laatikko::Laatikko(const Laatikko& altk) : pituus(altk.pituus), syvyys(altk.syvyys), korkeus(altk.korkeus) cout << "Laatikon kopiomuodostinta kutsuttu" << endl; Palauta mieleen luvusta 13, että kopiomuodostimen parametrin tulee olla viittaus. Tämä alustaa jäsenmuuttujat yksinkertaisesti kopioimalla alkuperäiset arvot ja tulostaa viestin, jonka avulla voimme seurata, milloin Laatikko-luokan kopiomuodostinta kutsutaan. Meidän tulee lisäksi lisätä kopiomuodostimen prototyyppi Laatikko-luokan määrittelyn julkiseen osaan Laatikko.h-tiedostossa: Laatikko::Laatikko(const Laatikko& altk); //Kopiomuodostin 599

24 C++ Ohjelmoijan käsikirja Lisäämme kopiomuodostimen myös PahviLaatikko-luokkaan. Ensimmäiseksi yritämme lisätä seuraavan määrittelyn PahviL.cpp-tiedostoon: // Kopiomuodostin PahviLaatikko::PahviLaatikko(const PahviLaatikko& apahviltk) pmateriaali = new char[strlen(apahviltk.pmateriaali)+1]; strcpy(pmateriaali, apahviltk.pmateriaali); cout << "PahviLaatikon kopiomuodostin" << endl; Meidän tulee tietysti lisätä funktion prototyyppi luokan määrittelyyn tiedostossa PahviL.h: PahviLaatikko(const PahviLaatikko& apahviltk); //Kopiomuodostin Itse asiassa PahviLaatikko-luokan kopiomuodostin on tärkeä, koska luokka sisältää jäsenmuuttujan pmateriaali, joka on osoitin. Kopiomuodostimemme täytyy kopioida osoittimen pmateriaali osoittama merkkijono. Pelkkä osoittimen kopiointi ei riitä, koska tällöin alkuperäinen ja kopio sisältävät osoittimen, joka osoittaa samaan merkkijonoon - ja kun toinen olio tuhotaan, merkkijono tuhotaan myös ja jäljellä olevan olion osoitin on käyttökelvoton. Katsotaan kuinka tämä toimii käytännössä. Kokeile itse - Kopiomuodostin periytetyssä luokassa Voimme testata juuri määrittelemäämme kopiomuodostinta luomalla PahviLaatikko-olion ja kopioimalla sen: // Esimerkki Kopiomuodostimen käyttö periytetyssä luokassa #include <iostream> #include "Laatikko.h" // Laatikko-luokka #include "PahviL.h" // PahviLaatikko-luokka using namespace std; int main() PahviLaatikko karkkiltk(20.0, 30.0, 40.0, "Ohut pahvi"); // Esittely ja alustus PahviLaatikko kopioltk(karkkiltk); // Käytetään kopiomuodostinta cout << endl << "karkkiltk:n tilavuus on " << karkkiltk.tilavuus() << endl << "kopioltk:n tilavuus on " << kopioltk.tilavuus() << endl; return 0; 600

25 Periytyminen Esimerkin tulostus on seuraava: Laatikon muodostinfunktio PahviLaatikon muodostinfunktio 2 Laatikon oletusmuodostinfunktio PahviLaatikon kopiomuodostin karkkiltk:n tilavuus on kopioltk:n tilavuus on 1 Kuinka se toimii (tai ei toimi) Tulostuksen ylimalkainen tutkimuskin osoittaa jo, että kaikki ei ole niin kuin pitäisi. Selvästikin kopioltk:n tilavuus ei ole sama kuin karkkiltk:n. Tämähän on outoa, sillä kopioltk on karkkiltk:n kopio. Tulostus kertoo myös syyn tähän. Kopioidaksemme karkkiltk:n, kutsumme PahviLaatikko-luokan kopiomuodostinta. Kopioinnin aikana PahviLaatikko-luokan kopiomuodostimen tulee tehdä kopio karkkiltk-olion Laatikko-alioliosta. Tämän tehdäkseen sen tulee kutsua Laatikko-luokan kopiomuodostinta. Tulostuksesta näemme kuitenkin, että Laatikko-luokan oletusmuodostinfunktiota kutsuttiin. PahviLaatikko-luokan kopiomuodostin ei kutsu Laatikko-luokan kopiomuodostinta, koska emme pyydä sitä tekemään niin. Kääntäjä kyllä tietää, että sen tulee luoda Laatikko-olio kopioltk:n aliolioksi, mutta emme kerro, miten se tulee tehdä, eikä kääntäjä voi arvuutella tarkoitustamme. Se pystyy vain luomaan oletuskantaolion. Kun kirjoitat periytetyn luokan muodostinfunktiota, muista, että sinun tulee itse huolehtia siitä, että perityt jäsenet alustetaan oikein. Tähän kuuluu kaikki perityt jäsenet sekä periytetyn luokan omat jäsenet. Tämän virheen voimme korjata kutsumalla Laatikko-luokan kopiomuodostinta PahviLaatikkoluokan kopiomuodostimen alkuarvolistassa. Muuta PahviL.cpp-tiedostossa oleva kopiomuodostimen määrittely seuraavanlaiseksi: // Kopiomuodostin PahviLaatikko::PahviLaatikko(const PahviLaatikko& apahviltk) : Laatikko(aPahviLtk) pmateriaali = new char[strlen(apahviltk.pmateriaali)+1]; strcpy(pmateriaali, apahviltk.pmateriaali); cout << "PahviLaatikon kopiomuodostin" << endl; Nyt Laatikko-luokan kopiomuodostinta kutsutaan parametrillä apahviltk. Olio apahviltk on tyyppiä PahviLaatikko, mutta Laatikko-luokan kopiomuodostimen parametri on viittaus Laatikko-olioon. Kääntäjä suorittaa muunnon apahviltk-oliolle - tyypistä PahviLaatikko tyyppiin Laatikko - jonka tuloksena on apahviltk-olion kantaosa, joka välitetään Laatikko-luokan kopiomuodostimelle. Jos nyt käännät ja suoritat esimerkin uudelleen, tulostus näyttää seuraavalta: Laatikon muodostinfunktio PahviLaatikon muodostinfunktio 2 Laatikon kopiomuodostinta kutsuttu PahviLaatikon kopiomuodostin 601