C/C++ - Aiuto Liste C++ e Classi

Ciao a tutti,

Sto svolgendo questo esercizio sulle classi con le quali devo creare un oggetto al cui interno ci sia una successione di interi.
Fino a qua niente di complesso (almeno dal mio modo di vedere), il problema sussiste quando devo fare la stampa della lista in senso inverso.
Mi spiego meglio, se all'interno della lista ho 1-2-3-4 con l'altra funzione di stampa deve uscire 4-3-2-1 (secondo la logica LIFO).

Questa è la classe:

class SuccessioneNumeri
{
public:

	struct Lista
	{
		int numero;
        Lista *nextElemento;
	};

	void inserisciInCoda(int numero);
	int cancellaUltimoElemento();
	int visualizzaUltimoElemento();
	int cancellaElementoFifo();
	int visualizzaElementoFifo();
    int stampaListaElementiFifo();
    int stampaListaElementiLifo();

private:

	Lista listaNumeri;
};

Queste invece sono le funzioni:

// EsercitazioneSuClasse.cpp : definisce il punto di ingresso dell'applicazione console.
//

#include <iostream>
#include <iomanip>
#include "ClasseListaNumeri.h"

using namespace std;

void SuccessioneNumeri::inserisciInCoda(int numero)
{
		Lista *ptr;
		ptr = &listaNumeri;
		if (ptr->nextElemento == NULL)
		{
			ptr = new Lista;
			ptr->numero = numero;
			ptr->nextElemento = NULL;
		}
		else 
		{
			Lista *ptrAux;
			ptr = ptr->nextElemento;
			while (ptr->nextElemento !=NULL)
				ptr = ptr->nextElemento;
			ptrAux = new Lista;
			ptrAux->numero = numero;
			ptrAux->nextElemento = NULL;
			ptr->nextElemento = ptrAux; 
		}
}

int SuccessioneNumeri::stampaListaElementiLifo()
{
    Lista *ptr;
    ptr = &listaNumeri;
    if (ptr->nextElemento != NULL)
    {
        return ptr->numero;
        stampaListaElementiLifo();
    }

}
    

int SuccessioneNumeri::stampaListaElementiFifo()
{
    Lista *ptr;
    Lista *lastPtr;
    ptr = &listaNumeri;
    do 
    {
        cout << ptr->numero;
        cout << endl;
        lastPtr = ptr;
        ptr = ptr->nextElemento;
        
    } while (lastPtr->nextElemento != NULL);
}

int SuccessioneNumeri::cancellaUltimoElemento()
{
	Lista *ptr;
	Lista *lastPtr;
	ptr = &listaNumeri;
	if (ptr->nextElemento == NULL)
	{
		return -1;
	}
	//ptr = ptr->nextElemento;
	//lastPtr = lastPtr->nextElemento;
	lastPtr = ptr;
    do
	{
		if (ptr->nextElemento == NULL)
		{
			lastPtr->nextElemento = NULL;
			return ptr->numero; 
		}
		lastPtr = ptr;
		ptr = ptr->nextElemento;
	} while (1);
}

int SuccessioneNumeri::visualizzaUltimoElemento()
{
	Lista *ultimoElemento;
	ultimoElemento = &listaNumeri;
	if (ultimoElemento->nextElemento == NULL)
	{
		return -1;
	}
	do
	{
		if (ultimoElemento->nextElemento == NULL)
		{
			return ultimoElemento->numero;
		}
		ultimoElemento = ultimoElemento->nextElemento;
	} while (1);

}

int SuccessioneNumeri::cancellaElementoFifo()
{
    Lista *ptr;
    ptr = &listaNumeri;
    if (ptr->nextElemento == NULL)
    {
        return -1;
    }
	else
    {
        //ptr = ptr->nextElemento;
    }
} 


int SuccessioneNumeri::visualizzaElementoFifo()
{
    Lista *primoElemento;
    primoElemento = &listaNumeri;
    if (primoElemento->nextElemento == NULL)
    {
        return -1;
    }
	else
    {
        return primoElemento->numero;
    }
}

Ricapitolando i problemi sono sostanzialmente due:
1) Come faccio a stampare una lista secondo la logica LIFO?! Io pensavo ad una ricorsione però visto che in tutte le funzioni che ho fatto non passo alcun parametro non saprei come fare

2) Per quanto riguarda la funzione cancellaElementoFifo esiste un problema simile, come faccio a riassegnare a &listaNumeri la nuova testa della lista?!!

Please Help Me!!

Grazie per l'attenzione!!!

Ciao,

penso che puoi agevolmente risolvere il problema inserendo ( e gestendo adeguatamente ) nel nodo della lista anche un campo precElemento in questo modo:

    public:
     
            struct Lista
            {
                    int numero;
            Lista *nextElemento;
            Lista *precElemento;
            };

in modo da poter scorrere la lista anche in senso inverso.

Ciao.

Già ho sbattuto la testa parecchie volte prima di riuscire a capire i puntatori figurati adesso.....le mie poche certezze stanno pian piano svanendo! Riesci ad essere più chiaro con un esempio pratico?! Non frequentando l'università mi viene veramente difficile capire un concetto come il ritorno all'indietro....

semplice, se per ogni nodo tieni memoria del nodo successivo usando il puntatore nextElemento, che ti permette di percorrere la lista in un verso,
analogamente puoi tenere memoria del nodo precedente usando il puntatore precElemento che ti permettera' di percorrerla nel verso opposto.

Ciao.