初识C++（三）构造函数和析构函数

目录

一、构造函数：

1.构造函数的概念：

2.构造函数的特性：

3.构造函数的形式：

4.为什么要引出构造函数这一概念

5.默认构造函数包括：

6.对默认生成的构造函数不处理内置类型的成员这事的解决办法：

二、析构函数：

1.析构函数的概念：

2.析构函数的特性：

三、构造和析构函数其余的特点：

---

一、构造函数：

1.构造函数的概念：

• 构造函数是一个特殊的成员函数，名字与类名相同，创建类类型对象时由编译器自动调用，保证每个数据成员都有一个合适的初始值，并且在对象的生命周期内只调用一次。

2.构造函数的特性：

• 函数名与类名相同。
• 无返回值。
• 编译器自动调用对应的构造函数。
• 构造函数可以重载。
• 需要注意的一点是，虽然构造函数叫"构造"函数，但是构造函数并不是用来构造对象的，构造函数的功能是用来完成对象的初始化的

3.构造函数的形式：

	Date(int year, int month, int day)   //进行初始化的操作
	{
		_year = year;
		_month = month;
		_day = day;
	}

4.为什么要引出构造函数这一概念

看下面的代码，对于Date类，可以通过InitDate公有的方法给对象设置内容，但是如果每次创建对象都调用该方法设置信息，未免有点麻烦，那能否在对象创建时，就将信息设置进去呢？

现在我们的需求就是不通过对象去调用初始化对象的数据，我们希望当这个对象创建出来的时候，他就已经是具有一定的初始值的，那么如何做到我们现在的这个需求的呢？

由此，引入了构造函数这一个概念，如下所示：

（1） 下面这段代码需要自己初始化：

d1,d2,d3都需要初始化，太麻烦了

#include<iostream>
using namespace std;
class Date
{
public:
	void InitDate(int year, int month, int day)   //进行初始化的操作
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void PrintDate()   //打印进行检测
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1, d2, d3;

	d1.InitDate(2020, 4, 30);//需要自己初始化
	d1.PrintDate();

	d2.InitDate(2020, 4, 29);
	d2.PrintDate();

	d3.InitDate(2020, 4, 28);
	d3.PrintDate();
}

---

（2）自动初始化（构造函数）：

#include<iostream>
using namespace std;
class Date
{
public:
	Date(int year, int month, int day)   //进行初始化的操作
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void PrintDate()   //打印进行检测
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
    Date d1(2002,11,05);//在创建对象时就一起初始化，编译器会自动调用进行初始化	
	d1.PrintDate();
}

用了重构函数之后，创建对象的时候，编译器自动调用Date

---

如果不想传参数，函数重载一个构造函数。Date() 和 Date(int year,int month,int day)

#include<iostream>
using namespace std;
class Date
{
public:
    Date()//不传参时调用这个构造函数
    {
        _year=1;
        _month=1;
        _day=1;
    }
	Date(int year, int month, int day)   //传参时调用这个函数
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void PrintDate()   //打印进行检测
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
    Date d1(2002,11,05);//在创建对象时就一起初始化，编译器会自动调用进行初始化	
	d1.PrintDate();
    Date d2;   //注意这里不能写成d2(),不能加括号
    d2.PrintDate();
}

d1调用了Date(int year,int month,int day)

d2调用了Date()

---

当然也可以使用缺省参数：

#include<iostream>
using namespace std;
class Date
{
public:
	Date(int year=1, int month=1, int day=1)   //进行初始化的操作
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void PrintDate()   //打印进行检测
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
    Date d1(2002,11,05);//在创建对象时就一起初始化，编译器会自动调用进行初始化	
	d1.PrintDate();
    Date d2(2013); //不能加括号
    d2.PrintDate();
    Date d3(2014,5); //不能加括号
    d2.PrintDate();
    Date d2; //不能加括号
    d2.PrintDate();
}

缺省函数的优势。

---

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

默认生成的构造函数：

内置类型的成员不做处理 ---- C++这里没有处理好，就会导致有数据的随机值

自定义类型的成员做处理

---

对内置类型的成员不做处理：

#include<iostream>
using namespace std;
class Date
{
public:
	//使用默认的构造函数，但是因为是内置类型，它就不会初始化

