Oppaat: C++-ohjelmointi: Osa 9 - Luokkien perusteet

#include <iostream>

// Tällä yksinkertaisella luokalla on kaksi jäsenmuuttujaa
// ja kaksi jäsenfunktiota.
struct luokka {
	int a, b;

	// Tämä funktio asettaa jäsenten arvot.
	void aseta(int a2, int b2) {
		// Olion jäsenmuuttujat ovat jäsenfunktion käytettävissä.
		a = a2;
		b = b2;
	}

	// Tämä funktio laskee jäsenten summan. Funktio ei muokkaa olion
	// sisältöä, joten se on hyvä merkitä const-sanalla.
	int summa() const {
		// Osoitin this osoittaa olioon, josta funktiota kutsutaan.
		// Jäseniä voi halutessaan käyttää myös this-osoittimen kautta.
		return this->a + this->b;
	}
};

// Olio-ohjelmointiin ei välttämättä tarvita olioita ja luokkia, vaan
// samanlaiset funktiot voisi toteuttaa luokan ulkopuolellakin.
// Jäsenfunktio saa automaattisesti osoittimen käsiteltävään olioon,
// ulkoiselle funktiolle osoitin täytyy erikseen määritellä parametriksi.
// Huomaa const-sanan paikka: nyt osoitinta ei voi muuttaa mutta jäseniä voi!
void ulkoasetus(luokka* const this2, int a2, int b2) {
	this2->a = a2;
	this2->b = b2;
}

// Jäsenfunktion perässä on const, kun se ei muokkaa luokan jäseniä.
// Tämä ulkoinen funktio ei myöskään muokkaa tietueen jäseniä, joten
// parametrina on const-osoitin const-luokkaan.
int ulkosumma(const luokka* const this2) {
	return this2->a + this2->b;
}

int main() {
	// Luodaan kaksi samanlaista oliota. Tehdään sitten samat asiat
	// s:lle jäsenfunktioilla ja u:lle ulkoisilla.
	luokka u, s;

	// Olion jäsenfunktiota kutsutaan samalla pistemerkinnällä, jolla
	// myös tietueen jäseniä käytetään. Asetetaan s.x = 1 ja s.y = 2.
	s.aseta(1, 2);

	// Jäsenfunktion kutsu antaa funktiolle käsiteltävän olion osoittimen.
	// Saman voi tehdä ulkoisella funktiolla tavalliselle tietueelle, kun
	// vain antaa osoittimen (tai viittauksen) funktiolle parametrina.
	// Asetetaan u.x = 1 ja u.y = 2.
	ulkoasetus(&u, 1, 2);

	if (s.summa() == ulkosumma(&u)) {
		std::cout
			<< "Kaksi tapaa, yksi lopputulos."
			<< std::endl
			<< "Olio-ohjelmointi onnistuu ilmankin luokkia!"
			<< std::endl;
	}
}

#include <iostream>
#include <cmath>

// Esitellään jana eli kerrotaan, että sellainen on olemassa.
struct jana;

// Määritellään piste.
struct piste {
	// Pisteen koordinaatit:
	float x, y;

	// Määritellään jäsenfunktio, joka laskee etäisyyden toiseen pisteeseen.
	// Funktiolla on automaattisesti käytössään yhden pisteen jäsenet, ja
	// parametrina on viittaus toiseen pisteeseen. Viimeinen const
	// tarkoittaa, että myös olio itse säilyy funktiossa muuttumattomana.
	float etaisyys(const piste& p2) const {
		// Lasketaan koordinaattien muutokset.
		// x ja y ovat tämän pisteen jäsenet, p2.x ja p2.y toisen.
		float dx = x - p2.x;
		float dy = y - p2.y;

		// Lasketaan etäisyys Pythagoraan lauseen avulla.
		// a*a + b*b = c*c   =>   c = sqrt(a*a + b*b)
		return std::sqrt(dx * dx + dy * dy);
	}

	// Esitellään jäsenfunktio, joka luo janan. Paluuarvona on siis jana,
	// parametrina toinen päätepiste. Tätä varten jana-luokka piti esitellä
	// jo ennen piste-luokkaa. Funktiota ei voi kuitenkaan toteuttaa, koska
	// jana-luokka on yhä määrittelemättä.
	jana yhdista(const piste& p2) const;
};

// Määritellään jana.
struct jana {
	// Janan päätepisteet:
	piste a, b;

	// Määritellään jäsenfunktio, joka laskee janan pituuden.
	float pituus() const {
		// Hyödynnetään pisteen etäisyyttä toisesta.
		// Jäsenfunktion kutsu muistuttaa tavallista funktiokutsua,
		// mutta alussa kerrotaan, minkä olion funktiota kutsutaan.
		// Nyt kutsutaan siis janan pisteen a funktiota.
		return a.etaisyys(b);
	}

