03 Klassen in Cpp

Zusammenfassung der Slides "Klassen in C++" mit passenden Codebeispielen

1. Klassendeklarationen

In C++ gibt es zwei Hauptarten zur Deklaration von Klassen: struct und class. Bei struct sind die Attribute standardmäßig öffentlich, während sie bei class privat sind.

Beispiel für eine Klassendeklaration:

struct Point {
    int m_x, m_y;
    double dist(Point p) const;
};

class Person {
private:
    std::string m_name;
    int m_age;

public:
    Person(const char name[], int age);
    std::string getName() const;
    void setAge(int age);
};

2. Erzeugen von Instanzen (Objekten)

Der Compiler berechnet den Speicherbedarf einer Instanz basierend auf der Deklaration der Klasse. Konstruktoren und Methoden benötigen in der Regel keinen Speicher innerhalb der Instanz.

Beispiel zur Objektallokation:

Point p;          // Statische Instanz auf dem Stack
Point* p_dyn = new Point();  // Dynamische Instanz auf dem Heap

Die Lebensdauer von Instanzen hängt davon ab, wo sie allokiert werden:

• Statischer Speicher: Globale Variablen bleiben während der gesamten Programmlaufzeit erhalten.
• Dynamischer Speicher (Heap): Objekte müssen manuell mit delete freigegeben werden, um Memory-Leaks zu vermeiden.
• Automatischer Speicher (Stack): Lokale Variablen werden automatisch gelöscht, wenn der Gültigkeitsbereich verlassen wird.

3. Konstruktoren und Destruktoren

Konstruktoren initialisieren die Attribute eines Objekts. Sie können Standard- oder benutzerdefinierte Konstruktoren sein.

Beispiel für Konstruktoren:

class Point {
    double m_x, m_y;
public:
    Point() : m_x(0), m_y(0) {}  // Standard-Konstruktor
    Point(double x, double y) : m_x(x), m_y(y) {}  // Benutzerdefinierter Konstruktor
};

Destruktoren tragen den gleichen Namen wie die Klasse, beginnen aber mit einer Tilde (~). Sie werden aufgerufen, bevor ein Objekt seine Gültigkeit verliert.

Beispiel für einen Destruktor:

class Point {
    ~Point() {
        std::cout << "Destruktor wird aufgerufen" << std::endl;
    }
};

4. Lebensdauer von Objekten

Die Lebensdauer von Objekten variiert je nach Speicherort:

• Statische Objekte: Während der gesamten Programmlaufzeit im Speicher.
• Dynamische Objekte: Manuell mit delete freigeben.
• Automatische Objekte: Werden beim Verlassen des Blocks gelöscht.

Beispiel zur Lebensdauer von Objekten:

void main() {
    Point p;  // Statisches Objekt, wird automatisch zerstört
    Point* pp = new Point();  // Dynamisches Objekt auf dem Heap
    delete pp;  // Manuelles Freigeben des Speichers
}

5. Klassenvariablen und -methoden

Klassenvariablen werden pro Klasse und nicht pro Instanz angelegt. Sie werden mit dem Modifikator static deklariert.

Beispiel für Klassenvariablen und -methoden:

class Point {
    static int s_instanceCount;
public:
    Point() { s_instanceCount++; }
    ~Point() { s_instanceCount--; }
    static int getInstanceCount() { return s_instanceCount; }
};
int Point::s_instanceCount = 0;

6. Kopierkonstruktor und Zuweisungsoperator

Der Kopierkonstruktor wird verwendet, um eine Kopie eines Objekts zu erstellen. Für tiefe Kopien muss ein eigener Kopierkonstruktor implementiert werden.

Beispiel für einen Kopierkonstruktor:

class Point {
    double m_x, m_y;
public:
    Point(const Point& p) : m_x(p.m_x), m_y(p.m_y) {}
};

7. this-Zeiger

Der this-Zeiger verweist auf die aktuelle Instanz der Klasse. Er wird häufig verwendet, um auf Mitglieder der Klasse zuzugreifen.

Beispiel für den this-Zeiger:

class Point {
    double m_x, m_y;
public:
    Point& move(double dx, double dy) {
        m_x += dx;
        m_y += dy;
        return *this;
    }
};

8. RAII (Resource Acquisition Is Initialization)

RAII bindet den Lebenszyklus einer Ressource an die Lebensdauer eines Objekts. Ressourcen werden im Konstruktor erworben und im Destruktor wieder freigegeben.

Beispiel für RAII:

struct FileHandle {
    FILE* file;
    FileHandle(const char* filename) { file = fopen(filename, "r"); }
    ~FileHandle() { if (file) fclose(file); }
};

9. Variant (typsichere Form der Union)

std::variant ist eine typsichere Form der Union, die verwendet werden kann, um ein Objekt aus einer Menge von möglichen Typen zu speichern.

Beispiel für std::variant:

#include <variant>
#include <iostream>

std::variant<int, float> vif = 5.5f;
std::cout << std::get<float>(vif) << std::endl;  // Ausgabe: 5.5
vif = 10;
std::cout << std::get<int>(vif) << std::endl;  // Ausgabe: 10

Diese Zusammenfassung bietet eine grundlegende Einführung in die Konzepte der Klassen in C++, einschließlich Konstruktoren, Destruktoren, RAII und weiteren wichtigen Merkmalen der Sprache.