View Full Version : [C++] Classe template che estende una classe template
Salve utenti esperti di c++, non riesco a risolvere questo problema:
Diciamo che ho una classe Node<T> (che rappresenta un nodo di un albero). Dovrebbe essere una classe astratta ma non ne sono sicuro. Ero abituato troppo bene con Java. :D
/* - Node.h - */
template<typename T>
class Parent<T>;//forward declaration, mi da errore: 'Parent' is not a class template
class Tree;
template<typename T>
class Node {
public:
const T *value;
Node(Tree &tree, T &value);
virtual ~Node() = 0;//dicono che così la classe diventa abstract
//metodi vari
protected:
Tree *tree;
Parent<T> *parent;
};
/* - Node.cpp - */
#include "Node.h"
template<typename T>
Node<T>::Node(Tree &tree, T &value) : tree(tree), value(value), parent(nullptr) {
}
Ora voglio creare una class Parent<T> che estenda Node<T>. Si tratta di un nodo dell'albero che ha altri figli
/* - Parent.h - */
#include <vector>
using namespace std;
template<typename T>
class Parent final : public Node<T> {
public:
Parent(Tree &tree, T &value, int children = 1);
//metodi vari
protected:
vector<Node<T>*> children;
};
/* - Parent.cpp - */
#include "Parent.h"
template<typename T>
Parent<T>::Parent(Tree &tree, T &value, int children=1) : Node<T>(tree, value) {
this->children.reserve(children);
}
Se invece della forward declaration includo il file "Parent.h" allora l'errore che ottengo è:
- expected unqualified-id before '<' token
- expected '{' before '<' token
- expected template-name before '<' token
class Parent final : public Node<T> {//qui
}
Poi ci sarebbe una classe Leaf ma è logicamente sullo stesso piano di Parent. Si tratta di una classe dell'albero che non ha figli.
Mmm ci sono diversi errori.
Per prima cosa ti conviene piazzare tutte le classi template (e la loro implementazione) in dei file h, questo ti evita mal di testa con la sintassi verbosa di C++.
Sintassi che per altro dovresti studiare meglio perché fai confusione tra variabili reference e puntatori.
Final è stata introdotta in C++11, prima di questo non c'era alcuna keyword con quel nome, assicurati di compilare usando --std=c++11.
Venendo al programma vero e proprio, non capisco perché vuoi distinguere in due classi Parent e Node, in un albero il parent di un nodo è ancora un nodo, o al massimo non esiste (se è la radice).
Al tempo stesso non capisco perché fare riferimento al Tree in ogni singolo Nodo.
Tieni presente che un albero può essere visto come puntatore al nodo radice.
template<typename T>
class Tree
{
Node<T>* root;
}
Per prima cosa ti conviene piazzare tutte le classi template (e la loro implementazione) in dei file h, questo ti evita mal di testa con la sintassi verbosa di C++.
Da quel che ho capito è convenzione inserire nel file header le dichiarazioni e nel file sorgente le definizioni (implementazioni) delle classi. Preferisco fare tutto in modo coerente e standard se possibile, anche perché sto imparando solo ora la sintassi. Se mi dici che è impossibile dividere le due cose lo farò, sennò le tengo così, anche a costo di qualche sbattimento in più :cool: .
Sintassi che per altro dovresti studiare meglio perché fai confusione tra variabili reference e puntatori.
Risolvo così vero? (Se è questo poi modifico anche il primo post)
/* - Node.cpp - */
template<typename T>
Node<T>::Node(Tree &tree, T &value) : tree(&tree), value(&value), parent(nullptr) {
}
Final è stata introdotta in C++11, prima di questo non c'era alcuna keyword con quel nome, assicurati di compilare usando --std=c++11.Questo c'è, si.
Venendo al programma vero e proprio, non capisco perché vuoi distinguere in due classi Parent e Node, in un albero il parent di un nodo è ancora un nodo, o al massimo non esiste (se è la radice).
La distinzione logica che ho fatto è Node che è una classe astratta, dalla quale ereditano due classi Parent e Leaf. La differenza tra queste due è che la prima può avere altri figli, mentre la seconda no. Cambiano chiaramente anche altri metodi come getNext() ad esempio, in cui prima restituisce il prossimo figlio o senno il padre, la seconda restituisce il padre (perché giustamente più in profondità di così non si può andare).
Al tempo stesso non capisco perché fare riferimento al Tree in ogni singolo Nodo. Questa è una sorta di funzionalità che dovrebbe simulare l'annidamento della classi in Java. In pratica in Java una classe annidata non può essere istanziata se non tramite un'istanza che classe outer.
Outer esterna = new Outer();
Outer.Inner interna = esterna.new Inner();
Insomma, la risposta è che non voglio che esistano istanze di classi Node che non siano associate ad un'istanza di Tree (per quello che nel costruttore uso reference, in modo che non venga passato un nullptr).
Tieni presente che un albero può essere visto come puntatore al nodo radice.È esattamente così che ho definito la classe Tree, oltre ovviamente ad altre cose che mi servono in quella classe.
Tornando al problema, posso fare una forward declaration di una classe template? (L'ho cercato, l'ho trovato da altre parti ma giuro che non sono riuscito a capire come fare praticamente).
Qual è la sintassi corretta per definire ed implementare (magari distinguendo in file sorgente e file header) una classe template con parametro T che estende una classe template con lo stesso parametro?
Da quel che ho capito è convenzione inserire nel file header le dichiarazioni e nel file sorgente le definizioni (implementazioni) delle classi. Preferisco fare tutto in modo coerente e standard se possibile, anche perché sto imparando solo ora la sintassi. Se mi dici che è impossibile dividere le due cose lo farò, sennò le tengo così, anche a costo di qualche sbattimento in più :cool: .
Questo è vero per le classi "normali" (non template).
Per i template tipicamente si preferisce mettere tutto in un unico header.
http://www.parashift.com/c++-faq-lite/templates-defn-vs-decl.html
Risolvo così vero? (Se è questo poi modifico anche il primo post)
/* - Node.cpp - */
template<typename T>
Node<T>::Node(Tree &tree, T &value) : tree(&tree), value(&value), parent(nullptr) {
}
Si dato che tree nella classe è un puntatore e tu passi un reference.
Comunque puoi anche usare direttamente un reference nella classe (ed inizializzarlo nel costruttore come avevi fatto prima) ma naturalmente non può essere NULL.
La distinzione logica che ho fatto è Node che è una classe astratta, dalla quale ereditano due classi Parent e Leaf. La differenza tra queste due è che la prima può avere altri figli, mentre la seconda no. Cambiano chiaramente anche altri metodi come getNext() ad esempio, in cui prima restituisce il prossimo figlio o senno il padre, la seconda restituisce il padre (perché giustamente più in profondità di così non si può andare).
Capito... il fatto è che senza avere altri dettagli è un po' difficile consigliarti su quale sia la cosa migliore che puoi fare in C++ (senza incorrere in mal di testa), dato che tecnicamente puoi fare tutto.
Per esempio non è che sia il massimo il comportamento di getNext(), per altro potresti incorrere in dei cicli, ma comunque...
Questa è una sorta di funzionalità che dovrebbe simulare l'annidamento della classi in Java. In pratica in Java una classe annidata non può essere istanziata se non tramite un'istanza che classe outer.
Outer esterna = new Outer();
Outer.Inner interna = esterna.new Inner();
Insomma, la risposta è che non voglio che esistano istanze di classi Node che non siano associate ad un'istanza di Tree (per quello che nel costruttore uso reference, in modo che non venga passato un nullptr).
È esattamente così che ho definito la classe Tree, oltre ovviamente ad altre cose che mi servono in quella classe.
Anche in C++ esistono le classi interne (nested classes), ma sinceramente mi è capitato raramente di usarle e ci sono molti dettagli sull'accesso da fuori ma anche dall'interno stesso della outer class, prova a vedere.
Potresti anche pensare di usare una funzione per generare nodi a partire dall'albero (simil-factory).
Tornando al problema, posso fare una forward declaration di una classe template? (L'ho cercato, l'ho trovato da altre parti ma giuro che non sono riuscito a capire come fare praticamente).
Qual è la sintassi corretta per definire ed implementare (magari distinguendo in file sorgente e file header) una classe template con parametro T che estende una classe template con lo stesso parametro?
A volte per fare queste cose servono dei trucchetti in C++, tipo la keyword using per creare alias sui nomi, prova con quello.
In genere cerco di evitare il più possibile queste dipendenze cicliche, specie usando i templates.
Al limite anziché usare una classe astratta prova a decomporre usando un'interfaccia ed implementando quella.
Le classi interne in C++ funzionano diversamente dal Java. Se la classe interna è pubblica può essere istanziata senza che esista un'istanza della classe esterna.
Per quanto riguarda la divisione tra dichiarazione ed implementazione di una classe template. Ho letto in in questo articolo:
http://www.bogotobogo.com/cplusplus/template_declaration_definition_header_implementation_file.php#sample
Che il metodo consigliato è quello descritto nella porzione di codice.
Lo stesso posso ottenerlo scrivendo la dichiarazione in un file .h e l'implementazione nel file .cpp con la differenza che sarà il file .h ad includere il file .cpp alla fine del suo codice.
Esempio:
/* - Tree.h - */
template<typename T>
class Tree {
public:
Tree();
Tree(Node<T> &root);
virtual ~Tree();
protected:
Node<T> *root;
bool descend;
};
#include "Tree.cpp"//invece di questa linea ci sarà il codice di Tree.cpp
/* - Tree.cpp - */
template<typename T>
Tree<T>::Tree() : root(nullptr), descend(true) {
}
template<typename T>
Tree<T>::Tree(Node<T> &root) : root(&root), descend(true) {
}
template<typename T>
Tree<T>::~Tree() {
if (this->root) delete this->root;
}
È corretto questo approccio?
Mi spiace ma scrivere tutto nell'header lo percepisco come sbagliato (anche nel caso volessi distribuire i file header e nascondere l'implementazione degli algoritmi), piuttosto torno a scrivere quello che ho in mente in java.
Grazie delle risposte finora :D
Non funziona perché a quanto parte ogni file cpp crea una translation unit separata. Quello che si può fare però è definire l'implementazione in un altro file che generalmente viene chiamato tpp (t=template) oppure ipp(i=include) (poco usata) che viene incluso nel header che a sua volta viene incluso in ogni cpp in cui viene usata quella determinata classe template. Mi sembra un buon compromesso.
A questo punto credo che userò .cpp, .hpp, .tpp per uniformità
EDIT:
Tra l'altro l'estensione .tpp è riconosciuta anche da GitHub
https://github.com/github/linguist/blob/master/lib/linguist/languages.yml
EDIT:
Eclipse non riconosce come file c++ l'estensione .tpp quindi bisogna modificare le impostazioni in:
Window > Preferences > General > Content Types > Text > C Source File > C++ Source File > C++ Header > Add > "*.tpp" > OK
vBulletin® v3.6.4, Copyright ©2000-2025, Jelsoft Enterprises Ltd.