Use a defined trait as template parameter for another trait - c++

Question

I am trying to implement a unit_converter using traits. Here is what I set up so far
// create an enumerate class including basic distance units.
enum class Unit {km, m, cm}
// name a trait _Measure_ holding unit and value
template<int v, Unit u> struct M{
static const int value=v;
static const Unit unit=u;
};
int main(int, char**){
// ...
}
now, what I expected is write another trait M_add which can be called in main()
as like M_add<M<10, Unit::cm>, M<10, Unit::m>>, and it has the same inner parameters value and unit. However, in the process of defining such trait, I found difficulties in registering it with proper template arguments.
Firstly, I've tried using M as a 'type' so I can make operations on innter paras of a and b and assign inner paras of M_add.
template<M<int, Unit> a, M<int, Unit> b> struct M_add{
// implementation
}
Then it returns error: template argument for non-type template parameter must be an expression
So I change the arguments as
template<template<int v, Unit u> class M1, template<int v, Unit u> class M2 >
struct M_add{
// implementation
};
while this time the registration pass the compilation, the implementation M_add<M<5, Unit::cm>, M<6, Unit::km>> a; in main() returns error error: template argument for template template parameter must be a class template or type alias template.
What I expect is to operate the inner parameters of M a and M b in template struct M_add, specifically the a.value and a.unit, so the typename specification would be necessary. So what would be the proper initiation for trait M_add in this case so I can do operation like
template<M a, M b> struct M_add{
// implementation
static const int value=a.value+b.value;
}

Answer 1

If you want to be able to write M_add<M<5, Unit::cm>, M<6, Unit::km>> a;, M_add must be something like this:
template <typename M1, typename M2>
struct M_add;
because M<5, Unit::cm> and M<6, Unit::km> are types, not templates.
Your try with template template parameters would be used like M_add<M, M> a;, because M is a template.
If you want to only allow types instantiated from M to be used as parameters, you can add a trait:
template <typename T>
struct is_M : std::false_type {};
template <int v, Unit u>
struct is_M<M<v, u>> : std::true_type {};
template <typename T>
static constexpr bool is_M_v = is_M<T>::value;
template <typename M1, typename M2>
struct M_add {
static_assert(is_M_v<M1> && is_M_v<M2>);
static const int value = []{
if constexpr (M1::unit == M2::unit) {
return M1::value + M2::value;
} else if constexpr (M1::unit == Unit::km && M2::unit == Unit::m
|| M1::unit == Unit::m && M2::unit == Unit::cm) {
return M1::value * 1000 + M2::value;
} else if constexpr (M1::unit == Unit::km && M2::unit == Unit::cm) {
return M1::value * 1000000 + M2::value;
} else if constexpr (M1::unit == Unit::m && M2::unit == Unit::km
|| M1::unit == Unit::cm && M2::unit == Unit::m) {
return M1::value + M2::value * 1000;
} else if constexpr (M1::unit == Unit::cm && M2::unit == Unit::km) {
return M1::value + M2::value * 1000000;
}
return 0;
}();
static const Unit unit = []{
if constexpr (M1::unit == Unit::cm || M2::unit == Unit::cm) {
return Unit::cm;
} else if constexpr (M1::unit == Unit::m || M2::unit == Unit::m) {
return Unit::m;
} else if constexpr (M1::unit == Unit::km || M2::unit == Unit::km) {
return Unit::km;
}
return Unit{};
}();
};
Demo