成员函数重载运算符和友元函数重载运算符区别

成员函数重载运算符和友元函数重载运算符的主要区别在于它们可以访问的数据成员不同。

成员函数重载运算符是类的成员函数，它们可以直接访问类的私有成员和保护成员。因此，当我们需要重载某些需要访问类的私有成员和保护成员的运算符时，我们通常会使用成员函数重载运算符。

而友元函数重载运算符不是类的成员函数，它们不能直接访问类的私有成员和保护成员。它们可以被声明为类的友元函数，从而获得访问类的私有成员和保护成员的权限。因此，当我们需要重载某些不能直接访问类的私有成员和保护成员的运算符时，我们通常会使用友元函数重载运算符。

综上所述，成员函数重载运算符和友元函数重载运算符在访问类的成员方面有所不同，开发者需要根据具体的需求选择适合的方式。

相关问题

计一个类，用菜单选择用成员函数重载运算符或友元函数重载运算符，使对整型的运算符=、+、-、*、/ 适用于分数运算。要求： (1) 输出结果是最简分数(可以是带分数)； (2) 分母为1，只输出分子。

以下是一个实现上述要求的分数类的示例代码：

#include <iostream>
using namespace std;

class Fraction {
private:
    int numerator;   // 分子
    int denominator; // 分母

public:
    Fraction() {
        numerator = 0;
        denominator = 1;
    }

    Fraction(int num, int den) {
        numerator = num;
        denominator = den;
        simplify();
    }

    void simplify() {
        int gcd = getGCD(numerator, denominator);
        numerator /= gcd;
        denominator /= gcd;
        if (denominator < 0) {
            numerator = -numerator;
            denominator = -denominator;
        }
    }

    int getGCD(int x, int y) {
        if (y == 0) {
            return x;
        }
        return getGCD(y, x % y);
    }

    friend Fraction operator+(const Fraction& f1, const Fraction& f2) {
        int num = f1.numerator * f2.denominator + f2.numerator * f1.denominator;
        int den = f1.denominator * f2.denominator;
        return Fraction(num, den);
    }

    friend Fraction operator-(const Fraction& f1, const Fraction& f2) {
        int num = f1.numerator * f2.denominator - f2.numerator * f1.denominator;
        int den = f1.denominator * f2.denominator;
        return Fraction(num, den);
    }

    friend Fraction operator*(const Fraction& f1, const Fraction& f2) {
        int num = f1.numerator * f2.numerator;
        int den = f1.denominator * f2.denominator;
        return Fraction(num, den);
    }

    friend Fraction operator/(const Fraction& f1, const Fraction& f2) {
        int num = f1.numerator * f2.denominator;
        int den = f1.denominator * f2.numerator;
        return Fraction(num, den);
    }

    Fraction& operator=(const Fraction& other) {
        numerator = other.numerator;
        denominator = other.denominator;
        return *this;
    }

    friend ostream& operator<<(ostream& os, const Fraction& f) {
        if (f.denominator == 1) {
            os << f.numerator;
        } else if (abs(f.numerator) >= f.denominator) {
            int integer = f.numerator / f.denominator;
            int num = abs(f.numerator) % f.denominator;
            if (f.numerator < 0) {
                os << "-";
            }
            os << integer << " " << num << "/" << f.denominator;
        } else {
            os << f.numerator << "/" << f.denominator;
        }
        return os;
    }
};

int main() {
    Fraction f1(1, 3);
    Fraction f2(2, 5);
    Fraction f3 = f1 + f2;
    cout << f3 << endl; // output: 11/15
    f3 = f1 - f2;
    cout << f3 << endl; // output: 1/15
    f3 = f1 * f2;
    cout << f3 << endl; // output: 2/15
    f3 = f1 / f2;
    cout << f3 << endl; // output: 5/6
    return 0;
}

该示例代码中，Fraction 类重载了运算符+、-、*、/ 和=，并且还定义了一个友元函数重载运算符<<，用于输出 Fraction 类型的对象。在运算符重载函数中，需要注意将分数化简为最简分数，且要处理分母为1的情况和负数的情况。

成员函数和友元函数重载运算符时传参区别

在重载运算符时，成员函数和友元函数在传参方面也有所不同。

成员函数重载运算符的第一个参数是隐含的this指针，它指向调用该成员函数的对象。因此，在成员函数重载运算符中，我们只需要传递一个参数即可。

友元函数重载运算符没有隐含的this指针，因此，它需要显式地传递所有的参数。在友元函数中，我们通常需要传递两个参数，第一个参数是一个对象，第二个参数是另一个对象或者其他需要的参数。

例如，我们可以使用如下代码重载加法运算符：

class Complex {
public:
    Complex(double r = 0.0, double i = 0.0) : real(r), imag(i) {}
    Complex operator+(const Complex& other) const;
private:
    double real, imag;
};

Complex Complex::operator+(const Complex& other) const {
    return Complex(real + other.real, imag + other.imag);
}

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

在上面的例子中，我们可以看到，成员函数重载了加法运算符，而友元函数也重载了加法运算符。在成员函数中，我们只需要传递一个参数(other)，而在友元函数中，我们需要传递两个参数(c1和c2)。

综上所述，在重载运算符时，成员函数和友元函数在传参方面也有所不同，开发者需要根据具体的情况选择适合的方式。