1.类的默认成员函数

默认成员函数就是用户没有显示实现，编译器会自动生成的成员函数称为默认成员函数。一个类我们不写的情况下编译器会默认生成以下的6个默认成员函数。

（1）构造函数：主要完成初始化的工作

（2）析构函数：主要完成销毁清理的工作

（3）拷贝构造函数：使用同类对象初始化创建对象

（4）赋值重载：主要是把一个对象赋值给另一个对象

（5）普通对象取地址重载：主要用于特殊情况，如安全敏感的应用、自定义内存管理或调试目的。在大多数日常编程中，不需要重载这个运算符。

（6）const对象取地址重载：和普通对象取地址重载一样。日常编程中不需要重载这个运算符。

以上六种默认成员函数我们主要学习前四种。

1.1构造函数

构造函数是特殊的成员函数，构造函数虽然名称是构造，但是构造函数的主要任务是实例化时初始化对象，并不是开空间创造对象（我们常使用的局部对象是栈帧创建时，空间就开好了）。

构造函数的语法特点如下

（1）函数名可以和类名相同

class MyClass {
public:MyClass() { // 构造函数与类名相同// 初始化代码}
};

（2）无返回值，无返回类型。甚至不能使用void（C++规定是这样，不用纠结）

（3）对象实例化时系统会自动调用对应的构造函数

MyClass obj; // 构造函数自动调用

（4）构造函数可以重载

一个类可以有多个构造函数，只要它们的参数列表不同。

class MyClass {
public:MyClass() { // 默认构造函数// 初始化代码}MyClass(int value) { // 带参数的构造函数// 使用value初始化}MyClass(int a, double b) { // 另一个重载// 使用a和b初始化}
};

（5）可以有默认参数

class MyClass {
public:MyClass(int a = 0, double b = 0.0) {// 使用默认参数或提供的值初始化}
};

（6）如果类中没有显式定义构造函数，则C++编译器会自动生成⼀个无参的默认构造函数，⼀旦用户显式定义编译器将不再生成。

#include<iostream>
using namespace std;
class Stack {
public:Stack()//无参的默认构造函数{}
private:int* _date;int _top;int _capacity;
};
int main()
{Stack s1;return 0;
}

这里我们来调试观察s1

会发现s1会被编译器自动生成默认构造函数

1.2析构函数

析构函数与构造函数功能相反，析构函数不是完成对对象本身的销毁，比如局部对象是存在栈帧的，函数结束栈帧销毁，他就释放了，不需要我们管，C++规定对象在销毁时会自动调用析构函数，完成对象中资源的清理释放工作。

析构函数的特点如下：

（1）在类名前加~

class MyClass {
public:~MyClass() { // 析构函数// 清理代码}
};

（2）无参数，无返回值也，不能被重载。一个类只能有一个析构函数 (这里跟构造类似，也不需要加void)

class MyClass {
public:~MyClass() { // 正确// 清理代码}// ~MyClass(int x) { } // 错误：析构函数不能有参数
};

（3）当对象离开其作用域或被显示删除时，析构函数会自动调用。这里跟构造函数类似，我们不写编译器自动生0成的析构函数对内置类型成员不做处理，自定类型成员会调用他的析构函数。

{MyClass obj; // 对象创建// 使用对象...
} // 对象离开作用域，析构函数自动调用MyClass* ptr = new MyClass();
delete ptr; // 析构函数被调用

（4）还需要注意的是我们显示写析构函数，对于自定义类型成员也会调用他的析构，也就是说自定义类型成员无论什么情况都会自动调用析构函数。

（5）对于继承层次中的对象，析构函数的调用顺序与构造函数相反：派生类的析构函数 成员对象的析构函数（按声明逆序）基类的析构函数

class Base {
public:~Base() { std::cout << "Base destructor" << std::endl; }
};class Member {
public:~Member() { std::cout << "Member destructor" << std::endl; }
};class Derived : public Base {
private:Member member;
public:~Derived() { std::cout << "Derived destructor" << std::endl; }
};// 创建Derived对象然后销毁
// 输出顺序:
// Derived destructor
// Member destructor
// Base destructor

1.3拷贝构造函数

拷贝构造是一种特殊的构造函数，用于创建一个新对象来当已存在对象的副本。以下是拷贝构造的主要特点。

（1）函数名与类名相同，没有返回类型。参数必须是同类型对象的引用，通常为const引用。如果不引用可能会出现无限递归的现象。

class MyClass {
public:// 正确的拷贝构造函数MyClass(const MyClass& other) {// 复制逻辑}// 错误的拷贝构造函数示例// MyClass(MyClass other) { } // 错误：值传递会导致无限递归// MyClass(MyClass* other) { } // 错误：这不是拷贝构造函数
};

如果不用引用导致递归，编译器会报错

（2）C++规定自定义类型对象进行拷贝行为必须调用拷贝构造，所以自定义类型传值传参和传值返回都会调用拷贝构造完成。

MyClass obj1;
MyClass obj2 = obj1;  // 调用拷贝构造函数
MyClass obj3(obj1);   // 调用拷贝构造函数void func(MyClass param); // 值传递参数时调用拷贝构造函数
func(obj1);              // 调用拷贝构造函数MyClass func2() {MyClass local;return local;       // 可能调用拷贝构造函数（取决于编译器优化）
}

（3）若未显式定义拷贝构造，编译器会生成自动生成拷贝构造函数。自动生成的拷贝构造对内置类型成员变量会完成值拷贝/浅拷贝(⼀个字节⼀个字节的拷贝)，对自定义类型成员变量会调用他的拷贝构造。

默认拷贝构造函数的陷阱。浅拷贝构造

这对于简单类足够使用，但是遇到指针类型就会出现双重释放的问题

class ShallowCopyExample {
private:int* data;public:ShallowCopyExample(int value) {data = new int(value);}// 默认拷贝构造函数执行浅拷贝：// ShallowCopyExample(const ShallowCopyExample& other) : data(other.data) {}~ShallowCopyExample() {delete data;}
};// 使用示例
int main()
{ShallowCopyExample obj1(42);ShallowCopyExample obj2 = obj1; // 浅拷贝：两个对象的data指向同一内存return 0;
}
// 问题：obj2析构时会释放内存，然后obj1析构时再次释放同一内存 → 双重释放错误！

因为浅拷贝构造的指针指向了同一块内存，我们用编译器调试或者转到反汇编就可以清楚的看到

那么我们遇到带有指针的成员变量，就需要用自定义拷贝构造来实现深拷贝。

#include <iostream>
#include <cstdlib>  // 包含 malloc 和 free
#include <cstring>  // 包含 strcpyclass StringWithMalloc
{
private:char* data;size_t length;public:// 构造函数 - 使用 malloc 分配内存StringWithMalloc(const char* str = ""){length = strlen(str);data = (char*)malloc(length + 1);  // 使用 malloc 分配内存if (data != nullptr) {strcpy(data, str);}else {length = 0;}std::cout << "构造函数: " << (data ? data : "NULL")<< " (地址: " << (void*)data << ")" << std::endl;}// 自定义拷贝构造函数 - 使用 malloc 实现深拷贝StringWithMalloc(const StringWithMalloc& other){length = other.length;data = (char*)malloc(length + 1);  // 使用 malloc 分配新内存if (data != nullptr) {strcpy(data, other.data);}else {length = 0;}std::cout << "拷贝构造函数: " << (data ? data : "NULL")<< " (新地址: " << (void*)data << ")" << std::endl;}// 析构函数 - 使用 free 释放内存~StringWithMalloc(){std::cout << "析构函数: " << (data ? data : "NULL")<< " (地址: " << (void*)data << ")" << std::endl;free(data);  // 使用 free 释放内存data = nullptr;  // 防止悬空指针}
};

（4）传值返回会产生⼀个临时对象调用拷贝构造，传值引用返回，返回的是返回对象的别名(引用)，没有产生拷贝。但是如果返回对象是⼀个当前函数局部域的局部对象，函数结束就销毁了，那么使用引用返回是有问题的，这时的引用相当于⼀个野引用，类似⼀个野指针⼀样。传引用返回可以减少拷贝，但是⼀定要确保返回对象，在当前函数结束后还在，才能用引用返。

1.4赋值运算符重载

1.4.1运算符重载

Class Data//定义一个类
{//......
}
int main()
{Data d1;Data d2;d1-d2//这里编译器没有对应的运算符重载会报错return 0;
}

（2）运算符重载是具有特殊名字的函数，他的名字是由operator和后面要定义的运算符共同构成。和其他函数⼀样，它也具有其返回类型和参数列表以及函数体。

基本语法如下

返回类型 operator操作符(参数列表) {// 函数体
}

（3）重载运算符函数的参数个数和该运算符作用的运算对象数量⼀样多。⼀元运算符有⼀个参数，⼆元运算符有两个参数，⼆元运算符的左侧运算对象传给第⼀个参数，右侧运算对象传给第⼆个参数。

（4）如果⼀个重载运算符函数是成员函数，则它的第⼀个运算对象默认传给隐式的this指针，因此运算符重载作为成员函数时，参数比运算对象少⼀个。

（5）运算符重载以后，其优先级和结合性与对应的内置类型运算符保持⼀致。

（6）不能通过连接语法中没有的符号来创建新的操作符：比如operator@。

（7）.*   ::    sizeof    ?:    . 注意以上5个运算符不能重载。

（8）重载操作符至少有⼀个类类型参数，不能通过运算符重载改变内置类型对象的含义

int operator+(int x, int y)//里面没有自定义的类，都是内置类型不可重载

1.4.2赋值运算符重载的特点