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 🤡



  • 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!!


Log in to reply