[C++] Errore : 'Cannot convert 'Class*' into 'Class*::Struct*' in initialization

[Zeldic]

Ciao a tutti! Ho provato ad implementare il mio primo albero binario (o almeno l'intenzione era quella!) .. Uff.. Credevo fosse un po' più semplice..
Come metodi della mia classe per ora vorrei solo l'inserimento, la ricerca di un nodo, e la stampa.. Poi nella parte privata ho definito due funzioni che vorrei mi calcolassero l'elemento + a sinistra ed un'altra l'elemento + a destra, perché voglio inserire il nuovo nodo nella prima locazione che risulti = NULL.. Ma l'errore che riscontro è il seguente :

''Cannot convert 'Albero*' to 'Albero::Node*''

Non ho capito bene cosa devo fare.. E' un errore grave? Come potrei risolverlo? Vi posto qui il mio codice (ho preso un po' spunto dalla mia ex-coda ) :

#include <iostream>
using namespace std;


class Albero {
  private :
    struct Node {  
      int data; 
      Albero* left; 
      Albero* right;
    };
    Node* node;              
    Node* figlio_sinistro();   
    Node* figlio_destro();    
  
  public :   
    Albero() { node = NULL; }
    ~Albero() { node = NULL; }
    int insert(int dato);
	bool Search(int& output);
	int print();
}; 

Albero::Node* Albero::figlio_sinistro() {
  if(node == NULL)
    return NULL;
    
    Node* ret;
    
    for(ret = node; ret->left != NULL; ret = ret->left);
    return ret;
}

Albero::Node* Albero::figlio_destro() {
  if(node == NULL)
    return NULL;
    
    Node* ret;
    
    for(ret = node; ret->right != NULL; ret = ret->right);
    return ret;
}

int Albero::insert(int dato) {
  Node* nuovo;
  Node* radice;
  
  if(nuovo == NULL) {         
    nuovo = new Node;
    nuovo->data = dato;
    radice = nuovo;     
  } else {                     
            nuovo = new Node; 
            nuovo->data = dato;
            
            if(nuovo < radice)
              figlio_sinistro()->left = nuovo;
                else if(nuovo > radice)
                  figlio_destro()->right = nuovo;
                    else
                      return 0;
    }
} 

bool Albero::Search(int& output) {
  Node* temp = node;
  
  while(temp != NULL) {
    if(output == temp->data) {
      cout << "Elemento presente nell'albero!\n";
      return true;
    }
       else {
               cout << "Elemento non trovato!\n";
               return false;
       }
  } 
}

int Albero::print() {
  if(node == NULL)
    cout << "L'albero e' vuoto!\n";
      else {
        cout << "L'albero contiene i seguenti elementi : \n\n";
        cout << node->data << "\n";
        Node* templ = node->left;
          while(templ != NULL) {
            cout << templ->data << "\n";      
            templ = templ->left;
          }
             Node* tempr = node->right;
               while(tempr != NULL) {
                 cout << tempr->data << "\n";
                 tempr = tempr->right;
               }
      } 
}

main() {
  Albero a;
  int scelta;
  
  do {
        cout << "Scegli una delle seguenti opzioni : \n"
                "1 ---> Per inserire nodi all'interno dell'albero;\n"
                "2 ---> Per cercare un nodo;\n"
                "3 ---> Per visualizzare l'albero;\n"
                "0 ---> Per uscire dal programma.\n"
                "Digita un'opzione : ";
        cin >> scelta;
        cout << "\n\n";
        
        switch(scelta) {
          case 1 : 
            int num;
            
            cout << "Inserisci un numero nell'albero : ";
            cin >> num;
            a.insert(num);
          break;
          
          case 2 : 
            int search;
            cout << "Cerca il nodo ---> ";
            cin >> search;
            cout << "\n";
            a.Search(search);
          break;   
          
          case 3 : 
            a.print();
          break;
          
          case 0 : 
            cout << "Exiting program!\n\n";
          break;
          
          default :  
            cout << "Wrong choice!\n\n";
          break;
        }
  } while(scelta != 0);
  
cin.ignore();

cout <<"Premi Invio per uscire... ";
cin.ignore();
return 0;
}

.. E' che non ho compreso bene cosa sia la 'ricorsione'.. uffa!

[shodan]

E' un errore grave?

Tremendo...

