C++ 类与对象进阶涵盖默认成员函数及操作符重载。构造函数负责初始化，编译器生成无参构造但内置类型成员可能未初始化。拷贝构造函数处理对象复制，需注意浅拷贝风险，涉及指针资源时需深拷贝。析构函数清理资源，遵循后进先出原则。操作符重载允许自定义类型使用运算符，分为全局与成员函数形式。赋值运算符重载需处理自赋值。遵循三法则，若定义析构、拷贝构造或赋值运算符之一，通常需全部定义以确保资源管理安全。
在前文中，我们已经系统地学习了类与实例化对象的概念定义、语法结构和核心特性。本文将深入探讨类与对象的默认成员函数，其中以下四个方面最为关键：构造函数、拷贝构造函数、析构函数以及操作符重载。
定义： 默认成员函数就是用户没有显式实现，编译器会自动生成的成员函数称为默认成员函数。
在一个类中，如果我们不显示编写的情况下，编译器会默认生成以下 4 个重要的默认成员函数：
默认成员函数是 C++ 中重要且复杂的知识点，需要从两个维度进行掌握：
什么是构造函数？
你可以把构造函数想象成产品的'出厂设置'，当你根据图纸（类）生产出一个新零件（对象）时，构造函数就是那个自动运行、负责把零件这一刻的状态（如赋值、分配内存）初始化好的程序。
误区： 构造函数不是给对象开辟空间的函数，而是给对象完成初始化的函数，对象开辟空间是函数栈帧需要完成的任务。
代码示例：显式实现一个构造函数
#include <iostream>
using namespace std;
class Student {
public:
int age;
// 构造函数的语法：类名 (形式参数) ---形式参数可有可无
// 1.无需返回值 2.名称与类名相同
Student() {
age = 18; // 设置默认值
cout << "调用了默认构造函数" << endl;
}
};
int main() {
Student s1; // 3.自动调用 Student()，age 变为 18
// s1.Student(); // error 不需要手动调用，在声明对象的时候自动调用
cout << s1.age << endl;
}
构造函数的语法： 类名 (形式参数)
- 无需返回值
- 名称与类名必须相同
- 形式参数可有可无，根据需求而定
无参构造函数： 顾名思义也就是不带任何参数的构造函数。
class Date {
public:
// 1.无参构造函数
Date() { _year = 1; _month = 1; _day = 1; }
private:
int _year;
int _month;
int _day;
};
带参数的构造函数： 允许你在创建对象时传入特定的值。
class Date {
public:
// 2.带参构造函数
Date(int year, int month, int day) {
_year = year; _month = month; _day = day;
}
private:
int _year;
int _month;
int _day;
};
全缺省的构造函数： 在未传参时设置默认的初始值，且允许你在创建对象时传入特定的值。
class Date {
public:
// 3.全缺省构造函数
Date(int year = 1, int month = 1, int day = 1) {
_year = year; _month = month; _day = day;
}
private:
int _year;
int _month;
int _day;
};
注意： 全缺省构造函数和无参构造函数不能同时出现，因为当你创建一个不带参数的对象时，编译器不知道该调用哪一个。
默认构造函数包括以下三种类型：
常见误区：
编译器生成这个构造函数有且仅有一个条件：你的类中没有定义任何默认构造函数。
这遵循'免费午餐原则'：
代码示例：
class A { // 什么都没写 -> 编译器生成 A() };
class B {
public:
B(int x) { cout << x << endl; } // 你写了一个带参构造 -> 编译器不再生成 B()
};
int main() {
// B b; // 错误写法，此时类中只含有一个带实参的构造函数，必须手动添上实参
B b(1); // 正确写法
}
前置知识： C++ 把类型分成内置类型 (基本类型) 和自定义类型。
这是最坑的地方，编译器生成的默认构造函数，对待不同类型的成员变量，态度是截然不同的：
A. 对待'自定义类型' (Class/Struct) —— 负责
如果你的类里包含其他的类对象（比如 string, vector 或另一个 class），编译器生成的构造函数会自动调用这些成员的默认构造函数。
B. 对待'内置类型' (int, double, 指针等) —— 摆烂
对于基础数据类型，编译器默认生成的构造函数什么都不做，这意味着这些变量的内存里原来是什么垃圾数据，现在还是什么。
代码示例 A：通过双栈实现队列，在队列类中无需实现构造函数，编译器默认生成的构造函数会主动调用 Stack 类的构造函数，完成队列类成员的初始化
typedef int STDataType;
class Stack {
public:
Stack(int n = 4) {
_a = (STDataType*)malloc(sizeof(STDataType) * n);
if (nullptr == _a) { perror("malloc 申请空间失败"); return; }
_capacity = n; _top = 0;
}
// ...
private:
STDataType * _a;
size_t _capacity;
size_t _top;
};
// 两个 Stack 实现队列
class MyQueue {
public:
// 编译器默认生成 MyQueue 的构造函数调用了 Stack 的构造，完成了两个成员的初始化
private:
Stack pushst;
Stack popst;
};
int main() {
MyQueue mq; // 编译器生成的构造函数，调用了 Stack 的默认构造函数。
return 0;
}
如果你在
Stack类中删除了显式定义的构造函数（即Stack(int n = 4) { ... }被移除），将会发生以下连带反应：
- 编译阶段：代码依然可以编译通过。原因：当你没有定义任何构造函数时，编译器会按照 C++ 标准自动为你生成一个隐式的默认构造函数（Implicit Default Constructor）。
MyQueue的默认构造函数会调用Stack的这个隐式默认构造函数。- 运行阶段：极度危险（未定义行为）。虽然编译通过了，但程序运行时处于一个不可用且危险的状态。编译器自动生成的默认构造函数对内置类型成员变量（如
int、指针、size_t）不做任何初始化处理。此时mq对象内部的pushst和popst状态如下：_a(指针)：变成了野指针，它存储的是内存中的随机值（垃圾值），而不是有效的堆内存地址，它没有指向malloc分配的空间。_capacity：随机值（垃圾值）。_top：随机值（垃圾值）。
代码示例 B：在日期类中未显式实现构造函数，使用编译器生成的构造函数，构造函数会给成员变量初始化垃圾数据
class Date {
public:
void Print() { cout << _year << "/" << _month << "/" << _day << endl; }
private:
int _year;
int _month;
int _day;
};
int main() {
Date d1; // 通过编译器生成的构造函数进行初始化，初始化了垃圾值
d1.Print(); // 输出垃圾值
}
代码示例 A 和 B：Boss 类中既包含自定义类型又包含内置类型
#include <iostream>
#include <string>
using namespace std;
class Inner {
public:
Inner() { cout << "Inner 被初始化了" << endl; }
};
class Boss {
public:
int number; // 内置类型
int* ptr; // 指针（也是内置类型）
Inner innerObj; // 自定义类型
// 这里没有写构造函数，编译器生成默认的 Boss()
};
int main() {
Boss b; // 调用编译器生成的默认构造
// 1. 自定义类型：安全
// 输出："Inner 被初始化了" (编译器帮你调用的)
// 2. 内置类型：危险！！！
cout << "Number: " << b.number << endl; // 输出可能是 0，也可能是 32767，也可能是 -842150451 (随机垃圾值)
// 3. 指针：极度危险！！！
// b.ptr 指向一个随机地址，如果不小心使用了 *b.ptr，程序直接崩溃
return 0;
}
结论： 永远不要信任编译器默认生成的构造函数来处理内置类型如：int、bool 或指针等。
构造函数是一种特殊的成员函数，主要用于在创建对象时初始化对象。
它的主要特点：
但是这三个函数有且只有一个存在，不能同时存在，并且无参构造函数和全缺省构造函数虽然构成函数重载，但是调用时会存在歧义。
什么是拷贝构造函数？
简单来说，它的作用是'克隆'：用一个已存在的对象来初始化一个新对象，这就像你有一份文件（对象 A），你放入复印机按一下，得到了一份一模一样的新文件（对象 B），这里复印机的功能就相当于拷贝构造函数的功能。
它的标准写法非常固定：
class ClassName {
public:
// 语法：类名 (const 类名& 别名)
ClassName(const ClassName& other) {
// 在这里做拷贝工作
}
};
这里有两个关键点必须记住（面试常考）：
- 引用
&是必须的：如果不传引用而是传值，传参过程本身又要拷贝，就会无限递归调用拷贝构造函数，导致栈溢出。const通常要加：保证在拷贝过程中，不会意外修改那个'原件'。
为什么拷贝构造函数的第一个参数必须要加引用？
1. 前置知识：按值传递的代价
在 C++ 中，当通过传值传参的方式调用函数时，编译器需要将实参对象复制给形参对象，此时复制的过程就会调用拷贝构造函数。
代码示例：调用 func1 函数
void func1(Date d) { d.print(); }
int main() {
// C++ 规定：传值传参必须要调用拷贝构造
Date d1;
func1(d1);
return 0;
}
当执行调用 func1 函数时分为两个步骤：
- 通过 Date 类中的拷贝函数，将实参 d1 通过 Date 拷贝构造函数复制给形参 d。
- 执行 func1 中的函数逻辑。
2. 灾难推演：如果去掉了 &
代码示例：假设我们将拷贝构造函数写成了这样（去掉了 &），通过调用拷贝构造函数让对象 d1 初始化新对象 d2。
class Date {
public:
// 1.默认构造函数
Date(int year = 1, int month = 1, int day = 1) { _year = year; _month = month; _day = day; }
// 2.拷贝构造函数
Date(Date d) { _year = d._year; _month = d._month; _day = d._day; }
void Print() { cout << _year << "-" << _month << "-" << _day << endl; }
private:
int _year;
int _month;
int _day;
};
int main() {
Date d1(2030, 1, 1);
Date d2(d1);
d2.Print();
}
详情解释：
- 程序执行 Date d2(d1)，准备调用拷贝构造函数。
- 系统发现拷贝构造函数 Date(Date d) 的参数是 Date d（按值传递）
- 为了调用这个函数，系统必须先把实参 d1 复制给形参 d
- 如何复制 d1 给 d 呢？系统必须调用 Date 的拷贝构造函数。
- 系统再次准备调用拷贝构造函数……回到第 2 步：为了调用这次新的拷贝构造函数，又必须先把参数复制一份……回到第 4 步：如何复制？调用拷贝构造函数…… 结果：这就形成了一个无限递归调用。
3. 为什么加了引用 & 就没事了？
上述代码出现错误的核心原因是：
- 当执行 Date d2(d1) 时，系统必须先通过 Date 类中的拷贝构造函数：Date(Date d)
- 需要先把实参 d1 复制给形参 d，然而实参 d1 不能正确的复制给形参 d。
当你加上 &，变成 Date(const Date& d) 时：
- 引用传递的含义是：形参 d 只是实参 d1 的一个别名。
- 传递参数时，不需要创建新的副本，也不需要分配新的内存，只是把 d1 的地址/身份传进去了。
- 既然不需要创建新对象，就不会触发'拷贝'动作，也就不会再次调用拷贝构造函数。
- 死循环被打破了，函数顺利进入内部执行赋值操作。
C++ 规定自定义类型对象进行拷贝行为必须调用拷贝构造，所以这里自定义类型传值传参和传值返回都会调用拷贝构造完成。
场景一：传值传参
当你把一个对象作为参数传给函数时，本质上是用实参初始化形参。
void func(Student s) // 这里的 s 是形参，它是 s1 的副本
{
// ...
}
int main() {
Student s1;
func(s1); // 调用 func，传入 s1
return 0;
}
调用逻辑：
- 开辟空间：函数 func 被调用，栈内存中为形参 s 开辟空间。
- 触发拷贝：既然 s 是新诞生的对象，且它的初值来源于 s1，编译器必须调用拷贝构造函数 Student(const Student&)。
- 结果：s 成为 s1 的一份独立拷贝。当函数结束后，s 被销毁，s1 不受影响。
场景二：传值返回
这是比较隐蔽的拷贝场景，当函数返回一个对象时，局部变量在函数结束时就会销毁，所以通过'拷贝'把值传出去。
Student createStudent() {
Student temp;
return temp; // 返回 temp
}
int main() {
Student s2 = createStudent();
return 0;
}
返回过程的详情解释：
- 创建临时对象：createStudent 结束前，编译器会在调用处的栈帧上创建一个'临时匿名对象'。
- 第一次拷贝：调用拷贝构造函数，把 temp 拷贝给这个'临时匿名对象'。（然后 temp 销毁）。
- 第二次拷贝：在 main 函数中，使用'临时匿名对象'去初始化 s2，再次调用拷贝构造函数。（然后临时对象销毁）。
若未显式定义拷贝构造，编译器会生成自动生成拷贝构造函数。
这遵循'免费午餐原则'：
A. 对内置类型成员变量会完成值拷贝/浅拷贝 (一个字节一个字节的拷贝)
B. 对自定义类型成员变量会调用他的拷贝构造。
代码示例 A：对内置类型的成员进行值拷贝
class Date {
public:
// 无参构造函数
Date() { _year = 1; _month = 1; _day = 1; }
// 拷贝构造函数
Date(const Date& d) { _day = d._day; _month = d._month; _year = d._year; }
void Print() { cout << _year << "/" << _month << "/" << _day << endl; }
private:
int _year;
int _month;
int _day;
};
int main() {
Date d1;
Date d2 = d1;
return 0;
}
代码示例 B：对自定义类型的成员，调用其类中的拷贝构造函数
#include <iostream>
#include <string>
using namespace std;
// 1. 一个自定义类型
class Wallet {
public:
Wallet() {}
// 自定义拷贝构造函数
Wallet(const Wallet& w) { cout << "【自定义类型】Wallet 的拷贝构造被调用了！" << endl; }
};
// 2. 包含各种成员的主类
class Person {
public:
int age; // 内置类型
int* scorePtr; // 内置类型
Wallet myWallet; // 自定义类型
// 这里我们【不写】拷贝构造函数
// 编译器会自动生成一个
};
int main() {
Person p1;
p1.age = 18;
int score = 100;
p1.scorePtr = &score;
cout << "--- 开始拷贝 ---" << endl;
Person p2 = p1; // 触发编译器生成的默认拷贝构造
cout << "p1 的年龄：" << p1.age << " " << "p2 的年龄：" << p2.age << endl;
cout << "p1 成绩的地址：" << p1.scorePtr << " " << "p2 成绩的地址：" << p2.scorePtr << endl;
cout << "--- 拷贝结束 ---" << endl;
// 验证结果：
// 1. Wallet 的拷贝构造被打印 -> 证明自定义类型调用了它的拷贝构造
// 2. p2.age 等于 18 -> 证明内置类型进行了值拷贝
// 3. p2.scorePtr 的地址 等于 p1.scorePtr -> 证明指针只拷贝了地址（浅拷贝）
return 0;
}
输出结果如下图所示：
浅拷贝是 C++ 编译器默认的复制行为，当你把一个对象赋值给另一个对象时，编译器会进行'按位拷贝'，即把原对象中所有变量的值直接复制给新对象。
代码示例：日期类的浅拷贝
class Date {
public:
// 无参构造函数
Date() { _year = 1; _month = 1; _day = 1; }
// 拷贝构造函数
Date(const Date& d) { _day = d._day; _month = d._month; _year = d._year; }
void Print() { cout << _year << "/" << _month << "/" << _day << endl; }
private:
int _year;
int _month;
int _day;
};
int main() {
Date d1;
Date d2 = d1;
return 0;
}
对于日期类来说，它仅对普通成员变量（如 int、char、double 等基本类型）进行拷贝操作，不涉及指针内存管理，浅拷贝操作是合理的。
代码示例：错误展示栈类的浅拷贝
typedef int STDataType;
class Stack {
public:
Stack(int n = 4) {
_a = (STDataType*)malloc(sizeof(STDataType) * n);
if (nullptr == _a) { perror("malloc 申请空间失败"); return; }
_capacity = n; _top = 0;
}
Stack(const Stack& st) {
_a = st._a; _capacity = st._capacity; _top = st._top;
}
~Stack() { free(_a); _a = nullptr; }
private:
STDataType * _a;
size_t _capacity;
size_t _top;
};
int main() {
Stack st1;
Stack st2 = st1;
return 0;
}
对于栈类而言，浅拷贝出现严重的缺陷 这就好比你把你家的钥匙（指针）复制了一把给你的朋友。现在，你们两个手里都有钥匙，但指向的是同一个房间（堆内存）。
- 数据共享冲突：如果你的朋友修改了房间里的东西，你回到家也会看到东西变了。
- 重复释放：这是最严重的问题。当你们两个的生命周期结束时（对象销毁），析构函数都会尝试'销毁房间'。
- 当对象 A 释放了内存，对象 B 尝试释放同一块已经被释放的内存，造成程序崩溃
为了克服浅拷贝的局限性，我们需要采用深拷贝机制。
在深拷贝过程中，当遇到指针成员时，会执行以下操作：
- 为新对象分配独立的内存空间
- 将原对象指针指向的数据完整复制到新内存中
- 使新对象的指针指向新分配的内存区域 这种处理方式确保了对象间的完全独立性。
代码示例：正确实现栈类的拷贝构造
typedef int STDataType;
class Stack {
public:
Stack(int n = 4) {
_a = (STDataType*)malloc(sizeof(STDataType) * n);
if (nullptr == _a) { perror("malloc 申请空间失败"); return; }
_capacity = n; _top = 0;
}
Stack(const Stack& st) {
// 需要对_a 指向资源创建同样大的资源再拷贝值
_a = (STDataType*)malloc(sizeof(STDataType) * st._capacity);
if (nullptr == _a) { perror("malloc 申请空间失败!!!"); return; }
memcpy(_a, st._a, sizeof(STDataType) * st._top);
_capacity = st._capacity;
_top = st._top;
}
~Stack() { free(_a); _a = nullptr; }
private:
STDataType * _a;
size_t _capacity;
size_t _top;
};
int main() {
Stack st1;
Stack st2 = st1;
return 0;
}
- 避免了数据共享冲突：对象 st1 数据进行改变，对象 st2 的数据不会受到影响
- 避免了重复释放：当 st1 和 st2 进行释放空间时，两者不会出现重复释放而是独立地释放各自的空间
特别注意： 若返回的是函数局部对象（函数结束后即销毁），则不能使用引用返回，否则会导致野引用（类似于野指针），只有当返回对象在函数结束后仍然有效时，才适合使用引用返回来减少拷贝开销。
什么是析构函数？
析构函数是面向对象编程（尤其是 C++）中的一个核心概念，简单来说，它是构造函数的'反义词'。
如果说构造函数是'对象出生时的初始化（比如分配资源）'，那么析构函数就是'对象临终前的遗言（比如清理资源）'。
核心语法特征：
~。代码示例：显式实现析构函数
class MyClass {
public:
// 构造函数
MyClass() { /* 初始化代码 */ }
// 析构函数
~MyClass() { /* 清理代码 */ }
};
代码示例：清理动态数组资源
typedef int STDataType;
class Stack {
public:
Stack(int n = 4) {
_a = (STDataType*)malloc(sizeof(STDataType) * n);
if (nullptr == _a) { perror("malloc 申请空间失败"); return; }
_capacity = n; _top = 0;
}
~Stack() { free(_a); _a = nullptr; }
private:
STDataType * _a;
size_t _capacity;
size_t _top;
};
注意： 在构造函数中动态分配内存资源时，必须显式实现析构函数来释放这些资源，以防止内存泄漏。
离开作用域 (栈对象)： 在函数内部定义的局部变量，当函数执行完毕或遇到右大括号 } 时。
代码示例：局部对象在函数执行完毕时自动调用析构函数
#include <iostream>
using namespace std;
class Date {
public:
// 无参构造函数
Date() { _year = 1; _month = 1; _day = 1; }
// 析构函数
~Date() { cout << "析构函数被调用" << endl; }
private:
int _year;
int _month;
int _day;
};
void testScope() {
cout << "---testScope 函数开始 ---" << endl;
// 局部对象，创建在栈 (Stack) 上
Date obj;
cout << "--- testScope 函数即将结束 ---" << endl;
} // <--- 遇到这个右大括号，obj 的生命周期结束，析构函数自动触发
int main() {
cout << "---执行 main 函数，准备调用 testScope 函数---" << endl;
testScope();
cout << "---回到 main 函数，继续执行---" << endl;
return 0;
}
打印结果如下：
delete 操作： 当你拥有一个指向堆对象的指针，并显式调用 delete pointer 时进行析构函数的调用。
代码示例：
class Date {
public:
// 无参构造函数
Date() { _year = 1; _month = 1; _day = 1; }
// 析构函数
~Date() { cout << "析构函数被调用" << endl; }
private:
int _year;
int _month;
int _day;
};
void testHeap() {
cout << "--- testHeap 函数开始 ---" << endl;
// 堆对象，使用指针指向它
Date* ptr = new Date;
cout << "--- 做一些操作 ---" << endl;
// 必须手动调用 delete，否则析构函数永远不会执行！
delete ptr; // <--- 只有这行代码执行时，析构函数才触发
cout << "--- testHeap 函数结束 ---" << endl;
}
int main() {
cout << "---执行 main 函数，准备调用 testHeap 函数---" << endl;
testHeap();
cout << "---回到 main 函数，继续执行---" << endl;
return 0;
}
打印结果如下：
编译器生成这个析构函数有且仅有一个条件：你的类中没有定义任何析构函数。
这遵循'免费午餐原则'：
A. 对待'自定义类型' (Class/Struct) —— 负责
如果你的类里包含其他的类对象（比如 string, vector 或另一个 class），编译器生成的析构函数会自动调用这些成员的析构函数。
B. 对待'内置类型' (int, double, 指针等) —— 摆烂
对于基础数据类型，编译器默认生成的构造函数什么都不做。
代码示例 A：通过双栈实现队列，在队列类中无需实现析构函数函数，编译器默认生成的析构函数会主动调用队列类中自定义成员栈类的析构函数。
typedef int STDataType;
class Stack {
public:
Stack(int n = 4) {
_a = (STDataType*)malloc(sizeof(STDataType) * n);
if (nullptr == _a) { perror("malloc 申请空间失败"); return; }
_capacity = n; _top = 0;
}
~Stack() { free(_a); _a = nullptr; }
private:
STDataType * _a;
size_t _capacity;
size_t _top;
};
// 两个 Stack 实现队列
class MyQueue {
public:
// 编译器默认生成 MyQueue 的构造函数调用了 Stack 的构造，完成了两个成员的初始化
// 编译器默认生成 MyQueue 的析构函数调用了 Stack 的析构，释放的 Stack 内部的资源
private:
Stack pushst;
Stack popst;
// int size;
};
注意： 即使你在队列类中实现了析构函数，编译器不信任用户实现的析构函数，仍然会调用 Stack 类中的析构函数完成自定义成员的资源释放，但如果栈类中也没有实现析构函数则会出现资源未释放，导致内存泄漏。
代码示例 B：在栈类中未显式实现析构函数，使用编译器生成的析构函数什么都不做，不会主动释放开辟的堆内存空间。
typedef int STDataType;
class Stack {
public:
Stack(int n = 4) {
_a = (STDataType*)malloc(sizeof(STDataType) * n);
if (nullptr == _a) { perror("malloc 申请空间失败"); return; }
_capacity = n; _top = 0;
}
private:
STDataType * _a;
size_t _capacity;
size_t _top;
};
特别注意： 编译器生成的默认析构函数回收了栈区的 _a（那把钥匙），堆区的那块内存（那个房间）依然被标记为'占用'，但因为钥匙没了，你再也无法访问它，也无法释放它，这就导致了内存泄漏。
如果在同一个函数里定义了多个对象，它们的析构顺序遵循栈 (Stack) 的特性：后进先出 (LIFO)。
代码示例：
class Date {
public:
// 无参构造函数
Date() { _year = 1; _month = 1; _day = 1; }
// 析构函数
~Date() { cout << "析构函数被调用" << endl; }
private:
int _year;
int _month;
int _day;
};
int main() {
Date d1;
Date d2;
}
注意： 析构顺序：d2 完成析构 -> d1 完成析构
对于数组对象而言：数组元素的析构顺序与构造顺序严格相反。
核心规则
0 -> N)。N -> 0)。代码示例：
#include <iostream>
using namespace std;
class Item {
private:
int id; // 对象的唯一编号
static int count; // 静态计数器，用于记录创建顺序
public:
// 构造函数
Item() { id = count++; // 赋值当前计数，并将计数器 +1
cout << "构造：Item [" << id << "] (地址：" << this << ")" << endl; }
// 析构函数
~Item() { cout << "析构：Item [" << id << "] (地址：" << this << ")" << endl; }
};
// 初始化静态成员变量
int Item::count = 0;
int main() {
cout << "--- 数组作用域开始 ---" << endl;
// 创建一个包含 3 个对象的数组
// 这里的 Item 相当于在栈上连续排列
Item myArray[3];
cout << "--- 数组作用域即将结束 ---" << endl;
return 0; // main 函数结束，myArray 生命周期结束，触发析构
}
打印结果如下：
这些对象像是'元老'，程序的生命不结束，它们就不退休。
main 开始前出生，main 结束后销毁。main 结束后销毁。#include <iostream>
#include <string>
using namespace std;
class Date {
public:
// 带参构造，传入名字
Date(string name) : _name(name) { cout << "构造：" << _name << endl; }
~Date() { cout << "析构：" << _name << endl; }
private:
string _name;
};
Date globalObj("Global 对象"); // 1. 全局先构造
void func() {
static Date staticObj("Static 对象"); // 3. 静态局部后构造
}
int main() {
cout << "--- main 开始 ---" << endl;
// 2. 进入 main
func();
cout << "--- main 结束 ---" << endl;
return 0;
}
打印结果如下：
~ 构成什么是操作符重载？
举例说明： 在 C++ 中，
1 + 2很容易理解（整数相加）。但是，如果你定义了一个Person类，person1 + person2是什么意思？编译器默认不知道。 操作符重载就是你告诉编译器：'当你在两个Person对象之间看到+号时，请执行这段代码。' 本质上，操作符重载只是函数调用的一种语法糖。
核心概念： C++ 支持通过运算符重载为自定义类型赋予新的运算语义，当对类对象使用运算符时，编译器会自动将其转换为对应的重载函数调用。
注意：
语法规则： 返回类型（ReturnType） + 关键字操作符（operatorOp）+ 参数（Parameters）
- 返回类型：可以是：void、int、bool、返回'引用'、返回'对象'等
- 关键字和操作符 关键字：必须是
operator。 操作符 Op：必须是 C++ 现有的符号。operator+(重载加法)operator-(重载减法)operator+=(重载加等) ...- 参数：重载运算符函数的参数个数和该运算符作用的运算对象数量一样多。 一元运算符：仅需一个参数 二元运算符：需要两个参数，对于二元运算符而言，其左侧的运算对象传给第一个参数，其右侧运算对象传给第二个参数。 注意： 有 5 个特殊的符号，绝对禁止重载（死记硬背即可，平时也用不到重载它们）：
.(点号，成员访问)、::(双冒号，域解析)、sizeof(看大小)、?:(三元运算符)、.*(成员指针访问)
代码示例：对 Person 这个自定义类型实现'＋'运算符重载
#include <iostream>
using namespace std;
class Person {
public:
Person(int age) { _age = age; }
// private: int _age;
};
int operator+(Person a, Person b) {
return a._age + b._age;
}
int main() {
Person p1(18);
Person p2(20);
cout << "p1 和 p2 的总年龄为：" << p1 + p2 << endl;
}
代码详解： 当你写下 p1 + p2 时，C++ 编译器做了以下动作：
- 扫描：编译器看到两个 Person 对象中间有一个 + 号。
- 查找：它去寻找是否存在一个函数签名匹配 operator+(Person, Person)。
- 调用：它找到了你写的全局函数，于是将 p1 + p2 翻译成了函数调用：operator+(p1, p2);
- 执行：函数内部提取了 p1 的 _age (18) 和 p2 的 _age (20)，相加得到整数 38。
- 返回：将 38 返回给 cout 进行打印。 可以简单理解为为一个普通函数调用 int 为返回类型 operator+ 为函数名 Person a, Person b 为形参
1. 全局函数的运算符重载
当我们将运算符重载为全局函数时，该函数不属于任何类，它只是一个普通的函数，名字叫 operatorX。
+）：需要 2 个参数（左侧和右侧）。代码示例：通过全局函数的运算符重载，实现二元操作符＋
class Point {
public:
Point(int x, int y) : x(x), y(y) {}
int x, y;
};
// 调用形式：p1 + p2 <=> operator+(p1, p2)
Point operator+(const Point& a, const Point& b) {
return Point(a.x + b.x, a.y + b.y);
}
缺陷： 全局函数的运算符重载会面临对象访问私有成员变量的问题，在类外没有足够权限访问类内的私有成员。 解决办法：
- 将私有成员放为公有成员 (不推荐，破坏了封装性)
- 自定义类提供 getxxx 函数，从而访问私有成员
- 通过声明为友元函数
- 重载为成员函数
2. 成员函数的运算符重载
当我们将运算符重载为类的成员函数时，该函数是类的一部分。
this 指针指向的对象）。this）。
+）：只需要 1 个参数（右侧操作数）。++）：不需要参数（或者是占位参数用于区分前/后置）。代码示例：通过在类内实现运算符重载函数，完成二元操作符＋
class Point {
public:
int x, y;
Point(int x, int y) : x(x), y(y) {}
// 调用形式：p1 + p2 <=> p1.operator+(p2)
Point operator+(const Point& other) {
// 这里的 x 和 y 指的是 p1 的属性
// other.x 和 other.y 指的是 p2 的属性
return Point(x + other.x, y + other.y);
}
};
这里有一套通用的'拇指法则' (Rule of Thumb)：
- 必须用成员函数的情况：
- = (赋值)
- [] (下标)
- () (函数调用)
- -> (成员访问) 这些运算符与对象的状态紧密相关，C++ 语法强制要求它们必须是成员。
- 必须用全局函数的情况：
- << (流插入)
(流提取) 原因：cout << p 的左操作数是 ostream 系统类，我们无法修改 ostream 的源码来添加成员函数，只能通过全局函数 operator<<(ostream& out, Point p) 来实现。
- 建议用全局函数的情况：
- 所有的二元算术运算符 (+, -, *, /)
- 比较运算符 (==, !=, <) 这样可以保持操作数的对称性，允许左侧操作数进行隐式类型转换。
- 建议用成员函数的情况： 复合赋值运算符 (+=, -=, *=)。 因为 a += b 通常会改变 a 自身的状态（修改 this），且返回值通常是 *this 的引用。
在重载 ++ 运算符时，存在前置 ++ 和后置 ++ 两种形式，它们都使用 operator++ 作为函数名，这会导致难以区分。
为了解决这个问题，C++ 规定：重载后置 ++ 运算符时，需要额外添加一个 int 类型的形参，这样就能通过函数重载机制来明确区分前置和后置 ++ 运算符。
1. 前置 ++ 进行函数重载
前置递增的逻辑是：'先加，后用'。
Type&)。这样做既提高了效率（避免拷贝），又支持链式调用Type& operator++()代码示例：前置 ++ 运算符重载函数的实现
// 类内部成员函数示例
MyInteger& operator++() {
this->value += 1; // 1. 先自增
return *this; // 2. 返回对象本身（引用）
}
2. 后置 ++ 进行函数重载
后置递增的逻辑是：'先用，后加'。
int 类型的占位参数。这个参数在调用时不需要传递，仅用于编译器区分签名。Type)，也就是一个副本，因为返回的是局部临时变量（旧值），不能返回引用。Type operator++(int)代码示例：后置 ++ 运算符重载函数的实现
// 类内部成员函数示例
MyInteger operator++(int) // int 参数仅用于区分，不使用
{
MyInteger temp = *this; // 1. 记录当前状态（旧值）
this->value += 1; // 2. 对象自增
return temp; // 3. 返回旧值的副本
}
代码示例：综合使用前置 ++ 和后置 ++
#include <iostream>
using namespace std;
class MyInt {
private:
int value;
public:
MyInt(int v = 0) : value(v) {}
// 1. 前置 ++
// 返回引用，允许链式操作，效率高
MyInt& operator++() {
value++;
return *this;
}
// 2. 后置 ++
// 必须带 int 参数，返回 const 值或普通值 (副本)
MyInt operator++(int) {
MyInt temp = *this; // 保存旧值
value++; // 自身加 1
return temp; // 返回旧值
}
// 3. 用于打印测试
void print() const {
cout << "Value: " << value << endl;
}
};
int main() {
MyInt a(10);
// 测试前置 ++
cout << "--- 测试前置 ++ ---" << endl;
MyInt b = ++a; // a 变成 11，b 等于 a 的新值 (11)
a.print(); // 11
b.print(); // 11
// 测试后置 ++
cout << "--- 测试后置 ++ ---" << endl;
MyInt c = a++; // c 保存 a 的旧值 (11)，a 变成 12
a.print(); // 12
c.print(); // 11
return 0;
}
```\n
类似于前置 ++ 和后置 ++ 的重载方式，我们同样可以实现前置 -- 和后置 -- 的运算符重载。
##### ② 流插入 << 和 流提取 >> 的运算符重载
**前置知识：** 在 C++ 中，`cout` 和 `cin` 是我们最常打交道的两个'老朋友'，它们是 C++ 标准库预定义好的'全局对象'。
- `cout` (标准输出流)：它是一个 ostream 类的全局对象。它的任务是管理输出缓冲区，把数据推送到显示器上。
- `cin` (标准输入流)：它是一个 istream 类的全局对象。它的任务是监听键盘输入，把数据存入缓冲区等待程序读取
**核心逻辑：** 在 C++ 中，重载流插入运算符 (<<) 和流提取运算符 (>>)，目的是让自定义类支持 cout 和 cin 的标准方式。
**核心规则：** 必须实现为全局函数（非成员函数），并通常声明为类的 friend（友元）。
**原因：** 如果写成成员函数，调用方式会变成 obj << cout，这非常反直觉。为了保持 cout << obj 的习惯，运算符的左操作数必须是 ostream，右操作数才是你的对象。
**1. 流插入运算符 <<**
**核心作用：** 用于输出对象的状态。
**函数原型：** `ostream& operator<<(ostream& out, const Type& obj)`
**参数 1 (out)：** ostream 的引用（即 cout），必须引用，因为流对象禁止拷贝。
**参数 2 (obj)：** 要输出的对象，必须加 const，因为输出不应修改对象。
**返回值：** 返回 out 的引用（即 cout），以支持链式调用 (如 cout << a << b).
**代码示例：**
```cpp
// 在类内部声明友元
friend ostream& operator<<(ostream& out, const MyClass& obj);
// 全局实现
ostream& operator<<(ostream& out, const MyClass& obj) {
out << "Data: " << obj.data; // 自定义输出格式
return out; // 必须返回流对象以支持链式调用
}
2. 流提取运算符 >>
核心作用： 用于从输入流读取数据并填充到对象中。
函数原型： istream& operator>>(istream& in, Type& obj)
参数 1 (in)： istream 的引用（即 cin），必须引用，因为流对象禁止拷贝。
参数 2 (obj)： 接收数据的对象，不能加 const，因为我们要修改它。
返回值： 返回 in（即 cin）的引用。
代码示例：
// 在类内部声明友元
friend istream& operator>>(istream& in, MyClass& obj);
// 全局实现
istream& operator>>(istream& in, MyClass& obj) {
// 实际开发中通常会检查输入是否合法:
// if(in) ...
in >> obj.data;
return in;
}
代码示例：综合使用流插入 << 和 流提取 >>
#include <iostream>
using namespace std;
class Complex {
private:
int real; // 实部
int imag; // 虚部
// 声明友元函数，允许它们访问 private 成员
friend ostream& operator<<(ostream& out, const Complex& c);
friend istream& operator>>(istream& in, Complex& c);
public:
Complex(int r = 0, int i = 0) : real(r), imag(i) {}
};
// 1. 重载 << (输出)
// 格式示例：3+4i
ostream& operator<<(ostream& out, const Complex& c) {
out << c.real << "+" << c.imag << "i";
return out;
}
// 2. 重载 >> (输入)
// 用户输入示例：3 4
istream& operator>>(istream& in, Complex& c) {
cout << "请输入实部和虚部 (空格分隔): ";
in >> c.real >> c.imag;
return in;
}
int main() {
Complex c1;
// 测试输入 >>
cin >> c1;
// 测试输出 << (支持链式调用)
cout << "你输入的复数是：" << c1 << endl;
return 0;
}
什么是赋值运算符重载？
赋值运算符重载是一个默认成员函数，用于实现两个已存在对象之间的拷贝赋值。
需要注意的是，它与拷贝构造函数有所区别：拷贝构造函数用于在创建新对象时，用另一个对象来初始化它。
核心语法：
ClassName& operator=(const ClassName& 参数名)
- 返回类型：ClassName& 核心作用：1. 通过返回类型，支持链式赋值
a = b = c;2. & (引用)：避免拷贝返回，提高效率- 函数名：operator=
- 参数：const ClassName& 核心作用：1. & (引用)：避免拷贝实参，提高效率。2. const：保证右值（源对象）在赋值过程中不被修改。
代码示例：
class Date {
public:
// 赋值重载拷贝函数
Date& operator=(const Date& d) {
// 检查自己给自己赋值的情况
if (this == &d) {
return *this;
}
// d1 = d2 表达式的返回对象应该为 d1，也就是*this
_year = d._year;
_month = d._month;
_day = d._day;
return *this;
}
private:
int _year;
int _month;
int _day;
};
1. 生成的条件
如果你没有自己编写赋值运算符重载（operator=），编译器会自动为你生成一个。
这遵循'免费午餐原则'：
2. 行为逻辑
内置类型成员变量会进行值拷贝（逐字节复制），而自定义类型成员变量则会调用其赋值运算符重载函数。
A. 对待'自定义类型' (Class/Struct) —— 负责
当类中包含自定义类对象（如 std::string、std::vector 或其他类）时，编译器默认生成的赋值运算符重载函数，会调用这些成员对象自身的赋值运算符重载函数。（operator=）。
B. 对待'内置类型' (int, double, 指针等) —— 摆烂
对于基础类型 (int, double, char, bool)，直接复制数值，对于指针类型 (int*, char*) 直接复制地址值，这是最危险的地方，因为它不复制指针指向的内容。
代码示例：
class User {
public:
User& operator=(const User& other) {
// 1. 基础类型：直接拷贝数值
this->id = other.id;
// 2. 类对象：调用 std::string 的赋值运算符
// std::string 内部实现了深拷贝，所以这一步是安全的！
this->name = other.name;
// 3. 指针类型：只拷贝地址（浅拷贝）
// 危险！两个 User 对象现在共享同一个 double 数组
this->score = other.score;
return *this;
}
private:
int id; // 基础类型
std::string name; // 类对象类型（标准库类）
double* score; // 指针类型
};
C++ 有一个著名的原则：如果你需要显式定义以下其中一个，你通常需要定义全部三个：
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online
将字符串、文件或图像转换为其 Base64 表示形式。 在线工具，Base64 文件转换器在线工具，online
将 Markdown（GFM）转为 HTML 片段，浏览器内 marked 解析；与 HTML转Markdown 互为补充。 在线工具，Markdown转HTML在线工具，online
将 HTML 片段转为 GitHub Flavored Markdown，支持标题、列表、链接、代码块与表格等；浏览器内处理，可链接预填。 在线工具，HTML转Markdown在线工具，online
通过删除不必要的空白来缩小和压缩JSON。 在线工具，JSON 压缩在线工具，online
将JSON字符串修饰为友好的可读格式。 在线工具，JSON美化和格式化在线工具，online