Passer des Pointeurs Uniques

Quand est-il acceptable de 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 du code. Cependant, lorsqu'il s'agit de pointeurs uniques, le passage devient un peu délicat.

Remarque

Il existe certaines bonnes pratiques que vous devez suivre lorsque vous accédez à des pointeurs uniques au-delà de la portée dans laquelle ils ont été initialisés.

Lors du retour de fonctions de construction :

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

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

Dans le code ci-dessus, nous utilisons une fonction de construction pour créer un pointeur unique vers une valeur entière. Une fois que la fonction retourne, le myUniquePtr 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.

Quand n'est-il pas approprié de passer des pointeurs uniques ?

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

Par exemple, vous pouvez créer une instance de pointeur unique à l'intérieur d'une classe puis 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.

Tout était clair ?

Merci pour vos commentaires !

Section 2. Chapitre 4