Weitergabe von Einzigartigen Zeigern

Wann ist es in Ordnung, eindeutige Zeiger zu übergeben?

Einer der Hauptgründe, warum wir Zeiger und dynamische Speicherzuweisung gegenüber statischen Variablen wählen, ist die Flexibilität, die sie beim Übergeben von Daten in verschiedenen Codeabschnitten bieten. Bei eindeutigen Zeigern wird das Übergeben jedoch etwas knifflig.

Hinweis

Es gibt bestimmte bewährte Praktiken, die Sie befolgen sollten, wenn Sie auf eindeutige Zeiger außerhalb des Bereichs, in dem sie initialisiert wurden, zugreifen.

Beim Zurückgeben von Builder-Funktionen:

Ein gültiger Anwendungsfall für das Übergeben eines eindeutigen Zeigers ist, wenn Sie von einer Builder-Funktion (einer Funktion, die nur zum Zuweisen/Aufbauen von Ressourcen existiert) zurückkehren.

uniquePtrBuilder


              123456789101112131415161718
            
#include <iostream>
#include <memory>

std::unique_ptr<int> uniquePtrBuilder() {
    return std::make_unique<int>(42);   
    // builder function initializes a new unique pointer 
    // and instantly returns it, transferring ownership to caller
}

int main() {
    // this will be the sole owner of the dynamically allocated integer 42
    std::unique_ptr<int> myUniquePtr = uniquePtrBuilder();

    if (myUniquePtr)
        std::cout << "Value from unique pointer: " << *myUniquePtr << std::endl;
    else
        std::cout << "Unique pointer is null." << std::endl;
}

Im obigen Code verwenden wir eine Builder-Funktion, um einen eindeutigen Zeiger auf einen Integer-Wert zu erstellen. Sobald die Funktion zurückkehrt, zeigt myUniquePtr in der main-Funktion auf den dynamischen Integer-Wert.

Beim Übertragen des Besitzes

Es wird auch als gültig und sicher angesehen, einen eindeutigen Zeiger zu move. Zum Beispiel können Sie den Besitz eines eindeutigen Zeigers von class A zu class B übertragen.

Wann ist es nicht in Ordnung, einzigartige Zeiger zu übergeben?

Das Teilen eines std::unique_ptr mit der Absicht, dass mehrere Parteien es besitzen, ist nicht geeignet. Dies bricht das Kernkonzept eines einzigartigen Zeigers, da er nur einen Besitzer haben sollte.

Zum Beispiel können Sie eine Instanz eines einzigartigen Zeigers innerhalb einer Klasse erstellen und dann seinen rohen Zeiger an eine externe Bibliotheksfunktion übergeben. Solches Teilen ist unsicher und kann zu schwer zu debuggen Speicherproblemen führen.

War alles klar?

Danke für Ihr Feedback!

Abschnitt 2. Kapitel 4