Iteración sobre un contenedor de unique_ptr's

Question

¿Cómo se accede a los elementos unique_ptr de un contenedor (a través de un iterador) sin quitarle la propiedad al contenedor? Cuando uno obtiene un iterador para un elemento en el contenedor, ¿la propiedad del elemento aún está en el contenedor? ¿Qué tal si uno descuenta el iterador para obtener acceso al unique_ptr? ¿Eso realiza un movimiento implícito de unique_ptr?

Me parece que estoy usando shared_ptr mucho cuando necesito almacenar elementos en un contenedor (no por valor), incluso si el contenedor posee los elementos conceptualmente y el otro código simplemente desea manipular elementos en el contenedor, porque Tengo miedo de no poder acceder realmente a los elementos uniqueptr en el contenedor sin que se le quite la propiedad.

¿Algún conocimiento?

Answer 1

Siempre y cuando no intente hacer una copia del unique_ptr, puede usarlo. Tendrás que "desreferencia doble" del iterador para obtener el valor del puntero, tal como lo harías con shared_ptr. He aquí un breve ejemplo:

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

Si lo hace (accidentalmente) crea una copia de la unique_ptr:

Ptr p = v[0]; 

continuación, usted encontrará a cabo en tiempo de compilación. No causará un error de tiempo de ejecución. Su caso de uso es por qué se construyó container<unique_ptr<T>>. Las cosas solo deberían funcionar, y si no lo hacen, el problema aparece en tiempo de compilación en lugar de tiempo de ejecución. Así que codifique y si no comprende el error de tiempo de compilación, haga otra pregunta aquí.

Answer 2

Con auto y la basada en el rango de-bucles de C++ 11 este se vuelve relativamente elegante:

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

La referencia a la &std::unique_ptr evita la copia y se puede utilizar el uniqe_ptr sin eliminación de referencias.