C＆＃x2B;＆＃x2B; 14中的模拟模板约束

Question

我在C ++中编码14一个使用模板类和功能的程序。当模板类型无法满足我对STD :: ENABLE的要求时，我不喜欢我收到的编译器错误消息，

如果我想知道我是否可以更好地尝试模仿C ++ 20概念的某些功能。以下是我必须定义的一些想法，该“概念”检查了某些模板参数的任意数量表达式的有效性

• ，我想检查t and u是否支持加法操作员，我会使用一个测试类似的模板别名

    template <typename T, typename U = T>
    using addition_test = decltype(declval<T>() + declval<U>());

• ，然后我将定义一个简单的要求

    template <typename ...T> 
    using addition_req = is_detected<addition_test, T...> 

• iS_detected 是 detector struct的成员类型的别名=“ https://en.cppreference.com/w/cpp/expermention/is_detected” rel =“ nofollow noreferrer”> tsv2检测idiom 。简而对于 std :: false_type ，否则它将具有 std :: true_type 的成员类型别名。

• 我使用连接 C ++ 17。 affed_group_concept 下面的 std :: true_type 如果满足我的所有要求，或者是 std :: false_type 否则。

template <typename T, typename U = T>
using addition_group_concept = conjunction <
        addition_req<T, U>,
        subtraction_req<T, U>,
        unary_plus_req<T>,
        unary_minus_req<T>
>;

• 最后，我可以使用我的“概念”，

template <typename T, typename U>
auto add (T const & t, U const & u) ->
std::enable_if_t<addition_group_concept<T, U>::value, decltype(t + u)>
{
    return t + u;
}

template <typename T, typename U>
auto add (T const & t, U const & u) ->
std::enable_if_t<!addition_group_concept<T, U>::value, void>
{
    static_assert(always_false<T>::value,
                                "The operands must support addition and substraction operations.");
}

如果不满足我的概念，我会收到一条编译器错误消息，它比您通常的失败模板替换消息短一些，较少的隐态。到目前为止还不错（？）...但是

我以为我认为我可以用尾随的返回类型编写虚拟函数，然后将我的要求序列放在 std :: enable_if 中在尾声返回类型中。然后，我可以在模板别名的帮助下定义我的概念，该模板别名被用作适配器。像这样

// void_t is the c++17 void_t defined as:
// template <typename ...T>
// using void_t = void;

    template <typename ...Requirements>
    using requirement_seq = std::enable_if_t<conjunction<Requirements...>::value>;

    template <typename T>
    using simple_req = std::is_same<void_t<T>, void>;

    template <typename T, typename U = T>
    auto addition_group (T t, U u) -> requirement_seq<
        simple_req<decltype(t + u)>,
        simple_req<decltype(t - u)>,
        simple_req<decltype(+t)>,
        simple_req<decltype(-t)>,
        simple_req<decltype(+u)>,
        simple_req<decltype(-u)>
        >;

    template <typename ...T>
    using addition_group_adapter = decltype(addition_group<T...>);

    template <typename T, typename U = T>
    using addition_group_concept = is_detected<addition_group_adapter, T, U>;

，这有效（！）。这也是与C ++ 20概念的语法最匹配的替代方法。甚至可以使用宏来简化它，

#define SIMPLE_REQ(expression)\
    std::is_same<void_t<decltype(expression)>,void>

template <typename T, typename U = T>
auto addition_group (T t, U u) -> requirement_seq
    <
    SIMPLE_REQ(t + u),
    SIMPLE_REQ(t - u),
    SIMPLE_REQ(+t),
    SIMPLE_REQ(-t),
    SIMPLE_REQ(+u),
    SIMPLE_REQ(-u)
    >;

我想知道这里人们对这种方法的看法是什么。潜在的缺点是什么？可以做得更好或更简洁吗？

我也很想传达“粒状”编译器错误消息。目前，我收到的错误消息是我在 static_assert add 函数的中写的一条，这并不能准确地告诉我我的要求序列中的哪些要求失败了。