首页 > 编程笔记 > C++笔记 阅读：16

C++运算符重载的2种方式（非常详细，附带实例）

在 C++ 中，运算符重载是一个强大的特性，它允许开发者为自定义数据类型定义运算符的操作。

运算符重载可以分为以下几个主要类别：
某些运算符如作用域解析（::）、成员访问（.）、成员指针访问（.*）和条件（?:）运算符不能被重载，因为它们在语言中具有特殊的意义和用途。此外，C++ 也不允许开发者定义新的运算符，这是语言设计中为保持核心语法的一致性和清晰性而做出的限制。

下表从多个角度总结和对比了C++中不同类型运算符重载的使用场景和表现形式。

表：不同类型运算符重载的使用场景和表现形式
运算符类型 运算符 重载能力 说明 使用场景示例
一元运算符 ++ 可重载 递增运算符，增加对象的值 实现自定义类型的递增操作
-- 可重载 递减运算符，减少对象的值 实现自定义类型的递减操作
! 可重载 逻辑非运算符，反转对象的布尔值 重载自定义类型的逻辑反操作，用于条件判断
+ 可重载 加法运算符，合并两个对象的值 重载以实现自定义类型对象间的加法运算
- 可重载 减法运算符，计算两个对象之间的差值 重载以实现自定义类型对象间的减法运算
二元运算符 * 可重载 乘法运算符，计算两个对象的乘积 重载以实现自定义类型对象间的乘法运算
/ 可重载 除法运算符，计算两个对象的商 重载以实现自定义类型对象间的除法运算
== 可重载 等于运算符，判断两个对象是否相等 重载以实现自定义类型对象间的等价比较
< 可重载 小于运算符，判断一个对象是否小于另一个对象 重载以实现自定义类型对象间的大小比较
特殊运算符 = 可重载 赋值运算符，将一个对象的值赋给另一个对象 重载以实现自定义类型的赋值操作，如深拷贝或移动赋值
<< 可重载 插入运算符，用于输出流 重载以实现自定义类型的输出流格式化输出
>> 可重载 提取运算符，用于输入流 重载以实现自定义类型的输入流处理，如格式化输入
不可重载运算符 :: 不可重载 作用域解析运算符 用于指定命名空间中的变量或函数名称
. 不可重载 成员访问运算符 用于访问对象的成员变量或成员函数
* 不可重载 指向成员的指针运算符 用于指针访问对象的成员
?: 不可重载 条件运算符 用于表达基于条件的值选择

C++运算符重载的两种方式

在 C++ 中，运算符重载可以通过两种方式实现：成员函数和非成员函数（通常是友元函数）。这两种方式各有其适用场景和特点，理解它们的区别和适用性对于设计合理的重载运算符至关重要。

1) 成员函数方式

当运算符重载作为类的成员函数时，它的第一个操作数隐式地绑定到调用它的对象上。这种方式适合那些操作涉及改变对象内部状态或需要访问对象的私有成员的情况。

例如，假设有一个 Complex 类代表复数，重载加法运算符作为成员函数可以直接访问和修改复数的实部和虚部。这种方式的定义如下： 
// 定义一个代表复数的Complex类
class Complex {
private:
    double real; // 存储复数的实部
    double imag; // 存储复数的虚部

public:
    // 构造函数，允许创建具有特定实部和虚部的复数
    Complex(double r, double i) : real(r), imag(i) {}

    // 重载+运算符作为成员函数。它接收另一个Complex对象作为参数，并返回两个复数相加的结果
    Complex operator+(const Complex& other) const {
        // 创建并返回一个新的Complex对象，其实部和虚部分别是当前对象(this指针指向的对象)
        // 和参数对象other的实部和虚部之和
        return Complex(this->real + other.real, this->imag + other.imag);
    }

    // 可选：添加一个显示函数，以便打印复数的值
    void display() const {
        std::cout << real << " + " << imag << "i" << std::endl;
    }
};
在这个例子中，重载的“+”运算符通过成员函数的方式实现。这个运算符接收一个 Complex 类型的参数 other，并返回一个新的 Complex 对象，该对象的实部是调用对象和参数对象实部之和，虚部是调用对象和参数对象虚部之和。

当使用“+”运算符对两个 Complex 对象进行操作时，实际上是调用了重载的“+”运算符函数，它返回了一个新的 Complex 对象作为结果。

2) 非成员函数方式

非成员函数方式的运算符重载通常声明为类的友元函数，这样它们可以访问类的私有和受保护成员，同时它们的操作数都是显式传递的，没有隐式的 this 指针。

这种方式特别适用于那些需要对称地处理两个操作数的情况。例如，当两个操作数的类型不同或者当操作不直接关联到对象状态的改变时。

