析构函数

析构函数：与构造函数的功能相反，对象在销毁时会自动调用析构函数，完成对象中资源的销毁（清理资源）

其特征如下：

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

        2.无参数无返回值类型

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

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

typedef int DataType;

struct Stack
{
public:
	Stack()
	{
		_array = (DataType*)malloc(10 * sizeof(DataType));
		if (NULL == _array)
		{
			assert(false);
			return;
		}

		_capacity = 10;
		_size = 0;

		cout << "Stack:" << this << endl;
	}
	void Push(DataType data)
	{
		_array[_size] = data;
		++_size;
	}
	void Pop()
	{
		if (Empty())
			return;

		_size--;

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

	 ~Stack()
	{
		 if (_array)
		 {
			 free(_array);
			 _array = nullptr;
			 _capacity = 0;
			 _size = 0;
		 }

		 cout << "~Stack():" << this << endl;
	}
	 /*    销毁函数  直接通过析构函数运行
	 void Destroy()
	{
		if (_array)
		{
			free(_array);
			_array = nullptr;
			_capacity = 0;
			_size = 0;
		}
	}
	*/
	
private:
	void _CheckCapacity();

private:
	DataType* _array;
	size_t _capacity; 
	size_t _size;
};


int main()
{
	Stack s;
	s.Push(1);
	s.Push(2);
	s.Push(3);
	s.Push(4);

	cout << s.Top() << endl;
	cout << s.Size() << endl;

	s.Pop();
	cout << s.Top() << endl;
	cout << s.Size() << endl;

	return 0;
}

拷贝构造：只有单个形参，该形参是对本类类型对象的引用（一般常用const修饰），在用已存在的类类型对象创建新对象时由编译器自动调用

1.拷贝构造函数是构造函数的一个重载形式

2.拷贝构造函数的参数只有一个且必须时类类型对象的引用，使用传值方式编译器直接报错，因为会引发无穷递归调用

class Date
{
public:
	Date(int year = 2023, int month = 4, int day = 18)
	{
		_year = year;
		_month = month;
		_day = day;
	}

    Date(const Date& d)
    {
        _year = d.year;
        _month = d.month;
        _day = d.day;
        cout << "Date(const Date& d) :" << this <<endl;
    }

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


int main()
{
	Date a(2023,4,19);
	a.Print();
	Date b(a);
	b.Print();
	return 0;
}

3.若未显示定义，编译器会生成默认的拷贝构造函数。（但实际编译器不一定会生成，但会完成拷贝）

4.编译器生成的拷贝构造（虽然没有生成但是也可以完成拷贝构造的工作），既然编译器已经可以完成，那拷贝构造函数还需要用户自己写吗？

答：像日期类这种没有涉及到资源管理时，一般不写，因为编译器就可以完成拷贝的工作，如果涉及到资源管理时，拷贝构造函数需要自己写（编译器按照值的方式拷贝的   即：将一个对象的内容原封不动的拷贝到另一个对象中）

struct Stack
{
public:
	Stack()
	{
		_array = (DataType*)malloc(10 * sizeof(DataType));
		if (NULL == _array)
		{
			assert(false);
			return;
		}

		_capacity = 10;
		_size = 0;

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

		 cout << "~Stack():" << this << endl;
	}	
	
private:
	void _CheckCapacity();

private:
	DataType* _array;
	size_t _capacity; 
	size_t _size;
};

因为Stack中没有写拷贝构造函数，所以将类中的值原封不动的拷贝到另一个类中，即拷贝了地址，没有拷贝值