Templated Vector and Colour Maths library (Specialisation)

Question

I have created a maths library that operates via templates, it allows the user to specify the size and type of the array within a class which is then used to create a maths vector of any dimension up to four. As soon as I went to create a colour class, it struck me how similar the vector and colour class are. Is there anyway in which I could reduce code reuse and use some form of inheritance or specialisation to separate:

1. Specific functionality (ie vector3 does not have a setXYZW() function, instead only a setXYZ()) to the dimension of which it can only be used in.
2. Colour class and vector class can both (in terms of array data member) be of size ranging from 1 to 4 and the both share the same operators, but differ in their use in some circumstances such as a multiply vector differs from a multiply colour.

My knowledge of templates is not that good, so I would very much appreciate if anyone can show me the best solution to such a situation?

template < std::size_t N = 3, typename T = float >
class Vector
{
  typedef T Degree, Radian;
private:
  T m_vecEntry[N];
public:
  // arithmetic operations
  Vector operator + (const Vector & _vector) const;
  Vector operator - (const Vector & _vector) const;
  Vector operator * (const Vector & _vector) const;
  Vector operator * (float _val) const;
};

template < std::size_t N = 4, typename T = float >
class Colour
{
private:
  T m_colEntry[N];
public:
  // arithmetic operations
  Colour operator + (const Colour& _colour) const;
  Colour operator - (const Colour& _colour) const;
  Colour operator * (const Colour& _colour) const;
  Colour operator * (float _val) const;
};

Answer 1

Your classes have a fair amount of duplicated code, it is advisable that you do something about it. A possible solution follows.

First, you take the common functionality to a base class:

template <class Derived, std::size_t N, typename T>
class VectorBase
{
protected:
  VectorBase() {} // Prevent instantiation of base

  Derived operator + (const Derived & _vector) const {
      std::cout << "Base addition\n";
      return Derived();
  }
  Derived operator * (T _val) const {
      std::cout << "Base scalar multiplication\n";
      return Derived();
  }

  T m_components[N];
};

Then you derive from it your Vector and Colour classes. In each derived class you use using Base::operation; to state explicitly that the corresponsing operation from the base class makes sense in the derived class.

For operations that don't make sense in the derived class you provide an alternative definition or not provide it at all (it will not be accessible since you didn't write using).

You can also add operations that were not in the base class, like Vector::norm:

template < std::size_t N = 3, typename T = float >
class Vector : VectorBase<Vector<N, T>, N, T>
{
  typedef VectorBase<Vector<N, T>, N, T> Base;
  typedef T Degree, Radian;

public:
  using Base::operator+; // Default implementation is valid
  using Base::operator*; // Default implementation is valid
  T norm() const {   // Not present in base class
      return T();
  }  
};

template < std::size_t N = 4, typename T = float >
class Colour : VectorBase<Colour<N, T>, N, T>
{
  typedef VectorBase<Colour<N, T>, N, T> Base; 
public:
  using Base::operator+; // Default implementation is valid

  Colour operator * (T _val) const {  // Redefines version in base class
      std::cout << "Colour scalar multiplication\n";
      return Colour();
  }
};

The only trick in this code is that I've used the CRTP to make base class operations work with derived types.

Here is a little test program:

int main()
{
  Vector<> va, vb;
  va + vb;
  va.norm();
  va * 3.0;

  Colour<> ca, cb;
  ca + cb;
  ca * 3.0f;
}

It prints:

Base addition
Base scalar multiplication
Base addition
Colour scalar multiplication

Answer 2

Ultimately the compiler will only create the parts of the template specialization it determines you are going to use. So it in affect will do the optimization for you e.g. not creating an unused method and so on.

So you may just want to consider making normal pre-processor macros to wrap the slight tweaks per template.

But obviously if you want to make some specializations you can do that too, but you'll still end up duplicating lines of code as it were ;)

Answer 3

A lot of graphic engines keep the two separate for precisely the reasons you mentioned. While the structure of the data is equal both require different semantics for operations on the data. This also has the added benefit of more meaningful function names (setX vs setRed) but means code duplication.

Your implementation is just a wrapper around fixed size arrays. You could move the data and shared functionality in a (possible abstract) base class and provide the specific functionality in child classes.

Another way would be to treat your vector and colour classes as decorators to an array wrapper. Write or use a wrapper around arrays and combine it with vector/color functionality through composition.