Por que usar iteradores em vez de índices de matriz?

Pegue as duas linhas de código a seguir:

for (int i = 0; i < some_vector.size(); i++)
{
    //do stuff
}

E isto:

for (some_iterator = some_vector.begin(); some_iterator != some_vector.end();
    some_iterator++)
{
    //do stuff
}

Disseram-me que a segunda maneira é preferida. Por que exatamente é isso?

A primeira forma é eficiente apenas se vector.size () for uma operação rápida. Isso vale para vetores, mas não para listas, por exemplo. Além disso, o que você planeja fazer dentro do corpo do loop? Se você planeja acessar os elementos como em

T elem = some_vector[i];

então você está assumindo que o contêiner operator[](std::size_t)definiu. Novamente, isso é verdade para vetores, mas não para outros contêineres.

O uso de iteradores aproxima você da independência do contêiner . Você não está fazendo suposições sobre a capacidade de acesso aleatório ou size()operação rápida , apenas que o contêiner possui recursos de iterador.

Você pode aprimorar ainda mais seu código usando algoritmos padrão. Dependendo do que é que você está tentando alcançar, você pode optar por usar std::for_each(), std::transform()e assim por diante. Ao usar um algoritmo padrão em vez de um loop explícito, você evita reinventar a roda. É provável que seu código seja mais eficiente (dado que o algoritmo correto foi escolhido), correto e reutilizável.

Faz parte do processo moderno de doutrinação em C ++. Os iteradores são a única maneira de iterar a maioria dos contêineres; portanto, você o usa mesmo com vetores apenas para entrar na mentalidade adequada. Sério, é a única razão pela qual faço isso - acho que nunca substituí um vetor por um tipo diferente de contêiner.

Eu acho que o índice da matriz é mais legível. Ele corresponde à sintaxe usada em outros idiomas e à sintaxe usada para matrizes C à moda antiga. Também é menos detalhado. A eficiência deve ser uma lavagem, se o seu compilador for bom, e quase não há casos em que isso seja importante.

Mesmo assim, continuo usando iteradores frequentemente com vetores. Eu acredito que o iterador é um conceito importante, então eu o promovo sempre que posso.

porque você não está vinculando seu código à implementação específica da lista some_vector. se você usar índices de matriz, deve ser alguma forma de matriz; se você usar iteradores, poderá usar esse código em qualquer implementação de lista.

Imagine que algum_vector seja implementado com uma lista vinculada. A solicitação de um item no i-ésimo lugar exige que sejam executadas i operações para percorrer a lista de nós. Agora, se você usar o iterador, em geral, fará o possível para ser o mais eficiente possível (no caso de uma lista vinculada, ele manterá um ponteiro para o nó atual e o avançará em cada iteração, exigindo apenas uma operação única).

Portanto, fornece duas coisas:

• Abstração de uso: você apenas deseja iterar alguns elementos, não se importa com como fazê-lo
• atuação

Eu serei o advogado do diabo aqui, e não recomendo iteradores. A principal razão pela qual, é todo o código-fonte em que trabalhei, desde o desenvolvimento de aplicativos da área de trabalho até o desenvolvimento de jogos, nem tenho que usar iteradores. O tempo todo eles não são necessários e, em segundo lugar, as suposições ocultas, os códigos e os pesadelos de depuração que você obtém com os iteradores fazem deles um excelente exemplo para não usá-lo em aplicativos que exijam velocidade.

Mesmo do ponto de vista da manutenção, eles são uma bagunça. Não é por causa deles, mas por causa de todo o aliasing que acontece nos bastidores. Como sei que você não implementou seu próprio vetor virtual ou lista de matrizes que faz algo completamente diferente dos padrões. Eu sei que tipo é atualmente atualmente durante o tempo de execução? Você sobrecarregou um operador? Não tive tempo de verificar todo o seu código-fonte. Inferno, eu sei mesmo qual versão do STL você está usando?

O próximo problema que você teve com os iteradores é a abstração com vazamento, embora existam vários sites que discutem isso em detalhes com eles.

