← C++

C++ · 04 / 24

Klassen, Referenzen, const und RAII

Du ordnest Fahrzeugdaten einem Typ zu und beobachtest, wie C++ Ressourcen beim Verlassen eines Bereichs freigibt.

  • Mittel
  • Fortgeschritten
  • 60 min

Voraussetzungen: Strings, Vektoren und Standardalgorithmen

In diesem Tutorial
  1. Den Fahrzeugtyp lesen
  2. Referenz und Kopie unterscheiden
  3. Eindeutigen Besitz beobachten
  4. Die Prüfung nachvollziehen
  5. Die Regel auf die App übertragen
  6. Übung und Lösung
  7. Projektbezug und Quellen

Lernpaket herunterladen

Einrichtung und Prüfstand

GCC mit C++20 und CMake ab 3.25. Zusätzlich Python 3 für den gemeinsamen Prüfstart. Entpacke das Lernpaket in einen neuen Ordner und führe dort python3 run_checks.py aus. Das Skript kopiert die enthaltenen Dateien in einen temporären Lernordner. Dort prüft es zuerst das Beispiel und danach die mitgelieferte Lösung. Die Ausgangsdateien bleiben erhalten. Benötigte Pakete werden beim ersten Lauf aus dem Netz geladen.

Geprüft am 21.10.2026 unter Linux x86_64. Der Konsolenlauf zeigt Besitz und Destruktor-Reihenfolge. Die Lösung verschiebt die Bereichsgrenze und macht die andere Lebensdauer sichtbar.

Ein Fahrzeug besitzt zusammengehörige Daten und Verhalten. Eine Klasse bündelt beides. public bezeichnet die von außen nutzbaren Teile. private schützt Details, die nur die Klasse selbst verwalten soll. Der Konstruktor erzeugt einen gültigen Anfangszustand. Der Destruktor wird beim Ende der Lebensdauer aufgerufen.

RAII verbindet eine Ressource mit einem Objekt, dessen Lebensdauer klar begrenzt ist. std::string und std::vector haben dieses Prinzip bereits benutzt. Jetzt betrachten wir zusätzlich std::unique_ptr als eindeutigen Besitzer eines dynamisch erzeugten Objekts. In der fertigen App bleiben einfache Fahrzeugdaten Werttypen. Nicht jedes Objekt benötigt einen Zeiger.

Paketinhalt und einzelne Dateien

01Den Fahrzeugtyp lesen

Vehicle erhält beim Erzeugen einen Namen. Die Initialisierung nach dem Doppelpunkt setzt name_, bevor der Konstruktorkörper läuft. std::move erlaubt die Übernahme der übergebenen Zeichenfolge. Die Methode name gibt lesenden Zugriff auf den gespeicherten Namen. Das private Feld kann nicht beliebig von außen verändert werden.

main.cpp · cppDatei öffnen
#include <iostream>
#include <memory>
#include <string>
#include <utility>
class Vehicle {
public:
  explicit Vehicle(std::string name) : name_(std::move(name)) {}
  ~Vehicle() { std::cout << "released=" << name_ << '\n'; }
  const std::string &name() const { return name_; }

private:
  std::string name_;
};
void printName(const Vehicle &vehicle) {
  std::cout << "vehicle=" << vehicle.name() << '\n';
}
int main() {
  {
    auto vehicle = std::make_unique<Vehicle>("Cart 1");
    printName(*vehicle);
  }
  std::cout << "scope_finished=true\n";
}

Starten / prüfen

g++ -std=c++20 main.cpp -o lesson
./lesson

02Referenz und Kopie unterscheiden

printName erhält const Vehicle&. Das kaufmännische Und bezeichnet eine Referenz auf das vorhandene Fahrzeug. Es wird keine zweite Fahrzeugkopie erzeugt. const verhindert Änderungen über diese Referenz. Die Referenz besitzt das Fahrzeug nicht und darf nicht länger als das Fahrzeug verwendet werden.

03Eindeutigen Besitz beobachten

std::make_unique erzeugt das Fahrzeug und gibt seinen Besitzer zurück. Der Stern vor vehicle greift auf das besessene Objekt zu. Der innere Block endet vor der letzten Ausgabe. Beim Blockende zerstört unique_ptr das Fahrzeug automatisch. Der Destruktor macht diesen Zeitpunkt durch eine Ausgabe sichtbar.

Erwartetes Ergebnis

vehicle=Cart 1 released=Cart 1 scope_finished=true

04Die Prüfung nachvollziehen

Der Konsolenlauf zeigt Besitz und Destruktor-Reihenfolge. Die Lösung verschiebt die Bereichsgrenze und macht die andere Lebensdauer sichtbar. Starte python3 run_checks.py aus dem entpackten Paket. Vergleiche die Test-Erwartungen mit der Übung, bevor du die Lösung öffnest.

Erwartetes Ergebnis

Beispiel und automatisierte Lösung bestehen. Die genannten manuellen Prüfungen bleiben getrennt.

05Die Regel auf die App übertragen

FactoryForge besitzt den Simulationskern über einen eindeutigen Besitzer. Der stoppbare Thread endet vor dessen Freigabe. Karten und Fahrzeugzustände werden dagegen als Werte kopiert. Entscheidend sind Besitz und Lebensdauer. Eine Referenz, ein Zeiger und eine Zustandskopie sind keine austauschbaren Lösungen für dasselbe Problem.

Deine Übung

Verschiebe die letzte Ausgabe in den inneren Block. Welche Ausgabe erscheint dann zuerst? Erkläre außerdem, weshalb eine Referenz auf das freigegebene Fahrzeug ungültig wäre.

Lösung mit Erklärung anzeigen

Im inneren Block erscheint scope_finished vor released, weil der Besitzer noch lebt. Erst an der schließenden Klammer wird das Fahrzeug zerstört. Eine gespeicherte Referenz verlängert die Lebensdauer nicht. Nach der Zerstörung darf sie nicht mehr gelesen werden. Behalte daher den Besitzer so lange, wie der Zugriff benötigt wird, oder übertrage einen unabhängigen Wert.

solution/main.cpp · cppDatei öffnen
#include <iostream>
#include <memory>
#include <string>
#include <utility>
class Vehicle {
public:
  explicit Vehicle(std::string name) : name_(std::move(name)) {}
  ~Vehicle() { std::cout << "released=" << name_ << '\n'; }
  const std::string &name() const { return name_; }

private:
  std::string name_;
};
void printName(const Vehicle &vehicle) {
  std::cout << "vehicle=" << vehicle.name() << '\n';
}
int main() {
  {
    auto vehicle = std::make_unique<Vehicle>("Cart 1");
    printName(*vehicle);
    std::cout << "scope_finished=true\n";
  }
}

Projektbezug und Quellen

Die ersten sechs Beispiele sind eigenständige Lernprogramme. Lektionen 7 bis 9 nutzen den vollständigen FactoryForge-Quellstand. Quellcode, Übungen und überprüfte Vereinfachungen sind getrennt beschrieben. Die Projektseite bietet ein Quellcode-ZIP, solange das GitHub-Repository noch nicht veröffentlicht ist.