	void PrintDate()   //打印进行检测
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1;//在创建对象时就一起初始化，编译器会自动调用进行初始化	
	d1.PrintDate();
	Date d2; //不能加括号
	d2.PrintDate();
}

内置类型产生的是随机值

---

对自定义类型的成员处理：

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;
class Stack
{
public:
	Stack()
	{
		std::cout << "Stack类型的初始化" << std::endl;
		_a = nullptr;
		_size = _capacity = 0;
	}
	Stack(int capacity)
	{
		_a = (int*)malloc(sizeof(int) * capacity);
		if (nullptr == _a)
		{
			perror("malloc error");
			exit(-1);
		}
		_capacity = capacity;
		_size = 0;
	}
	int* _a;
	int _size;
	int _capacity;
};
class MyQueue{
public:
	//默认生成构造函数，对自定义类型，会调用它的默认构造函数
	void push(int x)
	{

	}
private:
	Stack _pushST;
	Stack _popST;
};
int main()
{
	MyQueue q;
	return 0;
}

实现步骤如下表：

5.默认构造函数包括：

（1）编译器默认生成的构造函数

（2）无参构造函数

（3）全缺省构造函数

---

6.对默认生成的构造函数不处理内置类型的成员这事的解决办法：

C++在C11的时候打了补丁：

在声明那个地方加上一个缺省值，在无构造函数时，编译器自动生成的构造函数，会调用那里的值，就完成了没有自己写构造函数，也对内置类型的初始化。

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;
{
public:
	//默认生成的构造类型，对内置类型不处理
private:
	//这不是初始化，而是对构造和析构函数对内置类型不处理这个问题的解决方法
	//声明位置给缺省值，如果你不想写构造函数，你这样子写，它会默认给你初始化成这些值
	int _year=1;
	int _month=1;
	int _day=1;
};

二、析构函数：

1.析构函数的概念：

主要作用于在对象销毁前，执行一些清理工作（如释放new开辟在堆区的空间）

2.析构函数的特性：

~类名(){}

（1）析构函数，没有返回值也不写void

（2）函数名称与类名相同,在名称前加上符号 ~

（3）析构函数不可以有参数，因此不可以发生重载

（4）程序在对象销毁前会自动调用析构，无须手动调用，而且只会调用一次

---

//析构函数
~Date()//没有参数
{
	cout << "~Date()"<<endl;
	_year = 0;
	_month = 0;
	_day = 0;
}

析构函数具体放置的位置：

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;
class Date
{
public:
	//默认生成的构造类型，对内置类型不处理
	Date(int year=1, int month = 1, int day = 1)
	{
		//cout << "Date()" << endl;
		_year = year;
		_month = month;
		_day = day;
	}
	void print()
	{
		cout << _year << "年" << _month << "月" << _day << "日" << endl;
	}
	~Date()//没有参数   析构函数
	{
		cout << "~Date()"<<endl;
		_year = 0;
		_month = 0;
		_day = 0;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2023,11,5);//构造函数
	Date d2;//构造函数中的缺省函数
	d1.print();
	d2.print();
	return 0;
}

同样，编译器也有默认生成的析构函数，对自定义类型起作用，对内置类型不起作用。

三、构造和析构函数其余的特点：

• 构造函数和析构函数是一种特殊的公有成员函数，每一个类都有一个默认的构造函数和析构函数；

• 构造函数在类定义时由系统自动调用，析构函数在类被销毁时由系统自动调用；

• 构造函数的名称和类名相同，一个类可以有多个构造函数，只能有一个析构函数。不同的构造函数之间通过参数个数和参数类型来区分

• 我们可以在构造函数中给类分配资源，在类的析构函数中释放对应的资源。

• 如果程序员没有提供构造和析构，系统会默认提供

• 构造函数 和 析构函数，必须定义在public里面，才可以调用

  ---

  感谢各位大佬的观看，如果觉得还不错的话，支持一下我前面的文章，你的支持就是我创作的动力！

初识C++（一)啥是C++，关键字，命名空间 ，输入输出，缺省函数：http://t.csdnimg.cn/tJM4K

初识C++（二）引用，内联函数，auto：http://t.csdnimg.cn/ljtkY