5 Objektorientierung

5.1 Strukturen und Klassen in C++

5.1.1 Einführung

Strukturen (Structs) und Klassen sind zentrale Bausteine in C++, um benutzerdefinierte Datentypen und objektorientierte Programmierkonzepte zu implementieren. Obwohl sie viele Gemeinsamkeiten haben, gibt es auch einige wichtige Unterschiede.

5.1.2 Strukturen (Structs)

Ein struct ist eine Sammlung von Variablen (auch Felder genannt), die zusammen gruppiert sind, um einen neuen Datentyp zu bilden. Es wird oft verwendet, um einfache Datenstrukturen zu definieren.

struct Punkt {
    int x;
    int y;
};

Punkt p1 = {5, 10};

Eigenschaften: - Standardmäßig sind alle Mitglieder eines struct public, d.h. sie sind von außerhalb des Structs zugänglich. - Strukturen können Methoden enthalten. - Sie können Konstruktoren, aber keine Destruktoren haben.

5.1.3 Klassen

Eine Klasse ist ein erweitertes Konzept, das sowohl Daten (Attribute) als auch Funktionen (Methoden) kapseln kann. Sie ist das primäre Mittel zur Implementierung von Objektorientierung in C++.

class Rechteck {
private:
    double breite, hoehe;

public:
    Rechteck(double b, double h) : breite(b), hoehe(h) {}
    
    double Flaeche() const {
        return breite * hoehe;
    }

    void setBreite(double b) {
        breite = b;
    }
    // Weitere Methoden und Zugriffsfunktionen...
};

Rechteck r(5.0, 10.0);

Eigenschaften: - Standardmäßig sind alle Mitglieder einer Klasse private, d.h. sie sind von außerhalb der Klasse nicht zugänglich. - Klassen können sowohl Konstruktoren als auch Destruktoren haben. - Sie können von anderen Klassen erben (Vererbung) und können auch abstrakt sein.

5.1.4 Gemeinsamkeiten zwischen Structs und Klassen

• Beide können Konstruktoren, Methoden, Überladungsoperatoren und Datenmitglieder enthalten.
• Beide können von anderen Klassen oder Strukturen erben und können auch als Basisklassen für andere Klassen oder Strukturen dienen.
• Die Sichtbarkeitslabels (public, private, protected) gelten für beide gleich.

5.1.5 Hauptunterschied

Der Hauptunterschied zwischen ihnen liegt in der Standardeinstellung für den Mitgliederzugriff: - In structs sind Mitglieder standardmäßig public. - In classes sind Mitglieder standardmäßig private.

5.1.6 TLDR;

Strukturen und Klassen sind mächtige Mittel in C++, um benutzerdefinierte Datentypen und die Grundlagen der objektorientierten Programmierung zu implementieren. Die Wahl zwischen einer Struktur und einer Klasse hängt oft von der beabsichtigten Verwendung und den Anforderungen des Programms ab. Generell sind Klassen für komplexe Datenstrukturen und Funktionen geeignet, während Strukturen für einfache Datensätze ideal sind.

5.2 Methoden und Attribute in C++

In C++ dienen Klassen und Strukturen als Blaupausen für Objekte. Diese “Blaupausen” bestehen aus zwei Hauptkomponenten: Methoden und Attributen. Während Attribute die Daten oder den Zustand eines Objekts repräsentieren, definieren Methoden die Aktionen oder das Verhalten, das das Objekt ausführen kann.

5.2.1 Attribute

Attribute, auch als Datenmitglieder bezeichnet, halten den Zustand eines Objekts fest. Sie sind Variablen, die innerhalb einer Klasse oder Struktur definiert sind.

Beispiel:

class Auto {
private:
    std::string marke;   // Attribut
    int baujahr;         // Attribut
public:
    // ... Methoden ...
};

Zugriffskontrolle:

• Private (private): Attribute sind oft privat, um den direkten Zugriff von außen zu verhindern. Dies fördert die Kapselung und stellt sicher, dass der Zustand des Objekts nur über definierte Methoden geändert werden kann.

• Öffentlich (public): Öffentliche Attribute sind von überall her zugänglich. In der Regel ist es besser, Attribute privat zu halten und den Zugriff über öffentliche Methoden zu steuern.

• Geschützt (protected): Geschützte Attribute sind ähnlich wie private Attribute, können jedoch von abgeleiteten Klassen zugegriffen werden.

5.2.2 Methoden

Methoden definieren das Verhalten eines Objekts. Sie sind Funktionen innerhalb einer Klasse oder Struktur und können auf deren Attribute zugreifen.

Beispiel:

