Partager via

make_unique

  • Article

Crée et retourne un unique_ptr à un objet du type spécifié, qui est construit à l'aide des arguments spécifiés.

// make_unique<T>
template<class T, 
    class... Types>
    unique_ptr<T> make_unique(Types&&... Args)
    {
    return (unique_ptr<T>(new T(forward<Types>(Args)...))); 
    }

// make_unique<T[]>
template<class T>
    make_unique(size_t Size) 
    { 
    return (unique_ptr<T>(new Elem[Size]())); 
    }

// make_unique<T[N]> disallowed
template<class T, 
    class... Types>
    typename enable_if<extent<T>::value != 0, 
        void>::type make_unique(Types&&...) = delete;

Paramètres

  • T
    La type de l'objet vers lequel unique_ptr pointera.

  • Types
    Les types des arguments de constructeur spécifiés par Args.

  • Args
    Arguments à passer au constructeur de l'objet du type T.

  • Elem
    Un tableau d'éléments de type T.

  • Size
    Le nombre d'éléments pour lesquels allouer de l'espace dans le tableau.

Valeur de retour

Un unique_ptr pour un objet du type spécifié T.

Notes

La première surcharge est utilisée pour les objets unique, la deuxième surcharge est appelée pour les tableaux, et la troisième surcharge vous empêche de spécifier une taille du tableau dans l'argument de type (make_unique<T[N]>) ; cette construction n'est pas prise en charge par la norme actuel. Lorsque vous utilisez make_unique pour créer une unique_ptr dans un tableau, vous devez initialiser les éléments du tableau séparément. Si vous tenez compte de cette surcharge, il est peut-être préférable d'utiliser un std::vector.

Comme make_unique est attentivement implémenté pour la sécurité de l'exception, nous vous recommandons d'utiliser make_unique au lieu d'appeler directement des constructeurs unique_ptr.

Exemple

L'exemple suivant montre comment utiliser make_unique. Pour plus d'exemples, consultez Comment : créer et utiliser des instances unique_ptr.

class Animal
{
private:
    std::wstring genus;
    std::wstring species;
    int age;
    double weight;
public:
    Animal(const wstring&, const wstring&, int, double){/*...*/ }
    Animal(){}
};

void MakeAnimals()
{
    // Use the Animal default constructor.
    unique_ptr<Animal> p1 = make_unique<Animal>();

    // Use the constructor that matches these arguments
    auto p2 = make_unique<Animal>(L"Felis", L"Catus", 12, 16.5);

    // Create a unique_ptr to an array of 5 Animals
    unique_ptr<Animal[]> p3 = make_unique<Animal[]>(5);

    // Initialize the elements
    p3[0] = Animal(L"Rattus", L"norvegicus", 3, 2.1);
    p3[1] = Animal(L"Corynorhinus", L"townsendii", 4, 1.08);

    // auto p4 = p2; //C2280

    vector<unique_ptr<Animal>> vec;
    // vec.push_back(p2); //C2280 
    // vector<unique_ptr<Animal>> vec2 = vec; // C2280 

    // OK. p2 no longer points to anything
    vec.push_back(std::move(p2)); 

    // unique_ptr overloads operator bool
    wcout << boolalpha << (p2 == false) << endl; // Prints "true" 

    // OK but now you have two pointers to the same memory location
    Animal* pAnimal = p2.get();

    // OK. p2 no longer points to anything
    Animal* p5 = p2.release();
}

Lorsque vous voyez l'erreur C2280 en liaison avec unique_ptr, il est presque certaine que vous essayez d'appeler sa copie de constructeur, qui est une fonction supprimée.

Configuration requise

<mémoire>

Voir aussi

Tâches

Comment : créer et utiliser des instances unique_ptr