【C++入门】运算符重载

文章目录

• 前言
• • 什么是运算符重载？
  • • 运算符重载的作用
  • 类外运算符重载
  • • 使用方法
    • 作用范围
    • 参数注意事项
    • 示例
  • operator返回值
  • 类内运算符重载
  • • 使用方法
    • 作用范围
    • 参数
    • 示例
  • 运算符重载集合使用方法
• 总结

---

前言

C++ 运算符重载（Operator Overloading）是一项强大的特性，允许程序员为用户自定义类型（如类和结构体）定义新的操作方式。通过运算符重载，我们可以使自定义类型的实例能够以类似于内置类型的方式进行操作，从而提高代码的可读性和简洁性。例如，可以为自定义的复数类（Complex）重载加号运算符，使两个复数对象可以直接相加。本篇文章将介绍 C++ 运算符重载的基本概念和注意事项，以帮助读者更好地理解和应用这一特性。

---

什么是运算符重载？

运算符重载是一种允许程序员为自定义类型定义新行为的技术。简单来说，就是我们可以让自己的数据类型（比如一个类或结构体）使用类似于内置类型（如整数、浮点数）那样的操作符进行操作。这样做可以让代码更直观、更易读。

运算符重载的作用

运算符重载的主要作用是让自定义类型能够像内置类型一样进行运算。例如：

• 加法运算符（+）：你可以定义一个"复数"类，并重载加法运算符，使两个复数对象可以相加。
• 比较运算符（==）：你可以重载比较运算符，使两个自定义的"日期"类对象可以进行比较，判断它们是否相等。
• 输出运算符（<<） ：你可以重载输出运算符，使自定义类型可以直接使用 cout 输出它们的内容。

类外运算符重载

使用方法

类外运算符重载是在类的外部定义运算符的重载函数。这种方法通常用于那些需要访问类的私有成员或需要友元函数来实现的操作。

作用范围

类外运算符重载的作用范围是全局范围，因为它们是在类的外部定义的。因此，它们可以操作多个类或不同类型的数据。

参数注意事项

• 类外运算符重载函数通常需要两个参数，一个是左操作数，另一个是右操作数。
• 如果运算符是二元运算符（如加法运算符+），两个参数都是必须的。
• 如果运算符是单元运算符（如前置递增运算符++），只需要一个参数。

示例

考虑一个"复数"类，我们希望通过重载加法运算符来实现两个复数对象的相加。类外运算符重载的函数可能会接受两个复数对象，并返回它们相加的结果。

#include <iostream>

class Complex {
public:
    Complex(double real, double imag) : real(real), imag(imag) {}

    // 声明友元函数，使其可以访问私有成员
    friend Complex operator+(const Complex& c1, const Complex& c2);

    void print() const {
        std::cout << real << " + " << imag << "i" << std::endl;
    }

private:
    double real;
    double imag;
};

// 类外定义运算符重载
Complex operator+(const Complex& c1, const Complex& c2) {
    return Complex(c1.real + c2.real, c1.imag + c2.imag);
}

int main() {
    Complex c1(1.0, 2.0);
    Complex c2(3.0, 4.0);
    Complex c3 = c1 + c2; // 使用重载的加法运算符
    c3.print(); // 输出结果：4.0 + 6.0i
    return 0;
}

operator返回值

运算符重载函数的返回值类型通常是一个新对象或者对原对象的引用。使用返回值的原因是为了使运算符能够返回操作的结果，以便后续使用，简单来说就是连续运算。例如，重载加法运算符时，需要返回两个对象相加后的结果，这样可以链式调用或者继续对结果进行其他操作。

#include <iostream>

class Vector {
public:
    Vector(int x, int y) : x(x), y(y) {}

    // 重载加法运算符
    Vector operator+(const Vector& other) const {
        // 返回一个新的Vector对象，表示两个向量相加的结果
        return Vector(x + other.x, y + other.y);
    }

    void print() const {
        std::cout << "Vector(" << x << ", " << y << ")" << std::endl;
    }

private:
    int x;
    int y;
};

