Freigeben über

make_unique

  • Artikel

Erstellt ein unique_ptr-Element und gibt es an ein Objekt des angegebenen Typs zurück, das mithilfe der angegebenen Argumente erstellt wird.

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

Parameter

  • T
    Der Typ des Objekts, auf das unique_ptr zeigt.

  • Types
    Die von Args angegebenen Typen der Konstruktorargumente.

  • Args
    Die an den Konstruktor des Objekts vom Typ T übergebenen Argumente.

  • Elem
    Ein Array von Elementen des Typs T.

  • Size
    Die Anzahl von Elementen, denen im neue Array ein Bereich zugeordnet werden soll.

Rückgabewert

Ein unique_ptr für ein Objekt vom angegebenen Typ T.

Hinweise

Die erste Überladung wird für einzelne Objekte verwendet, die zweite Überladung wird für Arrays aufgerufen, und die dritte Überladung verhindert die Angabe einer Arraygröße im Typargument (make_unique<T[N]>). Diese Konstruktion wird nicht vom aktuellen Standard unterstützt. Wenn Sie make_unique verwenden, um unique_ptr in ein Array zu erstellen, müssen die Arrayelemente separat initialisiert werden. Bei Berücksichtigung dieser Überladung ist die Verwendung von std::vector eventuell besser.

Da make_unique sorgfältig für die Ausnahmesicherheit implementiert wird, wird empfohlen, make_unique zu verwenden, anstatt unique_ptr -Konstruktoren direkt aufzurufen.

Beispiel

Das folgende Beispiel veranschaulicht die Verwendung von make_unique. Weitere Beispiele finden Sie unter Gewusst wie: Erstellen und Verwenden von unique_ptr-Instanzen.

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

Wenn der Fehler "C2280" in Verbindung mit unique_ptr angezeigt wird, ist der Grund dafür fast sicherlich, der Versuch, den Kopierkonstruktor aufzurufen, der eine gelöschte Funktion ist.

Anforderungen

<Arbeitsspeicher>

Siehe auch

Aufgaben

Gewusst wie: Erstellen und Verwenden von unique_ptr-Instanzen