当前位置：首页 > article >正文

《C++探幽：运算符重载》

article 2025/3/13 14:03:15

《C++探幽:运算符重载》

一、引言

在C++中，运算符重载是一项非常强大的特性，它允许程序员重新定义运算符在自定义类型上的行为。通过运算符重载，我们可以让自定义类型（如类和结构体）的对象像内置类型一样使用运算符，从而使代码更加直观、易读且易于维护。

二、运算符重载的语法

运算符重载通过函数来实现，这些函数被称为运算符重载函数。运算符重载函数有两种形式：成员函数形式和非成员函数形式。

（一）成员函数形式

当运算符重载函数是类的成员函数时，其语法如下：

return_type operator运算符(参数列表);

例如，重载加号运算符：

class MyClass {
public:
    MyClass operator+(const MyClass& other) {
        // 实现加法运算符的逻辑
    }
};

在这种情况下，运算符的第一个操作数是该类的对象，而第二个操作数是参数列表中的参数。

（二）非成员函数形式

当运算符重载函数是类的友元函数或普通函数时，其语法如下：

return_type operator运算符(参数列表);

例如，重载加号运算符：

class MyClass {
public:
    friend MyClass operator+(const MyClass& a, const MyClass& b) {
        // 实现加法运算符的逻辑
    }
};

在这种情况下，运算符的两个操作数都是参数列表中的参数。

三、可重载的运算符

C++中并不是所有的运算符都可以被重载，以下是一些常见的可重载运算符：

算术运算符：+、-、、/、%、+=、-=、=、/=、%=
关系运算符：==、!=、<、>、<=、>=
逻辑运算符：!、||、&&
位运算符：~、&、|、^{、<<、>>、&=、|=、}=、<<=、>>=
自增自减运算符：++、–
赋值运算符：=
下标运算符：[]
函数调用运算符：()
箭头运算符：->

四、运算符重载示例

（一）重载双目运算符

以下是一个重载加号运算符的示例：

#include <iostream>

class Complex {
private:
    double real;
    double imag;

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

    // 重载加号运算符（成员函数形式）
    Complex operator+(const Complex& other) {
        return Complex(real + other.real, imag + other.imag);
    }

    // 重载加号运算符（非成员函数形式）
    friend Complex operator+(const Complex& a, const Complex& b) {
        return Complex(a.real + b.real, a.imag + b.imag);
    }

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

int main() {
    Complex c1(3.0, 4.0);
    Complex c2(1.0, 2.0);
    Complex c3 = c1 + c2; // 使用重载后的加号运算符
    c3.display(); // 输出：(4 + 6i)
    return 0;
}

（二）重载单目运算符

以下是一个重载自增运算符的示例：

#include <iostream>

class Counter {
private:
    int count;

public:
    Counter(int c = 0) : count(c) {}

    // 重载前置自增运算符
    Counter& operator++() {
        count++;
        return *this;
    }

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

    void display() const {
        std::cout << "Count: " << count << std::endl;
    }
};

int main() {
    Counter c1(5);
    ++c1; // 使用前置自增运算符
    c1.display(); // 输出：Count: 6

    Counter c2(5);
    c2++; // 使用后置自增运算符
    c2.display(); // 输出：Count: 6
    return 0;
}

（三）重载比较运算符

以下是一个重载等于运算符的示例：

#include <iostream>
#include <string>

class Person {
private:
    std::string name;
    int age;

public:
    Person(const std::string& n, int a) : name(n), age(a) {}

    // 重载等于运算符
    bool operator==(const Person& other) const {
        return (name == other.name) && (age == other.age);
    }

    void display() const {
        std::cout << "Name: " << name << ", Age: " << age << std::endl;
    }
};

int main() {
    Person p1("Alice", 25);
    Person p2("Alice", 25);
    Person p3("Bob", 30);

    if (p1 == p2) {
        std::cout << "p1 and p2 are the same person." << std::endl;
    } else {
        std::cout << "p1 and p2 are different persons." << std::endl;
    }

    if (p1 == p3) {
        std::cout << "p1 and p3 are the same person." << std::endl;
    } else {
        std::cout << "p1 and p3 are different persons." << std::endl;
    }
    return 0;
}

（四）重载自定义类型与内置类型的运算符

以下是一个重载自定义类型与内置类型的加法运算符的示例：

#include <iostream>
#include <string>

class String {
private:
    std::string str;

public:
    String(const std::string& s) : str(s) {}

    // 重载加法运算符，允许将String对象与std::string对象相加
    String operator+(const std::string& other) {
        return String(str + other);
    }

    // 重载加法运算符，允许将std::string对象与String对象相加
    friend String operator+(const std::string& a, const String& b) {
        return String(a + b.str);
    }

    void display() const {
        std::cout << str << std::endl;
    }
};

int main() {
    String s1("Hello, ");
    std::string s2 = "World!";
    String s3 = s1 + s2; // 使用String对象与std::string对象相加
    s3.display(); // 输出：Hello, World!

    String s4 = s2 + s1; // 使用std::string对象与String对象相加
    s4.display(); // 输出：World!Hello, 
    return 0;
}