何时使用内部运算符，何时使用外部运算符

When is the internal operator being used and when the external

本文关键字：运算符 何时使 外部 内部      更新时间：2023-10-16

假设我定义了一个具有内部+运算符和外部+运算符的类；

class MyClass {
    public:
        MyClass operator +();
};
MyClass operator +(const MyClass& a);

如果在我的主程序中我调用

MyClass a;
MyClass b = +a;

什么是所谓的，这个（内部）：

a.operator +()

还是这个（外部）？：

operator +(a)

二元运算符也有同样的问题。

选择成员函数：它可以直接绑定到表达式a，而非成员函数在绑定到引用参数之前需要将MyClass转换为const MyClass。因此，调用成员需要一个更好的转换序列，使其成为最佳重载。

如果您从非成员中删除了const，或者向成员中添加了const，那么两者都同样可行；您应该得到一个错误，说明重载是不明确的。

通过修复代码中的一些歧义，并进行一些打印，以下代码将给出答案Internal operator。

class MyClass {
public:
    MyClass operator+() {
        std::cout << "Internal operator." << std::endl;
        return *this;
    };
};
MyClass operator+(const MyClass& a) {
    std::cout << "External operator" << std::endl;
    return a;
}
int main() {
    MyClass a, b;
    b = +a;
    return 0;
}

使用内部运算符是因为一旦运算符已经存在，就不能用相同的参数重载它：不能为执行疯狂操作的字符串定义+运算符，因为已经有一个运算符将它们连接起来。情况也是如此。您在类中定义了一个+运算符，因此相同的运算符（作为函数原型）将变得毫无用处。

我自己做了一个小测试：

#include <iostream>
#include "MyClass.h"
using namespace std;
MyClass operator +(const MyClass& a, const MyClass& b)
{ cout << "external" << endl; return a; }
int main() {
    MyClass foo, bar;
    foo + bar;
    return 0;
}
class MyClass {
public:
    MyClass operator+(const MyClass& a) { cout << "internal" << endl; return a; }
};

该程序的输出是"内部"的。我的结论是，如果有一个内部运算符适合该操作，那么它将是所采用的运算符。如果内部更适合，我看不出有什么方法可以让外部的更适合。但我必须指出的是，我只做了一点测试，还没有从哪里了解到这是100%的答案。

相关文章：