std::unique_ptr::unique_ptr

This page has been machine-translated from the English version of the wiki using Google Translate.

The translation may contain errors and awkward wording. Hover over text to see the original version. You can help to fix errors and improve the translation. For instructions click here.

Click here for the English version of this page

Dynamische Speicherverwaltung

Low-Level-Speicherverwaltung

Zuweiser

(C++11)

(C++11)

(C++11)

(C++11)

scoped_allocator_adaptor

(C++11)

Initialisierter Speicher

(C++11)

return_temporary_buffer

Intelligente Zeiger

(C++11)

(C++11)

(C++11)

(veraltet)

(C++11)

enable_shared_from_this

(C++11)

bad_weak_ptr

(C++11)

default_delete

(C++11)

Garbage Collection Unterstützung

declare_reachable

(C++11)

undeclare_reachable

(C++11)

declare_no_pointers

(C++11)

undeclare_no_pointers

(C++11)

pointer_safety

(C++11)

get_pointer_safety

(C++11)

Verschiedenes

pointer_traits

(C++11)

addressof

(C++11)

align

(C++11)

C-Bibliothek

Member-Funktionen

unique_ptr::unique_ptr

unique_ptr::~unique_ptr

unique_ptr::operator=

Modifiers

Beobachter

unique_ptr::get_deleter

unique_ptr::operator bool

unique_ptr::operator*
unique_ptr::operator->

unique_ptr::operator[]

Non-Member-Funktionen

operator==
operator!=
operator<
operator>
operator<=
operator>
operator>=

std::swap

std::hash

[edit]


`constexpr unique_ptr();`	(1)	(seit C++11)

`explicit unique_ptr( pointer p );`	(2)	(seit C++11)

`unique_ptr( pointer p, d1 );`	(3)	(seit C++11)

`unique_ptr( pointer p, d2 );`	(4)	(seit C++11)

`unique_ptr( unique_ptr&& u );`	(5)	(seit C++11)

`constexpr unique_ptr( nullptr_t );`	(6)	(seit C++11)

`template< class U, class E > unique_ptr( unique_ptr<U, E>&& u );`	(7)	(seit C++11)

`template< class U > unique_ptr( auto_ptr<U>&& u );`	(8)	(seit C++11)

1)

Erzeugt eine leere std::unique_ptr .

2)

Erzeugt ein std::unique_ptr die p besitzt, die Initialisierung der gespeicherten Zeiger mit p und Wert-Initialisierung der gespeicherten deleter .

3-4)

Erzeugt ein std::unique_ptr Objekt, das p besitzt, die Initialisierung der gespeicherten Zeiger mit p und die Initialisierung eines deleter D wie unten (abhängig davon, ob D ist ein Referenz-Typ)

a)

Wenn D Nicht-Referenz-Typ A ist, dann die Unterschriften sind:

unique_ptr(pointer p, const A& d);

unique_ptr(pointer p, A&& d);

b)

Wenn D ein L-Wert-Referenz-Typ A& ist, dann die Unterschriften sind:

unique_ptr(pointer p, A& d);

unique_ptr(pointer p, A&& d);

c)

Wenn D ein L-Wert-Referenz-Typ const A& ist, dann die Unterschriften sind:

unique_ptr(pointer p, const A& d);

unique_ptr(pointer p, const A&& d);

5)

Erzeugt ein unique_ptr durch Eigentumsübertragung von u um *this .

6)

Erzeugt eine leere std::unique_ptr .

7)

Erzeugt ein unique_ptr durch Eigentumsübertragung von u um *this, wo u mit einem angegebenen deleter (E) aufgebaut ist. Es hängt davon ab, ob E ein Verweistyp ist, wie folgt lautet:

a)

wenn E ein Referenz-Typ ist, ist dies deleter Kopie von u die deleter gebaut .

b)

wenn E ein Nicht-Referenz-Typ ist, ist dies deleter Umzug von u die deleter gebaut .

8)

