std::shared_ptr::shared_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

shared_ptr::shared_ptr

shared_ptr::~shared_ptr

shared_ptr::operator=

Modificatori

shared_ptr::reset

shared_ptr::swap

Osservatori

shared_ptr::get

shared_ptr::operator*
shared_ptr::operator->

shared_ptr::use_count

shared_ptr::unique

shared_ptr::operator bool

shared_ptr::owner_before

Non membri funzioni

std::swap

make_shared

allocate_shared

static_pointer_cast
dynamic_pointer_cast
const_pointer_cast

get_deleter

operator==
operator|=
operator<
operator<=
operator>
operator>=

operator<<

atomic_is_lock_free
atomic_load
atomic_load_explicit
atomic_store
atomic_store_explicit
atomic_exchange
atomic_exchange_explicit
atomic_compare_exchange_weak
atomic_compare_exchange_strong
atomic_compare_exchange_weak_explicit
atomic_compare_exchange_strong_explicit

std::hash

[edit]


`constexpr shared_ptr();`	(1)

`template< class Y > explicit shared_ptr( Y* ptr );`	(2)

`template< class Y, class Deleter > shared_ptr( Y* ptr, Deleter d );`	(3)

`template< class Y, class Deleter, class Alloc > shared_ptr( Y* ptr, Deleter d, Alloc alloc );`	(4)

`constexpr shared_ptr( std::nullptr_t );`	(5)

`template< class Deleter > shared_ptr( std::nullptr_t, Deleter d );`	(6)

`template< class Deleter, class Alloc > shared_ptr( std::nullptr_t, Deleter d, Alloc alloc );`	(7)

`template< class Y > shared_ptr( const shared_ptr<Y>& r, T *ptr );`	(8)

`shared_ptr( const shared_ptr& r );`	(9)

`template< class Y > shared_ptr( const shared_ptr<Y>& r );`	(9)

`shared_ptr( shared_ptr&& r );`	(10)

`template< class Y > shared_ptr( shared_ptr<Y>&& r );`	(10)

`template< class Y > explicit shared_ptr( const std::weak_ptr<Y>& r );`	(11)

`template< class Y > shared_ptr( std::auto_ptr<Y>&& r );`	(12)

`template< class Y, class Deleter > shared_ptr( std::unique_ptr<Y,Deleter>&& r );`	(13)

Costruisce shared_ptr nuovo da una varietà di tipi di puntatore che fanno riferimento ad un oggetto da gestire. Opzionale deleter d possono essere forniti, che viene poi utilizzato per distruggere l'oggetto quando nessun oggetto shared_ptr lo possiede. Per impostazione predefinita, l'espressione è usata come eliminare espressione deleter. Espressione delete corretta corrispondente al tipo in dotazione è sempre selezionato, questo è il motivo per cui sono implementati i costruttori come modelli che utilizzano un parametro Y separata.

Se l'oggetto puntato da ptr è già di proprietà di qualche puntatore condiviso, i risultati del costruttore in un comportamento indefinito.

1)

Costruttore di default costruisce un shared_ptr senza oggetto gestito, shared_ptr cioè vuoto

2-4)

Costruisce un shared_ptr con ptr come oggetto gestito. Y deve essere di tipo completo e convertibile in modo implicito T. Inoltre:

2)

Utilizza l'espressione di eliminazione come il deleter. Un'espressione di cancellazione valida deve essere disponibile, delete ptr cioè devono essere ben formati, hanno un comportamento ben definito e non gettare alcuna eccezione.

3)

Utilizza la d specificato deleter come deleter. Deleter deve essere richiamabile per il tipo di T, cioè d(ptr) devono essere ben formati, hanno un comportamento ben definito e non generare alcuna eccezione. Deleter deve essere CopyConstructible.

4)

Stessa (3), ma utilizza inoltre una copia di alloc per l'assegnazione dei dati per uso interno. Alloc deve essere un Allocator. Il costruttore di copia e distruttore non devono generare eccezioni.

5-7)

Analoga alla (2), (3), (4), rispettivamente, ma costruisce un shared_ptr senza oggetto gestito, cioè vuoto shared_ptr.

8)

Costruisce un shared_ptr che condivide informazioni di proprietà con r, ma tiene un puntatore ptr indipendente e non gestiti. Anche se questo shared_ptr è l'ultimo del gruppo di uscire di portata, si chiamerà il distruttore per l'oggetto originariamente gestito da r. Tuttavia, chiamando get() su questo restituisce sempre una copia di ptr. E 'responsabilità del programmatore per fare in modo che questo ptr rimane valido fino a quando questo shared_ptr esiste, come ad esempio nei casi d'uso tipici dove ptr è un membro dell'oggetto gestito da r o un alias (ad esempio, bassi) di r.get()