Stai cercando di assegnare un puntatore Node a un puntatore Albero.
Devi cambiare la definizione della struttura.

    struct Node {  
      int data; 
      Node* left; 
      Node* right;
    };

[Zeldic]

Credo di aver capito l'errore, ma non ho ancora capito in che punto devo modificare il mio codice..

[shodan]

La struttura Node l'hai scritta tu, devi solo modificarla e vedere se ci sono altri errori.

[Zeldic]

La struttura Node l'hai scritta tu, devi solo modificarla e vedere se ci sono altri errori.

Grazie.. Ora sì che ho capito tutto!

Ho provato a rifare il mio programma completamente, definendo al posto della struttura una classe che gestisce il dato, all'interno di un'altra classe che gestisce i metodi riguardanti il dato (utilizzando il costrutto 'friend').. Ma il risultato non cambia..

[shodan]

class Albero {
  private :
    struct Node {  
      int data; 
      Node*  left; 
      Node*  right;
    };
    Node* node;              
    Node* figlio_sinistro();   
    Node* figlio_destro();    
  
  public :   
    Albero() { node = NULL; }
    ~Albero() { node = NULL; }
    int insert(int dato);
	bool Search(int& output);
	int print();
};

Ti è più chiaro adesso?

[Zeldic]

Ti è più chiaro adesso?

Sì, scusami.. Non avevo visto bene!

Almeno quell'errore di conversione non si presenta più.. Ora dovrò correggere il resto del programma, che presenta degli errori logici nell'inserimento dei dati (effettuando il debug, risulta sempre che la radice è diversa da NULL) ed il programma termina subito dopo l'inserimento del primo elemento..

Posso farti una domanda, magari è un po' banale : Forse nella classe dovrei aggiungere delle funzioni che mi consentano di scorrere tutti gli elementi dalla radice sino all'ultimo presente a sinistra o a destra, come se fossero liste, per poterle a sua volta chiamare ricorsivamente all'interno delle funzioni di inserimento e di stampa??

[shodan]

