2

作为对我最后一个问题的回答，建议尽可能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 的错误？

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

4

1 回答 1

8

使用的建议common_type是虚假的。

使用decltype您在其他问题中遇到的问题只是一个GCC bug。

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

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

即 anX和 aY都可以转换成什么类型​​。

x * y一般来说，这与, if的结果完全无关，X并且Y有一个返回完全不同类型的重载operator*。

在您的特定情况下，您有x*y两个变量都是 type的表达式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有效并生成 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)，这就是它的用途！

于 2012-06-15T18:37:15.783 回答