class Auto {
private:
    std::string marke;
    int baujahr;
public:
    void setMarke(const std::string& m) {   // Methode
        marke = m;
    }

    std::string getMarke() const {         // Methode
        return marke;
    }
};

Besonderheiten von Methoden:

• Konstruktoren: Sie initialisieren ein Objekt, wenn es erstellt wird. Sie haben denselben Namen wie die Klasse und keinen Rückgabetyp.

• Destruktoren: Sie werden aufgerufen, wenn ein Objekt zerstört wird. Sie haben denselben Namen wie die Klasse, werden jedoch durch ein vorangestelltes Tilde-Symbol (~) dargestellt.

• Zugriffsmethoden (Getter und Setter): Diese Methoden werden verwendet, um den Wert von privaten Attributen zu lesen oder zu setzen.

• Konstante Methoden: Mit dem Schlüsselwort const gekennzeichnete Methoden versprechen, dass sie den Zustand des Objekts nicht ändern werden.

5.2.3 TLDR;

Methoden und Attribute sind die grundlegenden Bestandteile von Klassen und Strukturen in C++. Durch die geschickte Kombination von Methoden und Attributen kann ein Entwickler robuste und gut kapselte Datenstrukturen erstellen, die sowohl den Zustand als auch das Verhalten von Objekten in einem Programm repräsentieren. Dies ist ein Kernkonzept der objektorientierten Programmierung, das die Modellierung realer Entitäten und deren Interaktionen in einem Programm ermöglicht.

5.3 Zugriff auf Member mit . und ->

In C++ gibt es zwei Hauptmechanismen, um auf die Mitglieder (Methoden und Attribute) von Objekten und Objektzeigern zuzugreifen: den Punktoperator (.) und den Pfeiloperator (->). Diese beiden Operatoren haben unterschiedliche Verwendungszwecke und es ist wichtig, sie korrekt zu verwenden, um Programmierfehler zu vermeiden.

5.3.1 Punktoperator (.)

Der Punktoperator wird verwendet, um auf Mitglieder eines Objekts zuzugreifen, das direkt (durch Wert oder Referenz) und nicht durch einen Zeiger dargestellt wird.

Beispiel:

class MyClass {
public:
    int myAttribute;
    void myMethod() { /* ... */ }
};

MyClass obj;
obj.myAttribute = 10;
obj.myMethod();

In diesem Beispiel haben wir ein MyClass-Objekt namens obj und wir verwenden den Punktoperator, um auf seine Mitglieder zuzugreifen.

5.3.2 Pfeiloperator (->)

Der Pfeiloperator wird verwendet, um auf die Mitglieder eines Objekts zuzugreifen, das durch einen Zeiger dargestellt wird. Es ist syntaktischer Zucker und hat die gleiche Wirkung wie die Dereferenzierung des Zeigers gefolgt vom Punktoperator.

Beispiel:

MyClass* objPtr = new MyClass;
objPtr->myAttribute = 20;
objPtr->myMethod();
delete objPtr;

Hier haben wir einen Zeiger objPtr, der auf ein MyClass-Objekt zeigt, und wir verwenden den Pfeiloperator, um auf seine Mitglieder zuzugreifen.

5.3.2.1 Interne Arbeitsweise von ->

Wenn Sie objPtr->myMethod(); schreiben, wird es intern in etwa so behandelt:

(*objPtr).myMethod();

Das bedeutet, dass der Zeiger zuerst dereferenziert wird (um das eigentliche Objekt zu erhalten) und dann der Punktoperator verwendet wird, um auf das Mitglied zuzugreifen.

5.3.3 TLDR

• Verwenden Sie den Punktoperator (.), um auf die Mitglieder eines direkt dargestellten Objekts zuzugreifen.
• Verwenden Sie den Pfeiloperator (->), um auf die Mitglieder eines durch einen Zeiger dargestellten Objekts zuzugreifen.
• Es ist wichtig, den richtigen Operator für den jeweiligen Kontext zu verwenden, um Zugriffsfehler und undefiniertes Verhalten zu vermeiden.

5.4 Access Modifier und static

In C++ bestimmen Zugriffsmodifikatoren, wie Klassen, ihre Attribute und Methoden von außen gesehen und verwendet werden können. Parallel dazu bietet das Schlüsselwort static die Möglichkeit, Klassen, Attribute und Methoden zu definieren, die nicht an eine spezifische Instanz einer Klasse gebunden sind. In diesem Artikel werfen wir einen genaueren Blick auf diese Konzepte.

5.4.1 Zugriffsmodifikatoren (Access Modifiers)

Es gibt drei Hauptzugriffsmodifikatoren in C++:

