友元重载和普通重载有什么区别举例子说明一下

友元重载和普通重载的主要区别在于函数的访问权限。

普通重载是指在同一个作用域内，针对不同的参数列表，定义了多个同名函数。这些函数的访问权限都是公共的，即可以被任意调用。

友元重载则是在类定义中，将某个函数声明为友元函数，并针对不同的参数列表，定义了多个同名函数。这些函数的访问权限是私有的，只有类的友元才能够调用。

下面举一个简单的例子：

class MyClass {
public:
    void foo(int x) {
        cout << "public foo: " << x << endl;
    }
private:
    friend void foo(MyClass& obj, double y);
};

void foo(MyClass& obj, double y) {
    cout << "friend foo: " << y << endl;
    obj.foo(int(y));
}

int main() {
    MyClass obj;
    obj.foo(10); // 调用 public foo
    foo(obj, 20.5); // 调用 friend foo
    return 0;
}

在上面的例子中，我们定义了一个类 `MyClass`，其中声明了一个公共函数 `foo` 和一个友元函数 `foo`。在 `main` 函数中，我们先调用了对象的公共函数 `foo`，再调用了类的友元函数 `foo`。注意，普通的函数重载是无法实现上述的访问权限控制的。

相关问题

友元重载

友元重载指的是在类中声明一个友元函数或友元类，并且该函数或类重载了类中的某个运算符。这样，该函数或类就可以直接访问类的私有成员变量和私有成员函数，从而实现更灵活的操作。

举个例子，假设有一个名为 `Complex` 的类表示复数，其中包含私有成员变量 `real` 和 `imag`，分别表示实部和虚部。我们可以声明一个名为 `operator+` 的友元函数，用来重载加号运算符，实现复数的加法操作：

class Complex {
private:
    double real;
    double imag;
public:
    Complex(double r, double i) : real(r), imag(i) {}
    friend Complex operator+(const Complex& c1, const Complex& c2);
};

Complex operator+(const Complex& c1, const Complex& c2) {
    return Complex(c1.real + c2.real, c1.imag + c2.imag);
}

这样，我们就可以直接使用加号运算符进行复数的加法操作，而不需要通过公有成员函数来实现：

Complex c1(1.0, 2.0);
Complex c2(3.0, 4.0);
Complex c3 = c1 + c2; // 相当于调用 operator+(c1, c2)

需要注意的是，友元函数并不属于类的成员函数，因此不能直接访问类的成员变量和成员函数。它们只是被允许访问类的私有成员。

友元重载运算符

友元重载运算符是指在C++中，可以使用友元函数或友元类来重载运算符。友元函数是指可以访问类的私有成员的非成员函数，而友元类是指可以访问类的私有成员的另一个类。在重载运算符时，我们可以定义一个友元函数或友元类，使其可以访问类的私有成员，并对运算符进行重载。

例如，我们可以定义一个名为“Point”的类，用来表示二维平面上的一个点。我们可以重载加号运算符来实现两个点的坐标相加。代码如下：

#include <iostream>
using namespace std;

class Point {
    private:
        int x, y;
    public:
        Point(int x = 0, int y = 0) {
            this->x = x;
            this->y = y;
        }
        friend Point operator+(const Point& p1, const Point& p2);
        void print() {
            cout << "(" << x << "," << y << ")" << endl;
        }
};

Point operator+(const Point& p1, const Point& p2) {
    return Point(p1.x + p2.x, p1.y + p2.y);
}

int main() {
    Point p1(1, 2), p2(3, 4);
    Point p3 = p1 + p2;
    p3.print();
    return 0;
}

在这个例子中，我们定义了一个类Point，其中包含了x和y两个私有成员变量。我们定义了一个友元函数operator+来重载加号运算符，使其可以实现两个点的坐标相加。在主函数中，我们定义了两个Point类型的对象p1和p2，并将它们相加得到了一个新的Point对象p3，最后输出p3的坐标。