Desculpe, ainda não vi nenhum ponto nos iteradores. Se eles abstraem a lista ou o vetor de você, quando na verdade você já deve saber com qual vetor ou lista está lidando, se não o fizer, estará se preparando para algumas ótimas sessões de depuração no futuro.

Você pode usar um iterador se quiser adicionar / remover itens ao vetor enquanto estiver iterando sobre ele.

some_iterator = some_vector.begin(); 
while (some_iterator != some_vector.end())
{
    if (/* some condition */)
    {
        some_iterator = some_vector.erase(some_iterator);
        // some_iterator now positioned at the element after the deleted element
    }
    else
    {
        if (/* some other condition */)
        {
            some_iterator = some_vector.insert(some_iterator, some_new_value);
            // some_iterator now positioned at new element
        }
        ++some_iterator;
    }
}

Se você estivesse usando índices, teria que embaralhar os itens para cima / baixo na matriz para manipular as inserções e exclusões.

Separação de preocupações

É muito bom separar o código de iteração da preocupação principal do loop. É quase uma decisão de design.

De fato, a iteração por índice vincula você à implementação do contêiner. Solicitar ao contêiner um iterador inicial e final, habilita o código do loop para uso com outros tipos de contêineres.

Além disso, std::for_eachvocê diz à coleção o que fazer, em vez de perguntar algo sobre seus componentes internos.

O padrão 0x introduzirá fechamentos, o que tornará essa abordagem muito mais fácil de usar - veja o poder expressivo de, por exemplo, o Ruby [1..6].each { |i| print i; }...

atuação

Mas talvez uma questão muito supervisionada seja a de que, usando a for_eachabordagem, haja uma oportunidade de paralelizar a iteração - os blocos de encadeamento de intel podem distribuir o bloco de código pelo número de processadores no sistema!

Nota: depois de descobrir a algorithmsbiblioteca e, principalmente foreach, passei dois ou três meses escrevendo estruturas ridiculamente pequenas de operadores 'auxiliares' que enlouquecerão seus colegas desenvolvedores. Após esse período, voltei a uma abordagem pragmática - pequenos corpos em loop não merecem foreachmais :)

Uma referência de leitura obrigatória nos iteradores é o livro "Extended STL" .

O GoF possui um pequeno parágrafo no final do padrão Iterator, que fala sobre esse tipo de iteração; é chamado de 'iterador interno'. Dê uma olhada aqui também.

Porque é mais orientado a objetos. se você estiver iterando com um índice, estará assumindo:

a) que esses objetos são ordenados
b) que esses objetos podem ser obtidos por um índice
c) que o incremento do índice atingirá todos os itens
d) que esse índice comece em zero

Com um iterador, você está dizendo "me dê tudo para que eu possa trabalhar com ele" sem saber qual é a implementação subjacente. (Em Java, há coleções que não podem ser acessadas por meio de um índice)

Além disso, com um iterador, não é necessário se preocupar em sair dos limites da matriz.

Outra coisa interessante dos iteradores é que eles permitem que você expresse (e imponha) sua preferência constante. Este exemplo garante que você não alterará o vetor no meio do seu loop:

for(std::vector<Foo>::const_iterator pos=foos.begin(); pos != foos.end(); ++pos)
{
    // Foo & foo = *pos; // this won't compile
    const Foo & foo = *pos; // this will compile
}

Além de todas as outras excelentes respostas ... intpode não ser grande o suficiente para o seu vetor. Em vez disso, se você deseja usar a indexação, use o size_typepara seu contêiner:

for (std::vector<Foo>::size_type i = 0; i < myvector.size(); ++i)
{
    Foo& this_foo = myvector[i];
    // Do stuff with this_foo
}

Eu provavelmente devo salientar que você também pode ligar

std::for_each(some_vector.begin(), some_vector.end(), &do_stuff);

Os iteradores STL estão principalmente lá, de modo que os algoritmos STL, como sort, podem ser independentes de contêineres.

Se você quiser fazer um loop sobre todas as entradas em um vetor, use o estilo de loop de índice.

