Oppaat: C++-ohjelmointi: Osa 11 - Luokkien perintä

#include <iostream>

// Kantaluokka on tapotavallinen luokka. Perintää silmällä pitäen voi kuitenkin
// miettiä, mitkä muuttujat ovat todella yksityisiä (private) ja julkisia (public)
// ja mitkä suojattuja (protected) eli aliluokkien kanssa jaettavia.
class suorakulmio {
protected:
	double leveys, korkeus;

public:
	suorakulmio(double l, double k): leveys(l), korkeus(k) {
	}

	double ala() const {
		return leveys * korkeus;
	}

	void tulosta() const {
		std::cout
			<< "Suorakulmion sivut ovat " << leveys << " ja " << korkeus
			<< " ja pinta-ala " << ala() << "." << std::endl;
	}
};

// Perintä merkitään luokan määrittelyyn kaksoispisteellä ja kantaluokan nimellä.
// Väliin voi laittaa suojamääreen; jos se puuttuu, oletus on sama kuin muillakin
// jäsenillä struct-sanan kanssa public ja class-sanan kanssa private.
class nelio: public suorakulmio {
public:
	// Aliluokka voi alustaa kantaluokan jäsenet kutsumalla
	// kantaluokan muodostinta alustuslistassa.
	nelio(double sivu): suorakulmio(sivu, sivu) {
	}

	// Aliluokka voi peittää kantaluokan jäsenen omallaan.
	void tulosta() const {
		// Aliluokka voi käyttää kantaluokan julkisia ja suojattuja jäseniä.
		std::cout
			<< "Neliön sivun pituus on " << leveys
			<< " ja pinta-ala " << ala() << "." << std::endl;
		// Aliluokka voi käyttää kantaluokasta myös piilotettuja jäseniä:
		suorakulmio::tulosta();
	}
};

int main() {
	suorakulmio s(3, 4);
	nelio n(5);

	// Kantaluokassa ei ole edelleenkään mitään uutta.
	std::cout << "s.tulosta():" << std::endl;
	s.tulosta();

	// Aliluokassa on samanniminen funktio kuin kantaluokassa,
	// mutta kutsu tapahtuu aivan normaalisti.
	std::cout << "n.tulosta():" << std::endl;
	n.tulosta();

	// Aliluokasta voi kutsua myös kantaluokan funktiota,
	// kunhan erikseen vaatii.
	std::cout << "n.suorakulmio::tulosta():" << std::endl;
	n.suorakulmio::tulosta();

	// Kun aliluokassa ei ole samannimistä funktiota,
	// kantaluokan funktiot ovat suoraan aliluokastakin käytössä.
	std::cout << "n.ala() " << (n.ala() < s.ala() ? "<" : ">=") << " s.ala()." << std::endl;
}

#include <iostream>

struct kanta {
	void funktio() const {
		std::cout << "kanta::funktio()" << std::endl;
	}
};

struct piilottaja: kanta {
	void funktio(char c) const {
		std::cout << "piilottaja::funktio('" << c << "')" << std::endl;
	}
};

struct kayttaja: kanta {
	using kanta::funktio;
	void funktio(char c) const {
		std::cout << "kayttaja::funktio('" << c << "')" << std::endl;
	}
};

int main() {
	piilottaja piilottaja;
	kayttaja kayttaja;

	// Aliluokkien omat funktiot toimivat aivan tavalliseen tapaan.
	piilottaja.funktio('x');
	kayttaja.funktio('x');

	// Kantaluokan funktioon pääsee yhä käsiksi, kun pyytää.
	piilottaja.kanta::funktio();
	kayttaja.kanta::funktio();

	// Kun aliluokassa ei ole using-esittelyä, sen oma funktio piilottaa
	// kantaluokan funktion, jolloin funktiota ei voi suoraan käyttää.
	std::cout << "piilottaja.funktio() => VIRHE!" << std::endl;
	// piilottaja.funktio();

	// Sen sijaan using-esittelyn kanssa kutsu menee kantaluokan funktiolle.
	std::cout << "kayttaja.funktio() => ";
	kayttaja.funktio();
}

