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

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