In questa pagina ( http://www.cplusplus.com/reference/memory/shared_ptr/ ), paragrafo 5, si dice:
Inoltre, gli oggetti shared_ptr possono condividere la proprietà su un puntatore mentre allo stesso tempo puntano a un altro object. Questa abilità è conosciuta come aliasing (vedi costruttori), ed è comunemente usata per puntare agli oggetti membri mentre si possiede l’object a cui appartengono. Per questo motivo, shared_ptr può riguardare due indicatori:
- Perché il mio modello non accetta un elenco di inizializzazione
- Posso elencare-inizializzare un vettore di tipo move-only?
- Is_constexpr è ansible in C ++ 11?
- C'è qualche caso in cui un ritorno di un riferimento RValue (&&) è utile?
- Differenza tra std :: regex_match & std :: regex_search?
Un puntatore memorizzato, che è il puntatore a cui si dice che punta, e quello che dereferenzia con l’operatore *.
Un puntatore proprietario (eventualmente condiviso), che è il puntatore che il gruppo proprietario è responsabile dell’eliminazione ad un certo punto e per il quale conta come un uso.
Generalmente, il puntatore memorizzato e il puntatore di proprietà si riferiscono allo stesso object, ma gli oggetti alias shared_ptr (quelli creati con il costruttore alias e le loro copie) possono fare riferimento a oggetti diversi .
- Passare le funzioni membro a std :: thread
- Un array di constexpr è necessariamente odr-used quando viene pedinato?
- Ritorna con `std :: move` ragionevole nel caso di più dichiarazioni di reso?
- Devo usare atomico per la variabile bool "exit"?
- Quali cambiamenti significativi sono stati introdotti in C ++ 11?
Poi ho letto questa pagina ( http://www.cplusplus.com/reference/memory/shared_ptr/shared_ptr/ ) sul costruttore di aliasing di shared_ptr. Ma continuo a pensare che questo comportamento “aliasing” sia fonte di confusione. Perché è qui? Cosa serve? In che situazione vorrei questa funzione?
Semplice esempio:
struct Bar { // some data that we want to point to }; struct Foo { Bar bar; }; shared_ptr f = make_shared (some, args, here); shared_ptr specific_data(f, &f->bar); // ref count of the object pointed to by f is 2 f.reset(); // the Foo still exists (ref cnt == 1) // so our Bar pointer is still valid, and we can use it for stuff some_func_that_takes_bar(specific_data);
L’aliasing è per quando vogliamo davvero puntare a Bar , ma non vogliamo neanche che Foo venga eliminato da sotto di noi.
Come sottolinea Johannes nei commenti, c’è una caratteristica linguistica un po ‘equivalente:
const Bar& specific_data = Foo(...).bar;
Stiamo prendendo un riferimento a un membro di un temporaneo, ma il Foo temporaneo è ancora tenuto in vita fino a quando è specific_data . Come con l’esempio shared_ptr , quello che abbiamo è un Bar cui durata è legata a un Foo – a Foo cui non possiamo accedere.