0
点赞
收藏
分享

微信扫一扫

每年几十万人报考PMP,含金量体现在哪?

_刘彦辉 2023-12-13 阅读 42

重载加法运算符+和减法运算符-,用于实现对象的加法和减法。加法运算符+和减法运算符-是两种常用的运算符,它们可以对两个操作数进行加法和减法运算,返回一个运算结果。但是,如果我们想要对自定义类型的数据进行加法和减法运算,例如类的对象,那么我们就需要重载加法运算符+和减法运算符-,以便实现对象的加法和减法,即将两个对象的对应成员变量进行加法或减法运算,返回一个新的对象。这样,我们就可以实现对象的组合和分解,提高代码的灵活性和可扩展性。例如,我们可以定义一个Vector 类来表示二维平面上的向量,然后重载加法运算符+和减法运算符-,用于实现向量的加法和减法。代码如下:

// 定义Vector 类
class Vector {
public:
    // 构造函数,用于初始化向量对象
    Vector(double x = 0, double y = 0) {
        this->x = x;
        this->y = y;
    }
    // 重载加法运算符,用于实现向量的加法
    Vector operator+(const Vector& v) {
        // 返回一个新的向量对象,其横坐标和纵坐标分别为两个向量的横坐标和纵坐标之和
        return Vector(this->x + v.x, this->y + v.y);
    }
    // 重载减法运算符,用于实现向量的减法
    Vector operator-(const Vector& v) {
        // 返回一个新的向量对象,其横坐标和纵坐标分别为两个向量的横坐标和纵坐标之差
        return Vector(this->x - v.x, this->y - v.y);
    }
    // 声明友元函数,用于输出向量对象
    friend std::ostream& operator<<(std::ostream& out, const Vector& v);
private:
    // 私有成员变量,用于存储向量的横坐标和纵坐标
    double x;
    double y;
};

// 定义友元函数,用于输出向量对象
std::ostream& operator<<(std::ostream& out, const Vector& v) {
    // 输出向量的横坐标和纵坐标,用尖括号和逗号分隔
    out << "<" << v.x << ", " << v.y << ">";
    // 返回输出流对象,以便进行连续输出
    return out;
}

// 主函数,用于测试
int main() {
    // 创建两个向量对象
    Vector v1(1.0, 2.0);
    Vector v2(3.0, 4.0);
    // 使用加法运算符对两个向量进行加法运算,并输出结果
    std::cout << v1 + v2 << std::endl; // 输出结果为:<4, 6>
    // 使用减法运算符对两个向量进行减法运算,并输出结果
    std::cout << v1 - v2 << std::endl; // 输出结果为:<-2, -2>
    return 0;
}

从上面的代码可以看出,重载加法运算符+和减法运算符-可以让我们对向量对象进行加法和减法运算,就像对内置类型的数据进行加法和减法运算一样。这样,我们就可以实现向量对象的组合和分解,提高代码的灵活性和可扩展性。

载乘法运算符*和除法运算符/,用于实现对象的乘法和除法。乘法运算符*和除法运算符/是两种常用的运算符,它们可以对两个操作数进行乘法和除法运算,返回一个运算结果。但是,如果我们想要对自定义类型的数据进行乘法和除法运算,例如类的对象,那么我们就需要重载乘法运算符*和除法运算符/,以便实现对象的乘法和除法,即将两个对象的对应成员变量进行乘法或除法运算,返回一个新的对象。这样,我们就可以实现对象的放大和缩小,提高代码的灵活性和可扩展性。例如,我们可以定义一个Fraction 类来表示分数,然后重载乘法运算符*和除法运算符/,用于实现分数的乘法和除法。代码如下:

// 定义Fraction 类
class Fraction {
public:
    // 构造函数,用于初始化分数对象
    Fraction(int numerator = 0, int denominator = 1) {
        // 如果分母为零,就抛出一个异常,否则就初始化分子和分母
        if (denominator == 0) {
            throw std::invalid_argument("Denominator cannot be zero");
        } else {
            this->numerator = numerator;
            this->denominator = denominator;
        }
    }
    // 重载乘法运算符,用于实现分数的乘法
    Fraction operator*(const Fraction& f) {
        // 返回一个新的分数对象,其分子和分母分别为两个分数的分子和分母的乘积
        return Fraction(this->numerator * f.numerator, this->denominator * f.denominator);
    }
    // 重载除法运算符,用于实现分数的除法
    Fraction operator/(const Fraction& f) {
        // 如果右操作数的分子为零,就抛出一个异常,否则就返回一个新的分数对象,其分子和分母分别为左操作数的分子乘以右操作数的分母,和左操作数的分母乘以右操作数的分子
        if (f.numerator == 0) {
            throw std::invalid_argument("Cannot divide by zero");
        } else {
            return Fraction(this->numerator * f.denominator, this->denominator * f.numerator);
        }
    }
    // 声明友元函数,用于输出分数对象
    friend std::ostream& operator<<(std::ostream& out, const Fraction& f);
private:
    // 私有成员变量,用于存储分数的分子和分母
    int numerator;
    int denominator;
};

// 定义友元函数,用于输出分数对象
std::ostream& operator<<(std::ostream& out, const Fraction& f) {
    // 输出分数的分子和分母,用斜杠分隔
    out << f.numerator << "/" << f.denominator;
    // 返回输出流对象,以便进行连续输出
    return out;
}

// 主函数,用于测试
int main() {
    // 创建两个分数对象
    Fraction f1(1, 2);
    Fraction f2(3, 4);
    // 使用乘法运算符对两个分数进行乘法运算,并输出结果
    std::cout << f1 * f2 << std::endl; // 输出结果为:3/8
    // 使用除法运算符对两个分数进行除法运算,并输出结果
    std::cout << f1 / f2 << std::endl; // 输出结果为:4/6
    return 0;
}

从上面的代码可以看出,重载乘法运算符*和除法运算符/可以让我们对分数对象进行乘法和除法运算,就像对内置类型的数据进行乘法和除法运算一样。这样,我们就可以实现分数对象的放大和缩小,提高代码的灵活性和可扩展性。

举报

相关推荐

0 条评论