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

好的，以下是代码实现：

#include <iostream>
using namespace std;

class Fraction {
private:
    int numerator; // 分子
    int denominator; // 分母
public:
    // 构造函数
    Fraction(int num = 0, int den = 1) : numerator(num), denominator(den) {}

    // 输出最简分数
    void print() {
        int gcd = getGCD(numerator, denominator);
        numerator /= gcd;
        denominator /= gcd;

        int integer = numerator / denominator;
        int remainder = numerator % denominator;

        if (denominator == 1) {
            cout << numerator << endl;
        } else if (integer == 0) {
            cout << numerator << "/" << denominator << endl;
        } else if (remainder == 0) {
            cout << integer << endl;
        } else {
            cout << integer << " " << remainder << "/" << denominator << endl;
        }
    }

    // 获取最大公约数
    int getGCD(int a, int b) {
        if (b == 0) {
            return a;
        } else {
            return getGCD(b, a % b);
        }
    }

    // 重载运算符=
    Fraction& operator=(const int& n) {
        numerator = n;
        denominator = 1;
        return *this;
    }

    // 重载运算符+
    Fraction operator+(const Fraction& f) {
        Fraction res;
        res.numerator = numerator * f.denominator + f.numerator * denominator;
        res.denominator = denominator * f.denominator;
        return res;
    }

    // 重载运算符-
    Fraction operator-(const Fraction& f) {
        Fraction res;
        res.numerator = numerator * f.denominator - f.numerator * denominator;
        res.denominator = denominator * f.denominator;
        return res;
    }

    // 重载运算符*
    Fraction operator*(const Fraction& f) {
        Fraction res;
        res.numerator = numerator * f.numerator;
        res.denominator = denominator * f.denominator;
        return res;
    }

    // 重载运算符/
    Fraction operator/(const Fraction& f) {
        Fraction res;
        res.numerator = numerator * f.denominator;
        res.denominator = denominator * f.numerator;
        return res;
    }

    // 友元函数重载运算符=
    friend Fraction& operator=(int& n, Fraction& f) {
        f = n;
        return f;
    }

    // 友元函数重载运算符+
    friend Fraction operator+(const int& n, const Fraction& f) {
        Fraction res(n, 1);
        return res + f;
    }

    // 友元函数重载运算符-
    friend Fraction operator-(const int& n, const Fraction& f) {
        Fraction res(n, 1);
        return res - f;
    }

    // 友元函数重载运算符*
    friend Fraction operator*(const int& n, const Fraction& f) {
        Fraction res(n, 1);
        return res * f;
    }

    // 友元函数重载运算符/
    friend Fraction operator/(const int& n, const Fraction& f) {
        Fraction res(n, 1);
        return res / f;
    }
};

int main() {
    Fraction f1(2, 3), f2(1, 4), f3;

    f3 = f1 + f2;
    f3.print(); // 输出：11/12

    f3 = f1 - f2;
    f3.print(); // 输出：5/12

    f3 = f1 * f2;
    f3.print(); // 输出：1/6

    f3 = f1 / f2;
    f3.print(); // 输出：8/3

    int n = 3;

    f3 = n + f1;
    f3.print(); // 输出：11/3

    f3 = n - f1;
    f3.print(); // 输出：7/3

    f3 = n * f1;
    f3.print(); // 输出：2

    f3 = n / f1;
    f3.print(); // 输出：9/2

    return 0;
}

实现思路：

1. 定义`Fraction`类，其中包含私有成员变量`numerator`和`denominator`，用于存储分数的分子和分母；
2. 定义`print`函数，用于输出最简分数；
3. 定义`getGCD`函数，用于获取最大公约数；
4. 重载运算符`=`, `+`, `-`, `*`, `/`，分别实现分数的赋值、加法、减法、乘法和除法；
5. 定义友元函数，重载运算符`=`, `+`, `-`, `*`, `/`，分别实现整数与分数的赋值、加法、减法、乘法和除法；
6. 在`main`函数中，定义三个`Fraction`对象`f1`、`f2`和`f3`，分别进行分数运算；
7. 定义一个整型变量`n`，与`Fraction`对象进行运算。

以上代码是一个简单的分数类实现，仅供参考。