How to check if template argument is a given value? - c++

Question

I cant figure out what this line should be:
class Mtx : public std::conditional<M==2 && N == 1, _Vec2<T>,
std::conditional<N == 1 && M == 3, _Vec3<T>, _MtxMN<T, M, N>>>
"M==2 && N == 1" is not valid code here I think.
Is what I am trying to do possible? If M=2 and N=1 I want to inherit from _Vec2, If M=3 and N=1 I want to inherit from _Vec3, otherwise from _MtxMN
This is so I can write code:
Vec2u v;
v.x=1;
Larger code snippet below:
template <typename T, std::size_t M, std::size_t N>
struct _MtxMN {
public:
std::array<T, M*N> v_;
};
template <typename T>
struct _Vec2 {
union {
struct { T x_, y_; };
struct { T width_, height_; };
struct { T cols_, rows_; };
std::array<T, 2> v_;
};
};
template <typename T>
struct _Vec3 {
union {
struct { T x_, y_, z_; };
struct { T width_, height_, depth_; };
std::array<T, 3> v_;
};
};
// M rows N columns
template <typename T, std::size_t M, std::size_t N>
class Mtx : public std::conditional<constexpr(M==2 && N == 1), _Vec2<T>, std::conditional<N == 1 && M == 3, _Vec3<T>, _MtxMN<T, M, N>>>
{
...
}

Answer 1

There are some syntax errors in your Mtx declaration. It should be
class Mtx : public std::conditional<M==2 && N == 1, _Vec2<T>, typename std::conditional<N == 1 && M == 3, _Vec3<T>, _MtxMN<T, M, N>>::type>::type
The underlying type of std::conditional needs to be refered with ::type, and for the second std::conditional we need to add a typename before it since it's a dependant name.
Also removed the constexpr() part, that's not needed and doesn't compile on gcc or clang.

Answer 2

An easily readable implementation (in my eyes) could go with partial template specialization:
template <typename T, std::size_t M, std::size_t N>
class Mtx : public _MtxMN<T, M, N>
{};
template <typename T>
class Mtx<T, 2, 1> : public _Vec2<T>
{};
template <typename T>
class Mtx<T, 3, 1> : public _Vec3<T>
{};
When the compiler looks for matches of your template instantiation, it will enforce the desired inheritance structure.
Mtx<int, 3, 6> mtx1; // instantiation that inherits from _MtxMN
Mtx<int, 2, 1> mtx2; // instantiation that inherits from _Vec2
Mtx<int, 3, 1> mtx3; // instantiation that inherits from _Vec3