C++ 设计一个分数类fration，其中包含以下功能：能防止分母为0的构造函数； 对非最简分数进行约分的成员函数；加、减、乘、除运算符重载函数（用友元函数实现）； 关系运算符、赋值运算符、流

下面是一个 C++ 分数类 `Fraction` 的实现，它包含了以下功能：

1. 防止分母为 0 的构造函数；
2. 对非最简分数进行约分的成员函数；
3. 加、减、乘、除运算符重载函数（用友元函数实现）；
4. 关系运算符、赋值运算符、流运算符的重载。

#include <iostream>
using namespace std;

class Fraction {
public:
    Fraction(int n = 0, int d = 1) {
        if (d == 0) {
            cout << "分母不能为 0！" << endl;
            exit(1);
        }
        if (n == 0) {
            numerator = 0;
            denominator = 1;
        } else {
            int g = gcd(abs(n), abs(d));
            numerator = n / g;
            denominator = d / g;
            if (denominator < 0) {
                numerator = -numerator;
                denominator = -denominator;
            }
        }
    }
    Fraction reduce() const {
        int g = gcd(abs(numerator), abs(denominator));
        return Fraction(numerator / g, denominator / g);
    }
    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 bool operator==(const Fraction& f1, const Fraction& f2);
    friend bool operator!=(const Fraction& f1, const Fraction& f2);
    friend bool operator<(const Fraction& f1, const Fraction& f2);
    friend bool operator<=(const Fraction& f1, const Fraction& f2);
    friend bool operator>(const Fraction& f1, const Fraction& f2);
    friend bool operator>=(const Fraction& f1, const Fraction& f2);
    Fraction& operator+=(const Fraction& f);
    Fraction& operator-=(const Fraction& f);
    Fraction& operator*=(const Fraction& f);
    Fraction& operator/=(const Fraction& f);
    friend istream& operator>>(istream& in, Fraction& f);
    friend ostream& operator<<(ostream& out, const Fraction& f);
private:
    int numerator;   // 分子
    int denominator; // 分母
    int gcd(int a, int b) const {
        return b == 0 ? a : gcd(b, a % b);
    }
};

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

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

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

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

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

bool operator!=(const Fraction& f1, const Fraction& f2) {
    return !(f1 == f2);
}

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

bool operator<=(const Fraction& f1, const Fraction& f2) {
    return f1 < f2 || f1 == f2;
}

bool operator>(const Fraction& f1, const Fraction& f2) {
    return f2 < f1;
}

bool operator>=(const Fraction& f1, const Fraction& f2) {
    return f2 <= f1;
}

Fraction& Fraction::operator+=(const Fraction& f) {
    *this = *this + f;
    return *this;
}

Fraction& Fraction::operator-=(const Fraction& f) {
    *this = *this - f;
    return *this;
}

Fraction& Fraction::operator*=(const Fraction& f) {
    *this = *this * f;
    return *this;
}

Fraction& Fraction::operator/=(const Fraction& f) {
    *this = *this / f;
    return *this;
}

istream& operator>>(istream& in, Fraction& f) {
    char c;
    in >> f.numerator >> c >> f.denominator;
    if (f.denominator == 0) {
        cout << "分母不能为 0！" << endl;
        exit(1);
    }
    if (f.numerator == 0) {
        f.denominator = 1;
    } else {
        int g = f.gcd(abs(f.numerator), abs(f.denominator));
        f.numerator /= g;
        f.denominator /= g;
        if (f.denominator < 0) {
            f.numerator = -f.numerator;
            f.denominator = -f.denominator;
        }
    }
    return in;
}

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

int main() {
    Fraction f1, f2;
    cout << "请输入两个分数（形如 a/b）：" << endl;
    cin >> f1 >> f2;

    cout << "f1 = " << f1 << endl;
    cout << "f2 = " << f2 << endl;
    cout << "f1 + f2 = " << f1 + f2 << endl;
    cout << "f1 - f2 = " << f1 - f2 << endl;
    cout << "f1 * f2 = " << f1 * f2 << endl;
    cout << "f1 / f2 = " << f1 / f2 << endl;

    if (f1 == f2) {
        cout << "f1 == f2" << endl;
    } else if (f1 != f2) {
        cout << "f1 != f2" << endl;
    }
    if (f1 < f2) {
        cout << "f1 < f2" << endl;
    } else if (f1 <= f2) {
        cout << "f1 <= f2" << endl;
    }
    if (f1 > f2) {
        cout << "f1 > f2" << endl;
    } else if (f1 >= f2) {
        cout << "f1 >= f2" << endl;
    }

    return 0;
}

在这个实现中，`Fraction` 类包含了以下成员变量和方法：

- `numerator`：分子；
- `denominator`：分母；
- `Fraction(int n = 0, int d = 1)`：构造函数，用来创建一个分数对象。如果分母为 0，则会输出错误信息并退出程序。如果分子为 0，则分母为 1。
- `reduce()`：成员函数，用来对非最简分数进行约分。
- `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 bool operator==(const Fraction& f1, const Fraction& f2)`：等于运算符重载函数，用来判断两个分数是否相等。
- `friend bool operator!=(const Fraction& f1, const Fraction& f2)`：不等于运算符重载函数，用来判断两个分数是否不相等。
- `friend bool operator<(const Fraction& f1, const Fraction& f2)`：小于运算符重载函数，用来判断一个分数是否小于另一个分数。
- `friend bool operator<=(const Fraction& f1, const Fraction& f2)`：小于等于运算符重载函数，用来判断一个分数是否小于或等于另一个分数。
- `friend bool operator>(const Fraction& f1, const Fraction& f2)`：大于运算符重载函数，用来判断一个分数是否大于另一个分数。
- `friend bool operator>=(const Fraction& f1, const Fraction& f2)`：大于等于运算符重载函数，用来判断一个分数是否大于或等于另一个分数。
- `Fraction& operator+=(const Fraction& f)`：加等于运算符重载函数，用来实现分数对象的自加操作。
- `Fraction& operator-=(const Fraction& f)`：减等于运算符重载函数，用来实现分数对象的自减操作。
- `Fraction& operator*=(const Fraction& f)`：乘等于运算符重载函数，用来实现分数对象的自乘操作。
- `Fraction& operator/=(const Fraction& f)`：除等于运算符重载函数，用来实现分数对象的自除操作。
- `friend istream& operator>>(istream& in, Fraction& f)`：输入流运算符重载函数，用来实现分数对象的输入操作。
- `friend ostream& operator<<(ostream& out, const Fraction& f)`：输出流运算符重载函数，用来实现分数对象的输出操作。

在主函数中，我们先创建两个 `Fraction` 对象 `f1` 和 `f2`，然后让用户分别输入两个分数。接着，我们依次输出 `f1`、`f2`、`f1 + f2`、`f1 - f2`、`f1 * f2`、`f1 / f2`，以及 `f1 == f2`、`f1 != f2`、`f1 < f2`、`f1 <= f2`、`f1 > f2`、`f1 >= f2` 的结果。