9)

Costruisce un shared_ptr che condivide la proprietà dell'oggetto gestito da r. Se r gestisce nessun oggetto, *this gestisce nessun oggetto troppo. Il sovraccarico basato su modelli non prende parte alla risoluzione di sovraccarico se Y* non è convertibile in modo implicito T*.

10)

Move-costruisce una shared_ptr da r. Dopo la costruzione, *this contiene una copia del precedente stato di r, r è vuoto. Il sovraccarico basato su modelli non prende parte alla risoluzione di sovraccarico se Y* non è convertibile in modo implicito T*.

11)

Costruisce un shared_ptr che condivide la proprietà dell'oggetto gestito da r. Y* deve essere convertibile in T*. Si noti che r.lock() possono essere utilizzati per lo stesso scopo: la differenza è che questo costruttore genera un'eccezione se l'argomento è vuoto, mentre std::weak_ptr<T>::lock() costruisce un std::shared_ptr vuoto in quel caso.

12)

Costruisce un shared_ptr che memorizza e possiede l'oggetto in precedenza di proprietà di r. Y* deve essere convertibile in T*. Dopo la costruzione, r è vuoto.

13)

Costruisce un shared_ptr che gestisce l'oggetto attualmente gestita da r. Il deleter associata r viene memorizzato per l'eliminazione futuro l'oggetto gestito. r gestisce nessun oggetto dopo la chiamata. Y* deve essere convertibile in T*.

Note

Quando si costruisce da un puntatore a un oggetto prima di un tipo derivato da std::enable_shared_from_this, i costruttori di shared_ptr rilevare altri proprietari dell'oggetto attraverso il riferimento debole memorizzato in quella classe di base e gli assetti proprietari con loro, invece di assumere che l'oggetto non è gestito.

Parametri

ptr	-	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.
d	-	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.
alloc	-	un allocatore da utilizzare per la ripartizione dei dati per uso interno Original: an allocator to use for allocations of data for internal use The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.
r	-	un altro puntatore intelligente per condividere la proprietà o acquisire la proprietà di Original: another smart pointer to share the ownership to or 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

1)

noexcept specification:


`noexcept`

(dal C++11)

2)

std::bad_alloc se richiesto ulteriore memoria non può essere ottenuto. Può lanciare implementazione definita un'eccezione per altri errori. delete ptr viene chiamato se si verifica un'eccezione.

3-4)

std::bad_alloc se richiesto ulteriore memoria non può essere ottenuto. Può lanciare implementazione definita un'eccezione per altri errori. d(ptr) viene chiamato se si verifica un'eccezione.

5)

noexcept specification:


`noexcept`

(dal C++11)

6-7)

std::bad_alloc se richiesto ulteriore memoria non può essere ottenuto. Può lanciare implementazione definita un'eccezione per altri errori. Se viene generata un'eccezione, d(ptr) viene eseguito.

8-10)

noexcept specification:


`noexcept`

(dal C++11)

11)

std::bad_weak_ptr se r.expired == true. Il costruttore non ha alcun effetto in questo caso.

12)

std::bad_alloc se richiesto ulteriore memoria non può essere ottenuto. Può lanciare implementazione definita un'eccezione per altri errori. Questo costruttore non ha alcun effetto se si verifica un'eccezione.

13)

Se viene generata un'eccezione, il costruttore non ha effetti.

Esempio

#include <memory>
#include <iostream>

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

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

int main()
{	
    // constructor with no managed object
    std::shared_ptr<Foo> sh1;

    // constructor with object
    std::shared_ptr<Foo> sh2(new Foo);
    std::shared_ptr<Foo> sh3(sh2);
    std::cout << sh2.use_count() << '\n';
    std::cout << sh3.use_count() << '\n';

    //constructor with object and deleter
    std::shared_ptr<Foo> sh4(new Foo, D());
}

Output:

Foo...
2
2
Foo...
Call delete for Foo object...
~Foo...
~Foo...

Vedi anche


make_shared	crea un puntatore condiviso che gestisce un nuovo oggetto Original: creates a shared pointer that manages a new object The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (funzione di modello) [modifica]

allocate_shared	crea un puntatore condiviso che gestisce un nuovo oggetto allocato con un allocatore Original: creates a shared pointer that manages a new object allocated using an allocator The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (funzione di modello) [modifica]

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::shared_ptr::shared_ptr

Indice

Note

Parametri

Eccezioni

Esempio

Vedi anche

Navigazione

Strumenti