C++：类的默认成员函数------构造函数&&析构函数（超详细解析，小白一看就懂！）

目录

一、前言

二、为什么会出现构造函数和析构函数 

 三、构造函数

🍎构造函数的概念 

🍐构造函数特性 

💦解释特性3：对象实例化时编译器自动调用对应的构造函数

💦解释特性4：构造函数支持重载

 💦解释特性5：如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成

 💦解释特性6：无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个

四、析构函数 

🍉析构函数概念 

🍓析构函数特性 

 五、共勉

---

一、前言

        在我们前面学习的类中，我们会定义成员变量和成员函数，这些我们自己定义的函数都是普通的成员函数，但是如若我们定义的类里什么也没有呢？是真的里面啥也没吗？如下：

class Date {};

如果一个类中什么成员都没有，简称为空类。空类中什么都没有吗？并不是的，任何一个类在我们不写的情况下，都会自动生成6个默认成员函数。

【默认成员函数概念】：用户没有显式实现，编译器会生成的成员函数称为默认成员函数

 

        其中两个默认成员函数是用来初始化和清理的分别为：构造函数、析构函数

     ⭐ 本次博客将详解为什么会出现这两个函数，这两个函数将如何使用 的问题⭐

二、为什么会出现构造函数和析构函数 

 首先看下面这段 C语言代码

typedef struct Date
{
	int year;
	int month;
	int day;
}D;
 
void Init(D* date)
{
	date->year = 2023;
	date->month = 10;
	date->day = 21;
}
void Printf(D* date)
{
	cout << date->year << "-" << date->month << "-" << date->day << endl << endl;
}
void Destory(D* date)
{
	date->year = 0;
	date->month = 0;
	date->day = 0;
}
int main()
{
	D date;
	Init(&date);
	Printf(&date);
	Destory(&date);
	return 0;
}

 

⚠ 注意：大家在日常写代码和刷题的时候，肯定会有过忘记初始化，或者忘记销毁，这些小细节很容易被大家忽略，但是出现在代码中，就会出现报错，导致我们写代码的时候，就很烦。

⚠ 忘记写初始化：输出随机值，结果会错误
 

⚠ 忘记写销毁：时间久了便会造成【内存泄漏】
 

💦你是否发现若是我们要去使用一个Date的话，通常不会忘了去往里面入数据或者是出数据，但是却时常会忘了【初始化】和【销毁】。这要如何是好呢😔
 

🔑 解决方案：

1️⃣：在上一文的学习中，我们学习到了一个类中的一个东西叫做this指针，只要是在成员函数内部都可以进行调用。而且还知晓了C++中原来是使用this指针接受调用对象地址的机制来减少对象地址的传入，减轻了调用者的工作。这也是C++区别于C很大的一点

2️⃣：那C++中是否还有东西能够替代【初始化】和【销毁】这两个工作呢？答案是有的，就是我们接下来要学习的【构造函数】和【析构函数】
 

 三、构造函数

🍎构造函数的概念 

 如下的日期类：

class Date
{
public:
	void Init(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << "今日日期输出：" << endl;
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;
	d1.Init(2023, 10, 21);
	d1.Print();
	return 0;
}

运行效果：

        正常情况下，我们写的这个日期类，首先初始化，其次打印。但如果说你突然忘记初始化了，直接就开始访问会怎么样呢？

        从运行结果上看，没初始化直接访问输出的是随机值。 忘记初始化其实是一件很正常的事情，C++大佬在这一方面为了填补C语言的坑（必须得手动初始化）。因而就设计出了构造函数。
        构造函数是一个特殊的成员函数，名字与类名相同,创建类类型对象时由编译器自动调用，保证每个数据成员都有 一个合适的初始值，并且在对象的生命周期内只调用一次。其目的就是为了方便我们不需要再初始化。

🍐构造函数特性 

        构造函数是特殊的成员函数，需要注意的是，构造函数的虽然名称叫构造，但是需要注意的是构造函数的主要任务并不是开空间创建对象，而是初始化对象。
其特征如下：

1. 函数名和类名相同
2. 无返回值
3. 对象实例化时编译器自动调用对应的构造函数
4. 构造函数可以重载
5. 如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成
6. 无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认成员函数。

如下即为构造函数：

Date()
{
	_year = 1;
	_month = 1;
	_day = 1;
}

 💦解释特性3：对象实例化时编译器自动调用对应的构造函数

        也就是说我们在实例化一个对象后，它会自动调用这个构造函数，自动就初始化了，我们可以通过调试看看：
 

💦解释特性4：构造函数支持重载

如下的函数：

Date(int year, int month, int day)
{
	_year = year;
	_month = month;
	_day = day;
}

