[C++] Template ed ereditarietà

[eardin]

Salve atutti, questa è la prima volta nel forum.
Vorrei chiedere un aiuto riguardo l'ereditarietà tra classi template.
Ecco parte del codice che ho scritto:

template<class V>
class BST: public Albero<V>{
	public:
		BST<V>();
		virtual ~BST<V>();
		
		//bool insert(const V&, const V&);//Inserisce un elemento

		bool insert(const V&); //inserisce un elemento nel BST

		//bool erase(V); //elimino un elemento
		typename Albero<V>::Iteratore find(const V &) const;
};

la classe template Albero è molto lunga, il suo unico campo dati è:

smartp radice; //smartp è un tipo di puntatore che funziona, non è il problema.

Gli specificatori di accesso di Albero sono pubblici per semplificare.
il metodo insert(const V&) non è presente in Albero.

Il problema è questo:
se in BST scrivo una cosa tipo:

template<class V>
bool BST<V>::insert(const V& el){
	if(Albero<V>::radice==0){  //è il caso in cui l'albero è vuoto
		cout<<"Faccio il primo inserimento\nNumero Figli:";
		Albero<V>::radice = new typename Albero<V>::Nodo(el);
		return true;
	}
}

funziona tutto, ma se tolgo Albero<V>::radice il compilatore g++-4.1 e g++-3.4 mi dice:
> error: `radice' was not declared in this scope

Spero di essermi spiegato
Grazie in anticipo.

[UltraBeginner]

Originariamente inviato da eardin
Salve atutti, questa è la prima volta nel forum.
Vorrei chiedere un aiuto riguardo l'ereditarietà tra classi template.
Ecco parte del codice che ho scritto:

template<class V>
class BST: public Albero<V>{
	public:
		BST<V>();
		virtual ~BST<V>();
		
		//bool insert(const V&, const V&);//Inserisce un elemento

		bool insert(const V&); //inserisce un elemento nel BST

		//bool erase(V); //elimino un elemento
		typename Albero<V>::Iteratore find(const V &) const;
};

la classe template Albero è molto lunga, il suo unico campo dati è:

smartp radice; //smartp è un tipo di puntatore che funziona, non è il problema.

Gli specificatori di accesso di Albero sono pubblici per semplificare.
il metodo insert(const V&) non è presente in Albero.

Il problema è questo:
se in BST scrivo una cosa tipo:

template<class V>
bool BST<V>::insert(const V& el){
	if(Albero<V>::radice==0){  //è il caso in cui l'albero è vuoto
		cout<<"Faccio il primo inserimento\nNumero Figli:";
		Albero<V>::radice = new typename Albero<V>::Nodo(el);
		return true;
	}
}

funziona tutto, ma se tolgo Albero<V>::radice il compilatore g++-4.1 e g++-3.4 mi dice:
> error: `radice' was not declared in this scope

Spero di essermi spiegato
Grazie in anticipo.

Ciao eardin,
innanzitutto benvenuto

con l'ereditarietà di tipo public i membri privati di Albero sono accessibile solo tramite ::, per questo motivo se togli Albero <V> il compilatore non sa che pesci prendere.
In ogni caso spero che qualche espertone del forum possa spiegare meglio



PS: spero di non aver scritto baggianate, il C++ lo studio da pochi mesi!!!!

[eardin]

Inviato da UltraBeginner:
...
con l'ereditarietà di tipo public i membri privati di Albero sono accessibile solo tramite ::, per questo motivo se togli Albero <V> il compilatore non sa che pesci prendere.
In ogni caso spero che qualche espertone del forum possa spiegare meglio
...

il fatto è che il Albero è tutto public, ho tolto appunto i private o protected per vedere se era quello, ma continua a darmi l'errore in compilazione.

Grazie cmq della risposta.

[UltraBeginner]

Originariamente inviato da eardin
il fatto è che il Albero è tutto public, ho tolto appunto i private o protected per vedere se era quello, ma continua a darmi l'errore in compilazione.

Grazie cmq della risposta.

Cavolo,

sai che è strano. In effetti ho riaperto un mio progetto con l 'ereditarieta e mettendo un dato public tutte le funzioni che ereditano lo vedono tranquillamente senza il ::.

Potresti scrivere la gerarchia di ereditarietà?

[eardin]

E' molto semplice:

template<class V>
class Albero{
...
};

template<class V>
class BST: public Albero<V>{
...
};

[UltraBeginner]

Originariamente inviato da eardin
E' molto semplice:

template<class V>
class Albero{
...
};

template<class V>
class BST: public Albero<V>{
...
};

Uhm,

e quindi Albero e cosi fatto

template<class V>
class Albero{
public:
/* Varie funzioni*/
smartp radice;


};

giusto?

Se e cosi allora proprio non capisco perchè ti dia quell errore...anche se il fatto che ti dica "non declared in this scope" mi fa sospettare qualche errore a livello di file .h
In ogni caso speriamo nell intervento di qualche espertone del forum, anche perchè è molto interessante come discussione.

[eardin]

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

#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;

		

};

[UltraBeginner]

Mumble mumble,

prova a spostare la definizione della classe Nodo in alto.... vediamo che succede!

PS. Forse e meglio continuare la discussione nei messaggi privati senno intasiamo il forum!

[eardin]

forse ho risolto il problema.
E' colpa del compilatore!!!
Nel g++ 3.3 non serviva dare lo scoping (: o passare per il this mentre dal 3.4 si

questo vuol dire che per accedere al campo radice o ad un metodo di Albero da BST devo scrivere:
this->radice;
oppure
Albero<V>::radice;

vedere anche qui:
http://www.icce.rug.nl/documents/cpl...us19.html#l352 sezione 19.11.1: Type resolution for base class members