Oppaat: C++-ohjelmointi: Osa 8 - Mallit

int itseisarvo(int x) {
	// Negatiivisen luvun itseisarvo on sen vastaluku.
	if (x < 0) {
		return -x;
	}
	// Muuten itseisarvo on luku itse.
	return x;
}

#include <iostream>

// Mallin parametrina on jokin tietotyyppi. Parametrin nimi on T.
template <typename T>
// Itse funktio kirjoitetaan nyt niin, että tietotyyppinä ei ole int vaan T.
T itseisarvo(T x) {
	// Negatiivisen luvun itseisarvo on sen vastaluku.
	if (x < 0) {
		return -x;
	}
	// Muuten itseisarvo on luku itse.
	return x;
}

int main() {
	int luku;
	std::cout << "Anna kokonaisluku: ";
	std::cin >> luku;
	// Käytetään mallia. Annetaan sille argumenttina int; mallista
	// muodostuu funktio, jossa T on korvattu todellisella tyypillä int.
	int tulos = itseisarvo<int>(luku);
	std::cout << "Luvun itseisarvo on " << tulos << std::endl;

	float liukuluku;
	std::cout << "Anna liukuluku: ";
	std::cin >> liukuluku;
	// Tällä kertaa annetaan kääntäjän valita oikea versio funktiosta.
	// Koska funktiolle annettava argumentti on tyypiltään float,
	// kääntäjä käyttää automaattisesti funktiota itseisarvo<float>
	// eli korvaa mallista T:n tyypillä float.
	float liukutulos = itseisarvo(liukuluku);
	std::cout << "Luvun itseisarvo on " << liukutulos << std::endl;
}

#include <iostream>

// Funktio ottaa kaksi samanlaista lukua ja palauttaa pienemmän.
template <typename T>
T pienempi(T x, T y) {
	if (x < y) {
		return x;
	}
	return y;
}

int main() {
	int a, b;
	std::cout << "Anna luku A: ";
	std::cin >> a;
	std::cout << "Anna luku B: ";
	std::cin >> b;

	// Otetaan liukuluku A:n ja B:n väliltä.
	float c = (a + b) / 2.0 + 0.2;
	std::cout << "C:n arvo on  " << c << std::endl;

	// Parametrit ovat int-tyyppisiä, joten kaikki on selvää.
	std::cout << "Pienempi luvuista A ja B on " << pienempi(a, b) << std::endl;
	// Jos float erityisesti muutetaan int-tyyppiseksi, tilanne on yhä sama.
	std::cout << "Pienempi luvuista A ja (int) C on " << pienempi(a, (int) c) << std::endl;

	// Seuraavaksi tulee virhe: kääntäjä ei tiedä, olisiko T int vai float!
	// Kokeile, millaisen viestin kääntäjäsi tästä virheestä antaa.
	//std::cout << "Pienempi luvuista A ja C on " << pienempi(a, c) << std::endl;

	// Kerrotaan kääntäjälle, että halutaan float-versio.
	std::cout << "Pienempi liukuluvuista A ja C on " << pienempi<float>(a, c) << std::endl;
	std::cout << "Pienempi liukuluvuista B ja C on " << pienempi<float>(b, c) << std::endl;

	// Kerrotaan kääntäjälle, että halutaan int-versio.
	std::cout << "Pienempi kokonaisluvuista A ja C on " << pienempi<int>(a, c) << std::endl;
	std::cout << "Pienempi kokonaisluvuista B ja C on " << pienempi<int>(b, c) << std::endl;
}

template <typename koordinaatti>
struct piste {
	koordinaatti x, y;
};

/*
 * Nyt esimerkiksi piste<int> vastaa tyyppiä, jolla on int-jäsenet x ja y.
struct piste_int {
	int x, y;
};
*/

// Määritellään kaksi muuttujaa. Tietuemalleille täytyy itse antaa oikea
// tyyppi argumenttina, koska kääntäjä ei voi päätellä sitä mistään.
// Pisteen a koordinaatit ovat kokonaislukuja:
piste<int> a,