        像这个重载函数是明确了我们要传参的，所以我们在实例化对象后就必须把参数写上去（虽然看着奇奇怪怪，但是没有办法，毕竟我们普通的调用，参数都是在函数名后面，而这个参数在实例化对象后面）：

Date d2(2023, 10, 21);

来输出和我们先前的构造函数对比看看：

• 注意：没有参数时我在调用的时候不能加上括号（），切忌！！构造函数尤为特殊
• 如果通过无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明

无参的情况下必须要像我们刚开始实例化的d1那样：

Date d1;
d1.Print();

•  构造函数的重载我们推荐写成全缺省的样子：

//普通的构造函数
	Date()
	{
		_year = 1;
		_month = 1;
		_day = 1;
	}
//全缺省的构造函数
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}

        首先，普通的构造函数和全缺省的构造函数在不调用的情况下可以同时存在，编译也没有错误。但是在实际调用的过程中，会存在歧义。如下的调用：

class Date
{
public:
//普通的构造函数
	Date()
	{
		_year = 1;
		_month = 1;
		_day = 1;
	}
//全缺省的构造函数
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;
	d1.Print();
}

        此时我实例化的d1到底是调用普通的构造函数？还是调用全缺省的构造函数？并且此段代码编译出现错误。何况我在没有调用函数的情况下编译是没错的。

       🔑 由此可见：它们俩在语法上可以同时存在，但是使用上不能同时存在，因为会存在调用的歧义，不知道调用的是谁，所以一般情况下，我们更推荐直接写个全缺省版的构造函数，因为是否传参数可由你决定。传参数数量也是由你决定。

 💦解释特性5：如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成

 看如下代码，自己不去写构造函数，使用编译器默认的构造函数：

class Date
{
public:
	
	// 我们不写，编译器会生成一个默认无参构造函数
	/*Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}*/
	
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	// 没有定义构造函数，对象也可以创建成功，因此此处调用的是编译器生成的默认构造函数
	Date d;
	d.Print();
}

        不是说好我不自己写构造函数，编译器会默认生成吗？为什么到这又是随机值了？这难道也算初始化？别急，搞清楚这个得先明白默认构造函数：
⚠ 默认构造函数：

• 1. 我们不写编译器默认生成的那个构造函数，叫默认构造
• 2. 无参构造函数也可以叫默认函数
• 3. 全缺省也可以叫默认构造

      总结： 可以不传参数就调用构造，都可以叫默认构造

⚠ C++把变量分成两种：

      1️⃣：内置类型/基本类型：int、char、double、指针……
      2️⃣：自定义类型：class、struct去定义的类型对象

        C++默认生成的构造函数对于内置类型成员变量不做处理，对于自定义类型的成员变量才会处理，这也就能很好的说明了为什么刚才没有对年月日进行处理（初始化），因为它们是内置类型（int类型的变量）

让我们来看看自定义类型是如何处理的。

class A
{
public:
	A()
	{
		cout << "A()" << endl;
		_a = 1;
	}
private:
	int _a;
};

        首先，这是一个名为A的类，有成员变量_a，并且还有一个无参的构造函数，对_a初始化为1。接着：

class Date
{
public:
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
		cout << endl;
	}
private:
	int _year = 2023;
	int _month = 11;
	int _day = 11;
	A _aa;
};
 
int main()
{
	Date d1;
	d1.Print();
	return 0;
}

       通过运行结果以及调试，也正验证了默认构造函数对自定义类型才会处理。这也就告诉我们，当出现内置类型时，就需要我们自己写构造函数了。

什么时候使用默认构造函数会凸显出其价值呢？就比如我们之前写的括号匹配这道题：

class Stack
{
public:
	Stack()
	{
		_a = nullptr;
		_top = _capacity;
	}
private:
	int* _a;
	int _top;
	int _capacity;
 
};
 
class MyQueue 
{
public:
	//默认生成的构造函数就可以用了
	void push(int x)
	{}
 
	int pop() 
	{}
private:
	Stack _S1;
	Stack _s2;
};

        此时我队列里自定义类型_s1和_s2就不需要单独写初始化了，直接用默认的。但是如果栈里没有写构造函数，那么其输出的还是随机的，因为栈里的也是内置类型。就是一层套一层，下一层生效的前提是上一层地基打稳了。

🔑总结：

1. 如果一个类中的成员全是自定义类型，我们就可以用默认生成的函数
2. 如果有内置类型的成员，或者需要显示传参初始化，那么都要自己实现构造函数。

 💦解释特性6：无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个

🔑 默认构造函数：

• 1. 我们不写编译器默认生成的那个构造函数，叫默认构造
• 2. 无参构造函数也可以叫默认函数
• 3. 全缺省也可以叫默认构造

总结： 可以不传参数就调用构造，都可以叫默认构造


🔑既然我默认构造函数只对自定义类型才会处理，那如果我不想自己再写构造函数也要对内置类型处理呢？我们可以这样做：

class Date
{
public:
 
	// 我们不写，编译器会生成一个默认无参构造函数
	/*Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}*/
 
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	// C++11 打的补丁，针对编译器自己默认成员函数不初始化问题
	int _year = 2023;
	int _month = 10;
	int _day = 21;
};
int main()
{
	// 没有定义构造函数，对象也可以创建成功，因此此处调用的是编译器生成的默认构造函数
	Date d;
	d.Print();
}

 🔑总结：

