É seguro enviar push_back a um elemento do mesmo vetor?

vector<int> v;
v.push_back(1);
v.push_back(v[0]);

Se o segundo push_back causar uma realocação, a referência ao primeiro número inteiro no vetor não será mais válida. Então isso não é seguro?

vector<int> v;
v.push_back(1);
v.reserve(v.size() + 1);
v.push_back(v[0]);

Isso torna seguro?

Parece que http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#526 abordou esse problema (ou algo muito semelhante a ele) como um potencial defeito no padrão:

1) Os parâmetros tomados pela referência const podem ser alterados durante a execução da função

Exemplos:

Dado std :: vector v:

inserção de v (v.begin (), v [2]);

v [2] pode ser alterado movendo elementos do vetor

A resolução proposta era que este não era um defeito:

É necessário que o vetor :: insert (iter, value) funcione porque o padrão não permite que ele não funcione.

Sim, é seguro e as implementações de bibliotecas padrão saltam através de argolas para fazê-lo.

Acredito que os implementadores rastreiam esse requisito de volta a 23.2 / 11 de alguma forma, mas não consigo descobrir como e também não consigo encontrar algo mais concreto. O melhor que posso encontrar é este artigo:

http://www.drdobbs.com/cpp/copying-container-elements-from-the-c-li/240155771

A inspeção das implementações do libc ++ e libstdc ++ mostra que elas também são seguras.

O padrão garante que mesmo o seu primeiro exemplo seja seguro. Citando C ++ 11

[sequence.reqmts]

3 Nas tabelas 100 e 101 ... Xdenota uma classe de contêiner de sequência, adenota um valor de Xelementos do tipo T, ... tdenota um valor l ou um valor constante deX::value_type

16 Tabela 101 ...

Expressão a.push_back(t) Tipo de retorno void Semântica operacional Anexa uma cópia de t. Requer: T deve estar CopyInsertabledentro X. Container basic_string , deque, list,vector

Portanto, mesmo que não seja exatamente trivial, a implementação deve garantir que não invalidará a referência ao fazer o push_back.

Não é óbvio que o primeiro exemplo é seguro, porque a implementação mais simples push_backseria realocar primeiro o vetor, se necessário, e depois copiar a referência.

Mas pelo menos parece seguro com o Visual Studio 2010. Sua implementação push_backfaz um tratamento especial do caso quando você empurra um elemento no vetor. O código está estruturado da seguinte maneira:

void push_back(const _Ty& _Val)
    {   // insert element at end
    if (_Inside(_STD addressof(_Val)))
        {   // push back an element
                    ...
        }
    else
        {   // push back a non-element
                    ...
        }
    }

Isso não é uma garantia do padrão, mas como outro ponto de dados, v.push_back(v[0])é seguro para o libc ++ do LLVM .

std::vector::push_backchamadas do libc ++__push_back_slow_path quando ele precisa realocar a memória:

void __push_back_slow_path(_Up& __x) {
  allocator_type& __a = this->__alloc();
  __split_buffer<value_type, allocator_type&> __v(__recommend(size() + 1), 
                                                  size(), 
                                                  __a);
  // Note that we construct a copy of __x before deallocating
  // the existing storage or moving existing elements.
  __alloc_traits::construct(__a, 
                            _VSTD::__to_raw_pointer(__v.__end_), 
                            _VSTD::forward<_Up>(__x));
  __v.__end_++;
  // Moving existing elements happens here:
  __swap_out_circular_buffer(__v);
  // When __v goes out of scope, __x will be invalid.
}

A primeira versão definitivamente NÃO é segura:

Operações em iteradores obtidos chamando um contêiner de biblioteca padrão ou uma função de membro de string podem acessar o contêiner subjacente, mas não devem modificá-lo. [Nota: Em particular, operações de contêiner que invalidam iteradores entram em conflito com operações em iteradores associados a esse contêiner. - nota final]

da seção 17.6.5.9

Note-se que esta é a seção em corridas de dados, que as pessoas normalmente pensam em conjunto com enfiar ... mas a própria definição envolve "acontece antes" relacionamentos, e eu não vejo qualquer relação ordenação entre os vários efeitos colaterais de push_backem jogar aqui, ou seja, a invalidação de referência parece não ser definida como ordenada em relação à cópia-construção do novo elemento de cauda.

É completamente seguro.

No seu segundo exemplo você tem

v.reserve(v.size() + 1);

o que não é necessário porque se o vetor sair do seu tamanho, isso implicará em reserve.

Vector é responsável por essas coisas, não você.

Ambos são seguros, pois o push_back copiará o valor, não a referência. Se você estiver armazenando ponteiros, isso ainda é seguro no que diz respeito ao vetor, mas saiba que você terá dois elementos do vetor apontando para os mesmos dados.

Seção 23.2.1 Requisitos gerais de contêiner

16

• a.push_back (t) Anexa uma cópia de t. Requer: T deve ser CopyInsertable em X.
• a.push_back (rv) Anexa uma cópia do rv. Requer: T deve ser MoveInsertable em X.

As implementações de push_back devem, portanto, garantir que uma cópia de v[0] seja inserida. Por exemplo, assumindo que uma implementação seria realocada antes da cópia, ela certamente não acrescentaria uma cópia v[0]e, como tal, violaria as especificações.

A partir de 23.3.6.5/1: Causes reallocation if the new size is greater than the old capacity. If no reallocation happens, all the iterators and references before the insertion point remain valid.

Como estamos inserindo no final, nenhuma referência será invalidada se o vetor não for redimensionado. Portanto, se o vetor capacity() > size()for garantido, ele funcionará, caso contrário, será um comportamento indefinido.