Wie viele andere Sprachen hat C++ Zeiger.
Du weißt schon, dass Referenzen und Zeiger sich ähneln, aber stell sie dir als eine Ebene näher an den inneren Abläufen deines Computers vor.
Zeiger sind Variablen, die Objektadressen speichern.
Man verwendet sie, um direkt mit Objekten zu interagieren, was dynamische Speicherverwaltung und effiziente Datenmanipulation in C++ ermöglicht.
Wenn Zeiger für dich neu sind, wirken sie vielleicht etwas mysteriös, aber sobald du dich an sie gewöhnt hast, sind sie ganz unkompliziert.
Sie sind ein entscheidender Teil von C++, also nimm dir etwas Zeit, um sie wirklich zu verstehen.
Die einfache Variante in diesem Konzept wird auch dumb pointer oder raw pointer genannt.
Im modernen C++ gibt es außerdem smart pointers; der einfache Typ ist überhaupt nicht intelligent und du musst die ganze Arbeit selbst erledigen.
Bevor wir in die Details eintauchen, lohnt es sich, den Nutzen von Zeigern zu verstehen.
Zeiger sind eine Möglichkeit, die Adresse eines Objekts mit anderen Teilen unseres Programms zu teilen, was aus zwei wichtigen Gründen nützlich ist:
- Wie Referenzen vermeiden Zeiger Kopien und helfen, den Ressourcenverbrauch deines Programms zu verringern.
- Im Gegensatz zu Referenzen kannst du einen Zeiger auf ein anderes Objekt zeigen lassen.
- Zeiger können außerdem auf einen Nullwert zeigen, um anzuzeigen, dass sie gerade auf kein Objekt zeigen.
Allgemeine Syntax
Bei einer Zeigerdeklaration in C++ gibst du den Datentyp an, auf den der Zeiger zeigt, gefolgt von einem Sternchen (*) und dem Namen des Zeigers.
Wenn Zeiger deklariert werden, sind sie nicht automatisch initialisiert.
Ohne explizite Zuweisung enthält ein Zeiger typischerweise einen unbestimmten Wert, der oft als „Garbage-Adresse“ bezeichnet wird.
Manche Compiler initialisieren Zeiger zwar mit nullptr, aber dieses Verhalten ist nicht bei allen Compilern garantiert, also solltest du dich nicht darauf verlassen.
Es gilt als bewährte Praxis, rohe Zeiger explizit zu initialisieren und vor der Verwendung zu prüfen, dass sie nicht null sind, um mögliche Probleme zu vermeiden.
int* ptr{nullptr}; // Declares a pointer and makes sure it is not invalid
Um die Adresse einer Variable einem Zeiger zuzuweisen, verwendest du den Adressoperator (&).
Zum Dereferenzieren eines Zeigers verwendest du den Dereferenzierungsoperator (*).
std::string opponent{"Solomon Lane"};
// 'ethan' points to the address of the string opponent
std::string* ethan{&opponent};
// Instead of ethan's, the opponent's name address is given to the passPort
std::string passportName{*ethan};
Achtung: Das Dereferenzieren muss explizit erfolgen, während Referenzen einfach wie ein Alias funktionierten.
Zeigerarithmetik
Zeigerarithmetik ermöglicht es dir, Rechenoperationen mit Zeigern durchzuführen, was besonders nützlich ist, wenn du mit Arrays arbeitest.
Wenn du eine Ganzzahl zu einem Zeiger addierst, zeigt er auf ein anderes Element.
// Stargate Coordinate Code
int gateCode[] = {462, 753, 218, 611, 977};
// 'ptr' points to the first element of 'gateCode'
int* ptr{&gateCode[0]};
// Accesses the third Stargate address through pointer arithmetic
int dialedAddress{*(ptr + 2)};
// Chevron encoded! Dialing Stargate address:
openStarGate(dialedAddress);
Zeigerarithmetik in C++ kann bei unvorsichtiger Handhabung leicht zu undefiniertem Verhalten führen.
Undefiniertes Verhalten kann sich in unerwarteten Programmergebnissen, Abstürzen oder sogar Sicherheitslücken äußern.
Ein berüchtigtes Beispiel für die Folgen undefinierten Verhaltens war die Explosion der Ariane-5-Rakete im Jahr 1996, bei der eine Softwareausnahme, ausgelöst durch die Umwandlung einer 64-Bit-Gleitkommazahl in eine 16-Bit-Ganzzahl mit Vorzeichen, zu einem katastrophalen Fehlschlag führte.
Zugriff auf Membervariablen
In C++ wird der Operator -> verwendet, um über einen Zeiger auf ein Objekt auf dessen Member zuzugreifen.
Er ist eine Kurzschreibweise, die den Zugriff auf Member von Objekten vereinfacht, auf die Zeiger zeigen.
Wenn ptr zum Beispiel ein Zeiger auf ein Objekt mit der Membervariablen x ist, kannst du statt (*ptr).x direkt ptr->x verwenden.
Dieser Operator verbessert die Lesbarkeit des Codes und verringert die Ausführlichkeit, wenn du mit Zeigern auf Objekte arbeitest.
Hier ist ein kurzes Beispiel mit einer struct Superhero, die eine Membervariable superpower hat.
Die main-Funktion erstellt einen Zeiger dianaPrince auf ein Superhero-Objekt (das Wonder Woman darstellt).
Mit dem Operator -> wird auf die Membervariable superpower zugegriffen, was Wonder Womans ikonisches „Lasso of Truth“ zeigt.
struct Superhero {
std::string superpower;
};
Superhero wonder_woman{};
Superhero* dianaPrince = &wonder_woman;
dianaPrince->superpower = "Lasso of Truth";
// Using the -> operator to access member variable superpower:
std::cout << "Wonder Woman, possesses the mighty " << dianaPrince->superpower;
Zeiger vs. Referenzen
Zeiger und Referenzen ermöglichen beide den indirekten Zugriff auf Objekte, unterscheiden sich aber in ihren Möglichkeiten und in puncto Sicherheit.
Zeiger bieten die Flexibilität, ihr Zielobjekt zu ändern, und können auf null gesetzt werden.
Diese Flexibilität bringt jedoch Risiken mit sich, etwa das Dereferenzieren von Nullzeigern oder das Erzeugen hängender Zeiger.
Referenzen hingegen können nicht null sein und sind bei ihrer Erstellung an gültige Objekte gebunden, wodurch diese Risiken vermieden werden.
Aufgrund ihrer sichereren Natur solltest du Referenzen Zeigern vorziehen, es sei denn, du brauchst die zusätzlichen Möglichkeiten, die Zeiger bieten.
Lernübung
