一、C++的六个默认成员函数

如果一个类中什么成员都没有，简称为空类。
空类中真的什么都没有吗？并不是，任何类在什么都不写时，编译器会自动生成以下6个默认成员函数。
默认成员函数：用户没有显式实现，编译器会生成的成员函数称为默认成员函数。

二、构造函数和析构函数

当我们使用类的函数的时候，我们经常会忘记初始化和销毁，而导致程序崩溃。为了解决这个问题，C++有了构造函数和析构函数，他可以自动完成初始化工作和销毁

如下代码所示，是我们使用C++写的一个栈

typedef int DataType;
class Stack
{
public:
	void Init()
	{
		_array = (DataType*)malloc(sizeof(DataType) * 4);
		if (NULL == _array)
		{
			perror("malloc申请空间失败!!!");
			return;
		}

		_capacity = 4;
		_size = 0;
	}

	void Push(DataType data)
	{
		CheckCapacity();
		_array[_size] = data;
		_size++;
	}

	void Pop()
	{
		if (Empty())
			return;
		_size--;
	}

	DataType Top() { return _array[_size - 1]; }
	int Empty() { return 0 == _size; }
	int Size() { return _size; }

	void Destroy()
	{
		if (_array)
		{
			free(_array);
			_array = NULL;
			_capacity = 0;
			_size = 0;
		}
	}
private:
	void CheckCapacity()
	{
		if (_size == _capacity)
		{
			int newcapacity = _capacity * 2;
			DataType* temp = (DataType*)realloc(_array, newcapacity * sizeof(DataType));
			if (temp == NULL)
			{
				perror("realloc申请空间失败!!!");
				return;
			}
			_array = temp;
			_capacity = newcapacity;
		}
	}
private:
	DataType* _array;
	int _capacity;
	int _size;
};

int main()
{
	Stack s;
	s.Init();

	s.Push(1);
	s.Push(2);
	s.Push(3);
	s.Push(4);

	printf("%d\n", s.Top());
	printf("%d\n", s.Size());

	s.Pop();
	s.Pop();
	printf("%d\n", s.Top());
	printf("%d\n", s.Size());

	s.Destroy();
	return 0;
}

但是我们其实是很容易忘记去初始化和销毁的。这极其容易导致程序崩溃和内存泄漏。我们可以使用构造函数和析构函数来自动解决这个问题

1.构造函数

①构造函数的概念

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

②构造函数的特性

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

1. 函数名与类名相同。
2. 无返回值。
3. 对象实例化时编译器自动调用对应的构造函数。
4. 构造函数可以重载。

根据上面的几点，我们可以写出如下代码，这就是构造函数。而他就可以替代掉Init函数。因为他在对象实例化的时候自动调用

	Stack(int deaultCapacity = 4)
	{
		cout << "Stack(int deaultCapacity = 4)" << endl;
		_array = (DataType*)malloc(sizeof(DataType) * 4);
		if (NULL == _array)
		{
			perror("malloc申请空间失败!!!");
			return;
		}

		_capacity = 4;
		_size = 0;
	}

2.析构函数

①析构函数的概念

析构函数：与构造函数功能相反，析构函数不是完成对对象本身的销毁，局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数，完成对象中资源的清理工作。

②析构函数的特性

析构函数是特殊的成员函数，其特征如下：

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

根据上面的四点特性，可以写出如下代码

	~Stack()
	{
		cout << "~Stack" << endl;
		if (_array)
		{
			free(_array);
			_array = NULL;
			_capacity = 0;
			_size = 0;
		}
	}

3.构造函数的其他特性

1. 构造函数可以重载
   如上所示，可以根据需要让构造函数进行重载

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

class Date
{
public:
	 如果用户显式定义了构造函数，编译器将不再生成
	//Date(int year, int month, int day)
	//{
	//_year = year;
	//_month = month;
	//_day = day;
	//}
	//
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	// 将Date类中构造函数屏蔽后，代码可以通过编译，因为编译器生成了一个无参的默认构造函数
	// 将Date类中构造函数放开，代码编译失败，因为一旦显式定义任何构造函数，编译器将不再生
	// 无参构造函数，放开后报错: 没有合适的默认构造函数可用
	Date d1;
	d1.Print();

	return 0;
}

3. 需要注意的是，对于自动生成的默认构造函数：C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语言提供的数据类型，如：int/char…，自定义类型就是我们使用class/struct/union等自己定义的类型，对于该自动生成的默认构造函数，如果是内置类型，C++不做任何处理，如果是自定义类型，C++会调用该自定义类型的默认构造函数对其初始化。（先看我们是否写了构造函数，如果没有写构造函数，那么调用编译器自己生成的默认构造函数；如果我们写了这个是默认构造函数，那么调用它就行；如果我们写了但不是默认构造函数。那么很遗憾，报错。）而它的默认构造函数同样对于内置类型直接不初始化。如果出现自定义类型，则重复上述流程。

我们可以使用下面代码来进行测试：

class Queue
{
public:
	Queue()
	{
		cout << "Queue()" << endl;
	}
private:
	int* a;
	int b;
	int c;
};
typedef int DataType;
class Stack
{
public:
	void Push(DataType data)
	{
		CheckCapacity();
		_array[_size] = data;
		_size++;
	}

	void Pop()
	{
		if (Empty())
			return;
		_size--;
	}

