Template specific constructor - c++

Question

I'm writing my own vector class and i got a problem.
i defined my class as template,i have definition for each of the vector sizes and i want specific constructor for each of the vector sizes.
here is the code:
template<int size>
ref class Vector
{
internal:
Vector(int _x, int _y, int _z, int _w);
private:
float *m_data = new float[4];
};
and the definitions is :
using Vector2 = Vector<2>;
using Vector3 = Vector<3>;
using Vector4 = Vector<4>;
first of all can i do that? if the answer is yes how?

Answer 1

If you want common interface, define constructor as having 4 arguments and specialize it. Inside, initialize only those members, that are valid for vector of this size:
template <>
Vector<1>::Vector(int _x, int _y, int _z, int _w)
: x(_x) //1D vector has only 'x'
{
}
template <>
Vector<2>::Vector(int _x, int _y, int _z, int _w)
: x(_x)
, y(_y) //2D vector has 'x' and 'y'
{
}
Etc. But that's ugly, forces you you to make some things "common", for example you will hold 4 components even for 2D vector. There are workarounds (templated structure used as member variable, specialized for vector of each size), but that's quite more complicated. Since vectors of different size are in fact different types, I would go for full class specialization:
template<int size>
class Vector;
template<>
class Vector<1>
{
protected:
int x;
public:
Vector(int _x)
: x(_x)
{ }
//other members
};
template<>
class Vector<2>
{
protected:
int x, y;
public:
Vector(int _x, int _y)
: x(_x)
, y(_y)
{ }
//other members
};
Then you can use it this way:
Vector<1> v_1(2);
Vector<2> v_2(4, 6);
//etc...
Also, second solution will allow clients of your vector to instantiate it only for those sizes, that you explicitly allow.

Answer 2

If you really want different behaviour for each template instance, you can do it like so:
//specific version for when 0 is passed as the template argument
template<>
Vector<0>::Vector (int _x, int _y, int _z, int _w)
{
//some Vector<0> related stuff
}
//Vector<1> will use the default version
//specific version for when 2 is passed as the template argument
template<>
Vector<2>::Vector (int _x, int _y, int _z, int _w)
{
//some Vector<2> related stuff
}

Answer 3

With C++11, you may do something like:
template<int size>
class Vector
{
public:
template <typename ...Ts,
typename = typename std::enable_if<size == sizeof...(Ts)>::type>
explicit Vector(Ts... args) : m_data{static_cast<float>(args)...} {}
private:
float m_data[size];
};
using Vector2 = Vector<2>;
using Vector3 = Vector<3>;
using Vector4 = Vector<4>;
int main()
{
Vector2 v2(42, 5);
Vector3 v3(42, 5, 3);
Vector4 v4(42, 5, 51, 69);
}