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

好的，我们来设计一个分数类，并重载对整型的运算符。

#include<iostream>
#include<cmath>
using namespace std;

class Fraction{
private:
    int numerator;   // 分子
    int denominator; // 分母
public:
    Fraction(int n = 0, int d = 1):numerator(n), denominator(d){
        if(denominator == 0){
            cout << "分母不能为0！" << endl;
            exit(1);
        }
        simplify();
    }

    void simplify(){    // 约分函数
        if(numerator == 0){
            denominator = 1;
            return;
        }
        int gcdValue = gcd(numerator, denominator);
        numerator /= gcdValue;
        denominator /= gcdValue;
        if(denominator < 0){    // 如果分母为负数，要将负号移到分子上
            numerator = -numerator;
            denominator = -denominator;
        }
    }

    int gcd(int a, int b){  // 求最大公约数
        if(b == 0) return a;
        return gcd(b, a % b);
    }

    Fraction operator=(int num){    // 重载整型赋值运算符
        numerator = num;
        denominator = 1;
        return *this;
    }

    friend Fraction operator+(const Fraction& f1, const Fraction& f2);   // 分数加法运算
    friend Fraction operator-(const Fraction& f1, const Fraction& f2);   // 分数减法运算
    friend Fraction operator*(const Fraction& f1, const Fraction& f2);   // 分数乘法运算
    friend Fraction operator/(const Fraction& f1, const Fraction& f2);   // 分数除法运算

    friend ostream& operator<<(ostream& os, const Fraction& f); // 重载输出运算符
};

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

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

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

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

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

其中，我们将整型赋值运算符重载为`Fraction operator=(int num)`，并且将其他运算符都定义为友元函数。

在友元函数中，我们使用辗转相除法求最大公约数，然后进行分数的加、减、乘、除运算。

在输出运算符中，我们需要判断输出的形式，如果分数可以化为整数，则只输出分子；如果分数不能化为整数但分子小于分母，则按照常规输出；如果分数大于等于1，则输出带分数形式。

下面是一个测试代码：

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

    cout << "f1 = " << f1 << endl;
    cout << "f2 = " << f2 << endl;

    Fraction f3 = f1 + f2;
    cout << "f1 + f2 = " << f3 << endl;

    Fraction f4 = f1 - f2;
    cout << "f1 - f2 = " << f4 << endl;

    Fraction f5 = f1 * f2;
    cout << "f1 * f2 = " << f5 << endl;

    Fraction f6 = f1 / f2;
    cout << "f1 / f2 = " << f6 << endl;

    return 0;
}

输出结果为：

f1 = 2
f2 = 3/4
f1 + f2 = 11/4
f1 - f2 = 5/4
f1 * f2 = 3/2
f1 / f2 = 8/3