Salve sto cercando di implementare il un albero binario per poi lavorarci sopra ma ho uno strano errore e non riesco a capire di cosa si tratta, il codice è il seguente:
// classe albero.h
// AlberoB.h: interface for the AlberoB class.
//
//////////////////////////////////////////////////////////////////////
#ifndef ALBEROB_H
#define ALBEROB_H
#include <assert.h>
enum Direzione { SIN=0, DES=1 };
template <class T>
struct SNodo{
T vinfo; // parte informativa
SNodo *ppadre, *pfiglio[2]; // puntatori al padre e ai due figli
SNodo( const T& inf ): vinfo(inf)
{ ppadre = pfiglio[SIN] = pfiglio[DES] = 0;
}
~SNodo( ) {delete pfiglio[SIN]; delete pfiglio[DES];}
};
template <class T>
class AlberoB
{
protected:
SNodo<T>* pradice; // puntatore alla radice
public:
// FUNZIONI NON COSTANTI
AlberoB ();
AlberoB ( const T&);
// inserisce l'albero AC come figlio d = SIN/DES di AC
void insFiglio ( Direzione, AlberoB&);
// estrae il figlio d = SIN/DES
AlberoB<T> estraiFiglio ( Direzione);
void modRadice ( const T& );
// svuota l'albero cancellandone tutti i nodi
void svuota();
// svuota l'albero ma senza cancellare i nodi
void annulla();
// FUNZIONI COSTANTI
bool nullo() const;
// restituisce una copia dell'albero
AlberoB<T> copia ( ) const;
// mostra l'info della radice
const T& radice ( ) const;
// restituisce true se la radice ? nodo foglia
bool foglia () const;
// restituisce il figlio d = SIN/DES
AlberoB<T> figlio ( Direzione d ) const;
// restituisce il padre eventualmente nullo
AlberoB<T> padre ( ) const;
};
#endif
// albero.cpp
// AlberoB.cpp: implementation of the AlberoB class.
//
//////////////////////////////////////////////////////////////////////
#include "AlberoB.h"
template <class T>
AlberoB<T>::AlberoB () {
pradice = 0;
}
template <class T>
AlberoB<T>::AlberoB ( const T& a) {
pradice = new SNodo<T>(a);
}
template <class T>
bool AlberoB<T>::nullo() const
{
return pradice == 0;
}
// inserisce l'albero AC come figlio d = SIN/DES di AC
template <class T>
void AlberoB<T>::insFiglio ( Direzione d, AlberoB& AC )
{
assert( !nullo() );
assert( figlio(d).nullo() );
if ( !AC.nullo() ) {
pradice->pfiglio[d]=AC.pradice;
AC.pradice->ppadre=pradice;
}
}
// estrae il figlio d = SIN/DES
template <class T>
AlberoB<T> AlberoB<T>::estraiFiglio ( Direzione d ) {
assert( !nullo() );
AlberoB<T> A = figlio(d);
A.pradice->ppadre=0;
pradice->pfiglio[d] = 0;
return A;
}
template <class T>
void AlberoB<T>::modRadice ( const T& a ) {
assert( !nullo() );
pradice->vinfo = a;
}
// svuota l'albero cancellandone tutti i nodi
template <class T>
void AlberoB<T>::svuota() {
delete pradice; pradice = 0;
}
// svuota l'albero ma senza cancellare i nodi
template <class T>
void AlberoB<T>::annulla() {
pradice = 0;
}
// FUNZIONI COSTANTI
// restituisce una copia dell'albero
template <class T>
AlberoB<T> AlberoB<T>::copia ( ) const {
if ( nullo() ) return AlberoB<T>();
AlberoB<T> AC(radice());
AlberoB<T> fs = figlio(SIN).copia();
AlberoB<T> fd = figlio(DES).copia();
AC.insFiglio(SIN,fs);
AC.insFiglio(DES,fd);
return AC;
}
// mostra l'info della radice
template <class T>
const T& AlberoB<T>::radice ( ) const {
assert( !nullo() );
return pradice->vinfo;
}
// restituisce true se la radice ? nodo foglia
template <class T>
bool AlberoB<T>::foglia () const {
return !nullo()&&figlio(SIN).nullo()&& figlio(DES).nullo();
}
// restituisce il figlio d = SIN/DES
template <class T>
AlberoB<T> AlberoB<T>::figlio ( Direzione d ) const {
assert( !nullo() );
AlberoB<T> AC;
AC.pradice = pradice->pfiglio[d];
return AC;
}
// restituisce il padre eventualmente nullo
template <class T>
AlberoB<T> AlberoB<T>::padre ( ) const {
assert( !nullo() );
AlberoB<T> AC;
AC.pradice = pradice->ppadre;
return AC;
}
// main:
//============================================================================
// Name : AlberoRicorsioneSX_Magg_DX.cpp
// Author :
// Version :
// Copyright : Your copyright notice
// Description : Hello World in C++, Ansi-style
//============================================================================
#include <iostream>
#include "AlberoB.h"
using namespace std;
//bool SX_Min_DX(const AlberoB<int>&, int&, int&);
bool dim(const AlberoB<int>&, int&, int&, int&, int&);
int nodoPiuGrande(const AlberoB<int>& , int &);
bool visitaPosticipata(const AlberoB<int>& );
int main()
{
//definisco gli elementi che contiene l'albero
AlberoB<int> a(1);
AlberoB<int> b(3);
AlberoB<int> c(5);
AlberoB<int> d(2);
AlberoB<int> e(7);
AlberoB<int> f(2);
AlberoB<int> g(3);
AlberoB<int> h(20);
AlberoB<int> i(2);
//costruisco l'albero con i figli:
//(vedi file di testo disegno albero stessa directory)
a.insFiglio(SIN,b);
a.insFiglio(DES,c);
b.insFiglio(SIN,d);
b.insFiglio(DES,e);
d.insFiglio(DES,h);
c.insFiglio(SIN,f);
c.insFiglio(DES,g);
f.insFiglio(SIN,i);
int somma=0;
int somma2=0;
/*
if( SX_Min_DX(a,somma,somma2) )
{
cout<<"OK"<<endl;
//cout<<"la somma dei figli sinistra e"<<somma<<endl;
//cout<<"la somma dei figli destri e"<<somma2<<endl;
}
else
{
cout<<"NO"<<endl;
}
*/
int cont=0;
int cont2=0;
int cont3=0;
int cont4=0;
cout<<dim(a,cont,cont2,cont3, cont4);
if(dim(a,cont, cont2,cont3,cont4))
cout<<"tutti i nodi di sinistra sono pari e tutti i nodi di destra sono dispari"<<endl;
else
cout<<"non va bene"<<endl;
int max=0;
cout<<"il nodo piu grande e:"<<" "<<nodoPiuGrande(a,max)<<endl;
cout<<"il massimo dei nodi e:"<<max<<endl;
int somma5=0;
cout<<"la somma dei sinistre::::::::::::"<<visitaPosticipata(a);
return 0;
}
bool visitaPosticipata(const AlberoB<int>& A)
{
if(A.nullo())
{
return true;
}
if(!A.figlio(SIN).nullo()&& !A.figlio(DES).nullo())
{
cout<<"sinistra"<<A.figlio(SIN).radice()<<endl;
cout<<"destra"<<A.figlio(DES).radice()<<endl;
return visitaPosticipata(A.figlio(SIN).radice());
return visitaPosticipata(A.figlio(DES).radice());
}
}
/* funzione che mi da il nodo piu grande di tutto l'albero*/
int nodoPiuGrande(const AlberoB<int>& A, int &max)
{
if(A.nullo())
{
return true;
}
if(!A.figlio(SIN).nullo())
{
if(A.figlio(SIN).radice() > max)
{
max=A.figlio(SIN).radice();
cout<<"il sinistro"<<max;
}
}
if(!A.figlio(DES).nullo())
{
if(A.figlio(DES).radice() > max)
{
max=A.figlio(DES).radice();
cout<<"il destro"<<max;
}
}
return nodoPiuGrande(A.figlio(SIN),max) , nodoPiuGrande(A.figlio(DES),max);
}
/*verifica che la somma dei nodi di sx è piu piccola della somma dei nodi di ds*/
bool dim(const AlberoB<int>&A,int &nNodi, int &nNodi2, int &nPari, int &nPari2 )
{
//cout<<"la dimensione dell'albero e:"<<" "<<dim<<endl;
if(A.nullo())
{
return nNodi+1;
}
if(!A.figlio(SIN).nullo())
{
cout<<"numero nodi sinistri"<<" "<<nNodi<<endl;
nNodi++;
if(A.figlio(SIN).radice()%2==0)
{
cout<<"numero pari sinistri"<<" "<<nPari<<endl;
nPari++;
}
}
if(!A.figlio(DES).nullo())
{
cout<<"numero nodi destri"<<" "<<nNodi2<<endl;
nNodi2++;
if(A.figlio(DES).radice()%2!=0)
{
cout<<"numero dispari"<<" "<<nPari2<<endl;
nPari2++;
}
}
if(nNodi!=nPari || nNodi2!=nPari2)
{
return false;
}
return dim(A.figlio(SIN),nNodi,nNodi2,nPari,nPari2) , dim(A.figlio(DES),nNodi,nNodi2,nPari,nPari2);
}
/*
/*verifica che la somma dei nodi di sx è piu piccola della somma dei nodi di ds*/
/*
bool SX_Min_DX(const AlberoB<int> &A, int &somma, int &somma2)
{
if(A.nullo() )
return true;
if(!A.figlio(SIN).nullo())
{
//if(A.figlio(SIN).radice() > A.figlio(DES).radice())
somma+=A.figlio(SIN).radice();
cout<<"sinistro:::::: "<<somma<<endl;
}
if(!A.figlio(DES).nullo())
{
somma2+=A.figlio(DES).radice();
cout<<"destro:::::: "<<somma2<<endl;
}
if(somma > somma2)
{
return false;
}
//somma+=A.figlio(DES);
//return false;
return SX_Min_DX(A.figlio(SIN), somma,somma2) && SX_Min_DX(A.figlio(DES),somma,somma2);
}
*/
l'errore riportato è il seguente:
Undefined symbols for architecture x86_64:
"AlberoB<int>::insFiglio(Direzione, AlberoB<int>&)", referenced from:
_main in Main.o
"AlberoB<int>::AlberoB(int const&)", referenced from:
_main in Main.o
visitaPosticipata(AlberoB<int> const&) in Main.o
"AlberoB<int>::nullo() const", referenced from:
dim(AlberoB<int> const&, int&, int&, int&, int&) in Main.o
nodoPiuGrande(AlberoB<int> const&, int&) in Main.o
visitaPosticipata(AlberoB<int> const&) in Main.o
"AlberoB<int>::figlio(Direzione) const", referenced from:
dim(AlberoB<int> const&, int&, int&, int&, int&) in Main.o
nodoPiuGrande(AlberoB<int> const&, int&) in Main.o
visitaPosticipata(AlberoB<int> const&) in Main.o
"AlberoB<int>::radice() const", referenced from:
dim(AlberoB<int> const&, int&, int&, int&, int&) in Main.o
nodoPiuGrande(AlberoB<int> const&, int&) in Main.o
visitaPosticipata(AlberoB<int> const&) in Main.o
ld: symbol(s) not found for architecture x86_64
clang: error: linker command failed with exit code 1 (use -v to see invocation)
make: *** [alberi] Error 1
grazie delle risposte