以下示例展示如何通过非成员函数（通常是友元函数）方式重载 Complex 类的“+”运算符。 
#include <iostream>
// 定义Complex类
class Complex {
private:
    double real; // 复数的实部
    double imag; // 复数的虚部
public:
    // 构造函数，初始化复数的实部和虚部
    Complex(double r = 0.0, double i = 0.0) : real(r), imag(i) {}
    // 声明运算符重载函数为友元，使它可以访问私有成员
    friend Complex operator+(const Complex& lhs, const Complex& rhs);
    // 可选：实现一个显示函数来打印复数
    void display() const {
        std::cout << real << " + " << imag << "i" << std::endl;
    }
};
// 以非成员函数（友元函数）的形式实现+运算符重载
Complex operator+(const Complex& lhs, const Complex& rhs) {
    // 直接访问两个操作数的私有成员，计算它们的和
    return Complex(lhs.real + rhs.real, lhs.imag + rhs.imag);
}
// 主函数，用于演示如何使用重载的“+”运算符
int main() {
    Complex c1(5, 4), c2(2, 10), c3;
    // 使用重载的“+”运算符将两个复数相加
    c3 = c1 + c2;
    // 显示结果
    c3.display(); // 应输出: 7 + 14i
    return 0;
}
在这个例子中，我们通过以下几个步骤完成了非成员函数方式的运算符重载：
通过这种方式，运算符重载函数能够平等地处理两个操作数，并且不需要依赖任何一个对象的内部状态，从而在逻辑上提供了更大的灵活性和对称性。

选择哪种方式的关键在于理解运算符重载的语义需求和操作的对称性：
在实际应用中，应根据具体的操作特性和需求来决定使用哪种方式进行运算符重载。

C++运算符重载的注意事项

C++运算符重载实例

以下是一个通过运算符重载实现字符串操作的自定义类型的示例。在这个示例中将演示如何为一个字符串包装类重载赋值运算符（=）、加法运算符（+）以及流插入运算符（<<），展示运算符重载在实现更复杂行为时的应用。
#include <iostream>
#include <string>

// 定义一个字符串包装类
class MyString {
private:
    std::string data;

public:
    // 默认构造函数
    MyString() : data("") {}

    // 从std::string构造MyString的构造函数
    MyString(const std::string& str) : data(str) {}

    // 重载赋值运算符
    MyString& operator=(const MyString& other) {
        if (this != &other) { // 防止自赋值
            this->data = other.data;
        }
        return *this;
    }

    // 重载加法运算符，实现字符串连接
    MyString operator+(const MyString& other) const {
        return MyString(this->data + other.data);
    }

    // 友元函数，重载流插入运算符，用于输出MyString对象
    friend std::ostream& operator<<(std::ostream& out, const MyString& str) {
        out << str.data;
        return out;
    }
};

// 使用示例
int main() {
    MyString str1("Hello, ");
    MyString str2("World!");
    MyString str3 = str1 + str2; // 使用重载的加法运算符连接字符串
    std::cout << "Concatenated string: " << str3 << std::endl;
    MyString str4;
    str4 = str3; // 使用重载的赋值运算符
    std::cout << "Assigned string: " << str4 << std::endl;
    return 0;
}
在这个示例中：
这个示例展示了运算符重载如何用于实现类似内置类型的自然操作，并在自定义类型中实现更加复杂的行为。通过这样的重载，MyString 类的对象可以直观地使用赋值和加法运算，以及直接输出到流中，从而提高了代码的可读性和易用性。

在实际编程中，某些时候我们可能需要重载类型转换运算符，以允许自定义类型的对象在需要时自动转换为其他类型。 
#include <iostream>
#include <string>

// 定义一个类，表示温度
class Temperature {
private:
    double degreesCelsius;

public:
    // 构造函数，初始化温度值
    Temperature(double degrees) : degreesCelsius(degrees) {}

    // 重载类型转换运算符，将Temperature对象转换为double类型
    operator double() const {
        return degreesCelsius;
    }

    // 重载类型转换运算符，将Temperature对象转换为std::string类型
    operator std::string() const {
        return std::to_string(degreesCelsius) + " °C";
    }

    // 友元函数，重载流插入运算符，用于输出Temperature对象
    friend std::ostream& operator<<(std::ostream& out, const Temperature& temp) {
        out << temp.degreesCelsius << " °C";
        return out;
    }
};

// 使用示例
int main() {
    Temperature temp(36.5);

    // 使用重载的类型转换运算符
    double tempInDouble = temp;  // 自动转换为double类型
    std::string tempInString = temp;  // 自动转换为std::string类型

    std::cout << "Temperature in double: " << tempInDouble << std::endl;
    std::cout << "Temperature in string: " << tempInString << std::endl;

    return 0;
}
在这个特殊情况示例中：
这个示例展示了运算符重载在特殊场景下的用法，即通过类型转换运算符的重载，实现了自定义类型到其他类型的隐式转换，使得类型在表达和使用上更加灵活和强大。然而，它们也可能引起潜在的问题，如意外的类型转换，这可能会导致代码难以理解和维护。

因此，虽然重载类型转换运算符是 C++ 提供的一个强大工具，它在某些情况下确实非常有用，但建议谨慎使用：
总的来说，重载类型转换运算符既可以视为特定情况下的解决方案，也可以在特殊设计中成为常见的做法，关键是要清楚地了解它带来的便利与潜在风险，确保它的使用符合设计目标和代码可维护性需求。

相关文章