bhe visto che pare interessare, almeno a UltraBeginner posto l'intera intestazione di Albero.h:

codice:
#include <iostream>

#include <vector>

#include <string>



using namespace std;



#ifndef ALBERO_H

#define ALBERO_H







template<class V>

class Albero{

	

	//Dichiarazione incompleta della classe Nodo
	//protected:
	public:

		class Nodo;

	

	///Dichiarazione di amicizia con la ridefinizione dell'operatore di output

// 	template<V>

// 	friend ostream& operator<<(ostream& , const Albero<V>&);

	

	//private:

	//protected:
	public:

		

		class smartp{

			public:

				///Campo dati di smartp

				Nodo * punt;

				

				///Costruttore di default

				smartp();

				///Costruttore ad un argomento

				smartp(Nodo*);

				///Costruttore di copia

				smartp(const smartp&);

				///distrutore

				~smartp();

				

				///Ridefinizione degli operatori necessari

				smartp& operator=(const smartp&);///assegnazione

				Nodo & operator*()const;///dereferenziazione

				Nodo* operator->()const;///accesso a membro

				bool operator==(const smartp&)const;///uguaglianza

				bool operator!=(const smartp&)const;///disuguaglianza

		};

		

		class Nodo{

			public:

			

				///Campi dati di Nodo

				V info;

				int riferimenti;

				vector<smartp> figli;

				smartp padre;

				

				///Costruttore di default

				Nodo();

				///Costruttore ad un argomento

				Nodo(V);

				

				///Ridefinizione degli operatoi necessari

				V operator*()const;///Dereferenziazione

				bool operator==(const Nodo &) const;///Uguaglianza

				bool operator!=(const Nodo &) const;///Disuguaglianza

				Nodo & operator=(const Nodo &);///Assegnazione

				

				///Metodo per cancellare un elemento dal vector dei figli

				void RimuoviDaVector(Nodo *);

		};

	

		///Campo dati di Albero

		smartp radice;	

		

	public:

	

		///Definizione dell'interfaccia della classe Iteratore

		class Iteratore{

			///Dichiarazione di amicizia con la classe Albero

			friend class Albero<V>;

			

			public:

				

				///Costruttore di default

				Iteratore();

				///Costruttore ad un argomento

				Iteratore(Nodo *);

				///Costruttore di copia

				Iteratore(const Iteratore &);



				///Ridefinizione degli operatori necessari

				bool operator==(const Iteratore & )const;///Uguaglianza

				bool operator!=(const Iteratore & )const;///Disuguaglianza

				Iteratore& operator++();///Incremento prefisso

				Iteratore operator++(int);///Incremento postfisso

				Nodo operator*()const;///Dereferenziazione

				Nodo* operator->()const;///Accesso a membro

				Iteratore& operator=(const Iteratore &);///Assegnazione



				///Metodo di supporto all'operatore di incremento

				smartp ItMove(smartp, smartp);



			private:

				///Campo dati di Iteratore

				Nodo * it;

		};

		

		

		

		///Costruttore

		Albero<V>();

		

		virtual ~Albero<V>();



		///METODI DI GESTIONE DELL'ALBERO

		virtual bool empty() const;///Controlla se l'albero e' vuoto

		virtual bool insert(const V&, const V&);///Inserisce un elemento

		virtual bool erase(V);///Cancella un elemento

		virtual void clear();///Svuota l'albero

		

		///METODI PER SCORRERE L'ALBERO

		virtual Iteratore find(const V &) const;///Trova un elemento

		virtual Iteratore find(const V &, const V &) const;///Trova un elemento in un dato sottoalbero

		virtual Iteratore begin() const;///Ritorna il puntatore all'inizio dell'albero

		virtual Iteratore end() const;///Ritorna il punttore alla fine dell'albero



		///Ridefinizione degli operatori necessari

		bool operator==(const Albero<V> &) const;///Uguaglianza

		Albero<V> operator=(const Albero<V> &);///Assegnazione

		

		///Metodo creato solo con lo scopo di testare il find(V,V)

		bool ProvaFind(const V&, const V&) const;

		

};