运算符重载C++； 以前我学习过C++中的操作符重载作为成员函数以及类的朋友函数。虽然，我知道如何在C++中使用两种技术来重载运算符。但我仍然很困惑**哪一个更好**？重载运算符的成员函数或朋友函数，我应该使用哪一个，为什么？ 请引导我！非常感谢您的回复。我将非常高兴并感谢您的回答。

这方面可能没有固定的规则，因此我仅给出我的意见：在可能的情况下，使用成员函数进行运算符重载。这样做的主要原因是，我将运算符视为类的组成部分，并且类的逻辑更加本地化

选择自由函数进行运算符重载的原因是为了尽可能精简类（仅在需要时使用friend）

---

在某些情况下，操作员不能成为成员，因此在这种情况下没有讨论。主要成员函数将类实例作为第一个参数，这并不总是可能的（例如operator成员函数和friend不是两个对立的函数，您只需要选择一个。它们都可以使用，例如，通过实现一个并让另一个调用来避免代码重复

struct A
{
    A operator+=(A const & second); 
};

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

但是，如果您想选择一个函数作为是否需要成为成员的函数，那么我遵循一条规则：实现一个非成员函数（

friend

或not）当我有一个二元运算符来尊重我们期望的对称性时。例如：使用

a

，并且可以隐式地将

int

转换为

a

（构造函数取

int

），如果我有一个成员函数，结果会是什么

A a1, a2; 
a1 + a2; // OK 
a1 + 42; // OK
42 + a2; // KO

A a1, a2; 
a1 + a2; // Ok 
a1 + 42; // Ok 
42 + a2; // Ok

有了自由函数，就有了结果

A a1, a2; 
a1 + a2; // OK 
a1 + 42; // OK
42 + a2; // KO

A a1, a2; 
a1 + a2; // Ok 
a1 + 42; // Ok 
42 + a2; // Ok

使用这种可能性的一个具体C++类是 > /P>

#include <iostream>
#include <string>

int main()
{
    std::string s {"World"};
    // Works with absolutely no problem.
    std::string chaine = "Hello " + s;
    std::cout << chaine << std::endl;
}

#包括
#包括
int main（）
{
std：：字符串s{“World”}；
//工作绝对没有问题。
std:：string chaine=“Hello”+s；
std：：cout选择不是“成员或朋友”，而是“成员或非成员”。

（友谊经常被过度使用，而且在学校里通常教得太早。）

这是因为您始终可以添加自由函数可以调用的公共成员函数

例如：

class A
{
public:
    explicit A(int y) : x(y) {}
    A plus(const A& y) const { return A{x + y.x}; }
private:
    int x;
};

A operator+(const A& lhs, const A& rhs) { return lhs.plus(rhs); }

至于如何选择：如果操作符不将类的实例作为其左操作数，那么它必须是自由函数，否则这几乎是个人喜好的问题（如果不是你一个人的话，也可以考虑编码标准）

例如：

// Can't be a member because the int is on the left.
A operator+ (int x, const A& a) { return A{x} + a; }

对于具有相应的变异运算符（如
+
和
+=
）的运算符，通常将变异运算符作为成员执行，而将另一个作为非成员执行：

class B
{
public:
    explicit B(int y) : x(y) {}
    B& operator+= (const B& y) { x += y.x; return *this; }
private:
    int x;
};

B operator+(B lhs, const B& rhs) { return lhs += rhs; }

当然，你也可以说清楚：

class C
{
public:
    explicit C(int y) : x(y) {}
    C& add(const C& y) { x += y.x; return *this; }
private:
    int x;
};

C& operator+=(C& lhs, const C& rhs) { return lhs.add(rhs); }
C operator+(C lhs, const C& rhs) { return lhs += rhs; }

这离品味不远，但一些用例显然需要两种方法中的一种

当运算符仅将您正在设计的类的成员作为参数时，封装投票支持使用成员函数。示例：添加两个对象：

class A {
    ...
    A operator + (const class A& other);   // naturally a member function
    ...
};

相反，当您正在编写的类的成员是运算符的第二个参数时，您只能使用friend函数

std::outstream& operator << (std::outstream& out, const class A& a);

class A {
    ...
    friend std::outstream& operator << (std::outstream& out, const class A& a); // must be friend here
};

std:：outstream&operator全局非友元函数呢？不管怎样，总是喜欢全局而不是成员。全局非友元函数？我以为重载的运算符只能是友元函数或成员函数。但是谢谢！我也会搜索它。
friend
只需要给函数访问类的的权限de>私人
和受保护的

成员。否则，如果不需要，则也不需要

朋友

。是的，先生@DeiDei我非常了解朋友功能。只想问哪一个更好！：-）谢谢您的回复先生：-）