¿Std :: vector está copiando los objetos con un push_back?

Después de muchas investigaciones con valgrind, he llegado a la conclusión de que std :: vector hace una copia de un objeto que desea hacer retroceder.

¿Es eso realmente cierto? ¿Un vector no puede mantener una referencia o un puntero de un objeto sin una copia?

Gracias

Sí, std::vector<T>::push_back()crea una copia del argumento y la almacena en el vector. Si desea almacenar punteros a objetos en su vector, cree un en std::vector<whatever*>lugar de std::vector<whatever>.

Sin embargo, debe asegurarse de que los objetos a los que hacen referencia los punteros siguen siendo válidos mientras el vector tiene una referencia a ellos (los punteros inteligentes que utilizan el lenguaje RAII resuelven el problema).

Sí, std::vectoralmacena copias. ¿Cómo debe vectorsaber cuáles son los tiempos de vida esperados de sus objetos?

Si desea transferir o compartir la propiedad de los objetos, use punteros, posiblemente punteros inteligentes como shared_ptr(que se encuentran en Boost o TR1 ) para facilitar la administración de recursos.

Desde C ++ 11 en adelante, todos los contenedores estándar ( std::vector, std::map, etc) de soporte se mueven semántica, lo que significa que ahora puede pasar a rvalues contenedores estándar y evitar una copia:

// Example object class.
class object
{
private:
    int             m_val1;
    std::string     m_val2;

public:
    // Constructor for object class.
    object(int val1, std::string &&val2) :
        m_val1(val1),
        m_val2(std::move(val2))
    {

    }
};

std::vector<object> myList;

// #1 Copy into the vector.
object foo1(1, "foo");
myList.push_back(foo1);

// #2 Move into the vector (no copy).
object foo2(1024, "bar");
myList.push_back(std::move(foo2));

// #3 Move temporary into vector (no copy).
myList.push_back(object(453, "baz"));

// #4 Create instance of object directly inside the vector (no copy, no move).
myList.emplace_back(453, "qux");

Alternativamente, puede usar varios punteros inteligentes para obtener el mismo efecto:

std::unique_ptr ejemplo

std::vector<std::unique_ptr<object>> myPtrList;

// #5a unique_ptr can only ever be moved.
auto pFoo = std::make_unique<object>(1, "foo");
myPtrList.push_back(std::move(pFoo));

// #5b unique_ptr can only ever be moved.
myPtrList.push_back(std::make_unique<object>(1, "foo"));

std::shared_ptr ejemplo

std::vector<std::shared_ptr<object>> objectPtrList2;

// #6 shared_ptr can be used to retain a copy of the pointer and update both the vector
// value and the local copy simultaneously.
auto pFooShared = std::make_shared<object>(1, "foo");
objectPtrList2.push_back(pFooShared);
// Pointer to object stored in the vector, but pFooShared is still valid.

std :: vector siempre hace una copia de lo que se está almacenando en el vector.

Si mantiene un vector de punteros, hará una copia del puntero, pero no la instancia a la que apunta el puntero. Si se trata de objetos grandes, siempre puede (y probablemente debería) usar un vector de punteros. A menudo, usar un vector de punteros inteligentes de un tipo apropiado es bueno para fines de seguridad, ya que manejar la vida útil de los objetos y la administración de la memoria puede ser complicado de lo contrario.

Std :: vector no solo hace una copia de lo que está presionando, sino que la definición de la colección establece que lo hará, y que no puede usar objetos sin la semántica de copia correcta dentro de un vector. Entonces, por ejemplo, no usa auto_ptr en un vector.

Relevante en C ++ 11 es la emplacefamilia de funciones miembro, que le permiten transferir la propiedad de los objetos moviéndolos a contenedores.

El modismo de uso se vería así

std::vector<Object> objs;

Object l_value_obj { /* initialize */ };
// use object here...

objs.emplace_back(std::move(l_value_obj));

El movimiento para el objeto lvalue es importante ya que de lo contrario se reenviaría como referencia o referencia constante y no se llamaría al constructor de movimiento.

si no quieres las copias; entonces la mejor manera es usar un vector puntero (u otra estructura que sirva para el mismo objetivo). si quieres las copias; usar directamente push_back (). No tienes otra opción.

¿Por qué tomó tanta investigación valgrind para descubrir esto? Solo demuéstralo a ti mismo con un código simple, por ejemplo

std::vector<std::string> vec;

{
      std::string obj("hello world");
      vec.push_pack(obj);
}

std::cout << vec[0] << std::endl;  

Si se imprime "hello world", el objeto debe haberse copiado