OP - C/C++ Dicas - O que são Iterators?

O que são Iterators?

A questão "quem inventou os Iterators?" pode ser muito difícil de se responder. Por exemplo, o índice de uma somatória em matemática é um Iterator. Há quem diga que a primeira aplicação formal de Iterators em codificação de software é o comando DO da linguagem FORTRAN.

O Iterator mais simples é um inteiro simples:

char array[100];
for (int i=0; i<100; i++) array[i] = 0;

Aqui, i é o Iterator. i identifica de modo único cada elemento do container, um a cada vez. Inteiros funcionam muito bem para containers simples como matrizes. Mas são problemáticos para containers que não tenham ordem ou tamanho implícitos. Por exemplo, não se vai querer usar um inteiro para percorrer os elementos de uma lista-vinculada. O melhor Iterator para esse caso deve apontar o elemento corrente da lista e ainda permitir o uso do mecanismo de vinculação para acessar o próximo elemento da lista. Outros tipos de containers poderão ainda usar mecanismos diferentes para localizar o próximo elemento a ser apontado.

Portanto, pode-se criar uma interface abstrata, e implementá-la de diferentes formas para diferentes tipos de containers.

template <class T>
class Iterator
{
public:
   Iterator(IterableContainer<T>&);
   virtual operator void*() = 0;
   virtual void operator++() = 0;
   virtual T& operator*() = 0;
};

Com essa interface pode-se criar, testar, incrementar e acessar um Interator, como se mostra a seguir:

Set<Garp> mySet;
for(SetIterator<Garp> i(mySet); i; i++)
(*i).DoSomethingIntelligent();

É claro que se pode criar vários Iterators simultaneamente. Isso permite que um container admita mais que uma iteração concorrentemente. Um resultado prático disso é a classe seguinte, que usa um iterator normal para criar um novo tipo de iterator para percorrer todos os pares possíveis de elementos dentro de um container.

template <class T>
class CombinationIterator 
{
  public:
    CombinationIterator(const MemberContainer<T>& theContainer)
    : itsI(theContainer), itsJ(theContainer)
    {
	itsJ++;
    }

    virtual ~CombinationIterator() {}
    CombinationIterator(const CombinationIterator<T>& i)
    : itsI(i.itsI), itsJ(i.itsJ)
    {}

    CombinationIterator<T>& operator=(const CombinationIterator<T>& i);

    operator void*() const {return (void*)(itsJ);}
    Association<T,T> operator*() {return Association<T,T>(*itsJ, *itsI);}
    void operator++(int);
  private:
    Iterator<T> itsI;
    Iterator<T> itsJ;
};

template <class T>
CombinationIterator<T>&
CombinationIterator<T>::operator=(const CombinationIterator<T>& i)
{
    if (&i != this)
    {
	itsI = i.itsI;
	itsJ = i.itsJ;
    }
    return *this;
}

template <class T>
void CombinationIterator<T>::operator++(int)
{
    if (itsJ)
    {
        itsJ++;
        if (!itsJ)
        {
            itsI++;
	    itsJ = itsI;
	    itsJ++;
        }
    }
}