作为对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()中指示的行将调用乘法2,如果没有错,这似乎很奇怪。这可能是使用std::common_type的后果/副作用,还是gcc的错误?

我一直认为返回类型与选择哪种拟合模板功能无关...

最佳答案

使用common_type的建议是虚假的。

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

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

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

XY都可以转换为哪种类型。

通常,如果x * yX具有重载的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),这就是它的作用!

10-07 19:29
查看更多