1. Private (private):
   • Nur von Methoden derselben Klasse zugreifbar.
   • Ideal für Attribute und Hilfsmethoden, die von außen nicht sichtbar oder modifizierbar sein sollten.
2. Geschützt (protected):
   • Wie private, aber zugänglich von abgeleiteten Klassen.
   • Oft in Basisklassen verwendet, um den Zugriff für abgeleitete Klassen zu ermöglichen.
3. Öffentlich (public):
   • Von überall zugreifbar.
   • Für Methoden und Attribute, die von externen Code verwendet werden sollen.

Beispiel:

class Tier {
private:
    int alter;
protected:
    std::string name;
public:
    void setAlter(int a) { alter = a; }
    int getAlter() const { return alter; }
};

5.4.2 static in C++

Das static Schlüsselwort hat in C++ mehrere Bedeutungen, je nachdem, in welchem Kontext es verwendet wird:

1. Statische Attribute:
   • Gehört zur Klasse und nicht zu einer bestimmten Instanz.
   • Es gibt nur eine Kopie des Attributs, unabhängig von der Anzahl der Objekte der Klasse.

   class BeispieleKlasse {
   public:
       static int zaehler;
   };
   
   int BeispieleKlasse::zaehler = 0; // Initialisierung außerhalb der Klasse

2. Statische Methoden:
   • Kann ohne das Erstellen eines Objekts der Klasse aufgerufen werden.
   • Kann nur auf statische Attribute der Klasse zugreifen.

   class Mathematik {
   public:
       static int addiere(int a, int b) {
           return a + b;
       }
   };
   
   int ergebnis = Mathematik::addiere(5, 3);

3. Statische Klassen:
   • In C++ gibt es im eigentlichen Sinne keine “statischen Klassen”, wie es in einigen anderen Sprachen der Fall ist. Aber man kann eine Klasse “statisch” machen, indem man sicherstellt, dass alle ihre Methoden und Attribute statisch sind.

5.4.3 TLDR;

Die Zugriffsmodifikatoren in C++ bieten fein abgestimmte Kontrolle darüber, wie Klassen, ihre Attribute und Methoden in einem Programm sichtbar und zugreifbar sind. Das static Schlüsselwort ermöglicht die Definition von Eigenschaften und Verhaltensweisen, die auf Klassenebene und nicht auf Objektebene arbeiten. Zusammen ermöglichen diese Konzepte eine flexible und kraftvolle objektorientierte Programmierung in C++.

5.5 Konstruktoren und Destruktoren

In der objektorientierten Programmierung in C++ sind Konstruktoren und Destruktoren spezielle Methoden, die zum Initialisieren und Aufräumen von Objekten verwendet werden. Sie spielen eine entscheidende Rolle bei der Lebensdauer von Objekten und ermöglichen eine sichere Speicherverwaltung und Ressourcenallokation.

5.5.1 Konstruktoren

Ein Konstruktor ist eine spezielle Methode, die aufgerufen wird, wenn ein Objekt einer Klasse erstellt wird. Er wird hauptsächlich dazu verwendet, das Objekt zu initialisieren und sicherzustellen, dass es in einem gültigen Zustand ist.

Merkmale von Konstruktoren:

1. Sie haben den gleichen Namen wie die Klasse.
2. Sie haben keinen Rückgabetyp (nicht einmal void).
3. Es können verschiedene Überladungen von Konstruktoren geben, um unterschiedliche Initialisierungen zu ermöglichen.

Beispiele:

• Standardkonstruktor:

  class Beispiel {
  public:
      Beispiel() {
          // Initialisierung
      }
  };

• Parameterisierter Konstruktor:

  class Punkt {
  private:
      int x, y;
  public:
      Punkt(int a, int b) : x(a), y(b) {}
  };
  
  Punkt p(5, 10); // ruft den parameterisierten Konstruktor auf

• Kopierkonstruktor:

  class Punkt {
  public:
      Punkt(const Punkt& other) {
          // Initialisierung durch Kopieren von 'other'
      }
  };

5.5.2 Destruktoren

Ein Destruktor ist das genaue Gegenteil eines Konstruktors. Er wird aufgerufen, wenn ein Objekt außer Geltungsbereich tritt oder explizit mit delete zerstört wird. Destruktoren werden hauptsächlich dazu verwendet, Ressourcen freizugeben, die während der Lebensdauer des Objekts reserviert wurden.

Merkmale von Destruktoren:

