Création de Pointeurs Uniques

Techniquement, il existe deux façons de créer un pointeur unique. Cependant, l'une de ces méthodes est largement déconseillée par les experts en C++. Dans un but d'apprentissage, nous explorerons les deux méthodes.

La méthode recommandée – utiliser std::make_unique

Le std::make_unique, introduit dans C++14, est une fonction qui fournit un moyen sûr et efficace de créer des pointeurs uniques. C'est une excellente alternative à l'utilisation des opérateurs new/delete et new[]/delete[], qui peuvent rendre le code C++ plus susceptible aux problèmes liés à la mémoire.

makeunique


              123456789
            
#include <iostream>
#include <memory>
#include <vector>

int main()
{
    // Here we use std::make_unique to create a unique pointer to a vector of integers.
    std::unique_ptr<std::vector<int>> uniqueVectorPtr = std::make_unique<std::vector<int>>();
}

Dans le code ci-dessus, std::make_unqiue alloue la ressource dynamique et retourne un pointeur unique qui en est propriétaire. Lorsque le pointeur unique sort de la portée, la ressource est automatiquement désallouée. De plus, il est conçu pour être sécurisé contre les exceptions, ce qui élimine les risques de fuites de ressources dues aux exceptions.

Remarque

N'utilisez pas std::make_unique lorsque vous spécifiez un destructeur personnalisé pour votre pointeur unique. Les destructeurs personnalisés sont un concept avancé que nous aborderons plus tard dans ce cours.*

La méthode déconseillée – Initialisation directe

Vous pouvez également créer un pointeur unique directement en l'initialisant avec le résultat de l'opérateur new. Cependant, cette approche est déconseillée, en raison des fuites de ressources potentielles en cas d'exception.

newUniquePtr


              123456789
            
#include <iostream>
#include <memory>
#include <vector>

int main()
{
    // Insecure way to create a unique pointer for a vector of integers.
    std::unique_ptr<std::vector<int>> uniqueVectorPtr(new std::vector<int>());
}

Le vecteur dans le code ci-dessus sera toujours automatiquement détruit lorsque le pointeur unique sort de la portée. Cependant, pour une sécurité maximale contre les exceptions et de meilleures pratiques de code, préférez toujours utiliser std::make_unique.

Gestion des objets personnalisés avec des pointeurs uniques

Les pointeurs uniques ne sont pas limités aux types de données primitifs (comme les entiers) ou aux conteneurs standard (comme les vecteurs). Ils peuvent également être utilisés pour gérer des objets personnalisés alloués dynamiquement.

customObjUniquePtr


              12345678910111213141516171819202122232425262728293031323334
            
#include <iostream>
#include <memory>

class CustomObject {
public:
    //defining a constructor of our CustomObject which takes in two values
    CustomObject(int value1, int value2) : param1(value1), param2(value2) {
        std::cout << "CustomObject constructed with values: " << param1 << " and " << param2 << std::endl;
    }

    void performAction() {
        std::cout << "CustomObject is performing an action." << std::endl;
    }
    //The destructor of our CustomObject, which will be called when the associated unique pointer goes out of scope.
    ~CustomObject() {
        std::cout << "CustomObject destroyed with values: " << param1 << " and " << param2 << std::endl;
    }

private:
    int param1;
    int param2;
};

int main() {
    // Using std::make_unique to create a unique pointer for a CustomObject, passing required values to the constructor
    std::unique_ptr<CustomObject> customObjectPtr = std::make_unique<CustomObject>(42, 77);

    // Invoking a member function
    customObjectPtr->performAction();

//Destructor of the custom object will be called when the function ends
    return 0;
}

Dans le code ci-dessus, nous gérons un objet personnalisé à l'aide d'un pointeur unique. Dès que l'objet sort de la portée, le pointeur unique appelle son destructeur pour le désallouer. Lisez les commentaires du code pour savoir exactement ce qui se passe !

Tout était clair ?

Merci pour vos commentaires !

Section 2. Chapitre 2