Passer des Pointeurs Uniques

L'une des principales raisons pour lesquelles nous choisissons les pointeurs et l'allocation dynamique de mémoire plutôt que les variables statiques est la flexibilité qu'ils offrent pour passer des données dans différentes sections de code. Cependant, lorsqu'il s'agit de pointeurs uniques, le passage devient un peu délicat.

Lors du retour des fonctions de constructeur

Un cas d'utilisation valide pour passer un pointeur unique est lorsque vous retournez d'une fonction de constructeur (une fonction qui existe uniquement pour allouer/construire des ressources).

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;
}

Utilisation d'une fonction de construction pour créer un pointeur unique vers une valeur int. Une fois que la fonction retourne, le unique_ptr dans la fonction main commence à pointer vers la valeur entière dynamique.

Lors du Transfert de Propriété

Il est également considéré comme valide et sûr de move un pointeur unique. Par exemple, vous pouvez transférer la propriété d'un pointeur unique de class A à class B.

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);

Quand ne pas passer des pointeurs uniques

Partager un std::unique_ptr avec l'intention que plusieurs parties en soient propriétaires n'est pas approprié. Cela brise le concept fondamental d'un pointeur unique, car il ne devrait avoir qu'un seul propriétaire.

Vous pouvez créer une instance de pointeur unique à l'intérieur d'une classe et ensuite passer son pointeur brut à une fonction de bibliothèque externe. Un tel partage est dangereux et peut entraîner des problèmes de mémoire difficiles à déboguer.

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.

Tout était clair ?

Merci pour vos commentaires !

Section 2. Chapitre 4