c++中的构造函数和析构函数

一、构造函数

构造函数是一个特殊的成员函数，构造函数的主要任务并不是开空间创建对象，而是初始化对象。

构造函数的特性：

一、函数名与类名相同；

二、无返回值（也不需要写void）；

三、对象实例化时编译器自动调用对应的构造函数；

四、构造函数可以重载；

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

六、c++把类型分成内置类型和自定义类型。内置类型就是语言提供的数据类型，如int/char......，自定义类型就是我们使用class/struct/union等自己定义的类型。

---

默认构造函数的特点：

1.我们不自己写构造函数，编译器自动生成；

2.对内置类型的成员不做处理；

3.对自定义类型的成员才会处理，回去调用这个成员的默认构造函数，如果成员变量全是自定义类型，可以考虑不写构造函数。

---

七、无参的构造函数和全缺省的构造函数都称为默认构造函数，，并且默认构造函数只能有一个。

无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都是默认构造函数。

对于Date类：

class Date
{
public:

	//全缺省构造函数和无参构造函数不可以同时存在，会产生二义性。

	//全缺省构造函数
	//......

	//无参构造函数
	//......

	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}

private:
	int _year;
	int _month;
	int _day;
};

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

    //无参构造函数
	Date()
	{
		_year = 1;
		_month = 1;
		_day = 1;
	}

全缺省构造函数和无参构造函数不可以同时存在，会产生二义性。

二、析构函数

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

析构函数的特性：

1.析构函数名是在类名前加上字符~；

2.无参数，无返回值类型；

3.一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。析构函数不能重载。

4.对象生命周期结束时，c++编译系统自动调用析构函数。

5.关于编译器自动生成的析构函数也就是默认析构函数；

默认析构函数对内置类型不做处理，对自定义类型会再调用它的析构函数

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

class Stack
{
public:

	Stack(int n = 4)
	{
		if (n == 0)
		{
			_a = nullptr;
			_top = 0;
			_capacity = 0;

		}
		_a = (int*)malloc(sizeof(int) * n);
		_top = 0;
		_capacity = n;
	}

	void Push(int x)
	{
		//判满，扩容
		if (_top == _capacity)
		{
			int* tmp = (int*)realloc(_a, sizeof(int) * 2 * _capacity);
			if (tmp == nullptr)
			{
				perror("realloc fail!");
				exit(-1);
			}
			_a = tmp;
			_capacity *= 2;
		}
		_a[_top] = x;
		_top++;
	}

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

	int Top()
	{
		return _a[_top - 1];
	}

	bool Empty()
	{
		return _top == 0;
	}

	int Size()
	{
		return _top;
	}

	~Stack()
	{
		cout << "~Stack()" << endl;
		if (_a)
		{
			free(_a);
			_a = nullptr;
			_top = _capacity = 0;
		}
	}
private:
	int* _a;
	int _top;
	int _capacity;
};

如果采用默认析构函数，那么_a指向的那块空间就不会被释放，会造成了内存泄漏。所以我们必须自己来写Stack类的析构函数。