Theorie

• Klassen
  
• Definition
• Konstruktoren & Destruktoren
• Operatoren
• friends, this, const

Klassen

• ähnlich zu den structs
• nur in C++ (nicht in C)
• bestehen aus : 
• member Variablen
• member Funktionen (= methods)
• members sind entweder
• private
• public

Definition

Objektdeklaration

• nach der Definition der Klasse ist sie als neuer Typ verfügbar
• man kann jetzt Variablen dieses Typs erstellen : Objekte

Complex number1;
Complex number2;

• wir können ausserdem die public member functions  aufrufen :  

number1.set(1,0);
number2.set(4.93,-1);

Member Funktionen implementieren

void Complex::set(double r, double i)
{
	real = r;
	imag = i;
}

Header Files

class Complex
{
private:
	double real;
	double imag;

public:
	void set(double r, double i);
};

• Body file
• complex.cpp
• includes complex.h
• Implementierung der member Funktionen

#include "complex.h"

void Complex::set(double r, double i);
{
	real = r;
	imag = i;
}

Konstruktor

• Wie initialisiert man Objekte?
• structs : 

Student stud = {"John", "Doe", 1324142}

• bei Klassen nicht möglich : auf private members kann man von ausserhalb nicht zugreifen! 
• Lösung : Konstruktoren

• Konstruktor = Methode die bei der Deklaration eines Objekts aufgerufen wird.

• Default-Konstruktor existiert immer : 

Complex c; //implizit
Complex d = Complex(); //explizit

• mehrere, personalisierte Konstruktoren möglich

Eigene Konstruktoren

Complex::Complex(double r, double i)
{
	real = r;
	imag = i;
}

• Konstruktor = spezielle member Funktion, ohne return, gleicher Name wie Klasse
  
• Der default-Konstruktor wird überschrieben!!!
• --> neu definieren

Konstruktor aufrufen

Complex c1 = Complex(1.0,2.0);
Complex c2(1.0, 2.0);
Complex c1; //no longer valid

Destruktor

• 2. spezielle member function
• nur 1 Destruktor möglich
• nur bei dynamischem Speicher !
• gleicher Name wie Klasse, mit ~
• kein return, keine Argumente
• Objekte löschen, Speicher freimachen

Complex::~Complex()
{
	// destroy the world.
}

Aufruf

• automatisch
• bei delete[]
• am Ende des scopes

• explizit  :

Complex c;
...
c.~Complex();

Operatoren

Complex c(8.3, 2.4);
Complex d(0.5, 4.1);

//Member Funktionen, die die arithmetischen Operationen implementieren
c.add(d);
c.sub(d);
c.mult(d);
c.div(d);

Complex e;
e = c + d;
e = c - d;
e = c * d;
e = c / d;

Definition der Operatoren

Aufruf

Complex a;
Complex b;

// Aufruf als Operator
Complex s1 = a + b;

// oder normal als Funktion
Complex s2 = a.operator+(b);

const

int j = 5, k = 6;
const int i = 1;
i = 2; // ERROR

const int *i = &j;
i = &k; //ERROR
*i = k; // ok

const Complex getSum(const Complex a) const; 

• Rückgabewert konstant
• Parameter konstant
• Funktion konstant
• member Variablen unverändert
• kann nur const Methoden aufrufen

This

const Stock & topval(const Stock &s) const;
// Prototyp, Funktion verändert Objekt nicht (const)!
const Stock & Stock::topval(const Stock &s) const
{
	if (s.total_val > total_val)
		return s;
	else 
		return *this; //aufrufendes Objekt
}top = stock1.topval(stock2);top = stock2.topval(stock1);

friend

• erlaubt Zugang zu privaten Funktionen / Variablen
• Funktionen, die nicht Mitgliedsfunktionen der Klasse sind, haben trotzdem Zugriff auf die private section
• Prototyp der friend Funktion innerhalb der Klasse.

Beispiel : Operatoren

Complex c = Complex(3.0, 1.5);
Complex d = c * 2.3; // ok, d = c.operator*(2.3);
Complex e = 2.3 * c; // Problem!

Lösung

friend Complex operator*(double m, const Complex &c);

Complex operator*(double m, const Complex &c)
{
	Complex result;
	result.real = m * c.real;
	result.imag = m * c.imag;

	return result;
}