É menos digitado e mais fácil de analisar para a maioria dos humanos. Seria bom se o C ++ tivesse um loop foreach simples sem exagerar na mágica de modelos.

for( size_t i = 0; i < some_vector.size(); ++i )
{
   T& rT = some_vector[i];
   // now do something with rT
}
'

Eu não acho que faz muita diferença para um vetor. Eu prefiro usar um índice, pois considero mais legível e você pode acessar aleatoriamente, como pular para a frente 6 itens ou pular para trás, se necessário.

Também gosto de fazer uma referência ao item dentro do loop dessa maneira, para que não haja muitos colchetes ao redor do local:

for(size_t i = 0; i < myvector.size(); i++)
{
    MyClass &item = myvector[i];

    // Do stuff to "item".
}

Usar um iterador pode ser bom se você achar que poderá precisar substituir o vetor por uma lista em algum momento no futuro e também parecer mais elegante para os malucos do STL, mas não consigo pensar em nenhum outro motivo.

A segunda forma representa o que você está fazendo com mais precisão. No seu exemplo, você realmente não se importa com o valor de i - tudo o que você quer é o próximo elemento no iterador.

Depois de ter aprendido um pouco mais sobre o assunto desta resposta, percebo que foi um pouco simplista demais. A diferença entre este loop:

for (some_iterator = some_vector.begin(); some_iterator != some_vector.end();
    some_iterator++)
{
    //do stuff
}

E esse loop:

for (int i = 0; i < some_vector.size(); i++)
{
    //do stuff
}

É bastante mínimo. De fato, a sintaxe de fazer loops dessa maneira parece estar crescendo em mim:

while (it != end){
    //do stuff
    ++it;
}

Os iteradores desbloqueiam alguns recursos declarativos bastante poderosos e, quando combinados com a biblioteca de algoritmos STL, você pode fazer algumas coisas bem legais que estão fora do escopo da administração de índices de matriz.

A indexação requer uma muloperação extra . Por exemplo, para vector<int> v, o compilador é convertido v[i]em &v + sizeof(int) * i.

Durante a iteração, você não precisa saber o número de itens a serem processados. Você só precisa do item e os iteradores fazem essas coisas muito bem.

Ninguém mencionou ainda que uma vantagem dos índices é que eles não se tornam inválidos quando você anexa a um contêiner contíguo como std::vector, portanto, você pode adicionar itens ao contêiner durante a iteração.

Isso também é possível com os iteradores, mas você deve ligar reserve()e, portanto, precisa saber quantos itens anexará.

Vários bons pontos já. Tenho alguns comentários adicionais:

1. Supondo que estamos falando sobre a biblioteca padrão C ++, "vetor" implica em um contêiner de acesso aleatório que possui as garantias da matriz C (acesso aleatório, layout de memória contíguo etc.). Se você tivesse dito 'some_container', muitas das respostas acima teriam sido mais precisas (independência do contêiner etc.).

