什么更适合用于自动返回类型:decltype或std :: common_type <> :: type(如果可能)？

Question

作为对我上一个问题的回答,建议尽可能使用std::common_type<X,Y>::type自动返回类型的声明而不是原始的decltype().但是,这样做我遇到了问题(使用gcc 4.7.0).请考虑以下简单代码

template<typename> class A;
template<typename X> class A {
  X a[3];
  template <typename> friend class A;
public:
  A(X a0, X a1, X a2) { a[0]=a0; a[1]=a1; a[2]=a2; }
  X operator[](int i) const { return a[i]; }
  X operator*(A const&y) const          // multiplication 0: dot product with self
  { return a[0]*y[0] + a[1]*y[1] + a[2]*y[2]; }
  template<typename Y>
  auto operator*(A<Y> const&y) const -> // multiplication 1: dot product with A<Y>
#ifdef USE_DECLTYPE
    decltype((*this)[0]*y[0])
#else
    typename std::common_type<X,Y>::type
#endif
  { return a[0]*y[0] + a[1]*y[1] + a[2]*y[2]; }
  template<typename Y>
  auto operator*(Y s) const ->          // multiplication 2: with scalar
#ifdef USE_DECLTYPE
    A<decltype((*this)[0]*s)>
#else
    A<typename std::common_type<X,Y>::type>
#endif
  { return A<decltype((*this)[0]*s)>(s*a[0],s*a[1],s*a[2]); }
};

int main()
{
  A<double> x(1.2,2.0,-0.4), y(0.2,4.4,5.0);
  A<double> z = x*4;
  auto dot = x*y;           // <-- 
  std::cout<<" x*4="<<z[0]<<' '<<z[1]<<' '<<z[2]<<'\n'
           <<" x*y="<<dot<<'\n';
}

当USE_DECLTYPE是#defined时,代码编译并运行正常使用gcc 4.7.0.但是否则,在main()调用多平面2时所指示的线,如果没有错误,这似乎很奇怪.这可能是使用的后果/副作用std::common_type还是gcc的错误？

我一直认为返回类型与选择多个拟合模板函数中的哪一个无关...

Answer 1

使用的建议common_type是虚假的.

decltype在你的另一个问题中使用你的问题只是一个GCC错误.

使用时你在这个问题中遇到的问题common_type是因为std::common_type<X, Y>::type告诉你从表达式得到的类型:

condition ? std::declval<X>() : std::declval<Y>()

即什么类型的an X和a Y都可以转换为.

一般来说,与结果完全无关x * y,如果X并且Y有重载operator*,则返回完全不同的类型.

在您的特定情况下,您有x*y两个变量都是类型的表达式A<double>.重载决策尝试检查每个重载operator*以查看它是否有效.作为重载解析的一部分,它实例化此成员函数模板:

template<typename Y>
    auto operator*(Y s) const ->
    A<typename std::common_type<X,Y>::type>;

用A<double>替换模板参数Y.这试图实例化common_type<double, A<double>>哪个无效,因为表达式

condition ? std::declval<double>() : std::declval< A<double> >()

无效,因为您无法转换A<double>为double或反之,或任何其他常见类型.

不会发生这个错误是因为重载的operator*被称为,这是因为必须将模板,以决定哪些操作应该被称为被实例化,实例化它的行为造成的错误.编译器永远不会决定调用哪个运算符,错误会在它到达之前停止它.

所以,正如我所说,使用的建议common_type是假的,它可以防止SFINAE禁用与参数类型不匹配的成员函数模板(正式地,SFINAE在这里不起作用,因为替换错误发生在"直接上下文"之外模板,即它发生common_type在SFINAE适用的函数签名中的定义内.)

它允许专门化,std::common_type因此它知道没有隐式转换的类型,所以你可以专门化它,使其common_type<double, A<double>>::type有效并产生类型double,如下所示:

namespace std {
  template<typename T>
    struct common_type<T, A<T>> { typedef T type; };
}

这样做会是一个非常糟糕的主意! 什么common_type是应该给的答案是"是什么类型可以这两种类型的安全转换为？".上面的专业化颠覆了它,给出了"将这些类型相乘的结果是什么？"的答案.这是一个完全不同的问题!与专业is_integral<std::string>成真一样愚蠢.

如果你想要答案"一般表达式的类型是什么,比如expr？" 然后使用decltype(expr),这就是它的用途!