Question

我们说我已经定义了一个内部+运算符和外部+运算符的类;

class MyClass {
    public:
        MyClass operator +();
};

MyClass operator +(const MyClass& a);

如果在我的主程序中我打电话

MyClass a;
MyClass b = +a;

被称为什么，这（内部）：

a.operator +()

或者这个（外部）？：

operator +(a)

二元运算符的相同问题。

Answer 1

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

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

Answer 2

通过修复代码中的一些歧义并进行一些打印，以下代码将给出答案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;
}

Answer 3

使用内部运算符是因为一旦运算符已经存在，就不能使用相同的参数重载运算符：您不能为执行某些事情的字符串定义一个+运算符，因为已经有一个连接它们的字符串。那是同样的情况。你在类中定义了一个+运算符，所以相同的一个（作为函数原型）变得无用。

Answer 4

我自己做了一点测试：

#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％的答案。

何时使用内部操作员以及何时使用外部操作员

4 个答案: