l'iterazione di un contenitore di di unique_ptr

Question

Come si fa accesso unique_ptr elementi di un contenitore (tramite un iteratore) senza prendere possesso di distanza dal contenitore? Quando si ottiene un iteratore su un elemento nel contenitore, la proprietà dell'elemento è ancora presente nel contenitore? Che ne dici di quando si deruba l'iteratore per accedere a unique_ptr? Questo compie una mossa implicita di unique_ptr?

trovo sto usando shared_ptr molto quando ho bisogno di memorizzare gli elementi in un contenitore (non per valore), anche se il contenitore possiede concettualmente gli elementi e altro codice vuole semplicemente per manipolare gli elementi nel contenitore, perché io Ho paura di non essere in grado di accedere effettivamente agli elementi unique_ptr nel contenitore senza che ne sia stata presa la proprietà.

Eventuali approfondimenti?

Answer 1

Finché non si tenta di fare una copia del unique_ptr, si può semplicemente utilizzare. Dovrai "raddire la dereferenza" all'iteratore per ottenere il valore del puntatore, proprio come dovresti con shared_ptr. Ecco un breve esempio:

#include <vector> 
#include <memory> 
#include <iostream> 

template <class C> 
void 
display(const C& c) 
{ 
    std::cout << '{'; 
    if (!c.empty()) 
     std::cout << *c.front(); 
    for (auto i = std::next(c.begin()); i != c.end(); ++i) 
     std::cout << ", " << **i; 
    std::cout << "}\n"; 
} 

int main() 
{ 
    typedef std::unique_ptr<int> Ptr; 
    std::vector<Ptr> v; 
    for (int i = 1; i <= 5; ++i) 
     v.push_back(Ptr(new int(i))); 
    display(v); 
    for (auto i = v.begin(); i != v.end(); ++i) 
     **i += 2; 
    display(v); 
} 

Se lo fai (accidentalmente) fare una copia del unique_ptr:

Ptr p = v[0]; 

allora scoprirete al momento della compilazione. Non causerà un errore di runtime. Il tuo caso d'uso è il motivo per cui è stato creato container<unique_ptr<T>>. Le cose dovrebbero funzionare, e se non lo fanno, il problema appare in fase di compilazione invece che in fase di esecuzione. Quindi, codice via, e se non capisci l'errore di compilazione, allora fai un'altra domanda qui.

Answer 2

Con auto e la gamma-based per-loop di C++ 11 questo diventa relativamente elegante:

std::vector< std::unique_ptr<YourClass>> pointers; 
for(auto&& pointer : pointers) { 
    pointer->functionOfYourClass(); 
} 

Il riferimento & alla std::unique_ptr evita la copia e si può utilizzare il uniqe_ptr senza dereferenziazione.