const N = 5;
char  V[N];

void Procese(char);

for (int i=0; i != N; ++i) {      //      for (int i=0; i < N; ++i) {
    Procese( V[i] );              //          Procese( V[i] );
}                                 //      }
                                                               

 [0] [1] [2] [3] [4] [5]
+---+---+---+---+---+
| C | A | L | O | R |   
+---+---+---+---+---+
  ^                   ^
  |                   |
  p                  endV

char *p;     // recorre el vector
char *endV;  // después del vector

p    = & V[0];  // p = V;
endV = & V[N];  // p = &*(V+N);

for ( ; p != endV; ++p) {
    Procese( *p );
}

Lista L;  // La lista

Lista::iterador p;     // recorre la lista
Lista::iterador endL;  // después de la lista

p    = L.begin();  // p.operator= ( Lista.begin() );
endL = L.end();    // generalmente NULL==0

for ( ; p != endL; ++p) {
    Procese( *p );
}


for ( ; operator != (p,endL); p.operator++() ) {
    Procese( p.operator *() );
}


p.m_p    = L.m_prm;
endL.m_p = 0;

for ( ; ! (p.m_p == endL.m_p) ; p.m_p = p.m_p -> next ) {
    Procese( p.m_p -> m_val );
}



void Procese(int);

for (list::iterator p = L.begin();  p != L.end();  ++p) {
    Procese(*p);  // p->Procese();
    Procese(*p);  // Procese( p.operator*() );
    *p = 13;
}


            _
           / \ Aleatorio ("random")          ==> i + 3    i - j
          /___\
         /     \ Bidireccional               ==> i++      i--
        /_______\
       /         \ Adelante ("forward")      ==> i++
      /___________\
     / Lee   Graba \ ("input" && "output")   ==> *i
    /_______________\



class List {
// ...
    class iterator {    friend class List;
        iterator();

        iterator(const iterator& ); // constructor copia
        iterator& operator=(const iterator& ); // copia

        friend bool operator == (const iterator&, const iterator& );
        friend bool operator != (const iterator&, const iterator& );

        iterator operator++()  // ++p
            { _puntero = _puntero -> next; return *this; }
        iterator operator++(int); // p++
            { iterator q = _puntero; _puntero = _puntero -> next; return q; }

        int& operator*(); // *p y p->
            { return _puntero -> _val; }
    private:
        nodo * _puntero;   // rep de List::iterator
    }; // List::iterator

    iterator begin() { iterator q; q._puntero = _prm; return q; }
// ...
}; // List

inline List::iterator & List::iterator::operator++() {
    // ++p
    // ...
}
inline List::iterator & List::iterator::operator* () {
    return this->_puntero->_val;
}


for (List::iterator p = L.begin();  p != L.end();  ++p) {
    Procese(*p);  // p->Procese();
}

VAR
  p : PLpos;
  pe: PElem;
{...}
  p := List.Last(L);
  IF p <> List.Null THEN BEGIN
    REPEAT
      pe := List.Retrieve(L,p);    { procese la lista L de }
      Elem.Print(pe^);             { atrás hacia adelante  }
      p  := List.Prev(p,L);
    UNTIL p = List.Null;
  END;


    PLpos p;
    PElem pe;
    /*...*/

    p = List.Last(L);
    if (p != List.Null) {
        do {
            pe = List.Retrieve(L,p);    /* procese la lista L de */
            Elem.Print(pe^);            /* atrás hacia adelante  */
            p  = List.Prev(p,L);
        } while ! (p == List.Null);
    }


// Ideas.itr (C) 2002 adolfo@di-mare.com

template <class E> class list {
    list();
    list(const list&);
    list();

    bool Empty();

    void Append( const E& o);
    void PrePend(c);


    class iterator {
    public:
        iterator(iterator&);         //constructor de copia
        iterator& operator++();      //++p
        iterator operator++(int);    //p++
        iterator& operator--();      //--p
        iterator operator--(int);    //p--
        int& operator*();
        iterator& operator=(iterator &x);
        friend bool operator!=(iterator&, iterator&);
        friend bool operator==(iterator&, iterator&);
   }; // iterator



    public interface IEnumerable {
        IEnumerator GetEnumerator();
    }

    public interface IEnumerator {
        bool MoveNext();
        object Current {get;}
        void Reset();
    }

    public virtual IEnumerator GetEnumerator() {
        return new EmployeeEnumerator(this);
    }

// EOF: Ideas.itr

iterador {
    nodo  * _n;
    Lista * _L;
};

iterator iterador::operator++() {
    if (_n == _L->last ) {
        return 0;
    }
    else {
        return _n->next;
    }
}