O std :: vector está copiando os objetos com um push_back?

Depois de muitas investigações com o valgrind, concluí que std :: vector faz uma cópia de um objeto que você deseja enviar push_back.

Isso é mesmo verdade? Um vetor não pode manter uma referência ou um ponteiro de um objeto sem uma cópia ?!

obrigado

Sim, std::vector<T>::push_back()cria uma cópia do argumento e a armazena no vetor. Se você deseja armazenar ponteiros para objetos em seu vetor, crie um em std::vector<whatever*>vez de std::vector<whatever>.

No entanto, você precisa garantir que os objetos referenciados pelos ponteiros permaneçam válidos enquanto o vetor mantém uma referência a eles (ponteiros inteligentes utilizando o idioma RAII resolvem o problema).

Sim, std::vectorarmazena cópias. Como devevector saber quais são os tempos de vida esperados dos seus objetos?

Se você deseja transferir ou compartilhar a propriedade dos objetos, use ponteiros, possivelmente ponteiros inteligentes como shared_ptr(encontrados no Boost ou TR1 ) para facilitar o gerenciamento de recursos.

A partir do C ++ 11, todos os contêineres padrão ( std::vector, std::mapetc) oferecem suporte à semântica de movimentação, o que significa que agora você pode passar rvalues ​​para contêineres padrão e evitar uma cópia:

// 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");

Como alternativa, você pode usar vários ponteiros inteligentes para obter o mesmo efeito:

std::unique_ptr exemplo

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 exemplo

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.

O std :: vector sempre faz uma cópia do que estiver sendo armazenado no vetor.

Se você estiver mantendo um vetor de ponteiros, ele fará uma cópia do ponteiro, mas não a instância para a qual o ponteiro está apontando. Se você estiver lidando com objetos grandes, poderá (e provavelmente deve) sempre usar um vetor de ponteiros. Freqüentemente, o uso de um vetor de ponteiros inteligentes de um tipo apropriado é bom para fins de segurança, pois o manuseio da vida útil do objeto e o gerenciamento de memória podem ser complicados.

O std :: vector não apenas faz uma cópia do que você está empurrando, mas a definição da coleção afirma que isso será feito e que você não poderá usar objetos sem a semântica correta da cópia em um vetor. Portanto, por exemplo, você não usa auto_ptr em um vetor.

Relevante no C ++ 11 é a emplacefamília de funções-membro, que permitem transferir a propriedade de objetos, movendo-os para contêineres.

O idioma de uso seria semelhante

std::vector<Object> objs;

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

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

A movimentação para o objeto lvalue é importante, caso contrário, ela seria encaminhada como uma referência ou referência const e o construtor da movimentação não seria chamado.

se você não quiser as cópias; então a melhor maneira é usar um vetor de ponteiro (ou outra estrutura que sirva para o mesmo objetivo). se você quiser as cópias; use diretamente push_back (). você não tem outra escolha.

Por que demorou bastante investigação para descobrir isso! Apenas prove com um código simples, por exemplo

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

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

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

Se "olá mundo" for impresso, o objeto deverá ter sido copiado