#include <iostream>

// Tämä luokka on abstrakti.
struct kuvio {
	// Tällä virtuaalifunktiolla on valmis toteutus.
	virtual void tulosta() const {
		std::cout
			<< "Erään kuvion ala on " << ala()
			<< " ja piiri on " << piiri() << "." << std::endl;
	}

	// Näillä funktioilla ei ole toteutusta lainkaan.
	// Ne ovat siis puhtaasti virtuaalisia.
	virtual double ala() const = 0;
	virtual double piiri() const = 0;
};

// Tämä luokka perii kuvio-luokan ominaisuudet.
// Jotta luokkaa voi käyttää, puhtaasti virtuaaliset funktiot täytyy toteuttaa.
struct suorakulmio: kuvio {
	double leveys, korkeus;

	suorakulmio(double l0, double k0): leveys(l0), korkeus(k0) {
	}

	// Nämä funktiot ovat kuvio-luokassa määriteltyjen
	// puhtaasti virtuaalisten funktioiden toteutukset.
	// Sanaa virtual ei tarvitse toistaa, vaan se käy ilmi kantaluokasta.
	double ala() const {
		return leveys * korkeus;
	}
	double piiri() const {
		return 2 * (leveys + korkeus);
	}
};

struct ympyra: kuvio {
	double sade;

	ympyra(double s0): sade(s0) {
	}

	// Ympyrän laskukaavat ovat erilaiset kuin suorakulmion.
	double ala() const {
		return pii() * sade * sade;
	}
	double piiri() const {
		return 2 * pii() * sade;
	}
	static double pii() {
		return 3.14159265358979323846;
	}

	// Ympyrä toteuttaa lisäksi oman version tulostuksesta.
	void tulosta() const {
		std::cout
			<< "Ympyrän säde on " << sade << ", ala on " << ala()
			<< " ja piiri on " << piiri() << "." << std::endl;
	}
};

int main() {
	// Luodaan suorakulmio-olio ja tulostetaan sen tiedot.
	suorakulmio(3, 4).tulosta();

	// Luodaan ympyra-olio ja tulostetaan sen tiedot.
	ympyra(5).tulosta();
}

// Samat luokat kuin yllä, sitten:
void tulosta(kuvio const& k) {
	std::cout << "Kuvion ala on " << k.ala() << " ja piiri on " << k.piiri() << "." << std::endl;
}

int main() {
	tulosta(suorakulmio(3, 4));
	tulosta(ympyra(5));
}

#include <iostream>

struct kantaluokka {
	// Tehdään luokasta polymorfinen.
	virtual ~kantaluokka() {
	}

	// Lisätään luokkaan ei-virtuaalinen funktio.
	int funktio() const {
		return 1;
	}
};

struct aliluokka: kantaluokka {
	int funktio() const {
		return 2;
	}
};

void testaa(const kantaluokka& kanta) {
	std::cout << "kanta.funktio() palauttaa " << kanta.funktio() << "." << std::endl;

	// dynamic_cast toimii kuin funktiomalli, jolle annetaan
	// malliargumentiksi uusi tyyppi ja argumentiksi muunnettava arvo.

	// Jos tyyppinä on osoitin, epäonnistunut muunnos palauttaa tyhjän.
	if (const aliluokka* a = dynamic_cast<const aliluokka*>(&kanta)) {
		std::cout << "a->funktio() palauttaa " << a->funktio() << "." << std::endl;
	} else {
		std::cout << "Osoitinmuunnos epäonnistui." << std::endl;
	}

	// Jos tyyppinä on viittaus, epäonnistunut muunnos aiheuttaa poikkeuksen.
	try {
		const aliluokka& a = dynamic_cast<const aliluokka&>(kanta);
		std::cout << "a.funktio() palauttaa " << a.funktio() << "." << std::endl;
	} catch (...) {
		std::cout << "Viittausmuunnos epäonnistui." << std::endl;
	}
}

int main() {
	std::cout << "testaa(kantaluokka());" << std::endl;
	testaa(kantaluokka());

	std::cout << "testaa(aliluokka());" << std::endl;
	testaa(aliluokka());
}

