Come da titolo devo implementare in C++ una classe che rappresenti un albero generico con un metodo che mi restituisca la profondità
(La radice r ha profondità 0, i suoi figli hanno profondità 1, i nipoti profondità 2 e così via).

La classe albero ha una interfaccia molto semplice:
(GLinkedList è una classe creata da me che consiste semplicemente in una lista linkata)
codice:
#include "GLinkedList.h"
template<class T> class GTreeIterator;    //questa classe serve per navigare attraverso l'albero, aggiungere figli, leggere e settare i valori dei nodi. Non la riporto per brevità

//----------------------------------------------------------------------------------------
//Class GTree : every node stores one <dataType> , have one parent and a list of children
//----------------------------------------------------------------------------------------
template<class T> class GTree
{
	friend class GTreeIterator<T>;
	typedef GTree<T> Node;
public:
	GTree(void)							: _parent(nullptr)			{}
	explicit GTree(const T& nodeValue)	: _data(nodeValue), _parent(nullptr)	{}
	virtual ~GTree(void)						            {clearChildren();}

	//delete all children from this node
	inline void clearChildren()
	{
		//salto il codice per brevità
	}

	//return total number of nodes
	inline int size()	const
	{
		//salto il codice per brevità
	}
	inline const T& value() const		{return _data;}
	inline void setValue(const T& v)	{_data=v;}
	inline bool haveChildren() const	{return !_children.isEmpty();}

	//0==only root, 1==root children are leafs, and so on
	int depth() const;
private:
        //TODO: copy
	GTree(const GTree<T>&);										
	GTree<T>& operator=(const GTree<T>&);

	T _data;
	Node* _parent;
	GLinkedList<Node*> _children;
};	//EO class GTree
al momento ho implementato la funzione depth() in questo modo: ma ritorna sempre dei valori più alti di quanto dovrebbe
codice:
template<class T> int GTree<T>::depth() const
{
	if( haveChildren() )
	{
		int c =1, temp=0;
		GList_ConstIterator<Node*> itr = _children.const_begin();
		while( itr.isValid() )
		{
                        //itr.data() in questo caso resituisce un puntatore al nodo figlio
			temp += itr.data()->depth();
			++itr;
			if(temp>c)
				c=temp;
		}
		return c;
	}
	else
		return 0;
}
Quello che ho pensato di fare è questo:
Se un nodo non ha figli torno 0.
Se ha figli:
- controllo ogni figlio
- richiamo la funzione in modo ricorsivo in modo da controllare tutti i nodi
- prendo il valore massimo (sostanzialmente il figlio che ha più nipoti)

spero che qualcuno possa aiutarmi perchè mi sento vicino alla soluzione ma non riesco a vedere l'errore nel mio ragionamento.
Grazie anticipatamente