Início / coding / Perguntas / 78715407
Accepted
Adrian McCarthy
Asked: 2024-07-07 00:52:34 +0800 CST

Um back_insert_iterator é válido durante toda a vida útil do contêiner?

  • 772

Acho que sei a resposta para isso, mas apreciaria uma verificação de sanidade.

A invalidação do iterador se aplica a std::back_insert_iterators?

#include <cassert>
#include <iterator>
#include <vector>

int main() {
    auto v = std::vector<int>{ 0, 1, 2 };
    auto iter = std::back_inserter(v);
    *iter++ = 3;
    v.clear();    // invalidates iterators, but
    *iter++ = 4;  //  back_insert_iterator is special?
    assert(v.size() == 1 && v[0] == 4);
    return 0;
}

Este código funciona para mim porque a implementação std::back_insert_iterator do meu fornecedor não contém um iterador (ou ponteiro ou referência). Ele simplesmente chama o método push_back do contêiner.

Mas o padrão exige essa implementação? O back_insert_iterator de outro fornecedor poderia manter e manter um iterador one-past-the-end para usar com uma chamada para o método de inserção do contêiner? Parece que atenderia aos requisitos. Esta diferença, claro, é que seria vulnerável à invalidação.

Eu sei que cppreference.com não é oficial, mas é mais acessível que o padrão.

[Método claro de um vetor] [i]nvalida quaisquer ... iteradores referentes aos elementos contidos. Quaisquer iteradores além do final também são invalidados. [ cppreference.com , ênfase adicionada ]

Um std::back_insert_iterator pode ser o filho-propaganda de um iterador passado.

c++

1 respostas

  1. Best Answer

    Por [back.insert.iterator]

    namespace std {
  template<class Container>
  class back_insert_iterator {
  protected:
    Container* container;

  public:
    using iterator_category = output_iterator_tag;
    using value_type        = void;
    using difference_type   = ptrdiff_t;
    using pointer           = void;
    using reference         = void;
    using container_type    = Container;

    constexpr explicit back_insert_iterator(Container& x);
    constexpr back_insert_iterator& operator=(const typename Container::value_type& value);
    constexpr back_insert_iterator& operator=(typename Container::value_type&& value);

    constexpr back_insert_iterator& operator*();
    constexpr back_insert_iterator& operator++();
    constexpr back_insert_iterator  operator++(int);
  };
}

    constexpr explicit back_insert_iterator(Container& x);

    1 Efeitos : Inicializa containercom addressof(x).

    constexpr back_insert_iterator& operator=(const typename Container::value_type& value);

    2 Efeitos : Como se por:container->push_back(value);

    3 Retorna : *this.

    constexpr back_insert_iterator& operator=(typename Container::value_type&& value);

    4 Efeitos : Como se por:container->push_back(std​::​move(value));

    5 Retorna : *this.

    [...]

    Como podemos ver, o iterador obtém um ponteiro para o contêiner e então push_backé chamado diretamente no contêiner, portanto, não há chance de UB.

    • 1

relate perguntas