Templated Vector and Colour Maths library (Specialisation)

Answer 1

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 2

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 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.