编写Fraction 类，封装分数的基本功能。 (1)实现函数重载。 (2)实现各个成员函数、友元函数。 (3) 规范化分数，即分母为0时，将其分母置1

好的，我明白了。以下是Fraction类的代码实现：

#include <iostream>
using namespace std;

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

public:
    Fraction(int num, int den = 1) {  // 构造函数
        if (den == 0) {  // 分母为0时规范化
            den = 1;
        }
        if (den < 0) {  // 分母为负数时，将负号移到分子上
            num = -num;
            den = -den;
        }
        numerator = num;
        denominator = den;
        reduce();  // 约分
    }

    int getNumerator() const {  // 获取分子
        return numerator;
    }

    int getDenominator() const {  // 获取分母
        return denominator;
    }

    double toDouble() const {  // 转化为double类型
        return (double)numerator / denominator;
    }

    Fraction operator+ (const Fraction& f) const {  // 加法运算符重载
        int num = numerator * f.denominator + f.numerator * denominator;
        int den = denominator * f.denominator;
        return Fraction(num, den);
    }

    Fraction operator- (const Fraction& f) const {  // 减法运算符重载
        int num = numerator * f.denominator - f.numerator * denominator;
        int den = denominator * f.denominator;
        return Fraction(num, den);
    }

    Fraction operator* (const Fraction& f) const {  // 乘法运算符重载
        int num = numerator * f.numerator;
        int den = denominator * f.denominator;
        return Fraction(num, den);
    }

    Fraction operator/ (const Fraction& f) const {  // 除法运算符重载
        int num = numerator * f.denominator;
        int den = denominator * f.numerator;
        return Fraction(num, den);
    }

    friend Fraction operator+ (int i, const Fraction& f) {  // 整数加分数的友元函数
        return Fraction(i) + f;
    }

    friend Fraction operator- (int i, const Fraction& f) {  // 整数减分数的友元函数
        return Fraction(i) - f;
    }

    friend Fraction operator* (int i, const Fraction& f) {  // 整数乘分数的友元函数
        return Fraction(i) * f;
    }

    friend Fraction operator/ (int i, const Fraction& f) {  // 整数除以分数的友元函数
        return Fraction(i) / f;
    }

    friend ostream& operator<< (ostream& os, const Fraction& f) {  // 输出运算符重载
        os << f.numerator << "/" << f.denominator;
        return os;
    }

private:
    int gcd(int a, int b) {  // 辗转相除法求最大公约数
        return b == 0 ? a : gcd(b, a % b);
    }

    void reduce() {  // 约分
        if (numerator == 0) {  // 0的分母规范为1
            denominator = 1;
            return;
        }
        int commonDivisor = gcd(abs(numerator), denominator);
        numerator /= commonDivisor;
        denominator /= commonDivisor;
    }
};

在这个代码中，我们实现了Fraction类，并封装了分数的基本功能。具体来说，我们实现了：

1. 构造函数，用于对象的初始化；
2. getNumerator()和getDenominator()函数，用于获取分子和分母；
3. toDouble()函数，用于将分数转化为double类型；
4. 四则运算符的重载，用于分数之间的加减乘除运算；
5. 整数加减乘除分数的友元函数；
6. 输出运算符的重载，用于输出分数；
7. gcd()函数和reduce()函数，用于求最大公约数和约分。

需要注意的是，我们在构造函数中对分母为0的情况进行了规范化处理，将其置为1；同时，在输出分数时，我们采用了“分子/分母”的形式。通过这些封装，我们可以更方便地使用分数，并且避免了分数运算过程中的错误。