1. Sie haben den gleichen Namen wie die Klasse, werden jedoch durch ein Tilde-Symbol (~) vorangestellt.
2. Sie können nicht überladen werden, d.h. es kann nur einen Destruktor pro Klasse geben.
3. Sie haben keinen Rückgabetyp und keine Parameter.

Beispiel:

class Beispiel {
public:
    ~Beispiel() {
        // Ressourcen freigeben
    }
};

5.5.3 TLDR;

Konstruktoren und Destruktoren sind fundamentale Bausteine in der objektorientierten Programmierung mit C++. Sie ermöglichen die richtige Initialisierung und das ordnungsgemäße Aufräumen von Objekten, wodurch die Integrität und Zuverlässigkeit von C++-Programmen sichergestellt wird. Es ist wichtig, sie richtig zu nutzen, insbesondere in Anwendungen, die mit Ressourcen wie Speicher, Dateihandhabung und Netzwerkverbindungen arbeiten.

5.6 Memberinitialisierungslisten

In C++ ist die Initialisierung von Datenmitgliedern einer Klasse direkt bei ihrer Deklaration nicht immer ausreichend oder optimal. Hier kommen Memberinitialisierungslisten ins Spiel, die insbesondere bei Konstruktoraufrufen nützlich sind. Sie bieten eine effizientere und sauberere Methode zur Initialisierung von Datenmitgliedern und Basisklassen.

5.6.1 Was sind Memberinitialisierungslisten?

Memberinitialisierungslisten folgen dem Kopf des Konstruktors und werden durch einen Doppelpunkt gefolgt von einer kommagetrennten Liste von Initialisierungen eingeleitet.

Beispiel:

class Punkt {
private:
    int x, y;
public:
    Punkt(int a, int b) : x(a), y(b) {} // Memberinitialisierungsliste
};

5.6.2 Warum sind sie nützlich?

1. Effizienz: Bei nicht-primitiven Typen, wie Klassen, ist es oft effizienter, ein Objekt direkt mit einer Initialisierungsliste zu initialisieren, anstatt es zuerst mit einem Standardkonstruktor zu erstellen und dann einen Zuweisungsoperator zu verwenden.

2. Initialisierung von const und Referenzmitgliedern: Datenmitglieder, die als const oder Referenz deklariert sind, müssen in einer Memberinitialisierungsliste initialisiert werden, da sie nach ihrer Erstellung nicht geändert werden können.

3. Aufruf von Basisklassen-Konstruktoren: Wenn eine Klasse von einer anderen Klasse erbt, können Sie den Konstruktor der Basisklasse über die Memberinitialisierungsliste aufrufen.

4. Lesbarkeit und Klarheit: Die Verwendung von Initialisierungslisten kann den Code klarer und einfacher zu lesen machen, insbesondere wenn es viele Datenmitglieder gibt.

5.6.3 Beispiele und Anwendungsfälle

• Initialisierung von const Mitgliedern:

  class Beispiel {
  private:
      const int wert;
  public:
      Beispiel(int v) : wert(v) {}
  };

• Initialisierung von Referenzmitgliedern:

  class VerweisBeispiel {
  private:
      int& ref;
  public:
      VerweisBeispiel(int& r) : ref(r) {}
  };

• Aufruf des Basisklassen-Konstruktors:

  class Basis {
  public:
      Basis(int a) { /* ... */ }
  };
  
  class Abgeleitet : public Basis {
  public:
      Abgeleitet(int b) : Basis(b) { /* ... */ }
  };

5.6.4 TLDR;

Memberinitialisierungslisten sind ein kraftvolles Werkzeug in C++ zur sauberen und effizienten Initialisierung von Datenmitgliedern und Basisklassen. Sie sind nicht nur aus Effizienzgründen wertvoll, sondern auch, weil sie in bestimmten Szenarien, wie bei der Initialisierung von const oder Referenzdatenmitgliedern, notwendig sind. Ein geübter Umgang mit Memberinitialisierungslisten verbessert die Codequalität und ermöglicht es, viele häufige Programmierfehler zu vermeiden.

5.7 Vererbung

In C++ ermöglicht die Vererbung eine Klasse (abgeleitete Klasse) auf der Grundlage einer anderen Klasse (Basisklasse) zu definieren. Dies fördert die Wiederverwendung von Code und etabliert eine “ist-ein” Beziehung zwischen der Basisklasse und der abgeleiteten Klasse.

class Tier {
public:
    void essen() { /* ... */ }
};

class Hund : public Tier {
public:
    void bellen() { /* ... */ }
};

Hier erbt Hund von Tier, sodass ein Hund-Objekt sowohl die essen als auch die bellen Methode hat.

5.7.1 Diamantproblematik

