2.分别用成员函数和友元函数重载运算符，使对整型的运算符＝、+、、*、/适用于分数运 要求: (1）输出结果是最简分数（可以是带分数）； 2）分母为1，只输出分子。

好的，我可以为您解答这个问题。

首先，我们需要定义一个名为 `Fraction` 的类来表示分数，其中包含分子和分母两个私有成员变量。然后，我们可以使用成员函数和友元函数分别重载运算符。

以下是使用成员函数重载运算符的示例代码：

class Fraction {
private:
    int numerator;
    int denominator;

public:
    Fraction(int num, int denom) : numerator(num), denominator(denom) {}

    Fraction& operator=(const int& num) {
        numerator = num;
        denominator = 1;
        return *this;
    }

    Fraction operator+(const Fraction& other) const {
        int num = numerator * other.denominator + other.numerator * denominator;
        int denom = denominator * other.denominator;
        return simplify(num, denom);
    }

    Fraction operator-(const Fraction& other) const {
        int num = numerator * other.denominator - other.numerator * denominator;
        int denom = denominator * other.denominator;
        return simplify(num, denom);
    }

    Fraction operator*(const Fraction& other) const {
        int num = numerator * other.numerator;
        int denom = denominator * other.denominator;
        return simplify(num, denom);
    }

    Fraction operator/(const Fraction& other) const {
        int num = numerator * other.denominator;
        int denom = denominator * other.numerator;
        return simplify(num, denom);
    }

    friend std::ostream& operator<<(std::ostream& os, const Fraction& f);

private:
    static int gcd(int a, int b) {
        return b == 0 ? a : gcd(b, a % b);
    }

    static Fraction simplify(int num, int denom) {
        int gcd_num_denom = gcd(num, denom);
        num /= gcd_num_denom;
        denom /= gcd_num_denom;
        if (denom < 0) {
            num = -num;
            denom = -denom;
        }
        if (denom == 1) {
            return Fraction(num, 1);
        } else {
            int whole_part = num / denom;
            num -= whole_part * denom;
            return Fraction(num, denom, whole_part);
        }
    }
};

std::ostream& operator<<(std::ostream& os, const Fraction& f) {
    if (f.whole_part == 0) {
        os << f.numerator << "/" << f.denominator;
    } else if (f.numerator == 0) {
        os << f.whole_part;
    } else {
        os << f.whole_part << " " << std::abs(f.numerator) << "/" << f.denominator;
    }
    return os;
}

在上面的代码中，我们定义了 `Fraction` 类，并重载了运算符 `=`、`+`、`-`、`*` 和 `/`。其中，`=` 运算符被重载为成员函数，其他运算符被重载为常规成员函数。

我们还定义了两个辅助函数，`gcd` 函数用于计算最大公因数，`simplify` 函数用于将分数简化为最简分数或带分数形式。

最后，我们还通过友元函数 `operator<<` 重载了插入运算符，以便将分数以最简或带分数形式输出。

现在，我们可以使用该类进行分数运算：

Fraction a(2, 3);
Fraction b(3, 4);

Fraction c = a + b;
std::cout << c << std::endl; // 输出: 5/6

Fraction d = a - b;
std::cout << d << std::endl; // 输出: -1/12

Fraction e = a * b;
std::cout << e << std::endl; // 输出: 1/2

Fraction f = a / b;
std::cout << f << std::endl; // 输出: 8/9

希望这个例子能够帮助您理解如何使用成员函数和友元函数重载运算符。