Die Macht von Troy

Das Schlüsselwort auto in C++

In C++ ist das Schlüsselwort auto ein mächtiges Feature, das mit C++11 eingeführt wurde. Du verwendest es, um Variablen mit einem abgeleiteten Datentyp zu deklarieren. Der Compiler leitet den Typ der Variablen aus ihrem Initialisierungswert ab. Das kann den Code lesbarer und einfacher zu warten machen.

Verwendungsbeispiel

Schauen wir uns das folgende Beispiel an, in dem auto zum Deklarieren von Variablen verwendet wird:

auto dragon_population{3};          // dragon_population is deduced as an integer
auto westeros{7.7777};              // westeros is deduced as a double
auto wedding_location{"The Twins"}; // wedding_location is deduced as a const char*, not std::string

In jedem Fall wird der Typ der Variable aus dem Wert abgeleitet, mit dem sie initialisiert wird.

Typableitung

Das Schlüsselwort auto hilft dir, prägnanteren und lesbareren Code zu schreiben, weil du explizite Typen nicht mehr so ausführlich hinschreiben musst.

const std::vector<std::string> pigeon_pie{"flour", "butter", "pigeon", "salt"};
auto purple_wedding_pie{pigeon_pie};
purple_wedding_pie.emplace_back("the strangler");

Hier leitet auto den Typ von purple_wedding_pie als std::vector<std::string> ab, sodass du den Typ nicht erneut explizit angeben musst.

Kompatibilität

Das Schlüsselwort auto ist mit verschiedenen C++-Konstrukten kompatibel und damit ein vielseitiges Werkzeug in der modernen C++-Programmierung.

auto& element{array[0]};           // reference to an element
const auto object{otherObject};    // const type version of otherObject's type
auto* ptr{&x};                     // pointer to x with the same type as x, but as a pointer.

In späteren Konzepten wirst du das Schlüsselwort auto oft zusammen mit Lambda-Ausdrücken, bereichsbasierten for-Schleifen und Iteratoren sehen.

Smart Pointer

Smart Pointer sind ein modernes C++-Feature für die automatische Speicherverwaltung. Sie helfen, Speicherlecks und hängende Zeiger zu vermeiden, wie sie bei rohen Zeigern häufig vorkommen. Sie wirken als Hüllen um rohe Zeiger und fügen zusätzliche Funktionalität hinzu, etwa das automatische Freigeben des Speichers, wenn der Zeiger nicht mehr gebraucht wird.

Allgemeine Syntax

Smart Pointer sind in der C++-Standardbibliothek typischerweise als Klassentemplates implementiert. Die beiden am häufigsten verwendeten Smart Pointer sind std::unique_ptr und std::shared_ptr.

Unique Pointer

std::unique_ptr ist ein Smart Pointer, der das Objekt exklusiv besitzt. Er stellt sicher, dass zu jedem Zeitpunkt nur ein std::unique_ptr-Objekt die Ressource besitzt. Wenn der besitzende std::unique_ptr zerstört oder zurückgesetzt wird, zerstört er automatisch das Objekt und gibt seinen Speicher frei.

#include <memory>
// Declaring and defining a unique pointer
auto rightful_king_of_england = std::make_unique<std::string>("Excalibur");

// Unique pointers cannot be copied or assigned
auto mordred = rightful_king_of_england; // Error: Cannot copy a unique_ptr

Vorteile von std::make_unique()

Wenn du einen std::unique_ptr erstellst, solltest du std::make_unique() verwenden, statt mit new direkt Speicher zu reservieren. std::make_unique() bietet mehrere Vorteile:

1. Ausnahmesicherheit: std::make_unique() garantiert Ausnahmesicherheit. Wird während der Konstruktion des Objekts eine Ausnahme ausgelöst, wird der Speicher automatisch freigegeben, sodass keine Speicherlecks entstehen.
2. Klarheit: std::make_unique() macht den Code klarer und prägnanter. Du musst den Typ, der reserviert wird, nicht mehr explizit angeben, weil die Template-Argumente automatisch abgeleitet werden.
3. Optimierungsmöglichkeiten: Compiler können std::make_unique() besser optimieren als eine manuelle Speicherreservierung mit new, was die Leistung verbessern kann.
4. Vermeidung von Fehlgebrauch: Wenn du den std::unique_ptr manuell konstruierst, kannst du die zugrunde liegende Ressource löschen. Das führt zu undefiniertem Verhalten, wenn der std::unique_ptr sie am Ende seines Gültigkeitsbereichs zu löschen versucht.

Shared Pointer

std::shared_ptr ist ein Smart Pointer, mit dem mehrere std::shared_ptr-Objekte gemeinsam den Besitz an derselben Ressource teilen können. Er zählt mit, wie viele Shared Pointer auf die Ressource verweisen, und gibt den Speicher erst frei, wenn der letzte Shared Pointer, der die Ressource besitzt, seinen Gültigkeitsbereich verlässt oder zurückgesetzt wird.

// Declaring and defining a shared pointer to a dynamically allocated string
auto martian_congressional_republic = std::make_shared<std::string>("protomolecule");

// Creating more shared pointer that shares ownership
auto outer_planets_alliance = martian_congressional_republic;
auto united_nations = martian_congressional_republic;

Vorteile von std::make_shared()

Ähnlich wie std::make_unique() bietet std::make_shared() Vorteile wie eine bessere Speichereffizienz, Ausnahmesicherheit und Lesbarkeit. Es fasst die Speicherreservierung für den Kontrollblock und das verwaltete Objekt in einem einzigen Schritt zusammen. Das erhöht die Effizienz und verringert das Risiko von Speicherlecks. Außerdem vereinfacht die automatische Ableitung der Template-Argumente den Code und verbessert die Lesbarkeit. Mit std::make_shared() schreibst du saubereren, sichereren und effizienteren Code, wenn du mit std::shared_ptr-Objekten in C++ arbeitest.

Empfehlungen zur Verwendung

Verwende standardmäßig Smart Pointer: std::unique_ptr für exklusiven Besitz und std::shared_ptr für gemeinsamen Besitz. Rohe Zeiger reservierst du für nicht-besitzende Referenzen oder für die Anbindung an alten Code. In den meisten Fällen reicht std::unique_ptr für exklusiven Besitz aus, denn er bietet eine schlanke Speicherverwaltung ohne den Overhead der Referenzzählung. std::shared_ptr solltest du sparsam einsetzen, denn er bringt Overhead und Komplexität mit sich, solange du nicht wirklich gemeinsamen Besitz brauchst.