跳转到内容

C++ 运算符重载基础

来自代码酷

C++运算符重载基础[编辑 | 编辑源代码]

介绍[编辑 | 编辑源代码]

运算符重载是C++中一项强大的特性，允许程序员为自定义类型（如类或结构体）重新定义运算符的行为。通过运算符重载，可以使代码更直观、更易于理解，同时保持与内置类型相似的语法。

在C++中，大多数运算符（如+、-、*、==等）都可以被重载，但部分运算符（如::、.、sizeof等）不能重载。运算符重载的本质是定义一个特殊的成员函数或全局函数，其名称以operator开头，后跟要重载的运算符符号。

基本语法[编辑 | 编辑源代码]

运算符重载可以通过成员函数或全局函数实现。以下是两种形式的语法：

成员函数形式[编辑 | 编辑源代码]

class MyClass {
public:
    ReturnType operatorOp(ArgumentType arg) {
        // 实现运算符逻辑
    }
};

全局函数形式[编辑 | 编辑源代码]

ReturnType operatorOp(MyClass obj, ArgumentType arg) {
    // 实现运算符逻辑
}

其中：

  • Op代表要重载的运算符（如+、-等）。
  • ReturnType是运算符的返回类型。
  • ArgumentType是运算符的参数类型。

示例：重载+运算符[编辑 | 编辑源代码]

以下是一个完整的示例，展示如何为自定义的Vector类重载+运算符： 

#include <iostream>

class Vector {
public:
    float x, y;

    // 构造函数
    Vector(float x = 0, float y = 0) : x(x), y(y) {}

    // 重载+运算符（成员函数形式）
    Vector operator+(const Vector& other) const {
        return Vector(x + other.x, y + other.y);
    }
};

int main() {
    Vector v1(1.0, 2.0);
    Vector v2(3.0, 4.0);
    Vector v3 = v1 + v2; // 使用重载的+运算符

    std::cout << "v3: (" << v3.x << ", " << v3.y << ")\n";
    return 0;
}

输出： 

v3: (4.0, 6.0)

解释： 1. 定义了一个Vector类，表示二维向量。 2. 重载了+运算符，使其能够将两个Vector对象的对应分量相加。 3. 在main函数中，使用+运算符直接相加两个Vector对象。

可重载的运算符列表[编辑 | 编辑源代码]

以下是C++中可重载的运算符分类：

类别 运算符
算术运算符 +, -, *, /, %, ++, --
关系运算符 ==, !=, <, >, <=, >=
逻辑运算符 &&, , !
位运算符 , ^, ~, <<, >>
赋值运算符 =, ^=, <<=, >>=
其他运算符 [], (), ->, ,, new, delete

实际应用案例：复数类[编辑 | 编辑源代码]

以下是一个更复杂的示例，展示如何为复数类重载多个运算符： 

#include <iostream>
#include <cmath>

class Complex {
private:
    double real, imag;

public:
    Complex(double r = 0, double i = 0) : real(r), imag(i) {}

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

    // 重载-运算符
    Complex operator-(const Complex& other) const {
        return Complex(real - other.real, imag - other.imag);
    }

    // 重载*运算符（复数乘法）
    Complex operator*(const Complex& other) const {
        return Complex(
            real * other.real - imag * other.imag,
            real * other.imag + imag * other.real
        );
    }

    // 重载<<运算符（用于输出）
    friend std::ostream& operator<<(std::ostream& os, const Complex& c) {
        os << "(" << c.real << " + " << c.imag << "i)";
        return os;
    }
};

int main() {
    Complex c1(1, 2);
    Complex c2(3, 4);

    std::cout << "c1 + c2 = " << (c1 + c2) << "\n";
    std::cout << "c1 - c2 = " << (c1 - c2) << "\n";
    std::cout << "c1 * c2 = " << (c1 * c2) << "\n";

    return 0;
}

输出： 

c1 + c2 = (4 + 6i)
c1 - c2 = (-2 + -2i)
c1 * c2 = (-5 + 10i)

解释： 1. 定义了一个Complex类表示复数。 2. 重载了+、-和*运算符，实现了复数的加法、减法和乘法。 3. 重载了<<运算符，使复数可以直接输出到流中。

运算符重载的限制[编辑 | 编辑源代码]

虽然运算符重载功能强大，但有以下限制： 1. 不能创建新的运算符，只能重载已有的运算符。 2. 不能改变运算符的优先级和结合性。 3. 不能改变运算符的操作数个数（一元运算符只能有一个操作数，二元运算符只能有两个操作数）。 4. 部分运算符（如::、.、.*、?:等）不能重载。

何时使用运算符重载[编辑 | 编辑源代码]

运算符重载最适合以下场景：

  • 自定义类型需要与内置类型有相似的操作（如数学向量、矩阵、复数等）。
  • 操作语义与运算符的常规含义一致（如+表示加法，==表示相等比较）。
  • 需要提高代码的可读性和简洁性。

滥用运算符重载会导致代码难以理解，特别是当运算符的行为与常规含义不符时。

总结[编辑 | 编辑源代码]

运算符重载是C++中实现多态的重要方式之一，它允许自定义类型像内置类型一样使用运算符。正确使用运算符重载可以使代码更直观、更易于维护，但需要谨慎选择重载的运算符，确保其行为符合预期。

通过本文的示例和解释，读者应该能够理解运算符重载的基本概念，并能够在自己的代码中实现简单的运算符重载。

检索自“https://wiki.echo.cool/index.php?title=C%2B%2B_运算符重载基础&oldid=277”