Geburt und Tod eines Objekts

Der Vorteil von Klassen, der wohl jedem Programmierer am schnellsten einleuchtet, ist die Möglichkeit, Funktionen zu definieren, die bei der Entstehung der Objekte automatisch aufgerufen werden und so garantieren können, dass ein Objekt immer korrekt initialisiert ist. Analog können Sie eine Funktion schreiben, die immer bei der Auflösung des Objekts aufgerufen wird und die dann angeforderte Ressourcen wieder freigeben kann. Da diese Aufgaben nur einmal bei der Definition der Klasse erledigt werden, entfallen viele Flüchtigkeitsfehler, die durch vergessene Initialisierungen entstehen.

Konstruktor und Destruktor

class tDatum 
{
public:
   tDatum();
   ~tDatum();
   ...
};

tDatum::tDatum()
{
  Tag=0; Monat=0; Jahr=0;
}

tDatum::~tDatum()
{
}

{
    tDatum heute;
    tDatum *morgen;  // kein Konstruktoraufruf!
    tDatum *Urlaub;  // auch kein Konstruktoraufruf

    morgen = new tDatum;     // aber hier wird er aufgerufen
    Urlaub = new tDatum[14]; // 14 Konstruktoraufrufe
    delete morgen;           // hier Destruktoraufruf
    ...
    delete[] Urlaub; // 14 Destruktoraufrufe
} // hier Destruktor von heute

tDatum::tDatum() : Tag(0),Monat(0),Jahr(0)
{
}

In diesem Fall werden die Elementvariablen Tag, Monat und Jahr auf 0 gesetzt. Der Konstruktorkörper ist leer. Die Initialisierung erfolgt bereits vor dem Ausführen des Funktionsrumpfes. Es gibt einen entscheidenden Unterschied zur Zuweisung der Werte an die Elementvariablen: Im Körper eines Konstruktors kann nur eine Zuweisung stattfinden, während diese Form eine Initialisierung ist. In den meisten Fällen ist der Unterschied unerheblich, aber wenn die Klasse Referenzvariablen oder Konstanten enthält, können diese nur durch eine Initialisierung vorbelegt werden. Alle Versuche, solche Elemente durch eine Zuweisung vorzubelegen, werden scheitern.[1]

Konstruktor und Parameter

Vorgabewerte

Überladen

Beispiel

[Konstruktor mit Parametern]

class tDatum 
{
public:
    tDatum(int Tag, int Monat, int Jahr=-1);
    ...
};

tDatum::tDatum(int Tag, int Monat, int Jahr)
{
    this->Tag=Tag; 
    this->Monat=Monat; 
    this->Jahr=Jahr;
    if (Jahr<0)
    {
        // setze das aktuelle Jahr ein
        ...
    }
}

tDatum Start(1,1,1970);
tDatum Silvester(31,12);
tDatum *HeiligAbend = new tDatum(24,12);

Das Objekt Start wird durch den Konstruktor auf den 1.1.1970 gesetzt. Das Objekt Silvester erhält als Parameter den 31.12. ohne eine Angabe des Jahres. Da der dritte Parameter in diesem Fall --1 vorgibt, wird dieser Wert angenommen. Innerhalb des Konstruktors wird im Falle eines negativen Jahres aber das aktuelle Jahr eingesetzt. Da der einzig existierende Konstruktor Parameter verlangt, kann für die Klasse tDatum kein Objekt erzeugt werden, ohne es zu initialisieren.

Konvertierungskonstruktor

class tBruch
{
public:
    tBruch(char *);
    Addiere(tBruch&);
};

...
char Eingabe[MAXSTR];
getline(cin, Eingabe, MAXSTR);
tBruch b1(Eingabe);
getline(cin, Eingabe, MAXSTR);
b1.Addiere(Eingabe);

class tBruch
{
public:
    explicit tBruch(long);
    ...
};

tBruch bruch=12;   // das läuft nicht durch den Compiler
tBruch bruch(12);  // so funktioniert's

[1]

Auch für den Aufruf von Konstruktoren von Basisklassen ist diese Form der Initialisierung wichtig. An der entsprechenden Stelle wird darauf noch einmal eingegangen.