Torre di hanoi,algoritmo iterativo

[melmar20]

ciao a tutti, questo che riporto qui sotto è il corpo della funzione che risolve l'algoritmo della torre di hanoi iterativamente. Fa uso di una struttura 'Pilapunt'(testata e funzionante) e una struct che riporto qui sotto

Struct:

     struct tipoelem{
     int num_dischi;
     int ritorno;
     Pilapunt<int> A,B,C;};

Questo il codice:

Pilapunt <tipoelem> pilaAppoggio;
     tipoelem stato;
     Pilapunt<int> temp;
     blocco1:
             if(num==1){
             Des.inPila(Sor.leggiPila());
             
             Sor.fuoriPila();
             goto blocco3;
             }else{
             stato.num_dischi=num;
             stato.A=Sor;
             stato.B=Aus;
             stato.C=Des;
             stato.ritorno=2;
             pilaAppoggio.inPila(stato);
             num=num-1;
             temp=Des;
             Des=Aus;
             Aus=temp;
             goto blocco1;
             }
     blocco2:
             Des.inPila(Sor.leggiPila());
             Sor.fuoriPila();
             stato.num_dischi=num;
             stato.A=Sor;
             stato.B=Aus;
             stato.C=Des;
             stato.ritorno=3;
             pilaAppoggio.inPila(stato);
             num=num-1;
             temp=Sor;
             Sor=Aus;
             Aus=temp;
             goto blocco1;
     blocco3:
             if(!pilaAppoggio.pilaVuota()){
             stato=pilaAppoggio.leggiPila();
             pilaAppoggio.fuoriPila();
             num=stato.num_dischi;
             Sor=stato.A;
             Des=stato.C;
             Aus=stato.B;
             switch(stato.ritorno)
             {
             case (2):
                  goto blocco2;     
                  break;
             case (3):
                  goto blocco3;
                  break;
             }
             }

Ora mi viene sempre segnalato un errore, si sta cercando di effettuare la lettura di una pila che non contiene elemeti.

Quindi tutte le mie attenzioni si sono spostate su questa istruzione :

stato=pilaAppoggio.leggiPila();

la funzione leggiPila della classe pila restituisce un tipo come quello definito al momento dell'istanzazione della classe, in questa caso quindi ,

Pilapunt<tipoelem> restituisce un tipoelem. E per me non c'è niente di strano.

Ora le mie domande sono 2 :

1-non è che c'è un problema di assegnazione quando viene restituito un puntatore, come nel mio caso dove il leggiPila restituisce un puntatore?

2-se non è quello citato sopra, dove si nasconde il problema??

[Stoicenko]

se tipoelem è un puntatore e leggipila ritorna un puntatore allora stato sarà un puntatore all'oggetto puntato dal puntatore ritornato da leggipila.

se è questo il comportamento giusto di leggipila allora è ok.

[melmar20]

tipoelem non è un puntatore ma una struttura, questa la definizione :

struct tipoelem{
     int num_dischi;
     int ritorno;
     Pilapunt<int> A,B,C;};

leggiPila invece non restituisce un puntatore ma un oggetto di tipo Pilapunt <tipoelem>

[Stoicenko]

tipoelem stato;

stato=pilaAppoggio.leggiPila();

qualcosa non mi torna.. se leggipila ritorna un oggetto di tipo Pilapunt <tipoelem> e stato è una oggetto di tipo tipoelem allora l'assegnazione è errata..

[melmar20]

si scusami, leggiPila ritorna tipoelem , ho scritto Pilapunt<tipoelem> solo per mettere in risalto che leggiPila restituisce un parametro dello stesso tipo di quello che si passa al template della classe Pilapunt

[Stoicenko]

Visto che la maggior parte delle istruzioni e classi utilizzate sono implementate da te o posti tutto il codice (se non è eccessivamente lungo) o un link dove poterlo scaricare e provare o prova a mettere un po' di log per vedere dove effettivamente il comportamento è errato..

ps: la goto non andrebbe usata così "all'acqua di rose"