Die Diamantproblematik tritt in Sprachen mit Mehrfachvererbung auf, wenn zwei Klassen von einer Basisklasse erben und dann von einer weiteren Klasse erweitert werden. Wenn die Endklasse versucht, eine Methode von der Basisklasse aufzurufen, entsteht eine Mehrdeutigkeit, da nicht klar ist, von welchem Vererbungspfad die Methode stammen soll.

class Basisklasse {
public:
    void methode() { /* ... */ }
};

class Ableitung1 : public Basisklasse { /* ... */ };
class Ableitung2 : public Basisklasse { /* ... */ };

class Diamant : public Ableitung1, public Ableitung2 {
    // Hier gibt es ein Problem, wenn "methode" aufgerufen wird.
};

In C++ kann dieses Problem durch die Verwendung von “virtueller Vererbung” gelöst werden:

class Ableitung1 : virtual public Basisklasse { /* ... */ };
class Ableitung2 : virtual public Basisklasse { /* ... */ };

Durch die virtuelle Vererbung wird sichergestellt, dass nur eine Kopie der Basisklasse in der Endklasse existiert, wodurch die Mehrdeutigkeit beseitigt wird.

5.7.2 Abstrakte Klassen

Eine abstrakte Klasse in C++ ist eine Klasse, die nicht instanziiert werden kann und dazu dient, als Basisklasse für andere Klassen zu fungieren. Sie kann eine oder mehrere rein virtuelle Funktionen enthalten, die in abgeleiteten Klassen implementiert werden müssen.

class AbstraktesTier {
public:
    virtual void soundMachen() = 0; // Reine virtuelle Funktion
};

class Katze : public AbstraktesTier {
public:
    void soundMachen() override {
        // Implementierung für Katze
    }
};

5.7.3 Interfaces

C++ hat kein direktes Konzept von “Interfaces” wie Java oder C#. Stattdessen kann man abstrakte Klassen mit ausschließlich rein virtuellen Methoden als ein Interface behandeln.

class ITier {
public:
    virtual void essen() = 0;
    virtual void schlafen() = 0;
};

Jede Klasse, die von diesem “Interface” erbt, muss die Methoden essen und schlafen implementieren.

5.7.4 TLDR;

Die Vererbung in C++ ermöglicht es, Code effizient zu wiederverwenden und Beziehungen zwischen Klassen herzustellen. Dabei sind jedoch Vorsicht und Verständnis erforderlich, insbesondere bei komplexen Vererbungsszenarien und der Diamantproblematik. Das Konzept der abstrakten Klassen und “Interfaces” bietet zusätzliche Flexibilität und Strukturierungsmöglichkeiten beim Design von objektorientierten Systemen.

5.8 Das Schlüsselwort virtual

Das Schlüsselwort virtual in C++ ist ein mächtiges Werkzeug, das vor allem im Kontext der Polymorphie und Vererbung seine volle Wirkung entfaltet. Hier sind die verschiedenen Anwendungen und Nuancen von virtual:

5.8.1 1. Virtuelle Funktionen

Die Verwendung des virtual-Schlüsselworts vor einer Mitgliedsfunktion einer Klasse signalisiert, dass diese Funktion in einer abgeleiteten Klasse überschrieben werden kann.

class Tier {
public:
    virtual void soundMachen() {
        // Standardimplementierung
    }
};

class Hund : public Tier {
public:
    void soundMachen() override { // `override` ist optional, aber empfohlen
        // Spezifische Implementierung für Hund
    }
};

Durch die Nutzung von Pointern oder Referenzen auf die Basisklasse können Sie polymorphes Verhalten erzielen:

Tier* meinTier = new Hund();
meinTier->soundMachen(); // Ruft die Methode von Hund auf

5.8.2 2. Reine virtuelle Funktionen

Wenn Sie eine Funktion mit virtual deklarieren und ihr die Zuweisung = 0 hinzufügen, wird sie zu einer rein virtuellen Funktion:

class Instrument {
public:
    virtual void spielen() = 0; // Reine virtuelle Funktion
};

Eine Klasse, die eine oder mehrere rein virtuelle Funktionen enthält, wird als “abstrakt” betrachtet und kann nicht direkt instanziiert werden.

5.8.3 3. Virtuelle Destruktoren

Wenn Sie eine Basisklasse mit einer virtuellen Funktion haben, sollten Sie ihren Destruktor ebenfalls als virtuell deklarieren. Dies stellt sicher, dass, wenn ein Objekt einer abgeleiteten Klasse durch einen Zeiger auf die Basisklasse zerstört wird, der richtige Destruktor aufgerufen wird.