int main() {
    Vector v1(1, 2);
    Vector v2(3, 4);
    Vector v3 = v1 + v2; // 使用重载的加法运算符
    v3.print(); // 输出结果：Vector(4, 6)
    return 0;
}

类内运算符重载

使用方法

类内运算符重载是在类的内部定义运算符的重载函数。这种方法适用于那些不需要友元函数即可访问类成员的运算符。

作用范围

类内运算符重载的作用范围是类的内部，因此它们通常只能操作当前类的对象。

参数

由于在类内，所以自带了一个参数，也就是第一个参数变成了这个类的指针this，所以，我们写参数的时候要比原本的参数少一个

示例

考虑一个"复数"类，我们希望通过重载加法运算符来实现两个复数对象的相加。类内运算符重载的函数可能会直接在类内部定义，并使用类的成员变量进行操作。

#include <iostream>

class Complex {
public:
    Complex(double real, double imag) : real(real), imag(imag) {}

    // 类内定义运算符重载
    Complex operator+(const Complex& other) const {
        return Complex(real + other.real, imag + other.imag);
    }

    void print() const {
        std::cout << real << " + " << imag << "i" << std::endl;
    }

private:
    double real;
    double imag;
};

int main() {
    Complex c1(1.0, 2.0);
    Complex c2(3.0, 4.0);
    Complex c3 = c1 + c2; // 使用重载的加法运算符
    c3.print(); // 输出结果：4.0 + 6.0i
    return 0;
}

运算符重载集合使用方法

#include <iostream>

class Point {
public:
    Point(int x = 0, int y = 0) : x(x), y(y) {}

    // 加法运算符重载
    Point operator+(const Point& other) const {
        return Point(x + other.x, y + other.y);
    }

    // 减法运算符重载
    Point operator-(const Point& other) const {
        return Point(x - other.x, y - other.y);
    }

    // 乘法运算符重载
    Point operator*(int scalar) const {
        return Point(x * scalar, y * scalar);
    }

    // 等于运算符重载
    bool operator==(const Point& other) const {
        return x == other.x && y == other.y;
    }

    // 不等于运算符重载
    bool operator!=(const Point& other) const {
        return !(*this == other);
    }

    // 前置递增运算符重载
    Point& operator++() {
        ++x;
        ++y;
        return *this;
    }

    // 后置递增运算符重载
    Point operator++(int) {
        Point temp = *this;
        ++(*this);
        return temp;
    }

    // 输出运算符重载（友元函数）
    friend std::ostream& operator<<(std::ostream& os, const Point& point) {
        os << "(" << point.x << ", " << point.y << ")";
        return os;
    }

private:
    int x, y;
};

int main() {
    Point p1(1, 2);
    Point p2(3, 4);

    // 加法运算
    Point p3 = p1 + p2;
    std::cout << "p1 + p2 = " << p3 << std::endl;

    // 减法运算
    Point p4 = p1 - p2;
    std::cout << "p1 - p2 = " << p4 << std::endl;

    // 乘法运算
    Point p5 = p1 * 2;
    std::cout << "p1 * 2 = " << p5 << std::endl;

    // 等于运算
    std::cout << "p1 == p2: " << (p1 == p2) << std::endl;

    // 不等于运算
    std::cout << "p1 != p2: " << (p1 != p2) << std::endl;

    // 前置递增
    ++p1;
    std::cout << "++p1: " << p1 << std::endl;

    // 后置递增
    p2++;
    std::cout << "p2++: " << p2 << std::endl;

    return 0;
}

---

总结

C++ 运算符重载提供了对用户自定义类型的强大扩展能力，使其能够像内置类型一样使用各种运算符，从而提高了代码的直观性和可读性。在使用运算符重载时，应注意保持运算符的语义一致性和避免滥用，以确保代码的可维护性和可理解性。通过掌握运算符重载的基本概念和技巧，程序员可以更灵活地设计和实现复杂的数据类型，从而编写出更加优雅和高效的代码。