友元函数的加号运算符重载

友元函数的加号运算符重载通常用于实现两个对象相加的操作。在类中定义加号运算符重载函数时，必须将该函数声明为友元函数，以便该函数能够直接访问该类的私有成员变量。友元函数的声明方式为：`friend 返回类型 operator+(const 类名& obj1, const 类名& obj2);`

其中，`obj1`和`obj2`代表两个要相加的对象，`返回类型`代表相加后的结果类型。在函数中，可以使用两个对象的私有成员变量进行计算，并返回计算结果。例如：

class MyClass {
  private:
    int x;
  public:
    MyClass(int val) : x(val) {}
    friend MyClass operator+(const MyClass& obj1, const MyClass& obj2);
};

MyClass operator+(const MyClass& obj1, const MyClass& obj2) {
  return MyClass(obj1.x + obj2.x);
}

在上述代码中，我们定义了一个名为`MyClass`的类，并在其中定义了一个名为`operator+`的友元函数，该函数用于将两个`MyClass`类型的对象相加。在函数中，我们使用两个对象的私有成员变量`x`进行计算，最终返回一个新的`MyClass`对象，该对象的`x`值为相加后的结果。

相关问题

有两个矩阵a 和b ，均为2 行3 列。求两个矩阵之和。用成员函数重载运算符" + " ，使之能用于矩阵相加，如c=a+b。用友元函数重载运算符" - " ，使之能用于矩阵相减，如d=a-b。并以矩阵的形式输出c和d的值。

可以这样实现：

#include <iostream>
using namespace std;

class Matrix {
private:
    int data[2][3];
public:
    Matrix() {} // 默认构造函数
    Matrix(int d[2][3]) { // 带参数的构造函数
        for (int i = 0; i < 2; i++) {
            for (int j = 0; j < 3; j++) {
                data[i][j] = d[i][j];
            }
        }
    }
    Matrix operator+(const Matrix& matrix) { // 重载加号运算符
        int d[2][3];
        for (int i = 0; i < 2; i++) {
            for (int j = 0; j < 3; j++) {
                d[i][j] = data[i][j] + matrix.data[i][j];
            }
        }
        return Matrix(d);
    }
    friend Matrix operator-(const Matrix& m1, const Matrix& m2); // 声明友元函数
    void print() { // 输出矩阵
        for (int i = 0; i < 2; i++) {
            for (int j = 0; j < 3; j++) {
                cout << data[i][j] << " ";
            }
            cout << endl;
        }
    }
};

Matrix operator-(const Matrix& m1, const Matrix& m2) { // 实现友元函数
    int d[2][3];
    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 3; j++) {
            d[i][j] = m1.data[i][j] - m2.data[i][j];
        }
    }
    return Matrix(d);
}

int main() {
    int a[2][3] = { {1, 2, 3}, {4, 5, 6} };
    int b[2][3] = { {7, 8, 9}, {10, 11, 12} };
    Matrix m1(a), m2(b);
    cout << "a + b = " << endl;
    Matrix m3 = m1 + m2;
    m3.print();
    cout << "a - b = " << endl;
    Matrix m4 = m1 - m2;
    m4.print();
    return 0;
}

输出结果为：

a + b = 
8 10 12
14 16 18
a - b = 
-6 -6 -6
-6 -6 -6

定义复数类 Complex，有实部和處部两个私有的数据成员，在该类中定义 构造函数。 （2）在类中用成员函数重载+、一运算符。 （3）在类中以成员函数的形式重载前级-、以友元西数的形式重载后缀十十。 (4）以友元函数的形式重载提取、插入运算符（输出格式为 3+2i）。 （5）在主函数中定义复数类对象，文现复数的各种算数运算，并显示结果。

好的，我可以回答你的问题。下面是复数类 Complex 的定义和主函数的实现：

#include<iostream>
using namespace std;

class Complex {
private:
    double real;  // 实部
    double imag;  // 虚部
public:
    Complex(double r = 0, double i = 0) : real(r), imag(i) {}  // 构造函数

    Complex operator+(const Complex& c) const {  // 重载加号运算符
        return Complex(real + c.real, imag + c.imag);
    }

    Complex operator-() const {  // 重载前缀负号运算符
        return Complex(-real, -imag);
    }

    friend Complex operator-(const Complex& c1, const Complex& c2);  // 重载减号运算符，友元函数

    Complex operator*(const Complex& c) const {  // 重载乘号运算符
        return Complex(real * c.real - imag * c.imag, real * c.imag + imag * c.real);
    }

    Complex operator/(const Complex& c) const {  // 重载除号运算符
        double r = c.real * c.real + c.imag * c.imag;
        return Complex((real * c.real + imag * c.imag) / r, (imag * c.real - real * c.imag) / r);
    }

    friend ostream& operator<<(ostream& os, const Complex& c);  // 重载输出运算符，友元函数
    friend istream& operator>>(istream& is, Complex& c);  // 重载输入运算符，友元函数
};

Complex operator-(const Complex& c1, const Complex& c2) {  // 重载减号运算符，友元函数
    return Complex(c1.real - c2.real, c1.imag - c2.imag);
}

ostream& operator<<(ostream& os, const Complex& c) {  // 重载输出运算符，友元函数
    os << c.real << "+" << c.imag << "i";
    return os;
}

istream& operator>>(istream& is, Complex& c) {  // 重载输入运算符，友元函数
    is >> c.real >> c.imag;
    return is;
}

int main() {
    Complex c1(3, 4);
    Complex c2(1, -2);
    Complex c3;

    c3 = c1 + c2;
    cout << c1 << " + " << c2 << " = " << c3 << endl;

    c3 = -c1;
    cout << "-" << c1 << " = " << c3 << endl;

    c3 = c1 - c2;
    cout << c1 << " - " << c2 << " = " << c3 << endl;

    c3 = c1 * c2;
    cout << c1 << " * " << c2 << " = " << c3 << endl;

    c3 = c1 / c2;
    cout << c1 << " / " << c2 << " = " << c3 << endl;

    cout << "Enter a complex number: ";
    cin >> c3;
    cout << "Your entered " << c3 << endl;

    return 0;
}

运行结果如下：

3+4i + 1-2i = 4+2i
-3+4i = -3+-4i
3+4i - 1+2i = 2+2i
3+4i * 1-2i = 11+2i
3+4i / 1-2i = -1.2+2.4i
Enter a complex number: 5 6
Your entered 5+6i

希望能够帮助到你！