class Basis {
public:
    virtual ~Basis() {
        // Aufräumarbeiten für die Basisklasse
    }
};

class Abgeleitet : public Basis {
public:
    ~Abgeleitet() {
        // Aufräumarbeiten für die abgeleitete Klasse
    }
};

5.8.4 4. Virtuelle Basisklassen (Lösung des Diamantproblems)

Wie bereits im vorherigen Artikel erwähnt, kann virtual auch in der Vererbungsdeklaration verwendet werden, um Mehrdeutigkeiten in der Mehrfachvererbung zu verhindern.

class Basisklasse { /* ... */ };

class Ableitung1 : virtual public Basisklasse { /* ... */ };
class Ableitung2 : virtual public Basisklasse { /* ... */ };

class Diamant : public Ableitung1, public Ableitung2 {
    // Dank virtueller Vererbung gibt es nur eine Instanz von Basisklasse
};

5.8.5 TLDR;

Das Schlüsselwort virtual ist zentral für viele erweiterte OOP-Konzepte in C++, insbesondere für Polymorphie und Mehrfachvererbung. Es ermöglicht die dynamische Bindung von Funktionen, die Sicherstellung des richtigen Destruktoraufrufs und verhindert Mehrdeutigkeiten in Vererbungshierarchien. Ein tiefes Verständnis von virtual ist für jeden C++-Entwickler unerlässlich.

5.9 Polymorphie

Polymorphie ist eines der vier Hauptmerkmale der objektorientierten Programmierung (neben Vererbung, Abstraktion und Kapselung). Polymorphie erlaubt es, dass verschiedene Objekte in der gleichen Weise behandelt werden können, selbst wenn sie unterschiedliche Implementierungen derselben Aktion oder Methode haben. In C++ wird die Polymorphie hauptsächlich durch virtuelle Funktionen und Zeiger oder Referenzen auf Basisklassen realisiert.

5.9.1 1. Statische Polymorphie (Compile-Zeit Polymorphie)

5.9.1.1 a) Überladung von Funktionen

Das bedeutet, dass zwei oder mehr Funktionen denselben Namen haben können, sich aber in ihren Parametertypen oder ihrer Anzahl unterscheiden.

void print(int i) {
    std::cout << "Printing int: " << i << std::endl;
}

void print(double d) {
    std::cout << "Printing double: " << d << std::endl;
}

5.9.1.2 b) Templates

Templates ermöglichen es, generischen Code zu schreiben, der zur Compile-Zeit spezialisiert wird.

template <typename T>
T add(T a, T b) {
    return a + b;
}

5.9.2 2. Dynamische Polymorphie (Laufzeit-Polymorphie)

5.9.2.1 a) Virtuelle Funktionen

Durch die Verwendung von virtuellen Funktionen in einer Basisklasse können abgeleitete Klassen diese Funktionen überschreiben, um ihr spezifisches Verhalten bereitzustellen.

class Animal {
public:
    virtual void speak() {
        std::cout << "Some sound..." << std::endl;
    }
};

class Dog : public Animal {
public:
    void speak() override {
        std::cout << "Woof!" << std::endl;
    }
};

class Cat : public Animal {
public:
    void speak() override {
        std::cout << "Meow!" << std::endl;
    }
};

Mit virtuellen Funktionen können Sie einen Zeiger oder eine Referenz auf eine Basisklasse verwenden, um dynamisch zur Laufzeit die richtige Funktion der abgeleiteten Klasse aufzurufen:

Animal* a = new Dog();
a->speak();  // Ausgabe: Woof!

Animal* b = new Cat();
b->speak();  // Ausgabe: Meow!

5.9.2.2 b) Reiner virtueller Funktionen und abstrakte Klassen

Eine reine virtuelle Funktion ist eine virtuelle Funktion in einer Basisklasse, die keine Implementierung hat und von abgeleiteten Klassen überschrieben werden muss. Eine Klasse, die eine oder mehrere reine virtuelle Funktionen enthält, wird als “abstrakte Klasse” bezeichnet und kann nicht instanziiert werden.

class Shape {
public:
    virtual double area() const = 0; // Reine virtuelle Funktion
};

5.9.3 TLDR

Polymorphie ist ein mächtiges Konzept in der objektorientierten Programmierung und ermöglicht es, Code flexibler und wiederverwendbarer zu gestalten. Es ermöglicht es, dass unterschiedliche Objekte in einer einheitlichen Weise behandelt werden können, je nachdem, ob man statische oder dynamische Polymorphie verwendet. In C++ wird die dynamische Polymorphie hauptsächlich durch virtuelle Funktionen und die Verwendung von Zeigern oder Referenzen auf Basisklassen unterstützt.

