我有一个模板 class A
template <unsigned int m>
class A
{
public:
A(int) {}
};
它有一个从int的构造函数。我有一个操作：
template<unsigned int m>
A<m> operator+(const A<m>&, const A<m>&)
{
return A<m>(0);
}
但是当我调用：
A<3> a(4);
A<3> b = a + 5;
A<3> c = 5 + a;
我希望int可以被隐式地转换为A，但编译器会报错。
是否有一种优雅的方法可以使隐式转换生效，而不使用以下解决方案：
a + A<m>(5)operator+<3>(a, 5)std::max和std::min函数：unsigned int i = 0;
std::min( i, 10 ); // Error!
类型推导会将 template <typename T> min( T const &, T const & ) 中的第一个参数推断为 unsigned，而将第二个参数推断为 int。由于它们不同，编译器将放弃这个模板函数。
在答案中提出的解决方案是使用语言的一种特性，使您能够在类定义内部定义非成员友元函数。对于每个（不同的）模板实例化，模板的优势在于编译器将创建一个在命名空间级别上具有通过在友元声明中替换实例化的实际类型获得的签名的自由非模板函数：
template <typename T>
class test {
friend test operator+( test const & lhs, test const & rhs ) { // [1]
return test();
}
}
test<int> t; // [2]
test<int> operator+( test<int> const & lhs, test<int> const & rhs ) {
return test<int>();
}
static test add(test const&, test const&)），并让友元函数的定义只是简单地转发：test operator+(test const& a, test const& b) { return add(a,b); }。虽然不完美，但至少类中的定义只有一行。更复杂的逻辑被隐藏在test<T>::add中。 - David Rodríguez - dribeasA传递吗？） - Ad NA 时可以工作（VS 16.10.13，编译为 C++17）。 - Ad N使用模板提供运算符的每个尝试都需要至少一个第二个重载。但是您可以通过在类内定义运算符来避免这种情况：
template <unsigned int m>
class A
{
public:
A(int) {}
inline friend A operator+(const A& a, const A& b) { return A(0); }
};
适用于 a+5 和 5+a。
A<m>，因为我想禁止对具有不同m的对象进行操作。 - SeagullA的定义中没有模板参数的A指的是A<m>而不仅仅是任何 A<x>。 - David Rodríguez - dribeas添加这个运算符
template<unsigned int m>
A<m> operator+(const A<m>&, const int&)
{
return A<m>(0);
}
或者试试这个
template <unsigned int m>
class A
{
friend const A operator+(const A& a, const A& b) { return A(0); }
public:
A(int) {}
// OR FOR UNARY
// const A operator+(const A &a) const {return A(0);}
};
int main(){
A<3> a(4);
A<3> b = a + 5;
A<3> c = 5 + a;
}
A<m>类型的operator+ (const int&，const A<m>&)，并对所有其他操作进行同样处理。 - Seagull5 + a的重载。 - Seth Carnegie5+a创建一些东西。 - SeagullA 类模板添加一个额外的“策略”类型参数，以确定实际所需的转换类型。例如：template <unsigned int m, typename ConvVal = int>
class A
{
public:
typedef ConvVal conv_val;
A(ConvVal) {}
};
template<template <unsigned int, class U> class T, unsigned int m, typename U>
T<m, U> operator+(const T<m, U>&, const T<m, U>&)
{
return T<m, U>(0);
}
template<template <unsigned int, class U> class T, unsigned int m, typename U>
T<m, U> operator+(const T<m, U>&, const typename T<m, U>::conv_val&)
{
return T<m, U>(0);
}
template<template <unsigned int, class U> class T, unsigned int m, typename U>
T<m, U> operator+(const typename T<m, U>::conv_val&, const T<m, U>&)
{
return T<m, U>(0);
}
int main()
{
A<3> a(4);
A<3> b = a + 5;
return 0;
}
现在你的A类将接受一个额外的模板参数，默认为int类型，并定义了你允许自动转换的实际类型。你只需要重载operator+函数三次，一次是没有转换值的版本，它将采用A<m, T>类型的显式类，另外两个版本是采用转换类型的operator+。在上面的代码中，我使用更通用的类型进行了泛化，以便可以对几乎任何具有适当模板签名并定义了conv_val typedef的其他类执行此操作。
operator+）接受一个int的函数。 - Nima + 5中，5应该变成A<3>(5)而不是A<5>(5)。如果选择后者，那么 3 应该来自于模板参数。 - Seth CarnegieA<3>(5)。在+中的m值对于两个参数是相同的，因此它应该从第一个参数中获取。 - Seagull