作为对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>()
即
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)
,这就是它的作用!