Koodit: C++: Operaattorien ylikuormitus; 3D-vektoriluokka

// Neliöjuurta varten matematiikkaotsikko
#include <cmath>

// Toiseen korotusta varten funktio
template <typename T>
inline T pow2(T x) {
	return x * x;
}

// Vektoriluokka
class vektori {
	// Itse vektori: v = xi + yj + zk
	double x, y, z;

public:
	// Muodostimet: nollavektori tai määrätty vektori
	vektori() : x(0), y(0), z(0) {}
	vektori(double _x, double _y, double _z) : x(_x), y(_y), z(_z) {}

	// Vastavektori; const tarkoittaa, ettei alkuperäisen vektorin arvo muutu
	vektori operator - () const {
		// Palautetaan uusi vektori, jonka komponentit ovat vastakkaiset
		return vektori(-x, -y, -z);
	}

	// Peruslaskutoimitukset
	vektori operator + (vektori const& t) const {
		return vektori(x + t.x, y + t.y, z + t.z);
	}
	vektori operator - (vektori const& t) const {
		return vektori(x - t.x, y - t.y, z - t.z);
	}

	// Kertominen ja jakaminen luvulla
	vektori operator * (double t) const {
		return vektori(x * t, y * t, z * t);
	}
	vektori operator / (double t) const throw (char const*) {
		if (!t) throw "Jaoit nollalla!";
		return vektori(x / t, y / t, z / t);
	}

	// Pistetulo;
	// Sama * kelpaa kuin luvun kanssa kerrottaessa.
	// Kääntäjä valitsee oikean vaihtoehdon sen mukaan,
	// onko oikealla luku vai toinen vektori.
	double operator * (vektori const& t) const {
		return x * t.x + y * t.y + z * t.z;
	}

	// Ristitulo;
	// Käytetään %:ta, kun se on kätevästi vapaana.
	vektori operator % (vektori const& t) const {
		return vektori(
			y * t.z - z * t.y,
			z * t.x - x * t.z,
			x * t.y - y * t.x
		);
	}

	// Funktio vektorin pituutta varten
	double len_sqr() const {
		// Pistetulo v * v on vektorin v pituuden neliö
		return (*this) * (*this);
	}
	double len() const {
		// Pituus on pituuden neliön neliöjuuri.
		return std::sqrt(len_sqr());
	}

	// Normalisoitu eli yhden yksikön pituinen vektori
	vektori norm() const {
		return *this / len();
	}

	// Vektorin muunto luvuksi palauttakoon pituuden.
	// Tarkkana siis, ettei tule virheellisiä sijoituksia!
	operator double () const {
		return len();
	}
};

// Jäsenfunktioihin sisältyy vasta "vektori * double"
// Toisin päin operaattori täytyy määritellä ulkopuolella
vektori operator * (double luku, vektori const& v) {
	// Turha sitä on uudestaan naputella, kun vaihdantalaki pätee
	return v * luku;
}
// Jakolaskua toisin päin ei olekaan.

int main(void) {
	// Oletusmuodostin nollaa kaiken
	vektori nollavektori;
	// Vektorin voi myös määritellä tässä
	vektori a(1,1,1), b(1,2,3);
	// Muodostin c(a) luo c:n kopioimalla a:sta.
	vektori c(a);
	double d = 10;

	c = -a;    // Vastavektori
	c = a + b; // Vektorien summa
	c = a - b; // Vektorien erotus
	d = a * b; // (vektori * vektori) eli jäsenfunktion pistetulo-operaattori
	c = a * d; // (vektori * luku) eli jäsenfunktion kertolaskuoperaattori
	c = d * a; // (luku * vektori) eli erillinen kertolaskuoperaattori
	c = d * a; // Kertominen luvulla toisin päin
	c = a / d; // Jakaminen luvulla
	c = a % b; // Ristitulo
	d = a;     // Pituus operaattorin avulla

	// Mutkikkaammatkin lausekkeet onnistuvat:
	// Skalaarikolmitulo
	d = a % b * c;
	d = a * (b % c); // Näin päin sulut tarpeen!

	// Pistettä avaruudessa on hyvä kuvata paikkavektorilla.
	// Pisteen c etäisyys suorasta ab optimoituna:
	c = vektori(2, 0, 0);
	b = vektori();
	a = vektori(5, 5, 0);

	d = sqrt((c - a).len_sqr() - pow2((b - a) * (c - a)) / (b - a).len_sqr());

	return 0;
}