wie weit sollte generizität gehen?



  • einfaches beispiel aus meiner mathelib

    // ganz normaler vektor
    template<
    	typename _T> class Vector4
    {
    	public:
    		Vector4() { /* .. */ }
    
    	private:
    		_T	val[4];
    };
    
    // bounding box oder im volksmund quader
    // erste möglichkeit
    template<
        typename _T> class AABB
    {
    	public:
    		AABB(const Vector4<_T> &vMin, const Vector4<_T> &vMax)
    		:	m_vMin(vMin),
    			m_vMax(vMax)
    		{ }
    
    	private:
    		Vector4<_T>	m_vMin, m_vMax;
    };
    // oder möglichkeit zwei
    template<
        typename _T> class AABB
    {
    	public:
    		AABB(const _T &vMin, const _T &vMax)
    		:	m_vMin(vMin),
    			m_vMax(vMax)
    		{ }
    
    	private:
    	    _T		m_vMin, m_vMax;
    };
    

    nun stellt sich für mich die frage was "besser" oder geschickter ist.
    natürlich gebe ich dem user die möglichkeit bei der zweiten variante
    seine eigene vektorklasse zu benutzen dieses setzt natürlich voraus
    das diese auch die entsprechenden methoden bzw. operatoren besitzt bzw.
    überlädt. sicherer wäre natürlich variante eins da ich ja weis was
    meine eigene vektorklasse kann und macht. klarer nachteil von variante
    zwei, finde ich, ist das wenn ich dieses konsequent durchziehen würde
    jedes member von allen klassen generisch machen müsste, was natürlich
    bei einigen klassen mit vielen unterschiedlichen member erheblicher
    aufwand ist.



  • Was, wenn Du in deiner Mathelib mehr als nur Multiplizieren oder Addieren mit Vektoren machen willst? Das kann bei dem Nutzer ja ganz anders aussehen. Dann plötzlich wieder eine Schnittstelle voraussetzen? Naja, das ginge schon, wenn der Nutzer irgentwelche optimieren, plattformabhängigen Libs nutzen will, müsste er sich halt nen Wrapper schreiben. Keine Ahnung, ob das die Mühe wert ist. Ich würd's nicht machen. 😃



  • Wie wär's mit

    template
    <
      typename T_,
      template <class> class VectorT = Vector4
    >
    class AABB
    {
        public:
            AABB(const VectorT<T_> &vMin, const VectorT<T_> &vMax)
            :    m_vMin(vMin),
                m_vMax(vMax)
            { }
    
        private:
            VectorT<T_>        m_vMin, m_vMax;
    };
    

    Das _T solltest du in T_ ändern da T ein Großbuchstabe ist - schau mal in die FAQ, da steht bestimmt auch irgendwo was über reservierte Bezeichner.



  • template template parameter daran hatte ich nicht gedacht. dank dir


Log in to reply