1. 构造函数是类中默认就带有的，不过日常自己在写一个类的时候尽量不要用默认生成的，最好是自己写一个，无参或者是缺省的都可以，但是不可以无参和全缺省共存，会引发歧义。
2. 若是使用默认生成的构造函数，会引发一些语言本身就带有的缺陷，【内置类型】的数据不会被初始化，还会是一个随机值；【自定义类型】的数据会调用默认构造函数（默认生成、无参、全缺省），若是不想看到随机值的话，可以参照C++11中的特性，在内置类型声明的时候就为其设置一个初始化值，便不会造成随机值的问题

四、析构函数 

🍉析构函数概念 

        前面通过构造函数的学习，我们知道一个对象时怎么来的，那一个对象又是怎么没呢的？
        析构函数：与构造函数功能相反，析构函数不是完成对象的销毁，局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数，完成类的一些资源清理工作。
 

🍓析构函数特性 

析构函数是特殊的成员函数。

其特征如下：

1. 析构函数名是在类名前加上字符 ~。
2. 无参数无返回值。
3. 一个类有且只有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。
4. 对象生命周期结束时，C++编译系统系统自动调用析构函数
5. 编译器生成的默认析构函数，对会自定类型成员调用它的析构函数

我们实际写一个析构函数看看：

~Date()
{
	cout << "~Date()" << endl;
}

带入示例再看看：

class Date
{
public:
	Date(int year = 2023, int month = 10, int day = 21)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
	~Date()
	{
		cout << "~Date()" << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;
	d1.Print();
	return 0;
}

        首先，我实例化出的d1会调用它的默认构造函数进行初始化，其次，出了作用域后又调用其析构函数，这也就是为什么输出结果会是~Date()
        析构的目的是为了完成资源清理，什么样的才能算是资源清理呢？像我这里定义的年月日变量就不需要资源清理，因为出了函数栈帧就销毁，真正需要清理的是malloc、new、fopen这些的，就比如清理栈里malloc出的

class Stack
{
public:
	//构造函数
	Stack(int capacity = 10)
	{
		_a = (int*)malloc(sizeof(int) * capacity);
		assert(_a);
		_top = 0;
		_capacity = capacity;
	}
	//析构函数
	~Stack()
	{
		free(_a);
		_a = nullptr;
		_top = _capacity = 0;
	}
private:
	int* _a;
	int _top;
	int _capacity;
};
int main()
{
	Stack st;
}

这里不难感慨C++的构造函数就像先前C语言常写的Init，而析构函数就像Destroy

• 看如下的题目：现在我用类实例化出st1和st2两个对象，首先，st1肯定先构造，st2肯定后构造，这点毋庸置疑，那关键是谁先析构呢？

int main()
{
	Stack st1;
	Stack st2;
}

答案：st2先析构，st1后析构

解析：这里st1和st2是在栈上的，建立栈帧，其性质和之前一样，后进先出，st2后压栈，那么它肯定是最先析构的。所以栈里面定义对象，析构顺序和构造顺序是反的。

        若自己没有定义析构函数，虽说系统会自动生成默认析构函数，不过也是有要求的，和构造函数一样，内置类型不处理，自定义类型会去调用它的析构函数，如下：

class Stack
{
public:
	//构造函数
	Stack(int capacity = 10)
	{
		_a = (int*)malloc(sizeof(int) * capacity);
		assert(_a);
		_top = 0;
		_capacity = capacity;
	}
	//析构函数
	~Stack()
	{
		cout << "~Stack():" << this << endl;
		free(_a);
		_a = nullptr;
		_top = _capacity = 0;
	}
private:
	int* _a;
	int _top;
	int _capacity;
 
};
class MyQueue
{
public:
	//默认生成的构造函数可以用
	//默认生成的析构函数也可以用
	void push(int x)
	{}
 
	int pop()
	{}
private:
	Stack _S1;
	Stack _s2;
};
int main()
{
	MyQueue q;
}

        对于MyQueue而言，我们不需要写它的默认构造函数，因为编译器对于自定义类型成员（_S1和_S2）会去调用它的默认构造，Stack提供了默认构造，出了作用域，编译器会针对自定义类型的成员去默认调用它的析构函数，因为有两个自定义成员（_S1和_S2），自然析构函数也调了两次，所以会输出两次Stack()……
 

🔑总结：

• 如果类中没有申请资源时，析构函数可以不写，直接使用编译器生成的默认析构函数，比如Date类；有资源申请时，一定要写，否则会造成资源泄漏，比如Stack类。

 五、共勉

        以下就是我对C++类的默认成员函数--------构造函数&&析构函数的理解，如果有不懂和发现问题的小伙伴，请在评论区说出来哦，同时我还会继续更新对C++ 类的默认成员函数-------拷贝构造&&赋值重载的理解，请持续关注我哦！！！