食用指南：本文在有C基础的情况下食用更佳
🍀本文前置知识： C++类
♈️今日夜电波： アイネクライネ —米津玄師
1:11 ━━━━━━️💟──────── 4:50
🔄 ◀️ ⏸ ▶️ ☰
💗关注👍点赞🙌收藏您的每一次鼓励都是对我莫大的支持😍
目录
一、构造和析构函数的初识
概述
定义
构造函数：
析构函数：
二、构造函数
构造函数的分类
无参构造
有参构造
构造函数的调用规则
三、析构函数
特别注意：
析构函数的语法
四、拷贝构造函数
什么是拷贝构造函数？
拷贝构造函数的语法
一句重要的话
拷贝构造的调用
拷贝构造注意事项
浅拷贝与深拷贝
五、构造函数的调用
结论
一、构造和析构函数的初识
概述
构造函数（Constructor）在创建对象时被调用，用于初始化对象的成员变量和执行其他必要的操作。它的作用是确保对象在创建后处于一个合理的状态。构造函数具有与类同名的特点，并且没有返回类型。可以有多个构造函数，具有不同的参数列表，称为函数重载。
析构函数（Destructor）在对象被销毁时自动调用，用于进行清理操作，例如释放动态分配的内存或关闭打开的文件等。析构函数与类同名，但前面加上一个波浪号（~）。与构造函数不同，析构函数没有参数列表，也没有返回类型。
简而言之：构造函数和析构函数，这两个函数将会被编译器自动调用，构造函数完成对象的初始化动作，析构函数在对象结束的时候完成清理工作。
特别注意：对象的初始化和清理工作是编译器强制我们要做的事情，即使你不提供初始化操作和清理操作，编译器也会给你增加默认的操作，只是这个默认初始化操作不会做任何事。
构造函数：实例化对象的时候系统自动调用。 析构函数：对象释放的时候系统自动调用。
定义
构造函数：
构造函数函数名和类名相同，没有返回类型，连void都不可以，但可以有参数，可以重载。
析构函数：
析构函数函数名是在类名前面加”~”组成,没有返回类型，连void都不可以,不能有参数，
不能重载。
栗子：
#include<iostream>
using namespace std;
class Data
{
public:
int num;
public:
//构造函数(无参的构造)
Data()
{
num = 0;
cout<<"无参的构造函数"<<endl;
} //构造函数（有参的构造）
Data(int n)
{
num = n;
cout<<"有参的构造函数"<<endl;
}
//析构函数
~Data()
{
cout<<"析构函数"<<endl;
}
};
void test01()
{
//类实例化对象 系统自定调用构造函数
Data ob;
Data op(1);
//函数结束的时候 局部对象ob 被释放 系统自动调用析构函数
}
int main(int argc, char *argv[])
{
test01();
return 0;
}
二、构造函数
构造函数的分类
按参数类型：分为无参构造函数和有参构造函数
按类型分类：普通构造函数和拷贝构造函数(复制构造函数)
无参构造
没有参数的构造函数，再次强调：构造函数没有返回类型！例子：创建一个Pico类，存放数量以及价格，在调用此类时初始化默认都为0。
class Pico
{
public:
int num;
int price;
Pico()
{
num = 0, price = 0;
cout << "无参数构造" << endl;
cout << "初始化num = " << num << " price= " << price << endl;
}
};
void text()
{
Pico op;
}
有参构造
如果我们想要自定义初始化，能够随心所欲的初始化数值，那么我们可以在无参的基础上加上定义参数传入。下面为在上个例子的基础上的变化。
class Pico
{
public:
int num;
int price;
Pico(int n,int m)
{
num = n, price = m;
cout << "有参数构造" << endl;
cout << "初始化num = " << num << " price= " << price << endl;
}
};
void text()
{
Pico op(1,3);
}
构造函数的调用规则
1、如果用户提供了有参构造 将屏蔽 系统的默认构造函数
2、如果用户提供了有参构造 不会屏蔽 系统的默认拷贝构造函数
3、如果用户提供了拷贝构造函数 将屏蔽 系统的默认构造函数、默认拷贝构造函数
三、析构函数
一个类只有一个析构函数，并且如果析构函数没有被定义，系统将默认定义一个析构函数。C++编译系统将在对象的生命周期结束后自动调用析构函数。析构函数将回收系统的资源。比如临时开辟的空间等。
特别注意：
如果我们在用了malloc、calloc等在类中动态开辟了空间，也就是在堆区开辟了空间，我们则必须定义析构函数来释放处于堆区开辟的动态空间！
我们都知道函数调用函数时会有函数栈帧的概念。在类中，对象在栈区中开辟了空间，而默认的析构函数只是会释放栈区的空间，不会释放堆区的空间，如果我们不自定义析构函数来释放堆区的空间，就会造成内存泄漏！
析构函数的语法
~类名()
{
// 执行析构操作操作
}
栗子：
class Pico
{
public:
int num;
int price;
Pico()//无参数构造
{
num = 0, price = 0;
cout << "无参数构造" << endl;
cout << "初始化num = " << num << " price= " << price << endl;
}
~Pico()//析构函数
{
cout << "析构函数的调用" << endl;
}
};
void text()
{
Pico op;
}四、拷贝构造函数
什么是拷贝构造函数？
拷贝构造函数是一个特殊的成员函数，用于将一个对象的值复制到另一个对象中。用于创建一个新对象并将其初始化为已有对象的副本。如果拷贝函数函数没有被定义，系统将默认定义一个默认拷贝构造函数（浅拷贝）。
拷贝构造函数的语法
类名(const 类名& 源对象)
{
// 执行拷贝操作
}
栗子：
class Pico
{
public:
int num;
int price;
Pico()//无参构造
{
cout << "无参构造" << endl;
}
Pico(int n, int m)//有参构造
{
num = n, price = m;
cout << "有参构造" << endl;
cout << "初始化num = " << num << " price= " << price << endl;
}
Pico(const Pico&op)
{
num = op.num;
price = op.price;
cout << "拷贝函数调用" << endl;
cout << "new num=" << num <<" new price="<<price << endl;
}
~Pico()//析构函数
{
cout << "析构函数的调用 num= " <<num<<" price= "<<price << endl;
}
};
void text()
{
Pico op1(1, 2);
Pico op2 = op1;
}
一句重要的话
旧对象 初始化 新对象 才会调用拷贝构造函数。
什么意思呢？请看！
拷贝构造的调用
以下会调用拷贝构造：
Pico op1(1, 2);
Pico op2 = op1;//拷贝构造
Pico op3(op1);//拷贝构造
Pico op5 = Pico(op1);//拷贝构造以下不会会调用拷贝构造：
Pico op3(3, 4);
Pico op4;
op4 = op3;拷贝构造注意事项
1、不能调用拷贝构造函数去初始化匿名对象
2、对象作为函数的参数 如果实参与形参 都是普通对象 那么就会调用拷贝构造
3、函数返回局部对象 在vs中会被优化 从而调用不了拷贝构造
浅拷贝与深拷贝
如果类中的成员 指向了堆区空间 一定要记得在析构函数中 释放该空间
如果用户 不实现 拷贝构造 系统就会提供默认拷贝构造
而默认拷贝构造 只是单纯的赋值 容易造成浅拷贝问题
用户记得 要实现：无参构造（初始化数据）、有参构造（赋参数）、拷贝构造（深拷贝）、析构函数（释放空间）
class Person
{
private:
char* m_name;
int m_num;
public:
Person()
{
m_name = NULL;
m_num = 0;
cout << "无参构造" << endl;
}
Person(char* name, int num)
{
//为m_name申请空间
m_name = (char*)calloc(1, strlen(name) + 1);
if (m_name == NULL)
{
cout << "构造失败" << endl;
}
cout << " 已经申请好空间" << endl;
strcpy(m_name, name);
m_num = num;
cout << "有参构造" << endl;
}
Person(const Person & ob)//ob==>lucy//深拷贝
{
cout << "拷贝构造函数" << endl;
m_name = (char*)calloc(1, strlen(ob.m_name) + 1);
cout << "空间已被申请" << endl;
strcpy(m_name, ob.m_name);
m_num = ob.m_num;
}
~Person()
{
if (m_name != NULL)
{
cout << "空间已被释放" << endl;
free(m_name);
m_name = NULL;
}
cout << "析构函数" << endl;
}
void showPerson(void)
{
cout << "m_name = " << m_name << ", m_num = " << m_num << endl;
}
};
void test01()
{
char s[] = "lucy";
Person lucy(s, 100);
lucy.showPerson();
//浅拷贝的问题（多次释放同一块堆区空间）
//通过自定义 拷贝构造函数 完成深拷贝动作
Person bob = lucy;//调用系统的默认拷贝构造（单纯的值拷贝）
}
注意：本质上这个还是函数栈与堆的问题，请看下图对本例的分析
五、构造函数的调用
class Data
{
public:
int num;
public:
//构造函数(无参的构造)
Data()
{
num = 0;
cout << "无参的构造函数 num = " << num << endl;
}
//构造函数（有参的构造）
Data(int n)
{
num = n;
cout << "有参的构造函数 num = " << num << endl;
}
//析构函数（没有返回值类型 没有参数 不能重载）
~Data()
{
cout << "析构函数 num = " << num << endl;
}
};
void test02()
{
//调用无参 或 默认构造 (隐式调用)
Data ob1;
//调用无参构造 （显示调用）
Data ob2 = Data();
//调用有参构造（隐式调用）
Data ob3(10);
//调用有参构造（显示调用）
Data ob4 = Data(20);
//隐式转换的方式 调用有参构造（针对于 只有一个数据成员）（尽量别用)
Data ob5 = 30;//转化成Data ob5(30)
//匿名对象(当前语句结束 匿名对象立即释放)
Data(40);
cout << "‐‐‐‐‐‐" << endl;
//千万不要 用一下方式调用 无参构造
}测试效果：
结论
在同一作用域 构造和析构的顺序相反
感谢你耐心的看到这里ღ( ´･ᴗ･` )比心，如有哪里有错误请踢一脚作者o(╥﹏╥)o！
给个三连再走嘛~
