⚡ CYBER_PROFILE ⚡
/// SYSTEM READY ///
WARNING \]: DETECTING HIGH ENERGY
**🌊 🌉 🌊 心手合一 · 水到渠成**
|------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------|
| **\>\>\> ACCESS TERMINAL \<\<\<** ||
| [**\[ 🦾 作者主页 \]**](https://blog.csdn.net/fengtinghuqu520?spm=1000.2115.3001.5343) | [**\[ 🔥 C语言核心 \]**](https://blog.csdn.net/fengtinghuqu520/category_12955956.html) |
| [**\[ 💾 编程百度 \]**](https://blog.csdn.net/fengtinghuqu520/category_13083835.html) | [**\[ 📡 代码仓库 \]**](https://blog.csdn.net/fengtinghuqu520/article/details/147275999?spm=1001.2014.3001.5502) |
---------------------------------------
Running Process: 100% \| Latency: 0ms
*** ** * ** ***
#### 索引与导读
* [什么叫重载？](#什么叫重载？)
* [为什么会有 运算符重载？](#为什么会有 运算符重载？)
*
* [1）实现自然语义表达](#1）实现自然语义表达)
* [2）提高代码可读性和可维护性](#2）提高代码可读性和可维护性)
* [3）保持类型使用的一致性](#3）保持类型使用的一致性)
* [❗ 单目运算符与双目运算符](#❗ 单目运算符与双目运算符)
* [一、基本语法](#一、基本语法)
*
* [💻代码示例](#💻代码示例)
* [❓为何参数列表通常是const引用？](#❓为何参数列表通常是const引用？)
* [二、运算符重载的返回值](#二、运算符重载的返回值)
*
* [1）返回引用的情况](#1）返回引用的情况)
* [2）返回值的情况](#2）返回值的情况)
* [3）返回布尔值](#3）返回布尔值)
* [4）总结表](#4）总结表)
* [三、实现方式](#三、实现方式)
*
* [1）成员函数形式](#1）成员函数形式)
* [2）全局函数（友元函数）重载](#2）全局函数（友元函数）重载)
* [核心差异对比](#核心差异对比)
* [四、运算符重载的规则与限制](#四、运算符重载的规则与限制)
*
* [1）不可改变内置含义](#1）不可改变内置含义)
* [2） 优先级与结合性不变](#2） 优先级与结合性不变)
* [3）操作数个数固定](#3）操作数个数固定)
* [五、限制与禁忌](#五、限制与禁忌)
*
* [1）不能创造新符号](#1）不能创造新符号)
* [2）五个不能重载的运算符](#2）五个不能重载的运算符)
* [3）必须包含类类型参数](#3）必须包含类类型参数)
* [六、自增自减重载](#六、自增自减重载)
*
* [💻 代码演示 (前置 vs 后置)：](#💻 代码演示 (前置 vs 后置)：)
* [七、重载 \<\< 和 \>\>](#七、重载 << 和 >>)
*
* [1）重载输出运算符 \<\<](#1）重载输出运算符 <<)
* [2）重载输入运算符 \>\>](#2）重载输入运算符 >>)
* [💻结尾--- 核心连接协议](#💻结尾— 核心连接协议)
## 什么叫重载？
**重载** 是`C++`中**允许同一作用域内存在多个同名函数或运算符**，但它们的参数列表不同的特性
> [🔗Lucy的空间骇客裂缝：函数重载](https://blog.csdn.net/fengtinghuqu520/article/details/156944877?spm=1011.2415.3001.10575&sharefrom=mp_manage_link)
*** ** * ** ***
## 为什么会有 运算符重载？
* **我们先来看看传统C语言方法的局限性**
```cpp
// C风格复数运算示例
#include // 添加头文件
using namespace std;
struct Complex {
double real;
double imag;
};
Complex add_complex(Complex a, Complex b) {
return { a.real + b.real, a.imag + b.imag }; // C++11及以后支持这种初始化方式
}
int main() {
Complex c1 = { 1.0, 2.0 };
Complex c2 = { 3.0, 4.0 };
Complex result = add_complex(c1, c2);
// 添加输出以便查看结果
cout << "Result: " << result.real << " + " << result.imag << "i" << std::endl;
return 0;
}
```
**存在的问题：**
1. **语法不自然：** 必须调用函数而非使用数学符号
2. **代码可读性差：** 无法一眼看出运算意图
3. **一致性缺失：** 与内置类型使用方式不同
*** ** * ** ***
### 1）实现自然语义表达
```cpp
// 使用运算符重载的C++复数类
class Complex {
private:
double real, imag;
public:
Complex operator+(const Complex& other) const {
return Complex(real + other.real, imag + other.imag);
}
};
int main() {
Complex c1(1.0, 2.0);
Complex c2(3.0, 4.0);
Complex result = c1 + c2; // 自然，直观！
}
```
### 2）提高代码可读性和可维护性
```cpp
// 矩阵运算示例
Matrix a, b, c, d;
// 传统方式
Matrix result = multiply(add(a, b), subtract(c, d));
// 运算符重载方式
Matrix result = (a + b) * (c - d); // 清晰表达数学公式
```
### 3）保持类型使用的一致性
```cpp
// 自定义字符串类
class MyString {
public:
MyString operator+(const MyString& other) const;
bool operator==(const MyString& other) const;
char& operator[](size_t index);
};
MyString s1 = "Hello";
MyString s2 = "World";
MyString s3 = s1 + " " + s2; // 与std::string使用方式一致
```
*** ** * ** ***
### ❗ 单目运算符与双目运算符
> [🔗Lucy的空间骇客裂缝：操作数与运算符的关系](https://blog.csdn.net/fengtinghuqu520/article/details/157518773?spm=1011.2415.3001.10575&sharefrom=mp_manage_link)
*** ** * ** ***
## 一、基本语法
**运算符重载** 是通过定义一个名为 `operator@` 的函数来实现的，其中`@`是你要重载的运算符符号
```cpp
// 语法形式
返回类型 operator运算符(参数列表) {
// 实现逻辑
}
```
### 💻代码示例
```cpp
class Vector {
public:
int x, y;
Vector operator+(const Vector& other) const {
return {x + other.x, y + other.y};
}
Vector& operator+=(const Vector& other) {
x += other.x;
y += other.y;
return *this;
}
};
```
> ### ❓为何参数列表通常是const引用？
>
> `1`. 性能：避免昂贵的深拷贝
>
> 对于非内置类型（如 `std::vector`、大型 `struct` 或自定义类），如果按值传递（`Pass by Value`），编译器会调用拷贝构造函数生成一份实参的副本。
>
> * **开销**：拷贝大型对象涉及内存分配和数据复制，极其耗时。
> * **优化** ：使用引用（`Reference`）本质上是传递地址，开销极小。
>
> *** ** * ** ***
>
> `2`. 语义：防止意外修改
>
> 运算符（如 `+`、`-`、`*`）在数学逻辑上通常不应该改变操作数本身。
>
> * **只读保障** ：添加 `const` 修饰符可以确保在运算符函数内部，代码无法修改传入\>的对象。
> * **代码契约**：这向调用者明确传达了一个信号："我只是用你的数据算个结果，绝\>不会动你的原件。"
>
> *** ** * ** ***
>
> `3`. 兼容性：支持右值和临时对象
>
> 这是技术上最关键的一点。在 `C++` 中，非 `const` 引用不能绑定到临时对象（右值）
*** ** * ** ***
## 二、运算符重载的返回值
**运算符重载** 的返回值类型并不是随意指定的
它直接决定了该运算符是否符合 `C++` 的原生语义、是否支持链式操作（如 `a + b + c `或 `std::cout << a << b`），以及程序的执行效率
### 1）返回引用的情况
**适用场景：** 修改对象自身的操作（**赋值、自增、流输入输出**）
赋值运算符（`=`，`+=`，`-=` 等）
* **返回值** : `T&` (当前对象的引用)
* **原因** : 为了支持链式赋值（如 `a = b = c`）。如果不返回引用，`b = c` 的结果将是一个临时副本，无法再赋值给 `a`。
* **惯用法** : 始终返回 `*this`。
前置自增/自减（`++obj`，`--obj`）
* **返回值** : `T&`
* **原因** : 前置操作是"先加后用"，返回的是增加后的原对象本身。这符合原生 `int` 的逻辑：`++(++i)` 是合法的。
流操作符（`<<`，`>>`）
* **返回值** : `std::ostream&` 或 `std::istream&`
* **原因** : 为了支持连续打印（如 `cout << a << b;`）。必须返回流对象的引用，才能让下一个 `<<` 继续作用于该流
*** ** * ** ***
### 2）返回值的情况
**适用场景：** 产生新对象的操作（算术运算、后置自增）
算术运算符（`+`，`-`，`*`，`/`）
* **返回值** ：`T`（或者 `const T`）
* **原因** ：当你执行 `a + b` 时，`a` 和 `b` 本身不应该改变，而是产生一个全新的中间值。由于这个中间值是局部变量，绝不能返回引用（否则会指向已销毁的内存）。
后置自增/自减（`obj++`，`obj--`）
* **返回值** ：`T`
* **原因**：后置操作是"先用后加"。你需要先拷贝一份当前状态，修改原对象，然后返回那个还没改之前的备份。
*** ** * ** ***
### 3）返回布尔值
**适用场景：** 关系运算符（`==`，`!=`，`<`，`>`，`<=`，`>=`）
* **返回值** ：`bool`
* **原因**：逻辑判断的直观结果。
*** ** * ** ***
### 4）总结表
*** ** * ** ***
## 三、实现方式
**实现运算符重载主要有两种方式：**
1. 作为**成员函数**
2. 作为**非成员函数** ，通常设为**友元 (friend)** 以访问私有成员
### 1）成员函数形式
**这种方式将运算符重载函数定义在类的内部**
对于**双目运算符** ，**左侧的操作数必须是该类的对象** ，因为重载函数会自动通过`this`指针访问左操作数
* **参数数量：** 比操作数少一个（左操作数由 `this` 隐式传递）
* **适用场景：** 修改对象内部状态的运算符，如 `+=`, `-=`, `++` 等
```cpp
#include
using namespace std;
class Complex {
public:
double real, imag;
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);
}
};
int main() {
Complex c1(1.0, 2.0), c2(2.0, 3.0);
Complex c3 = c1 + c2;
cout << "Sum: " << c3.real << " + " << c3.imag << "i" << endl;
return 0;
}
```
**╔═█▓▒░ CODE CORE 🔥**
**┌─────────────┐
│ 代码关键点 │ **`c3 = c1 + c2`**
└─────────────┘**
当你写 **`c3 = c1 + c2`** 时，本质上是`c1`调用了函数，而`c2`是传进来的参数
**等价于：** `c1.operator+(c2)`
* 所以，当你调用`c3.real`与`c3.imag`的时候，
* **`real`** ：指的是 `c1`（调用者）的实部
* **`other.real`** ：指的是 `c2`（参数）的实部
* **计算过程：**
* 实部相加：**1.0 (c1.real) + 2.0 (c2.real) = 3.0**
* 虚部相加：**2.0 (c1.imag) + 3.0 (c2.imag) = 5.0**
*** ** * ** ***
### 2）全局函数（友元函数）重载
> 🔗[Lucy的空间骇客裂缝：友元函数friend]()
* 主要用于**处理那些左侧操作数不是本类对象的情况** ，或者**需要对称性转换的运算符** ，比如 **`<<、>>、+`** 等
**使用全局函数重载**，两侧操作数可以是对称的，甚至可以支持隐式转换：
```cpp
Vector operator+(int a, const Vector& v);
Vector operator+(const Vector& v, int a);
```
🚩通常将其声明为` friend（友元）`，以便访问类的私有成员
*下面通过一个完整的 `Vector2`（二维向量）类，详细解析最常用且最具代表性的运算符重载实现*
```cpp
#include
using namespace std;
class Vector {
int x, y;
public:
Vector(int x, int y) : x(x), y(y) {}
// 声明友元，以便全局函数访问私有成员
friend ostream& operator<<(ostream& os, const Vector& v);
};
// 全局函数实现
ostream& operator<<(ostream& os, const Vector& v) {
os << "(" << v.x << ", " << v.y << ")";
return os;
}
int main() {
Vector v(10, 20);
cout << "Vector position: " << v << endl;
return 0;
}
```
### 核心差异对比
*** ** * ** ***
## 四、运算符重载的规则与限制
### 1）不可改变内置含义
**核心：** 运算符重载必须涉及用户自定义类型，不能修改纯内置类型（如 int）的运算逻辑
* **❌ 错误：** 试图修改两个 int 的加法（编译器报错）
```cpp
int operator+(int a, int b) { return a - b; }
```
* **✅ 正确：** 至少有一个参数是自定义类 CyberUnit
```cpp
class CyberUnit {};
CyberUnit operator+(CyberUnit a, int b) { return a; }
```
*** ** * ** ***
### 2） 优先级与结合性不变
**核心：** 无论你怎么重载，`*`总是先于 `+` 执行，赋值 `=` 总是从右往左结合
```cpp
// 逻辑矩阵中：v1 + v2 * v3 永远等同于 v1 + (v2 * v3)
// 你无法通过重载让 + 的优先级高于 *
CyberVector v1, v2, v3;
CyberVector res = v1 + v2 * v3;
// 结合性：a = b = c 依然是先算 b = c
v1 = v2 = v3;
```
*** ** * ** ***
### 3）操作数个数固定
**核心：** 一元运算符重载后还是一个操作数，二元还是两个，不能增减
```cpp
class HackerPoint {
public:
// 一元运算符：! (逻辑非)，重载时参数为空（隐式使用 this）
bool operator!() { return true; }
// 二元运算符：^ (按位异或)，重载时接收一个参数
int operator^(const HackerPoint& p) { return 0; }
};
HackerPoint p1, p2;
!p1; // 依然是一元
p1 ^ p2; // 依然是二元
```
*** ** * ** ***
## 五、限制与禁忌
### 1）不能创造新符号
你不能自创 `C++` 中不存在的符号，例如 `operator@` 是非法的
### 2）五个不能重载的运算符
1. `.*` (成员指针访问运算符)
2. `::` (域作用域解析符)
3. `sizeof` (长度运算符)
4. `?:` (三目条件运算符)
5. `.` (成员访问运算符)
### 3）必须包含类类型参数
* **防止篡改内置逻辑：** 你不能改变内置类型（如 `int`, `double`）的运算规则
* **例子：** `int operator+(int, int)` 是非法的，因为你不能重新定义 `1 + 1` 的含义。重载函数的参数中**至少有一个**必须是自定义类型（类或枚举）
**✅ 正确：** 至少有一个参数是自定义类型
```cpp
class MyClass {};
MyClass operator+(MyClass a, int b) { return a; }
```
**❌ 错误：** 所有参数都是内置类型 (int)
```cpp
int operator+(int a, int b) { return a - b; }
```
*** ** * ** ***
## 六、自增自减重载
因为**前置 `++i`** 和**后置 `i++`** 用的符号都是 **`++`**，编译器如何区分？
* 前置`++`（`++i`）：函数名为 `operator++()`，无参数。
* 后置`++`（`i++`）：`C++`规定，在参数列表中增加一个 `int` 类型的占位参数，构成了函数重载。函数名为 `operator++(int)`。
### 💻 代码演示 (前置 vs 后置)：
```cpp
#include
using namespace std;
class Number {
int val;
public:
//使用初始化列表将传入的参数v赋值给成员变量val
Number(int v) : val(v) {}
// 前置++: 先加，再返回引用
Number& operator++() {
val++; //1、先增加对象自身的值
return *this; //2、返回对象自身的引用（即返回修改后的自己）
//*this 是对象的完全体
}
// 后置++: 带有 int 占位参数
// 参数中的 int 是占位符，仅用于告诉编译器这是"后置"版本，区分于前置版本
Number operator++(int) {
Number temp = *this; // 保存旧状态
val++; // 自增
return temp; // 返回旧状态
}
// 辅助函数：用于打印当前值
void display() const {
cout << "当前值: " << val << endl;
}
};
int main() {
Number n(10);
cout << "初始状态：" << endl;
n.display();
// 1. 测试前置++
// 逻辑：n 先自增变为 11，然后返回 11
cout << "\n执行 ++n (前置):" << endl;
Number n1 = ++n;
cout << "n1 (返回值): "; n1.display();
cout << "n (原对象): "; n.display();
// 2. 测试后置++
// 逻辑：先返回 n 的当前值 11 给 n2，然后 n 自增变为 12
cout << "\n执行 n++ (后置):" << endl;
Number n2 = n++;
cout << "n2 (返回值): "; n2.display();
cout << "n (原对象): "; n.display();
return 0;
}
```
*** ** * ** ***
## 七、重载 \<\< 和 \>\>
### 1）重载输出运算符 \<\<
输出重载的主要目的是**将类的数据成员格式化后传给输出流**
```cpp
ostream& operator<<(ostream& cout, const MyClass& obj) {
cout << obj.data; // 将成员变量写入流
return cout;
}
```
### 2）重载输入运算符 \>\>
输入重载用于**从键盘或文件中读取数据并赋值给对象的成员**
```cpp
istream& operator>>(istream& cin, MyClass& obj) {
cin >> obj.data; // 从流中读取数据到成员变量
return cin;
}
```
**╔═█▓▒░ CODE CORE 🔥**
**┌─────────────┐
│ 代码关键点 │非 const 引用
└─────────────┘**
第二个参数 `MyClass &obj` 不能加 `const`，因为我们需要修改它的值
*** ** * ** ***
## 💻结尾--- 核心连接协议
**警告：** 🌠🌠正在接入底层技术矩阵。如果你已成功破解学习中的逻辑断层，请执行以下指令序列以同步数据：🌠🌠
*** ** * ** ***
**【📡】 建立深度链接：** **关注**本终端。在赛博丛林中深耕底层架构，从原始代码到进阶协议，同步见证每一次系统升级。
**【⚡】 能量过载分发：** 执行**点赞**操作。通过高带宽分发，让优质模组在信息流中高亮显示，赋予知识跨维度的传播力。
**【💾】 离线缓存核心：** 将本页加入**收藏**。把这些高频实战逻辑存入你的离线存储器，在遭遇系统崩溃或需要离线检索时，实现瞬时读取。
**【💬】 协议加密解密：** 在**评论区**留下你的散列码。分享你曾遭遇的代码冲突或系统漏洞（那些年踩过的坑），通过交互式编译共同绕过技术陷阱。
**【🛰️】 信号频率投票：** 通过**投票**发射你的选择。你的每一次点击都在重新定义矩阵的进化方向，决定下一个被全量拆解的技术节点。
*** ** * ** ***
