C++ 嵌套 SFINAE 模板产生编译错误

C++ Nesting SFINAE Template Produces Compilation Error

我正在尝试为自定义模板 class 创建加法运算符,其中第一个参数可以是我的 class 的实例或基本数字类型。我的运算符的定义类似于下面的示例代码:

#include <type_traits>

template<typename T>
struct MyTemplateStruct {
    T val;
};

template<typename T, typename U>
struct MyCommonType {
    typedef std::common_type_t<T, U> type;
};
template<typename T, typename U>
using MyCommonTypeT = typename MyCommonType<T, U>::type;

template<typename T, typename U>
MyTemplateStruct<MyCommonTypeT<T, U>> operator +(
    MyTemplateStruct<T> const& a, MyTemplateStruct<U> const& b)
{
    return { a.val + b.val };
}

template<typename T, typename U>
MyTemplateStruct<MyCommonTypeT<T, U>> operator +(
    T const a, MyTemplateStruct<U> const& b)
{
    return { a + b.val };
}

int main()
{
    MyTemplateStruct<double> a{ 0 }, b{ 0 };
    a = a + b;

    return 0;
}

我的预期是,由于 SFINAE,尝试使用 T = MyTemplateStruct<double>, U = double 实例化第二个运算符定义所导致的编译错误只会将该模板从潜在匹配列表中排除。但是,当我编译时,出现以下错误:

/usr/include/c++/7/type_traits: In substitution of ‘template<class ... _Tp> using common_type_t = typename std::common_type::type [with _Tp = {MyTemplateStruct, double}]’:
main.cpp:18:38: required from ‘struct MyCommonType<MyTemplateStruct, double>’
main.cpp:31:39: required by substitution of ‘template<class T, class U> MyTemplateStruct<typename MyCommonType<T, U>::type> operator+(T, const MyTemplateStruct&) [with T = MyTemplateStruct; U = double]’
main.cpp:40:13: required from here /usr/include/c++/7/type_traits:2484:61: error: no type named ‘type’ in ‘struct std::common_type, double>’

如果我直接在运算符定义中使用 std::common_type_t,而不是使用我的包装器模板 MyCommonTypeT,那么 SFINAE 会按我预期的那样工作并且没有错误。当我必须在另一个模板中包装对 std::common_type 的调用时,如何编译上述代码?

您需要使MyCommonTypeT<T, U>(即MyCommonType<T, U>::type)本身无效,在MyCommonType中声明type时,std::common_type_t<T, U>无效是不够的。例如,您可以特化 MyCommonType,当 MyTemplateStruct 被指定为模板参数时,type 未声明。

template<typename T, typename U>
struct MyCommonType {
    typedef std::common_type_t<T, U> type;
};
template<typename T, typename U>
struct MyCommonType<MyTemplateStruct<T>, U> {};
template<typename T, typename U>
struct MyCommonType<T, MyTemplateStruct<U>> {};

LIVE