运算符重载为什么要用友元函数

运算符重载可以使用成员函数和友元函数两种方式来实现。如果使用成员函数来重载运算符，那么该函数只能访问对象的私有成员和保护成员，无法访问其他对象的私有成员和保护成员，这就限制了运算符重载的灵活性。

而使用友元函数来重载运算符，可以访问多个对象的私有成员和保护成员，从而提高了运算符重载的灵活性。另外，使用友元函数还可以使代码更加简洁和易于理解。

例如，当我们重载一个二元运算符时，如果将其实现为成员函数，那么只能访问一个对象的私有成员和保护成员，而使用友元函数则可以同时访问两个对象的私有成员和保护成员，从而使代码更加简洁和易于理解。此外，有些运算符比如输入输出运算符，通常使用友元函数来重载。

因此，运算符重载中使用友元函数可以提高代码的灵活性、简洁性和易读性。

相关问题

将运算符重载为complex类的友元函数的代码

下面是将运算符重载为complex类的友元函数的代码：

class complex {
public:
    complex(double r = 0.0, double i = 0.0) : re(r), im(i) {}
    friend complex operator+(const complex& a, const complex& b);
    friend complex operator-(const complex& a, const complex& b);
    friend complex operator*(const complex& a, const complex& b);
    friend complex operator/(const complex& a, const complex& b);
private:
    double re, im;
};

complex operator+(const complex& a, const complex& b)
{
    return complex(a.re + b.re, a.im + b.im);
}

complex operator-(const complex& a, const complex& b)
{
    return complex(a.re - b.re, a.im - b.im);
}

complex operator*(const complex& a, const complex& b)
{
    return complex(a.re * b.re - a.im * b.im, a.re * b.im + a.im * b.re);
}

complex operator/(const complex& a, const complex& b)
{
    double r = b.re * b.re + b.im * b.im;
    return complex((a.re * b.re + a.im * b.im) / r, (a.im * b.re - a.re * b.im) / r);
}

在这个示例中，我们定义了一个名为`complex`的类，该类表示一个复数。为了实现运算符重载，我们将运算符定义为该类的友元函数。在这个示例中，我们重载了四个基本运算符：加、减、乘和除。每个运算符都接受两个`complex`对象，然后返回一个新的`complex`对象，表示两个对象的运算结果。请注意，我们使用`friend`关键字来声明这些函数是友元函数，以便它们可以访问`complex`类的私有成员。

将运算符重载为complex类的友元函数的完整代码

下面是将运算符重载为complex类的友元函数的完整代码：

#include <iostream>
using namespace std;

class complex {
public:
    complex(double r = 0.0, double i = 0.0) : re(r), im(i) {}
    friend complex operator+(const complex& a, const complex& b);
    friend complex operator-(const complex& a, const complex& b);
    friend complex operator*(const complex& a, const complex& b);
    friend complex operator/(const complex& a, const complex& b);
    friend ostream& operator<<(ostream& os, const complex& c);
private:
    double re, im;
};

complex operator+(const complex& a, const complex& b)
{
    return complex(a.re + b.re, a.im + b.im);
}

complex operator-(const complex& a, const complex& b)
{
    return complex(a.re - b.re, a.im - b.im);
}

complex operator*(const complex& a, const complex& b)
{
    return complex(a.re * b.re - a.im * b.im, a.re * b.im + a.im * b.re);
}

complex operator/(const complex& a, const complex& b)
{
    double r = b.re * b.re + b.im * b.im;
    return complex((a.re * b.re + a.im * b.im) / r, (a.im * b.re - a.re * b.im) / r);
}

ostream& operator<<(ostream& os, const complex& c)
{
    os << "(" << c.re << ", " << c.im << ")";
    return os;
}

int main()
{
    complex a(1.0, 2.0);
    complex b(3.0, 4.0);
    complex c = a + b;
    complex d = a - b;
    complex e = a * b;
    complex f = a / b;
    cout << "a = " << a << endl;
    cout << "b = " << b << endl;
    cout << "a + b = " << c << endl;
    cout << "a - b = " << d << endl;
    cout << "a * b = " << e << endl;
    cout << "a / b = " << f << endl;
    return 0;
}

在这个示例中，我们还定义了一个`operator<<`函数，用于将`complex`对象输出到标准输出流中。在`main`函数中，我们创建了两个`complex`对象`a`和`b`，然后使用重载的运算符来执行加、减、乘和除运算，并将结果输出到控制台。