	// Määritellään jäsenfunktio, joka venyttää janan kaksinkertaiseksi.
	// Tämän funktion lopussa ei voi olla const-määrettä, koska tämä
	// muuttaa janaa itseään!
	void kaksinkertaista() {
		float dx = b.x - a.x;
		float dy = b.y - a.y;
		a.x -= dx / 2;
		b.x += dx / 2;
		a.y -= dy / 2;
		b.y += dy / 2;
	}
};

// Nyt jana on määritelty, joten toteutetaan pisteen puuttuva jäsenfunktio.
// Tässä tilanteessa täytyy erikseen mainita, minkä luokan jäsenestä on kyse.
jana piste::yhdista(const piste& p2) const {
	// Luodaan ja palautetaan jana tästä pisteestä ja toisesta.
	// Luokkien jäsenfunktioissa this on osoitin olioon, josta
	// funktiota on kutsuttu. Sitä voidaan siis käyttää, jos nykyistä
	// oliota pitää pystyä käyttämään kokonaisena piste-oliona kuten nyt.
	jana j = {*this, p2};
	return j;
}

int main() {
	// Luodaan pisteet (2.1, 5.2) ja (4.1, 6.7). Pisteitä ei tarvitse
	// muuttaa myöhemmin, joten määritellään ne vakioiksi.
	const piste a = {2.1, 5.2}, b = {4.1, 6.7};

	// Luodaan jana pisteestä a pisteeseen b jäsenfunktion avulla.
	// Janaa muokataan vielä, joten se ei voi olla vakio.
	jana j = a.yhdista(b);

	// Tulostetaan janan tiedot ja kasvatetaan janaa kolmesti.
	// Janan pituus lasketaan jäsenfunktion avulla,
	// ja samoin tapahtuu kasvattaminenkin.
	for (int i = 0; i < 3; ++i) {
		std::cout
			<< "Jana alkaa pisteestä (" << j.a.x << ", " << j.a.y << ")"
			<< " ja päättyy pisteeseen (" << j.b.x << ", " << j.b.y << ")"
			<< "." << std::endl;
		std::cout << "Janan pituus on " << j.pituus() << "." << std::endl;
		j.kaksinkertaista();
	}
}

struct S {
	// Jäsenfunktio:
	void f() {
		// Käytetään jäsenmuuttujaa x.
		x = 10;
	}
	// Jäsenmuuttuja esitellään kuitenkin vasta täällä!
	int x;
};

// Esitellään luokka. Muuten sen nimi olisi tuntematon ja aiheuttaisi virheen.
struct yritys;

// Tämän funktion parametrina on viittaus yritys-tyyppiseen olioon.
void hylatty(yritys& y) {
	// Tässä yritetään käyttää olion jäsentä. Tämä on virhe,
	// koska olion jäseniä ei ole vielä esitelty!
	y.arvosana = 0;
}

// Jäsenet esitellään vasta luokan määrittelyssä.
struct yritys {
	int arvosana;
};

// Tämä funktio toimii, koska luokka määriteltiin juuri yllä.
void onnistunut(yritys& y) {
	y.arvosana = 5;
}

#include <iostream>
#include <string>

struct salaisuus {
	// julkisia:
	int julkinen;
private:
	// yksityisiä:
	int yksityinen;
	int salafunktio() const {
		return 123;
	}
protected:
	// suojattuja:
	int suojattu;
public:
	// julkisia (taas):
	int julkkis;

	// Lisätään luokalle ystäväksi funktio ja toinen luokka.
	// Rivit vastaavat esittelyjä, mutta edessä on sana friend.
	friend struct media;
	friend void muuta(salaisuus& s);
};

// Tämä luokka saa käyttää salaisuuden kaikkia osia.
struct media {
	std::string nimi;
	void kerro(const salaisuus& s) {
		std::cout
			<< nimi << " paljastaa: "
			<< s.yksityinen << ", "
			<< s.salafunktio() << std::endl;
	}
};

// Tämä funktio saa käyttää salaisuuden kaikkia osia.
void muuta(salaisuus& s) {
	s.yksityinen = 112358;
	s.suojattu = 314159;
}

// Muut eivät saa käyttää kuin julkisia osia.
int main() {
	salaisuus s;
	muuta(s);
	media m = {"Salainen media"};
	m.kerro(s);
	// s.suojattu = 0; // VIRHE! Kokeile, mitä kääntäjä sanoo.
}

struct S {
private:
	int a;
public:
	int b;
	void f();
};

class C {
	int a; // private
public:
	int b;
	void f();
};