C++ 重载运算符中没有隐式转换
C++ 重载运算符中没有隐式转换,c++,operator-overloading,implicit-conversion,C++,Operator Overloading,Implicit Conversion,d1+4可以工作,但是4+d1不能工作,即使4可以隐式转换为GMan。为什么它们不相等 struct GMan { int a, b; GMan() : a(), b() {} GMan(int _a) : a(_a), b() {} GMan(int _a, int _b) : a(_a), b(_b) {} GMan operator +(const GMan& _b) { GMan d; d.a
d1+4
可以工作,但是4+d1
不能工作,即使4可以隐式转换为GMan。为什么它们不相等
struct GMan
{
int a, b;
GMan() : a(), b() {}
GMan(int _a) : a(_a), b() {}
GMan(int _a, int _b) : a(_a), b(_b) {}
GMan operator +(const GMan& _b)
{
GMan d;
d.a = this->a + _b.a;
d.b = this->b + _b.b;
return d;
}
};
int main()
{
GMan d1(1, 2), d(2);
GMan d3;
d3 = d1 + 4;
d3 = 4 + d1;
}
一个调用<代码> x+y 由C++编译器转换成以下两个调用之一(取决于<代码> x/COD>是否为类类型,以及是否存在这样的函数):
x.operator +(y);
operator +(x, y);
现在C++有一个简单的规则:在成员访问运算符之前不可能发生隐式转换(<代码> ./COD>)。这样,上述代码中的
x
在第一个代码中不能进行隐式转换,但在第二个代码中可以进行隐式转换
这个规则是有意义的:如果<>代码> x>代码>可以在上面的第一个代码中隐式转换,C++编译器就不知道调用哪个函数(即它属于哪个类),所以它必须搜索所有现有类来匹配一个成员函数。这将严重影响C++的类型系统,使重载规则更加复杂和混乱。这些要点包括实现此类运算符的规范方法:
struct GMan
{
int a, b;
/* Side-note: these could be combined:
GMan():a(),b(){}
GMan(int _a):a(_a),b(){}
GMan(int _a, int _b):a(_a),b(_b){}
*/
GMan(int _a = 0, int _b = 0) : a(_a), b(_b){} // into this
// first implement the mutating operator
GMan& operator+=(const GMan& _b)
{
// the use of 'this' to access members
// is generally seen as noise
a += _b.a;
b += _b.b;
return *this;
}
};
// then use it to implement the non-mutating operator, as a free-function
// (always prefer free-functions over member-functions, for various reasons)
GMan operator+(GMan _a, const GMan& _b)
{
_a += b; // code re-use
return _a;
}
等等。你试过问吗?@GMan的粉丝?太神了我的粉丝(如果有的话)在哪里<代码>:P我认为其中一个GMan应该是明确的:)我喜欢这个问题。@GMan lol我对那个名称更改限制的事情一无所知。这是史诗般的失败xD