struct uusi: public kanta1, private kanta2, protected kanta3, public kanta4 {
	uusi(int x, int y, int z, int w): kanta1(x), kanta2(y), kanta3(z), kanta4(w) {
	}
};

#include <iostream>

struct elio {
	int numero;
	elio() {
		static int maara = 0;
		numero = ++maara;
		std::cout << "Luotiin ohjelman " << numero << ". eliö." << std::endl;
	}
};

// Tavallinen moniperintä: kaksi kantaluokkaa ja niistä peritty luokka.
struct lihansyoja: elio { /* ... */ };
struct kasvi: elio { /* ... */ };

struct outo_lihansyojakasvi: lihansyoja, kasvi {
	void tulosta() const {
		// Tässä lihansyöjäkasvissa on kaksi osaa: lihansyoja ja kasvi.
		// Molemmat osat ovat erillisiä elio-luokan ilmentymiä.
		std::cout
			<< "Meitähän on kaksi! "
			<< lihansyoja::numero << " + " << kasvi::numero << " = "
			<< (lihansyoja::numero + kasvi::numero) << std::endl;
	}
};

// Virtuaaliperintä: laitetaan sana virtual ennen kantaluokkaa.
struct virtuaalilihansyoja: virtual elio { /* ... */ };
struct virtuaalikasvi: virtual elio { /* ... */ };

// Tässä ohjelmassa riittää, että elio-luokka periytyy virtuaalisesti,
// joten tähän kohtaan ei enää tarvita virtual-sanaa.
struct virtuaalilihansyojakasvi: virtuaalilihansyoja, virtuaalikasvi {
	void tulosta() const {
		// Virtuaaliperinnän ansiosta on vain yksi elio-kanta,
		// joten numero on yksiselitteinen.
		std::cout << "Olen taatusti eliö numero " << numero << "." << std::endl;
	}
};

int main() {
	std::cout << "outo_lihansyojakasvi():" << std::endl;
	outo_lihansyojakasvi().tulosta();

	std::cout << "virtuaalilihansyojakasvi():" << std::endl;
	virtuaalilihansyojakasvi().tulosta();
}

#include <iostream>

// Hyvä kantaluokka: virtuaalinen tuhoaja.
struct oikea_kanta {
	oikea_kanta() {
		std::cout << "oikea_kanta()" << std::endl;
	}
	virtual ~oikea_kanta() {
		std::cout << "~oikea_kanta()" << std::endl;
	}
};

// Huono kantaluokka: ei virtuaalista tuhoajaa.
struct vaara_kanta {
	vaara_kanta() {
		std::cout << "vaara_kanta()" << std::endl;
	}
	~vaara_kanta() {
		std::cout << "~vaara_kanta()" << std::endl;
	}
};

// Molemmat kantaluokat perivä aliluokka; tuhoajasta tulee virtuaalinen, koska
// toisen kantaluokan tuhoaja on virtuaalinen.
struct aliluokka: oikea_kanta, vaara_kanta {
	aliluokka() {
		std::cout << "aliluokka()" << std::endl;
	}
	~aliluokka() {
		std::cout << "~aliluokka()" << std::endl;
	}
};

int main() {
	// Tuhotaan luokka aliluokkana. Tämä toimisi joka tapauksessa oikein.
	std::cout << "delete (aliluokka*) new aliluokka();" << std::endl;
	delete new aliluokka();

	// Luokalla oikea_kanta on virtuaalinen tuhoaja, joten tämä koodi
	// kutsuu aliluokan tuhoajaa, ja kaikki toimii yhä.
	std::cout << std::endl << "delete (oikea_kanta*) new aliluokka();" << std::endl;
	delete (oikea_kanta*) new aliluokka();

	// Luokalla vaara_kanta ei ole virtuaalista tuhoajaa, joten tämä koodi
	// ei kutsu lainkaan aliluokan omaa tuhoajaa!
	std::cout << std::endl << "delete (vaara_kanta*) new aliluokka();" << std::endl;
	delete (vaara_kanta*) new aliluokka();
}