Weitergabe von Unique Pointers

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

Beim Zurückgeben von Builder-Funktionen

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

unique_pointer_builder


              123456789101112131415
            
#include <iostream>
#include <memory>

std::unique_ptr<int> unique_ptr_builder() { return std::make_unique<int>(42); }

int main()
{
    // This will be the sole owner of the dynamically allocated integer 42
    std::unique_ptr<int> p_unique = unique_ptr_builder();

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

Verwendung einer Builder-Funktion, um einen einzigartigen Zeiger auf einen int-Wert zu erstellen. Sobald die Funktion zurückkehrt, zeigt der unique_ptr in der main-Funktion auf den dynamischen Integer-Wert.

Beim Übertragen des Besitzes

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

transferring_ownership


              12345
            
// Create a unique pointer inside classA
classA->source_ptr = std::make_unique<int>(42);

// Later, move the ownership to classB, this is perfectly fine
classB->target_ptr = std::move(sourcePtr);

Wann man keine Unique Pointers übergeben sollte

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

Sie können eine Instanz eines Unique Pointers innerhalb einer Klasse erstellen und dann ihren rohen Pointer an eine externe Bibliotheksfunktion übergeben. Solches Teilen ist unsicher und kann zu schwer zu debuggenden Speicherproblemen führen.

passing_raw_pointer


              12345
            
// Create a unique pointer.
std::unique_ptr<std::string> p_unique = std::make_unique<int>(33);

// Extract the raw pointer and pass it to an external class.
ExternalClass obj(p_unique.get()); // Never do this, not safe.

War alles klar?

Danke für Ihr Feedback!

Abschnitt 2. Kapitel 4