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

好的，我可以帮你设计这样一个类。

首先，这个类应该包含两个整型成员变量，分别表示分子和分母。可以定义一个构造函数，用来初始化这两个成员变量。

其次，需要重载运算符=、+、-、*、/，并且输出结果是最简分数或带分数。在重载运算符的过程中，需要注意分母为0的情况，还有对于最简分数的约分等问题。

最后，定义一个友元函数，用来重载整型运算符，使之适用于分数运算。在友元函数的实现中，需要将整型转换为分数类型，然后再进行分数运算。

下面是一个简单的代码示例：

#include <iostream>
using namespace std;

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

public:
    // 构造函数
    Fraction(int n = 0, int d = 1) : numerator(n), denominator(d) {}

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

    // 重载运算符+
    friend Fraction operator+(const Fraction& f1, const Fraction& f2) {
        int n = f1.numerator * f2.denominator + f2.numerator * f1.denominator;
        int d = f1.denominator * f2.denominator;
        return Fraction(n, d).simplify();
    }

    // 重载运算符-
    friend Fraction operator-(const Fraction& f1, const Fraction& f2) {
        int n = f1.numerator * f2.denominator - f2.numerator * f1.denominator;
        int d = f1.denominator * f2.denominator;
        return Fraction(n, d).simplify();
    }

    // 重载运算符*
    friend Fraction operator*(const Fraction& f1, const Fraction& f2) {
        int n = f1.numerator * f2.numerator;
        int d = f1.denominator * f2.denominator;
        return Fraction(n, d).simplify();
    }

    // 重载运算符/
    friend Fraction operator/(const Fraction& f1, const Fraction& f2) {
        int n = f1.numerator * f2.denominator;
        int d = f1.denominator * f2.numerator;
        return Fraction(n, d).simplify();
    }

    // 输出分数
    void print() const {
        if (denominator == 1) {
            cout << numerator << endl;
        } else if (numerator % denominator == 0) {
            cout << numerator / denominator << endl;
        } else {
            int gcd = get_gcd(numerator, denominator);
            int n = numerator / gcd;
            int d = denominator / gcd;
            if (abs(n) >= d) {
                int i = n / d;
                n = abs(n) % d;
                cout << i << " " << n << "/" << d << endl;
            } else {
                cout << n << "/" << d << endl;
            }
        }
    }

private:
    // 约分
    Fraction simplify() {
        if (denominator < 0) {
            numerator = -numerator;
            denominator = -denominator;
        }
        int gcd = get_gcd(numerator, denominator);
        numerator /= gcd;
        denominator /= gcd;
        return *this;
    }

    // 求最大公约数
    int get_gcd(int a, int b) {
        return b == 0 ? abs(a) : get_gcd(b, a % b);
    }
};

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

Fraction operator-(int n, const Fraction& f) {
    return Fraction(n) - f;
}

Fraction operator*(int n, const Fraction& f) {
    return Fraction(n) * f;
}

Fraction operator/(int n, const Fraction& f) {
    return Fraction(n) / f;
}

// 测试
int main() {
    Fraction f1(1, 2);
    Fraction f2(2, 3);
    Fraction f3 = f1 + f2;
    Fraction f4 = f1 - f2;
    Fraction f5 = f1 * f2;
    Fraction f6 = f1 / f2;
    f3.print(); // 7/6
    f4.print(); // -1/6
    f5.print(); // 1/3
    f6.print(); // 3/4
    Fraction f7 = 3 + f1;
    Fraction f8 = 4 - f2;
    Fraction f9 = 5 * f1;
    Fraction f10 = 6 / f2;
    f7.print(); // 7/2
    f8.print(); // 10/3
    f9.print(); // 15/2
    f10.print(); // 9/4
    return 0;
}