2. Para eliminar quaisquer dependências na otimização do compilador, você pode mover some_vector.size () para fora do loop no código indexado, da seguinte maneira:

   const size_t numElems = some_vector.size ();
   para (size_t i = 0; i 

3. Sempre pré-incremente os iteradores e trate os pós-incrementos como casos excepcionais.

Portanto, assumindo e indexável std::vector<>como o contêiner, não há uma boa razão para preferir um ao outro, passando sequencialmente pelo contêiner. Se você precisar consultar com freqüência índices mais antigos ou mais recentes, a versão indexada é mais apropriada.

Em geral, é preferível usar os iteradores porque os algoritmos os utilizam e o comportamento pode ser controlado (e implicitamente documentado) alterando o tipo do iterador. Os locais da matriz podem ser usados ​​no lugar dos iteradores, mas a diferença sintática será destacada.

Não uso iteradores pelo mesmo motivo que não gosto de declarações foreach. Ao ter vários loops internos, é bastante difícil acompanhar as variáveis ​​globais / membros sem ter que lembrar todos os valores locais e nomes de iteradores também. O que acho útil é usar dois conjuntos de índices para diferentes ocasiões:

for(int i=0;i<anims.size();i++)
  for(int j=0;j<bones.size();j++)
  {
     int animIndex = i;
     int boneIndex = j;


     // in relatively short code I use indices i and j
     ... animation_matrices[i][j] ...

     // in long and complicated code I use indices animIndex and boneIndex
     ... animation_matrices[animIndex][boneIndex] ...


  }

Eu nem quero abreviar coisas como "animation_matrices [i]" para algum iterador aleatório "anim_matrix"-named-iterator, por exemplo, porque então você não pode ver claramente de qual matriz esse valor é originado.

• Se você gosta de estar próximo do metal / não confia nos detalhes de sua implementação, não use iteradores.
• Se você alternar regularmente um tipo de coleção para outro durante o desenvolvimento, use iteradores.
• Se você achar difícil lembrar como iterar diferentes tipos de coleções (talvez você tenha vários tipos de várias fontes externas diferentes em uso), use iteradores para unificar os meios pelos quais você percorre os elementos. Isso se aplica à troca de uma lista vinculada por uma lista de matrizes.

Realmente, isso é tudo o que existe. Não é como se você fosse ganhar mais concisão de qualquer maneira, em média, e se a concisão realmente é seu objetivo, você sempre pode recorrer às macros.

Se você tiver acesso aos recursos do C ++ 11 , também poderá usar um loop baseado em intervalofor para iterar sobre seu vetor (ou qualquer outro contêiner) da seguinte maneira:

for (auto &item : some_vector)
{
     //do stuff
}

O benefício desse loop é que você pode acessar elementos do vetor diretamente através da itemvariável, sem correr o risco de bagunçar um índice ou cometer um erro ao fazer a referência a um iterador. Além disso, o espaço reservado autoimpede que você precise repetir o tipo dos elementos do contêiner, o que o aproxima ainda mais de uma solução independente do contêiner.

Notas:

• Se você precisa do índice do elemento em seu loop e o operator[]existe para o seu contêiner (e é rápido o suficiente para você), é melhor seguir seu primeiro caminho.
• Um forloop baseado em intervalo não pode ser usado para adicionar / excluir elementos em / de um contêiner. Se você quiser fazer isso, é melhor seguir a solução dada por Brian Matthews.
• Se você não deseja alterar os elementos em seu recipiente, então você deve usar a palavra-chave constda seguinte forma: for (auto const &item : some_vector) { ... }.

Ainda melhor do que "dizer à CPU o que fazer" (imperativo) é "dizer às bibliotecas o que você deseja" (funcional).

Então, ao invés de usar loops, você deve aprender os algoritmos presentes no stl.

Para independência do contêiner

Eu sempre uso o índice de matriz, porque muitas aplicações minhas exigem algo como "exibir imagem em miniatura". Então eu escrevi algo como isto:

some_vector[0].left=0;
some_vector[0].top =0;<br>

for (int i = 1; i < some_vector.size(); i++)
{

    some_vector[i].left = some_vector[i-1].width +  some_vector[i-1].left;
    if(i % 6 ==0)
    {
        some_vector[i].top = some_vector[i].top.height + some_vector[i].top;
        some_vector[i].left = 0;
    }

}

Ambas as implementações estão corretas, mas eu preferiria o loop 'for'. Como decidimos usar um vetor e não qualquer outro contêiner, o uso de índices seria a melhor opção. O uso de iteradores com vetores perderia o benefício de ter os objetos em blocos de memória contínua, o que ajuda a facilitar o acesso.

Eu senti que nenhuma das respostas aqui explica por que gosto de iteradores como um conceito geral sobre indexação em contêineres. Observe que a maior parte da minha experiência no uso de iteradores não vem do C ++, mas de linguagens de programação de nível superior, como Python.

A interface do iterador impõe menos requisitos aos consumidores da sua função, o que permite que os consumidores façam mais com ela.

Se tudo que você precisa é ser capaz de transmitir-iterate, o desenvolvedor não se limita ao uso de recipientes indexáveis - eles podem usar qualquer classe de implementação operator++(T&), operator*(T)e operator!=(const &T, const &T).

#include <iostream>
template <class InputIterator>
void printAll(InputIterator& begin, InputIterator& end)
{
    for (auto current = begin; current != end; ++current) {
        std::cout << *current << "\n";
    }
}

// elsewhere...

printAll(myVector.begin(), myVector.end());

Seu algoritmo funciona para o caso de você precisar - repetindo um vetor - mas também pode ser útil para aplicativos que você não necessariamente antecipa:

#include <random>

class RandomIterator
{
private:
    std::mt19937 random;
    std::uint_fast32_t current;
    std::uint_fast32_t floor;
    std::uint_fast32_t ceil;

public:
    RandomIterator(
        std::uint_fast32_t floor = 0,
        std::uint_fast32_t ceil = UINT_FAST32_MAX,
        std::uint_fast32_t seed = std::mt19937::default_seed
    ) :
        floor(floor),
        ceil(ceil)
    {
        random.seed(seed);
        ++(*this);
    }

    RandomIterator& operator++()
    {
        current = floor + (random() % (ceil - floor));
    }

    std::uint_fast32_t operator*() const
    {
        return current;
    }

    bool operator!=(const RandomIterator &that) const
    {
        return current != that.current;
    }
};

int main()
{
    // roll a 1d6 until we get a 6 and print the results
    RandomIterator firstRandom(1, 7, std::random_device()());
    RandomIterator secondRandom(6, 7);
    printAll(firstRandom, secondRandom);

    return 0;
}

Tentar implementar um operador de colchetes que faça algo semelhante a esse iterador seria artificial, enquanto a implementação do iterador é relativamente simples. O operador de colchetes também traz implicações sobre os recursos de sua classe - que você pode indexar para qualquer ponto arbitrário - que podem ser difíceis ou ineficientes de implementar.

Os iteradores também se prestam à decoração . As pessoas podem escrever iteradores que utilizam um iterador em seu construtor e ampliam sua funcionalidade:

template<class InputIterator, typename T>
class FilterIterator
{
private:
    InputIterator internalIterator;

public:
    FilterIterator(const InputIterator &iterator):
        internalIterator(iterator)
    {
    }

    virtual bool condition(T) = 0;

    FilterIterator<InputIterator, T>& operator++()
    {
        do {
            ++(internalIterator);
        } while (!condition(*internalIterator));

        return *this;
    }

    T operator*()
    {
        // Needed for the first result
        if (!condition(*internalIterator))
            ++(*this);
        return *internalIterator;
    }

    virtual bool operator!=(const FilterIterator& that) const
    {
        return internalIterator != that.internalIterator;
    }
};

template <class InputIterator>
class EvenIterator : public FilterIterator<InputIterator, std::uint_fast32_t>
{
public:
    EvenIterator(const InputIterator &internalIterator) :
        FilterIterator<InputIterator, std::uint_fast32_t>(internalIterator)
    {
    }

    bool condition(std::uint_fast32_t n)
    {
        return !(n % 2);
    }
};


int main()
{
    // Rolls a d20 until a 20 is rolled and discards odd rolls
    EvenIterator<RandomIterator> firstRandom(RandomIterator(1, 21, std::random_device()()));
    EvenIterator<RandomIterator> secondRandom(RandomIterator(20, 21));
    printAll(firstRandom, secondRandom);

    return 0;
}

Embora esses brinquedos possam parecer comuns, não é difícil imaginar o uso de iteradores e decoradores de iteradores para fazer coisas poderosas com uma interface simples - decorando um iterador de encaminhamento somente dos resultados do banco de dados com um iterador que constrói um objeto de modelo a partir de um único resultado, por exemplo . Esses padrões permitem a iteração com eficiência de memória de conjuntos infinitos e, com um filtro como o que escrevi acima, uma avaliação potencialmente lenta dos resultados.

Parte do poder dos modelos C ++ é a sua interface do iterador, quando aplicada a tipos de matrizes C de comprimento fixo, decai para uma aritmética simples e eficiente do ponteiro , tornando-a uma abstração verdadeiramente de custo zero.