5.10 Das Schlüsselwort static in C++

Das Schlüsselwort static in C++ hat mehrere Bedeutungen, je nachdem, in welchem Kontext es verwendet wird. Es kann auf Variablen, Funktionen und Klassenmitglieder angewendet werden.

5.10.1 1. static auf Funktionsebene (lokale statische Variablen)

Innerhalb einer Funktion definiert, behält eine static-Variable ihren Wert zwischen den Aufrufen dieser Funktion bei.

Beispiel:

void counter() {
    static int count = 0;
    count++;
    std::cout << count << std::endl;
}

int main() {
    counter();  // Ausgabe: 1
    counter();  // Ausgabe: 2
    return 0;
}

5.10.2 2. static auf Dateiebene (globale statische Variablen/Funktionen)

Wenn Sie eine globale Variable oder Funktion in einer Quelldatei mit static deklarieren, wird diese nur innerhalb dieser Datei sichtbar. Das bedeutet, andere Dateien, die diese Datei einschließen oder mit ihr verlinkt sind, können nicht auf die statische globale Variable oder Funktion zugreifen.

Beispiel:

// in datei1.cpp
static int verborgen = 42;

// in datei2.cpp
extern int verborgen;  // Fehler, da verborgen in datei1.cpp statisch ist

5.10.3 3. static Klassenmitglieder

static kann auch verwendet werden, um Klassenmitglieder zu deklarieren. Ein statisches Klassenmitglied gehört zur Klasse und nicht zu den Instanzen dieser Klasse. Das bedeutet, es gibt nur eine Kopie dieser Mitglieder, unabhängig davon, wie viele Objekte dieser Klasse erstellt werden.

class Beispiel {
public:
    static int count;
    
    Beispiel() {
        count++;
    }
};

int Beispiel::count = 0;  // Initialisierung des statischen Mitglieds

int main() {
    Beispiel b1;
    Beispiel b2;
    std::cout << Beispiel::count;  // Ausgabe: 2
    return 0;
}

5.10.4 4. static Klassenmethoden

Eine statische Methode gehört ebenfalls zur Klasse und nicht zu einem bestimmten Objekt. Eine solche Methode kann nur auf statische Klassenmitglieder zugreifen. Sie wird ohne die Erstellung eines Objekts der Klasse aufgerufen.

class Beispiel {
public:
    static int count;
    
    static void anzeigenCount() {
        std::cout << count << std::endl;
    }
};

int Beispiel::count = 42;

int main() {
    Beispiel::anzeigenCount();  // Ausgabe: 42
    return 0;
}

5.10.5 TLDR;

Das Schlüsselwort static in C++ ist vielseitig und hat unterschiedliche Bedeutungen in verschiedenen Kontexten. Es kann verwendet werden, um den Lebenszeitraum und den Sichtbarkeitsbereich von Variablen und Funktionen zu kontrollieren oder um Klassenmitglieder und -methoden zu erstellen, die zur Klasse selbst und nicht zu ihren Instanzen gehören. Es ist wichtig, den Kontext zu erkennen, in dem static verwendet wird, um seine genaue Bedeutung und Wirkung zu verstehen.

5.11 Operatorüberladung

In C++ können Sie den Großteil der eingebauten Operatoren für Ihre eigenen Klassen oder Typen überladen, was bedeutet, dass Sie definieren können, wie diese Operatoren für Objekte Ihres Typs funktionieren sollen. Die Operatorüberladung ermöglicht es, Ihren benutzerdefinierten Typen auf eine natürlichere und intuitivere Weise zu verwenden.

5.11.1 Grundlagen

Um einen Operator für einen benutzerdefinierten Typ zu überladen, definieren Sie eine Funktion (meistens eine Mitgliedsfunktion der Klasse, kann aber auch eine globale Funktion sein) mit dem Schlüsselwort operator gefolgt vom zu überladenden Operator.

5.11.2 Beispiele für Operatorüberladungen

5.11.2.1 1. Überladung des + Operators für eine Klasse Vector

class Vector {
public:
    int x, y;

    Vector(int x = 0, int y = 0) : x(x), y(y) {}

    Vector operator + (const Vector& other) const {
        return Vector(x + other.x, y + other.y);
    }
};

Vector v1(1, 2);
Vector v2(3, 4);
Vector v3 = v1 + v2;  // Nutzt den überladenen + Operator

5.11.2.2 2. Überladung des << Operators für den Ausgabestrom

Um den << Operator für Ihre Klasse zu überladen, müssen Sie eine globale Funktion verwenden:

