> Profe, si yo tengo el vector: 
> 
>   F
>   |
>   v
> +-----------+
> | A | B | C |
> +-----------+
> 
> Con F iterador apuntando al primer nodo del arreglo. 
> 
> ¿Al responder a la solicitud de --F (disminuir la posición del iterador) lo
> que debo devolver es 0? (así como cuando se llega al último indice del arreglo
> + 1)

En buena teoría, Vector.end() está un lugar más allá del final de "Vector". Si
el arreglo tiene "N"  elementos, es la "dirección" del elemento [N] que está
fuera del vector:

Vector
 [0] [1] [2] [3] [4] [5]   N == 5
+---+---+---+---+---+
| C | A | L | O | R |
+---+---+---+---+---+
  ^                   ^
  |                   |
  p==Vector.begin()  endV == Vector.end()

Siendo así las cosas, para el caso de "p" (o de "F"), el valor de --p y --F
debiera ser el mismo de "endV". Que yo sepa, los iteradores de STL marcan el
igual el final que está "al principio" que el final que está "al final". Pero si
uno quiere puede inventarse iteradores que funcionan diferente.

Retornar CERO no funciona muy bien, pues no calza con la aritmética de puntero
que se usa con los vectores. Si te fijás en el archivo de encabezado de
algoritimos de la biblioteca STL, que está en:
   C:\Program Files\Microsoft Visual Studio .NET\Vc7\include\algorithm
vas a ver que la implementación del Sort usa la expresión:
    Vector().end - Vector.begin()
para determinar la cantidad de elementos que hay en "Vector":

template<class _RanIt> inline     void sort(_RanIt _First, _RanIt _Last) {
                                  // order [_First, _Last), using operator<
                                        _Sort(_First, _Last, _Last - _First);
                                  }

Si en lugar de retornar "& Vector[N]" usás 0, lo que ocurre es que la resta
"_Last - _First" no sirve para determinar las cantidad de elementos del vector,
y en consecuencia tus clases no son compatibles con STL.

En 2 platos: Vector.end() debe ser "& Vector[N]"

        Adolfo
               ///

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];

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._puntero    = Lista._prm;
endL._puntero = 0;

for ( ; p._puntero != endL._puntero ; p._puntero = p._puntero -> next ) {
    Procese( p._puntero -> _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;
}

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);
    }