std::unique_ptr::unique_ptr

Questa pagina è stata tradotta in modo automatico dalla versione in ineglese della wiki usando Google Translate.

La traduzione potrebbe contenere errori e termini strani. Muovi il puntatore sopra al testo per vedere la versione originale. Puoi aiutarci a correggere gli gli errori. Per ulteriori istruzioni clicca qui.

Click here for the English version of this page

Utilità libreria

Tipo di supporto (basic types, RTTI, type traits)

Gestione della memoria dinamica

La gestione degli errori

(C++11)

(C++11)

Gli operatori relazionali

rel_ops::operator!=
rel_ops::operator>
rel_ops::operator<=
rel_ops::operator>=

Coppie e tuple

pair

tuple

(C++11)

piecewise_construct_t

(C++11)

piecewise_construct

(C++11)

Swap, in avanti e spostare

(C++11)

(C++11)

(C++11)

(C++11)

Gestione della memoria dinamica

Basso livello di gestione della memoria

Allocatori

(C++11)

(C++11)

(C++11)

(C++11)

scoped_allocator_adaptor

(C++11)

Non inizializzata stoccaggio

(C++11)

return_temporary_buffer

Puntatori intelligenti

(C++11)

(C++11)

(C++11)

(deprecato)

(C++11)

enable_shared_from_this

(C++11)

bad_weak_ptr

(C++11)

default_delete

(C++11)

Garbage collection supporto

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)

Varie

pointer_traits

(C++11)

addressof

(C++11)

align

(C++11)

C Library

Membri funzioni

unique_ptr::unique_ptr

unique_ptr::~unique_ptr

unique_ptr::operator=

Modificatori

Osservatori

unique_ptr::get_deleter

unique_ptr::operator bool

unique_ptr::operator*
unique_ptr::operator->

unique_ptr::operator[]

Non membri funzioni

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

std::swap

std::hash

[edit]


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

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

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

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

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

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

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

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

1)

Costruisce un std::unique_ptr vuoto.

2)

Costruisce un std::unique_ptr che possiede p, l'inizializzazione del puntatore memorizzato con p e valore-inizializzazione del memorizzato deleter.

3-4)

Costruisce un oggetto che possiede std::unique_ptr p, l'inizializzazione del puntatore memorizzato con p e l'inizializzazione di un D deleter come di seguito (dipende dal fatto che D è un tipo di riferimento)

a)

Se D non è riferimento A tipo, quindi le firme sono:

unique_ptr(pointer p, const A& d);

unique_ptr(pointer p, A&& d);

b)

Se D è un lvalue riferimento A& tipo, quindi le firme sono:

unique_ptr(pointer p, A& d);

unique_ptr(pointer p, A&& d);

c)

Se D è un lvalue riferimento const A& tipo, quindi le firme sono:

unique_ptr(pointer p, const A& d);

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

5)

Costruisce un unique_ptr trasferendo la proprietà da u a *this.

6)

Costruisce un std::unique_ptr vuoto.

7)

Costruisce un unique_ptr trasferendo la proprietà da u a *this, dove è costruito con un u specificato deleter (E). Dipende dal fatto E è un tipo di riferimento, come segue:

a)

E se è un tipo di riferimento, questo deleter è copia costruito da deleter u di.

b)

E se non è un tipo di riferimento, questo deleter è mossa costruito da deleter u di.

8)

Costruisce un unique_ptr in cui viene inizializzato il puntatore memorizzato con u.release() e la stored deleter è valore inizializzato.

Parametri

p	-	un puntatore ad un oggetto da gestire 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	-	deleter una da utilizzare per distruggere l'oggetto 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	-	un altro puntatore intelligente per acquistare la proprietà di 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.

Eccezioni

noexcept specification:


`noexcept`

(dal C++11)

Esempio

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

}

Linguaggio
Concetti
Libreria di Utilità
Stringhe
Contenitori
Algoritmi
Iteratori
Libreria matematca
Input/output
Localizzazione
Espressioni regolari (C++11)
Operazioni atomicche (C++11)
Multithreading (C++11)

cppreference.com

Ricerca

Namespace

Varianti

Visite

Azioni

std::unique_ptr::unique_ptr

Parametri

Eccezioni

Esempio

Navigazione

Strumenti