E' normale visto che usi variabili locali non inizializzate, ma anche se lo fossero avresti altri problemi. Il punto (e qui rispondo alla seconda questione) è che un albero per sua natura è ricorsivo, quindi anche le varie funzioni dell'albero devono esserlo.
La ricorsione tra l'altro è anche uno dei concetti più difficili da comprendere, quindi è normale avere delle difficolta.
Ti mostro un esempio (volutamente ridotto all'osso e da completare) di come fare un inserimento nell'albero tramite la ricorsione. Compreso questo, il resto è in discesa (spero)

class Albero {
  private :
    struct Node {  
      int data; 
      Node* left; 
      Node* right;
    };
    Node* node;              
    void internal_insert(Node*&, int); // notare il passaggio del puntatore per reference.

  public :   
    Albero() { node = NULL; }
    ~Albero() { }
    void insert(int dato);
}; 

void Albero::internal_insert(Node*& nd, int dato) {
       // punto a
       // se viene ricevuto un nodo NULL occorre crearlo e ne settarne i parametri;
       // passandone il reference le modifiche saranno riportate
       // all'esterno e non su una copia locale.
	if (nd == NULL) {
		nd = new Node;
		nd->data = dato;
		nd->left = NULL;
		nd->right = NULL;
	} else {
                // Qui il nodo esiste e stabilisco il criterio di inserimento.
                // I valori maggiori del campo data vanno a destra, altrimenti a sinistra.
		if (nd->data < dato) {
                        // Qui inizia la ricorsione. Richiamo la stessa funzione
                        // passando come valore il puntatore al nodo destro e il dato.
                        // L'attuale chiamata di internal_insert viene sospesa e ne verrà
                        // invocata una nuova che ripartirà dal punto a.
			internal_insert(nd->right,dato);
		} else {
                        // Qui inizia la ricorsione. Richiamo la stessa funzione
                        // passando come valore il puntatore al nodo sinistro e il dato.
                       // L'attuale chiamata di internal_insert viene sospesa e ne verrà
                        // invocata una nuova che ripartirà dal punto a.
			internal_insert(nd->left,dato);
		}
	}
}

voidAlbero::insert(int dato) {
        // passo il nodo radice e il dato alla vera funzione ricorsiva.
	internal_insert(node,dato);
}

[Zeldic]

Ti mostro un esempio (volutamente ridotto all'osso e da completare) di come fare un inserimento nell'albero tramite la ricorsione. Compreso questo, il resto è in discesa (spero)

Ciao, Shodan!! Rispondo solo adesso, perché avrei voluto scrivere che sono riuscito ad implementare il mio albero correttamente, ma sono ancora fermo con altri tipi di problemi. Prendendo esempio dal tuo suggerimento e da altre fonti, ho completato il codice, ma ho alcuni errori nella compilazione, primo fra tutti :
- Ho bisogno di annidare due classi, ma non riesco a 'renderle amiche' tra loro con l'operatore friend, per cui campi di una classe risultano sconosciuti all'altra ed 'undeclared' al compilatore..

Qualcuno può darmi per favore qualche suggerimento??
Qui il mio codice :

#include <iostream>
#include <stdlib.h>                          
#include <stdexcept>

using namespace std;


class BinAlbero {                            
  private :   
    class Nodo {                            
      private : 
        struct nodo {                       
          int data;                         
          nodo* left;                        
          nodo* right;                       
        };
        
      public :   
        nodo* internal_insert(nodo*&, int);  
      friend class BinAlbero;             // E' corretto scrivere qui l'operatore 'friend', ed in questo modo??
    };
    
  public : 
    Nodo::nodo* radice;                           
    
    BinAlbero() { radice = NULL; }                 
    ~BinAlbero() { radice = NULL; }                
    void insert(int);                              
    void search(int);                             
    void print();                                  
  friend class Nodo;
};

nodo* Nodo::internal_insert(nodo*& nd, int dato) {
  int count = 0;
  
  if(nd == NULL) {
    nd = new nodo;                          
    nd->data = dato;                        
    nd->left = NULL;                        
    nd->right = NULL;                       
    
    if(count == 0) {                        
      radice = nd;                          
      count++;                              
      return;
    } 
    if(nd->data < dato)                     
      internal_insert(nd->right, dato);     
        else                                
          internal_insert(nd->left, dato);  
  }	
} 


void BinAlbero::insert(int dato) {
  internal_insert(radice, dato);
} 

void BinAlbero::search(int target) {
  if(! radice) {                       
    cout << "L'albero e' vuoto!\n\n";
    return;
  } 
  
  Nodo::nodo* temp = radice;
  
  if(target < temp->data)              // Qui ho un problema col puntatore.. Non è legale effettuare il confronto tra un.. 
    temp = temp->left;                 // .. puntatore ed un intero! Come posso fare??  :'( 
      else if(target > temp->right)
        temp = temp->right;
        
  if(temp != NULL)
    cout << "Nodo ricercato ---> ( " << temp->data << " )\n\n";
      else
        cout << "Elemento non presente!\n\n";
          
    
    cout << "Elemento presente nel sottoalbero sinistro.\n\n";
} 

void BinAlbero::print() {
  if(radice == NULL) {
    cout << "Impossibile visualizzare. L'albero e' vuoto!\n\n";
    return;
  }
  Nodo::nodo* temp = radice;
  cout << "L'albero contiene i seguenti elementi : \n\n";  
  print(temp->left);
  cout << " ( " << temp->data << " )\n";
  print(temp->right);
} 


main() {
  BinAlbero a;
  int choice;
  
  cout << "********************   ALBERO BINARIO   ********************\n\n";
  
  do {
        cout << "Scegli una delle seguenti opzioni : \n\n"
                "1 ---> Per inserire un nodo nell'albero;\n"
                "2 ---> Per cercare un nodo;\n"
                "3 ---> Per visualizzare l'albero;\n"
                "0 ---> Per uscire dal programma.\n"
                "Digita un'opzione : ";
        cin >> choice;
        cout << "\n\n";
        
        switch(choice) {
          case 1 :  
            int n;
            
            cout << "Inserisci un dato intero nell'albero : ";
            cin >> n;
            cout << "\n\n";
            a.insert(n);            
          break;
          
          case 2 :  
            int t;
            
            cout << "Cerca il nodo ---> ";
            cin >> t;
            cout << "\n\n";
            
            a.search(t);             
          break;   
          
          case 3 : 
            a.print();               
          break;
          
          case 0 : 
            continue;
          break;
          
          default :  
            cout << "Wrong choice!\n\n";
          break;
        }
  } while(choice != 0);

cout << "Premi Invio per uscire..";
cin.ignore();
return 0;
}

[Zeldic]

Per favore, ho un esame imminente tra qualche giorno!! Helpatemi!!