为什么要定义运算符 +或者 += 在课堂之外，如何正确地做到这一点？

Question

首选哪种方式有点困惑

Type  operator +  (const Type &type);
Type &operator += (const Type &type);

我对两者之间的差异以及

friend Type  operator +  (const Type &type1, const Type &type2);
friend Type &operator += (const Type &type1, const Type &type2);

，它们是什么样的以及何时应该使用？

Answer 1

运算符的第一种形式是您在类 Type 中定义的形式。

运算符的第二种形式是您在与类 Type 相同的命名空间中定义的独立函数。

定义独立函数是一个非常好的主意，因为这些函数的操作数可以参与隐式转换。

示例

假设此类：

class Type {
    public:
    Type(int foo) { }

    // Added the const qualifier as an update: see end of answer
    Type operator + (const Type& type) const { return *this; }
};

您可以这样写：

Type a = Type(1) + Type(2); // OK
Type b = Type(1) + 2; // Also OK: conversion of int(2) to Type

但您不能这样写：

Type c = 1 + Type(2); // DOES NOT COMPILE

将 operator+ 作为自由函数也允许最后一种情况。

运算符的第二种形式的错误在于它通过直接调整其操作数的私有成员来执行加法（我假设是这样，否则它不需要成为朋友）。它不应该这样做：相反，运算符也应该在类内部定义，并且独立函数应该调用它们。

为了看看结果如何，让我们请求一位大师的服务：http://www. gotw.ca/gotw/004.htm。滚动到最后查看如何实现独立功能。

更新：

正如 James McNellis 在他的评论中指出的那样，给出的两种形式还有另一个区别：第一个版本中的左侧不是 const 限定的。由于 operator+ 的操作数实际上不应该作为加法的一部分进行修改，因此始终对它们进行 const 限定是一个非常非常好的主意。我的示例中的 Type 类现在执行此操作，而最初它没有执行此操作。

结论

处理运算符+和+=的最佳方法是：

1. 将operator+=定义为T& T::operator+=(const T&); 在你的类中。这是实施添加的地方。
2. 在类中将 operator+ 定义为 TT::operator+(const T&) const; 。该运算符将根据前一个运算符来实现。
3. 在类外部但在同一命名空间内提供一个自由函数 T operator+(const T&, const T&);。该函数将调用成员operator+来完成工作。

您可以省略第 2 步并直接让自由函数调用 T::operator+=，但根据个人喜好，我希望将所有加法逻辑保留在类中。

Answer 2

相对于 C++03 和 C++0x 实现运算符的正确方法 (NRVO 和 move-semantics)，是：

struct foo
{
    // mutates left-operand => member-function
    foo& operator+=(const foo& other)
    {
        x += other.x;

        return *this;
    }

    int x;
};

// non-mutating => non-member function
foo operator+(foo first, // parameter as value, move-construct (or elide)
                const foo& second) 
{
    first += second; // implement in terms of mutating operator

    return first; // NRVO (or move-construct)
}

注意，很容易将上述内容合并为：

foo operator+(foo first, const foo& second) 
{
    return first += second;
}

但有时（在我的测试中）编译器不会启用 NRVO（或移动语义）因为无法确定（直到它内联变异运算符）first += secondary 与 first 相同。更简单、更安全的方法是将其分开。

Answer 3

当所声明的事物不是类的成员，但需要访问类实例的私有成员才能完成其工作时，将使用 friend 说明符。

如果您的运算符将在类本身中定义，请使用第一种方法；如果它是一个独立的函数，请使用第二个。

Answer 4

在许多情况下，您可以针对类中的类类型 T 编写运算符。主要是作为一个约定。然而，正如乔恩的回答所述，独立的函数可以帮助解决某些情况，而不需要更多的实现。

我还想提一下另一个重要的情况：存在一个类，但它不支持您想要的某个运算符。

这是一个示例：

std::string & operator += (std::string & lhs, char32_t rhs)
{
    lhs += (...rhs converted to UTF-8...);
    return lhs;
}

系统没有定义该运算符，因此，如果您有许多函数在各处执行此类操作，那么能够将其添加到您自己的标头中并允许将 rhs 从 Unicode 字符自动转换为 UTF-8 是非常实用的。

在这种情况下，您别无选择，只能选择独立的函数，因为您不能只扩展您无法控制的现有类。

我的 libutf8 库中的功能示例：
https://github.com/m2osw/libutf8/斑点/c516aa954004cbbaca401e6aba3eb867fd329acd/libutf8/libutf8.h#L89-L132