	DataType Top() { return _array[_size - 1]; }
	int Empty() { return 0 == _size; }
	int Size() { return _size; }
private:
	void CheckCapacity()
	{
		if (_size == _capacity)
		{
			int newcapacity = _capacity * 2;
			DataType* temp = (DataType*)realloc(_array, newcapacity * sizeof(DataType));
			if (temp == NULL)
			{
				perror("realloc申请空间失败!!!");
				return;
			}
			_array = temp;
			_capacity = newcapacity;
		}
	}
private:
	DataType* _array;
	int _capacity;
	int _size;
	int a[10];
	Queue q;
};
class Date
{
public:
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
	Stack s;
};
int main()
{
	Date d1;
	d1.Print();

	return 0;
}

最终运行结果为

在这里，我们发现编译器貌似对内置类型做了处理，这里要谨慎，这是编译器自己的行为。个性化处理，不是所有的编译器都会处理的。

那么我们之前在写栈的时候，假如没有初始化，也没有写构造函数。这个栈会调用默认构造函数。不过可惜的是，我们的栈里面全是内置类型，不会进行初始化。自然因为野指针而导致出错了。

总结：
一般情况下，有内置类型成员，就需要自己写构造函数。不能用编译器自己生成的。
全都是自定义类型成员，可以考虑让编译器自己生成

4. C++11 中针对内置类型成员不初始化的缺陷，又打了补丁，即：内置类型成员变量在类中声明时
   可以给默认值。
   在一些编译器上，如果我们使用了内置类型成员的缺省值的话，有可能造成对没有赋予缺省值的成员进行处理

class Date
{
public:
	 如果用户显式定义了构造函数，编译器将不再生成
	//Date(int year, int month, int day)
	//{
	//_year = year;
	//_month = month;
	//_day = day;
	//}
	//
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year = 2023;
	int _month = 5;
	int _day = 3;

};
int main()
{

	Date d1;
	d1.Print();

	return 0;
}

需要注意的是：这里不是初始化，这里只是声明
这里给的是默认的缺省值，给编译器生成默认构造函数用

5. C++中构造函数的调用也和普通函数不一样
   构造函数的调用是，对象加参数列标或不加参数列表，同时如果我们已经有了自己写的默认构造函数。那么我们给成员变量的缺省值也将失效。如果我们调用的是默认构造函数，那么切记，不可以带括号，否则无法区分函数声明和调用默认构造函数

class Date
{
public:
	// 如果用户显式定义了构造函数，编译器将不再生成
	Date(int year = 2023, int month = 5, int day = 2)
	{
	_year = year;
	_month = month;
	_day = day;
	}
	
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year = 2023;
	int _month = 5;
	int _day = 3;

};
int main()
{

	Date d1;
	Date d2(2022, 5, 3);
	d1.Print();
	d2.Print();
	return 0;
}

但是如果我们的无参构造函数里面什么也没有写。那么在成员变量里面的缺省值就可以起到作用了

class Date
{
public:
	 如果用户显式定义了构造函数，编译器将不再生成
	//Date(int year = 2023, int month = 5, int day = 2)
	//{
	//_year = year;
	//_month = month;
	//_day = day;
	//}
	Date()
	{

	}
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year = 2023;
	int _month = 5;
	int _day = 3;

};
int main()
{

	Date d1;
	//Date d2(2022, 5, 3);
	d1.Print();
	//d2.Print();
	return 0;
}

同时如果我们自己写的构造函数中部分成员变量没有修改，但是成员变量有缺省值，那么采用缺省值

6. 无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认构造函数。

这一点就告诉我们，全缺省的构造函数和无参的构造函数不可以同时存在。虽然他们可以构成重载。但是存在歧义。

4.构造函数总结

1. 一般情况下，构造函数都需要我们自己写
2. 内置类型成员都有缺省值，且初始化符合我们的要求，可以不用写构造函数, 注意构造类型的指针其实也是内置类型，因为它本质还是一个指针
3. 全是自定义类型的构造，且这些类型都定义默认构造（默认构造不存在的情况当且仅当我们自己写了构造函数，且构造函数不存在要么全缺省要么无参）
4. 注意我们如果给成员变量加上缺省值的话，会出现很多复杂的情形，但是我们可以这样简化处理，编译器先不管这些成员变量的缺省值，而是先去处理构造函数里面的东西。然后判断经过构造函数处理之后，还剩下哪些成员变量没有处理，对于没有处理的成员变量且它有成员变量的缺省值，那么则采用该缺省值进行处理（要注意的是，在一些编译器上，一旦一部分成员变量存在缺省值，那么其余的成员变量也会被处理一下，但是C++标准并未这样规定，所以我们要当成他们没有处理）

5.一些不写构造函数的样例

1. 如下代码所示：满足了两种不需要写构造函数的情形

struct TreeNode
{
	TreeNode* _left;
	TreeNode* _right;
	int _val;
	TreeNode(int val = 0)
	{
		_left = nullptr;
		_right = nullptr;
		_val = val;
	}
};
class Tree
{
private:
	TreeNode* _root = nullptr;
};
int main()
{
	Tree t1;
	TreeNode n1(2);
	TreeNode n2;
	return 0;
}

6.析构函数的其他特性

我们其实从前面也可以得知，析构函数是用来清理资源的。

编译器自己生成的析构函数是不会自动释放堆区的空间的且内置类型不做处理
当遇到自定义类型时候，会自动调用该自定义类型所对应的析构函数

1. 一般情况下，有动态资源申请，就需要写析构函数释放资源
2. 没有动态申请的资源，就不需要写析构
3. 需要释放的资源都是自定义类型，不需要写析构

而以上三种情形可以分别对应以下三种类

---

好了，本期内容就到这里了
如果对你有帮助的话，不要忘记点赞加收藏哦！！！