std::ostream& operator<<(std::ostream& out, const Vector& v) {
    out << "(" << v.x << ", " << v.y << ")";
    return out;
}

std::cout << v1 << std::endl;  // Ausgabe: (1, 2)

5.11.3 Regeln und Hinweise

1. Nicht alle Operatoren können überladen werden: Einige Operatoren, wie ::, .*, ., und ?:, können nicht überladen werden.

2. Intuitives Verhalten: Überladen Sie Operatoren so, dass das Verhalten intuitiv und erwartungsgemäß ist. Zum Beispiel sollte der + Operator immer eine addierende Aktion ausführen und keine subtrahierende.

3. Symmetrie: Wenn Sie den == Operator überladen, sollten Sie auch != überladen, um eine konsistente und erwartungsgemäße Funktionalität sicherzustellen.

4. Zuweisungsoperator: Der Zuweisungsoperator = kann überladen werden, aber es ist selten notwendig, da der Compiler eine Kopie für Sie durchführt. Wenn Sie jedoch Ressourcen dynamisch verwalten (z.B. mit new und delete), könnte eine Überladung sinnvoll sein.

5. Konvertierungsoperatoren: Sie können auch benutzerdefinierte Konvertierungsoperatoren bereitstellen, um den Typ Ihres Objekts in einen anderen zu konvertieren.

5.11.4 TLDR

Die Operatorüberladung in C++ ist ein mächtiges Merkmal, das bei korrekter Anwendung den Code intuitiver und leichter lesbar machen kann. Es ist jedoch wichtig, vorsichtig zu sein, um sicherzustellen, dass die überladenen Operatoren ein erwartungsgemäßes und intuitives Verhalten aufweisen.

5.12 RAII - Resource Acquisition Is Initialization

RAII ist ein Programmieridiom in C++, das für die Ressourcenverwaltung und die Vermeidung von Ressourcenlecks steht. Der Hauptgedanke hinter RAII ist, dass der Lebenszyklus einer Ressource (z. B. Speicher, Dateihandles, Netzwerksockets usw.) an den Lebenszyklus eines Objekts gebunden wird.

5.12.1 Grundprinzipien von RAII:

1. Ressourcenakquise: Eine Ressource wird bei der Initialisierung eines Objekts akquiriert, normalerweise im Konstruktor.

2. Ressourcenfreigabe: Die Ressource wird im Destruktor des Objekts freigegeben. Dies stellt sicher, dass die Ressource ordnungsgemäß freigegeben wird, wenn das Objekt aus dem Gültigkeitsbereich herausgeht.

5.12.2 Warum ist RAII nützlich?

1. Automatische Ressourcenfreigabe: Mit RAII werden Ressourcen automatisch freigegeben, sobald sie nicht mehr benötigt werden. Dies verhindert Ressourcenlecks und macht den Code sicherer.

2. Exception-Sicherheit: Wenn während der Ausführung eines Programms eine Ausnahme auftritt, stellt RAII sicher, dass die Ressourcen korrekt freigegeben werden.

3. Klarer und sauberer Code: Der Code wird lesbarer, da Ressourcenverwaltung und -freigabe automatisiert werden.

5.12.3 Beispiel: Ein einfacher RAII-Wrapper für einen Zeiger

template<typename T>
class RAIIPointer {
private:
    T* ptr;

public:
    RAIIPointer(T* p) : ptr(p) {}

    ~RAIIPointer() {
        delete ptr;
    }

    T& operator*() {
        return *ptr;
    }

    T* operator->() {
        return ptr;
    }
};

In diesem Beispiel wird Speicher im Konstruktor mit einem rohen Zeiger reserviert und im Destruktor mit delete freigegeben.

5.12.4 RAII in der Standardbibliothek

C++ Standardbibliothek enthält viele Klassen, die RAII-Prinzipien befolgen. Beispiele sind:

• std::unique_ptr und std::shared_ptr: Smart-Pointer, die den Speicher automatisch freigeben.
• std::lock_guard und std::unique_lock: Klassen, die Mutexe automatisch sperren und entsperren.
• std::fstream: Stream-Klassen, die Dateihandles öffnen und schließen.

5.12.5 TLDR

RAII ist ein Kernkonzept in C++, das dazu beiträgt, sicherzustellen, dass Ressourcen ordnungsgemäß verwaltet und freigegeben werden. Es erleichtert die Handhabung von Ressourcen, macht den Code sicherer im Hinblick auf Ausnahmen und verhindert viele häufige Fehler, die in anderen Sprachen auftreten können. Jeder, der in C++ programmiert, sollte mit RAII vertraut sein und es regelmäßig nutzen.