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

Question

作为对我的 last 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() 中指示的行调用 multiplaction 2，如果没有错误的话，这看起来很奇怪。这可能是使用 std::common_type 的结果/副作用吗？还是 gcc 的错误？

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

Answer 1

建议使用common_type是假的。

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

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

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

即什么类型 X和一个 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) , 这就是它的用途!