Erzeugt ein unique_ptr wo die gespeicherte Zeiger mit u.release() initialisiert wird und die gespeicherte deleter Wert ist initialisiert .

Parameter

p	-	werden. ein Zeiger auf ein Objekt zu verwalten Original: a pointer to an object to manage The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.
d1,d2	-	ein deleter zu verwenden, um das Objekt zu zerstören Original: a deleter to use to destroy the object The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.
u	-	ein weiteres Smart-Pointer auf das Eigentum von erwerben Original: another smart pointer to acquire the ownership from The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.

Ausnahmen

noexcept specification:


`noexcept`

(seit C++11)

Beispiel

#include <iostream>
#include <memory>

struct Foo {
    Foo() { std::cout << "Foo...\n"; }
    ~Foo() { std::cout << "~Foo...\n\n"; }
};

struct D{

    D(){};

    D(const D& other){
        std::cout << "call D const copy constructor... \n";
    }

    D(D& other){
        std::cout << "call D copy constructor... \n";
    }

    D(D&& other){
        std::cout << "call D move constructor... \n";
    }

    void operator () (Foo* p) const {
        std::cout << "Call delete for Foo object...\n";
        delete p;
    };
};

int main()
{
    //constructor (1)
    std::cout << "Example constructor(1)...\n\n";
    std::unique_ptr<Foo> up;

    //constructor (2)
    std::cout << "Example constructor(2)...\n";
    Foo* f = new Foo();
    std::unique_ptr<Foo> up2(f); //up2 now owns f
    up2.reset();

    //constructor (3&4)
    std::cout << "Example constructor(3&4)...\n";

    //D is not an lvalue-reference - d is a non-const rvalue
    std::unique_ptr<Foo, D> up3(new Foo(), D()); //D must be MoveConstructible
    up3.reset();

    //D is not an lvalue-refernce - d is a left value
    D d2;
    std::unique_ptr<Foo, D> up4(new Foo(), d2); //D must be Copyconstructible
    up4.reset();

    //D is a left value reference type
    D d3;
    std::unique_ptr<Foo, D&> up5(new Foo(), d3); //up3 holds a reference to d3
    up5.reset();

    //D is a const left value reference type
    const D d4;
    std::unique_ptr<Foo, const D&> up6(new Foo(), d4);
    up6.reset();

    //constructor (5)
    std::cout << "Example constructor(5)...\n";
    std::unique_ptr<Foo> up7(new Foo());
    std::unique_ptr<Foo> up8(move(up7)); //ownership is transfered to up8
    up8.reset();

    //constructor 6
    std::cout << "Example constructor(6)...\n\n";
    std::unique_ptr<Foo> up9(nullptr);

    //constructor 7 - D is move constructed
    D d;
    std::cout << "Example constructor(7)...\n";
    std::unique_ptr<Foo, D> up10(new Foo(), d);     //D is not a reference
    std::unique_ptr<Foo, D> up11(move(up10));       //D is move constructed
    up11.reset();

    //constructor 7 - D is copy constructed
    std::unique_ptr<Foo, D&> up12(new Foo(), d);    //D is a reference
    std::unique_ptr<Foo, D> up13(move(up12));       //D is copy constructed
    up13.reset();

    //constructor 8
    std::cout << "Example constructor(8)...\n";
    std::auto_ptr<Foo> up14(new Foo());
    std::unique_ptr<Foo> up15(move(up14));
    up15.reset();

}

Sprache
Concepts
Utilities-Bibliothek
Strings Bibliothek
Container-Bibliothek
Algorithmen-Bibliothek
Iteratoren Bibliothek
Numerik-Bibliothek
Input / Output-Bibliothek
Lokalisierungen Bibliothek
Reguläre Ausdrücke Bibliothek (C++11)
Atomare Operationen Bibliothek (C++11)
Thread Support-Bibliothek (C++11)

cppreference.com

Suche

Namensräume

Varianten

Ansichten

Aktionen

std::unique_ptr::unique_ptr

Parameter

Ausnahmen

Beispiel

Navigation

Werkzeuge