// Pisteen b koordinaatit ovat liukulukuja:
piste<float> b;

#include <iostream>

// Tällä mallilla on kaksi parametria, ja tietueeseen tulee kaksi jäsentä.
// T:n oletusarvo on float, ja U:n oletusarvo on T.
template <typename T = float, typename U = T>
struct pari {
	T a;
	U b;
};

// Nimetään typedef-riveillä muutama uusi tyyppi.
// pari<> olkoon piste_ab. Koska T = float ja U = T, jäsenet ovat float-tyyppisiä.
typedef pari<> piste_ab;

// pari<piste_ab> olkoon jana. T = piste_ab ja U = T.
typedef pari<piste_ab> jana;

// Tämä mallifunktio tulostaa saamansa arvon. Jos mallia yritetään käyttää
// sellaisella tyypillä T, ettei sitä voi tulostaa totuttuun tapaan, ohjelma
// ei käänny. Tämän funktion ei ole tarpeen muuttaa parametriaan, joten
// käytetään viittausta ja const-sanaa.
template <typename T>
void tulosta(const T& t) {
	std::cout << t;
}

// Tehdään myös kuormitettu malli, joka osaa tulostaa pareja.
// Nyt malliparametrit välitetään edelleen pari-mallille.
// Kun tulosta-funktiota kutsutaan pari-tyyppisellä parametrilla,
// kääntäjä käyttää tätä mallia ja päättelee T:n ja U:n arvot
// tulostettavan parin perusteella.
template <typename T, typename U>
void tulosta(const pari<T, U>& p) {
	// Tulostetaan rekursiivisesti a ja b muodossa (a, b)
	// Jos a tai b on pari, kutsutaan tätä samaa funktiota uudestaan.
	// Muuten kutsutaan tulosta-funktiota, joka tulostaa suoraan arvon.
	std::cout << "(";
	tulosta(p.a);
	std::cout << ", ";
	tulosta(p.b);
	std::cout << ")";
}

int main() {
	// Janassa on kaksi päätepistettä, joilla on kaksi koordinaattia.
	jana j = {{1.3, 2.7}, {3.015, 4.945}};
	j.a.a = 6.21;

	// Tulostetaan jana. Kääntäjä valitsee jälkimmäisen mallin; se
	// sopii paremmin parametrin tyyppiin (pari-mallista luotu jana).
	// Tämä funktio tulostaa pista_ab-tyyppiset jäsenet, jotka myös
	// tulostetaan pari-malliinerikoistuneella versiolla.
	// Pisteen jäsenet ovat kuitenkin float-tyyppisiä, joten niihin
	// käytetäänkin ensimmäistä mallia.
	std::cout << "Jana: ";
	tulosta(j);
	// Janan tulostaminen tapahtuu seuraavan kaavion mukaan:
	// tulosta(j):
	//     tulosta(j.a):
	//         tulosta(j.a.a): 6.21
	//         tulosta(j.a.b): 2.7
	//     tulosta(j.b):
	//         tulosta(j.b.a): 3.015
	//         tulosta(j.b.b): 4.945
	// Loppuun on hyvä tulostaa rivinvaihto; tulosta-funktio ei sitä tee.
	std::cout << std::endl;

	// Mallin parametreille voi antaa myös eri arvot.
	// Luodaan pari, jossa on kokonaisluku ja tekstiä. Laitetaan luvuksi
	// vaadittava pistemäärä ja tekstiksi arvomerkissä komeileva eläin.
	pari<int, std::string> merkit[] = {
		{10, "papukaija"},
		{22, "leppäkerttu"},
		{8, "hämähäkki"},
	};
	const int maara = sizeof(merkit) / sizeof(merkit[0]);
	for (int i = 0; i < maara; ++i) {
		std::cout << merkit[i].a << " pistettä ja " << merkit[i].b << "merkki!" << std::endl;
	}
}