Grundlagen der Objektorientierten Programmierung (OOP)

Kapselung und Abstraktion

Kapselung (Encapsulation)

Die Kapselung von Daten bedeutet, dass diese in der Regel vor dem Benutzer verborgen bleiben oder nur innerhalb der Klasse zugänglich sind. Benutzer können auf die Daten zum Lesen oder Schreiben nur indirekt über die Methoden der Klasse zugreifen.

Abstraktion (Abstraction)

In der strukturierten Programmierung wird die Abstraktion durch Funktionen realisiert. Dabei wird die Funktion verwendet, ohne deren interne Implementierung kennen zu müssen.

Klassifizierung von Methoden

Die Methoden können in drei Gruppen eingeteilt werden:

• Administratoren (Konstruktoren/Destruktoren): Führen die Initialisierung und Bereinigung durch. Beispiele hierfür sind Konstruktoren und Destruktoren.
• Modifikatoren (Mutatoren): Ändern die Datenmitglieder (den Zustand) des Objekts.
• Inspektoren (Accessoren): Geben Informationen über den aktuellen Zustand eines Objekts zurück, ohne Änderungen vorzunehmen.

Freundfunktionen (Friends)

Freundfunktionen dienen als Verbindung zwischen Funktionen und Klassen, die nicht direkt miteinander verwandt sind. Sie entstehen aus der Notwendigkeit, dass bestimmte Funktionen, die nicht Teil der Klasse sind, auf die privaten Datenelemente der Klasse zugreifen müssen.

Inline-Funktionen

Eine Inline-Funktion ist eine Funktion, deren Code direkt an der Aufrufstelle ersetzt wird (Vermeidung des Overheads eines Funktionsaufrufs).

Vorteile von Inline-Funktionen (gegenüber Makros)

Inline-Funktionen bieten Vorteile gegenüber Makros:

• Inline-Funktionen können Methoden sein.
• Inline-Funktionen können Freundfunktionen sein.
• Inline-Funktionen können überladen werden.

Nachteil

Der Nachteil bei der Verwendung dieser Funktionen ist, dass die Größe des Programms zunimmt, da der Compiler den Funktionsaufruf durch den tatsächlichen Code ersetzt, was die Gesamtzahl der Codezeilen erhöht.

Rein Virtuelle Funktionen

Eine rein virtuelle Funktion ist eine virtuelle Funktion, die keine Implementierung (keinen geschriebenen Code) in der Basisklasse besitzt. Sie wird in der Basisklasse definiert und muss in den abgeleiteten Klassen neu implementiert werden.

Auf diese Weise stellen abgeleitete Klassen sicher, dass sie die gleichen Methoden definieren, die für den Betrieb der Basisklasse notwendig sind. Die Implementierung der Basisklasse wird jedoch nicht vererbt.

Syntax (Beispiel für eine abgeleitete Klasse)

Nom_claseDerivada Klasse: virtuelle tipo_derivacion Nom_claseBase { /* class-Code */ };

Zusammensetzung vs. Vererbung

• Zusammensetzung (Composition)

  Bei der Zusammensetzung wird ein Objekt einer anderen Klasse als Mitglied innerhalb einer neuen Klasse verwendet. Wir sagen, dass die neue Klasse "hat ein" (has-a) Mitglied (oder Mitglieder) eines anderen Typs.

• Vererbung (Inheritance)

  Vererbung ist die Erstellung einer neuen Klasse als Erweiterung einer bestehenden Basisklasse. Die abgeleitete Klasse enthält alle Mitglieder der Basisklasse sowie ihre eigenen. Die abgeleitete Klasse "ist ein" (is-a) Typ der Basisklasse.

Vererbungssyntax und Zugriffsmodifikatoren

Syntax der abgeleiteten Klasse

Nom_clase_abgeleitet: tipo_derivacion Nom_clase_base {
    // Mitglieder: public, private und protected
};

Zugriffsregeln bei Vererbung

Die Zugriffsart (tipo_derivacion: public, protected, private) bestimmt, wie die Mitglieder der Basisklasse in der abgeleiteten Klasse behandelt werden:

• Öffentlicher Zugriff (public) in der Basisklasse bleibt öffentlich (public) in der abgeleiteten Klasse (bei öffentlicher Vererbung).
• Geschützter Zugriff (protected) in der Basisklasse bleibt geschützt (protected) in der abgeleiteten Klasse.
• Privater Zugriff (private) in der Basisklasse ist für die abgeleitete Klasse unzugänglich.

Zusammenfassung der Zugriffsänderungen (Beispiel: Private Vererbung)

• Öffentlich (Basis) → Privat (Abgeleitet)
• Geschützt (Basis) → Privat (Abgeleitet)
• Privat (Basis) → Unzugänglich

Codebeispiele (Analyse)

(Anmerkung: Die ursprünglichen Codebeispiele sind fehlerhaft und wurden zur Verdeutlichung der Zugriffsregeln korrigiert.)

Beispiel 1: Zugriff von außerhalb der Klasse (Ejemplo.cpp)

// mi_base.print2(); // Fehler: Methode ist protected und kann nicht von außerhalb verwendet werden.
// mi_derivado.print(); // Fehler: Zugriff ist private.
// printf("%d", mi_base.un_dato); // Fehler: 'un_dato' ist protected/private und nicht zugänglich.
// printf("%d", mi_derivado.dato_publico); // Fehler: Wenn die Vererbung private ist, wird 'dato_publico' in der abgeleiteten Klasse private.
printf("%d", mi_base.dato_publico); // OK: Wenn das Mitglied public ist und wir uns in der Basisklasse befinden.

Beispiel 2: Zugriff innerhalb der abgeleiteten Klasse (Derivada.cpp)

void Derived::metodo_d() {
    un_dato = 0; // OK: 'un_dato' ist protected in der Basisklasse und kann innerhalb der abgeleiteten Klasse verwendet werden.
    // otro_dato = 0; // Fehler: 'otro_dato' ist private in der Basisklasse und unzugänglich.
}