Template in Klasseneigenschaften

Ich fange programmiere gerade so rum und habe festgestellt warum es gut sein kann Templates zu haben Es kommt doch vor das man Code mehrmals schreiben muss. Warum, wenn es Template gibt.

class _CBrush
	{
	private:
		std::string name;

	public:
		gdx::_CBrush *prev;			
		gdx::_CBrush *next;

		gdx::_CMesh  *first;
		gdx::_CMesh  *last;

	public:
		_CBrush();
		~_CBrush();

		void SetName(std::string name);

		void Init(void);
		void Release(gdx::_CBrush *brush);

		void Cut(void);

		void Debug(gdx::_CBrush *brush);
	};

class _CMesh
	{
	private:
		std::string name;

	public:
		gdx::_CBrush	*brush;

		gdx::_CMesh		*prev;			
		gdx::_CMesh		*next;

		gdx::_CSurface  *first;
		gdx::_CSurface  *last;

	public:
		_CMesh();
		~_CMesh();

		void SetName(std::string name);

		void Init(void);
		void Release(gdx::_CMesh *mesh);

		void Cut(void);

		void Debug(gdx::_CMesh *mesh);
	};

Die Klassen sehen ja sehr ählich aus und machen im Code auch das gleiche. Der Unterschied ist halt der Typ der Eigenschaften. Da ich mich c++ Anfänger schimpfen kann habe ich wirklich keine Ahnung ob man das vereinfachen kann. Es gibt die Möglichkeit der Vererbung und auch Templates. Wie mache ich das mit den Eigenschaften?

PS: Ich habe so einen Beitrag schon mal geschrieben. Ich finde es nicht mehr

Swordfish

Ich posts nur, damits mir jemand um die Ohren haut

#include <string>
#include <iostream>

template< typename T, typename U >
class thingy_t
{
	private:
		std::string my_name;
		T * prev;
		T * next;
		U * first;
		U * last;

	public:
		virtual ~thingy_t() { std::cout << "thingy_t<" << T::T_type << ", " << U::U_type << ">::~thingy_t()\n"; }

        void init() {}
        void set_name( std::string const & name ) { my_name = name; }
        void release( T * that ) {}
        void cut() {}
        void debug( T * that ) {}
};

class mesh_t;

class brush_t : public thingy_t< brush_t, mesh_t >
{
	public:
		static char const * T_type;
		static char const * U_type;

	public:
		 brush_t()  { std::cout << "mesh_t::brush_t()\n";  }
		~brush_t()  { std::cout << "mesh_t::~brush_t()\n"; }
};

char const * brush_t::T_type = "brush_t";
char const * brush_t::U_type = "mesh_t";

class surface_t;

class mesh_t : public thingy_t< mesh_t, surface_t >
{
	public:
		static char const * T_type;
		static char const * U_type;

	private:
		brush_t * brush;

	public:
		 mesh_t()   { std::cout << "mesh_t::mesh_t()\n";  }
		~mesh_t()   { std::cout << "mesh_t::~mesh_t()\n"; }
};

char const * mesh_t::T_type = "mesh_t";
char const * mesh_t::U_type = "surface_t";

class surface_t : public thingy_t< surface_t, surface_t >
{
	public:
		static char const * T_type;
		static char const * U_type;	
};

char const * surface_t::T_type = "foo?";
char const * surface_t::U_type = "bar?";

int main()
{
	brush_t  brush;
	mesh_t   mesh;
}

Ohhh mein Gott. Das muss ich mir langsam reinziehen. Sonst wird es häftig. Das ist ja sowas von kyriptisch. Danke!!