C++, invertire l'ordine degli elementi di una lista

[pietrol83]

ciao, sto facendo degli esercizi sulle liste me mi è capitato uno di questi che chiede di creare un metodo per la classe lista, chiamato reverse, che inverte l'ordine degli elementi di una lista. posto il codice della classe lista contenente il metodo reverse (da me creato) e di un codice che serve per provare se il metodo funziona correttamente.

listap.h

#ifndef _LISTAP_H
#define _LISTAP_H

#include <iostream>

using namespace std;

template<class T> class lista
{
    private:
        typedef T tipoelem;
        struct nodo
        {
            nodo *precedente;
            tipoelem elemento;
            nodo *successivo;
        };
    public:
        typedef nodo * posizione;
        posizione sentinella;
            
        lista();
        void crealista();
        bool listavuota();
        posizione primolista() const;
        bool finelista(posizione);
        void inslista(posizione&, tipoelem&);
        void canclista(posizione&);
        tipoelem leggilista(posizione) const;
        void scrivilista(posizione&, tipoelem&);
        posizione predlista(posizione);
        posizione succlista(posizione) const;
        void clear();
        void reverse();
        
        bool operator==(const lista<T> &) const;
        bool operator!=(const lista<T> &) const;
};


template<class T> lista<T>::lista()
{
	crealista();
}

template<class T> void lista<T>::crealista()
{
	sentinella = (posizione)malloc(sizeof(nodo));
    tipoelem elemnullo = 0;
	sentinella->precedente = sentinella;
	sentinella->elemento = elemnullo;
	sentinella->successivo = sentinella;
}

template<class T> bool lista<T>::listavuota()
{
	return((sentinella->precedente == sentinella) && (sentinella->successivo == sentinella));
}

template<class T> typename lista<T>::posizione lista<T>::primolista() const
{
    return(sentinella->successivo);
}

template<class T> bool lista<T>::finelista(posizione p)
{
    return(p->successivo == sentinella);
}

template<class T> void lista<T>::inslista(lista<T>::posizione &p, tipoelem& elem)
{
    posizione temp = new nodo;
    temp->elemento = elem;
    temp->precedente = p->precedente;
    temp->successivo = p;
    p->precedente->successivo = temp;
    p->precedente = temp;
    p = temp;
}

template<class T> void lista<T>::canclista(posizione &p)
{
    posizione temp = p;
    p->precedente->successivo = p->successivo;
    p->successivo->precedente = p->precedente;
    p = p->successivo;
    delete(temp);
}

template<class T> typename lista<T>::tipoelem lista<T>::leggilista(posizione p) const
{
    return(p->elemento);
}

template<class T> void lista<T>::scrivilista(posizione &p, tipoelem& elem)
{
    p->elemento = elem;
}

template<class T> typename lista<T>::posizione lista<T>::predlista(posizione p)
{
    return(p->precedente);
}

template<class T> typename lista<T>::posizione lista<T>::succlista(posizione p) const
{
    return(p->successivo);
}

template<class T> void lista<T>::clear()
{
    typename lista<T>::posizione p = primolista();
    
    do
    {
        canclista(p);
    }while(p != sentinella);
}

template<class T> void lista<T>::reverse()
{
    typename lista<T>::posizione p = primolista();
    typename lista<T>::posizione temp = p;
        
    while(p != sentinella)
    {
        temp->precedente = p->successivo;
        temp->successivo = p->precedente;
        cout << temp->precedente << "  " << temp->elemento << "  " << temp->successivo << "\n";
        p->successivo = temp->successivo;
        p->precedente = temp->precedente;
        p = predlista(p);
    }
    temp->precedente = sentinella->successivo;
    temp->successivo = sentinella->precedente;
    sentinella->successivo = temp->successivo;
    sentinella->precedente = temp->precedente;
}

template<class T> bool lista<T>::operator==(const lista<T> &lis) const
{
    typename lista<T>::posizione p1 = primolista();
    typename lista<T>::posizione p2 = lis.primolista();
    bool esito = false;
    bool fine = false;
    
    while(((p1 != sentinella) && (p2 != lis.sentinella)) && fine == false)
    {
        if(leggilista(p1) == lis.leggilista(p2))
            esito = true;
        else
        {
            esito = false;
            fine = true;
        }
        p1 = succlista(p1);
        p2 = lis.succlista(p2);
    }
    return esito;
}

template<class T> bool lista<T>::operator!=(const lista<T> &lis) const
{
    typename lista<T>::posizione p1 = primolista();
    typename lista<T>::posizione p2 = lis.primolista();
    bool esito = false;
    bool fine = false;
    
    while(((p1 != sentinella) && (p1 != lis.sentinella)) && fine == false)
    {
        if(leggilista(p1) != lis.leggilista(p2))
        {
            esito = true;
            fine = true;
        }
        else
            esito = false;
        p1 = succlista(p1);
        p2 = lis.succlista(p2);
    }
    return esito;
}
#endif

esercizio11.cpp

#include <cstdlib>
#include <iostream>
#include "listap.h"

using namespace std;

int main(int argc, char *argv[])
{
    lista<int> list;
    lista<int>::posizione p = list.primolista();
    
    for(int a = 0; a < 10; a++)
    {
        list.inslista(p, a);
        p = list.succlista(p);
    }
    p = list.primolista();
    while(p != list.sentinella)
    {
        cout << p->precedente << "  " << list.leggilista(p) << "  " << p->successivo << "\n";
        p = list.succlista(p);
    }
    cout << "\n\n";
        
    list.reverse();
    system("pause");
    
    p = list.primolista();
    while(p != list.sentinella)
    {
        cout << p->precedente << "  " << list.leggilista(p) << "  " << p->successivo << "\n";
        p = list.succlista(p);
    }
    cout << "\n\n";
    
    system("PAUSE");
    return EXIT_SUCCESS;
}

in pratica quando eseguo il codice la lista non viene stampate nell'ordine inverso. chi mi aiuta a capire perchè non riesco ad ottenere tale risultato??? vi ringrazio.