Ich versuch mich grad interessehalber an etwas "baumähnlichen", bin aber erst dabei, die einzelnen Knoten zu programmieren.
Hab mir dabei eine klasse "Node" erstellt und bei der Gelegenheit wollte ich mich gleich in die Template-Programmierung einarbeiten.

grobe Überlegung: ein Knoten beinhaltet den Typ int und hat natürlich drei Zeiger auf andere Knoten (parent, lhs, rhs), die aber nicht zwingend auch den selben Typ haben, sondern bspw. einen float, string oder andere benutzerdefinierte Klassen.

die Definition sieht bisher so aus (Ausschnitt):

template<typename T>
class Node
{
public:
	Node( T e );
	~Node();

	void setData( const T& theValue );
	T data() const;
	template<typename U> void setLeft( const Node<U>& theValue );
private:
	Node* m_left;
	Node* m_right;
	Node* m_parent;
	T m_data;

};

#include "node.hpp"

bzw. entsprechend die impl:

template<typename T> Node<T>::Node( T e )
: m_left( 0 ),
m_right( 0 ),
m_parent( 0 ),
m_data( e )
{
}

template<typename T> Node<T>::~ Node()
{
}

template<typename T> T Node<T>::data() const
{
	return m_data;
}

template<typename T> void Node<T>::setData( const T& theValue )
{
	m_data = theValue;
}

template<typename T> template<typename U> void Node<T>::setLeft( const Node<U>& theValue )
{
	m_left = theValue;
}

ich kann mir bereits denken, dass dieser Ansatz falsch ist, aber ich hab bisher nirgends den entscheidenden Tipp gefunden, wie man es richtig macht...
Der Compiler meldet folgendes in Zeile 25 im unteren Codeausschnitt:

error: cannot convert 'const Node<int>*' to 'Node<float>*' in assignment

für einen Schubs in die richtige Richtung wär ich dankbar

aber nicht zwingend auch den selben Typ haben

struct base_node
{
    base_node* left;
    base_node* right;
    base_node* parent;

    base_node()
        : left(NULL), right(NULL), parent(NULL)
    {}
};

template<typename Type>
class basic_node : public base_node
{
    typedef Type value_type;

    value_type m_data;

public:
    basic_node(value_type const& value)
        : m_data(value) 
    {}

public:
    void set(value_type const& value)
    { m_data = value; }
    value_type const& get() const { return m_data; }
};

typedef basic_node<int> int_node;
typedef basic_node<bool> bool_node;

so ... dann einfach base_node als root nehmen ... evtl. noch wie unten gezeigt typdef für int_node, bool_node usw. einfügen und fertig