class Date
{
public:
	//无参构造函数
	Date()
	{
		_year = 0;
		_month = 0;
		_day = 0;
	}
	//有参构造函数
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	全缺省构造函数
	//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()
{
	// 如果留下三个构造中的第二个带参构造，第一个和第三个注释掉
	// 编译报错：error C2512: “Date”: 没有合适的默认构造函数可用
	Date d1; // 调用默认构造函数
	Date d2(2025, 1, 1); // 调用带参的构造函数
	// 注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则编译器无法
	// 区分这里是函数声明还是实例化对象
	// 比如上面的d1我们就不能写成Date d1()。这样无法确定是定义了一个函数还是实例化对象，比如下面就会报警告
	// warning C4930: “Date d3(void)”: 未调用原型函数(是否是有意用变量定义的?)
	Date d3();
	d1.Print();
	d2.Print();
	return 0;
}

class Stack
{
public:
	Stack(int n = 4)
	{
		_a = (int*)malloc(sizeof(int) * n);
		if (_a == nullptr)
		{
			return;
		}
		_capacity = n;
		_top = 0;
	}
private:
	int* _a;
	size_t _capacity;
	size_t _top;

};
// 两个Stack实现队列
class MyQueue
{
public:
	//编译器默认生成MyQueue的构造函数调用了Stack的构造，完成了两个成员的初始化
private:
	Stack pushst;
	Stack popst;
};
int main()
{
	MyQueue s1;

	return 0;
}

	~Stack()
	{
		free(_a);
		_a = nullptr;
		_capacity = 0;
		_top = 0;
	}

（1~2）这也是在Stack类里写的。

class Stack
{
public:
	Stack(int n = 4)
	{
		_a = (int*)malloc(sizeof(int) * n);
		if (_a == nullptr)
		{
			return;
		}
		_capacity = n;
		_top = 0;
	}
	~Stack()
	{
		free(_a);
		_a = nullptr;
		_capacity = 0;
		_top = 0;
	}
private:
	int* _a;
	size_t _capacity;
	size_t _top;

};
// 两个Stack实现队列
class MyQueue
{
public:
	//编译器默认生成MyQueue的析构函数调用了Stack的析构，释放的Stack内部的资源
	// 显示写析构，也会自动调用Stack的析构
	/*~MyQueue()
	{}*/
private:
	Stack pushst;
	Stack popst;
};
int main()
{
	Stack s1;

	return 0;
}

也就是说，如果我们没有写析构函数，系统会生成，但是系统生成的不管内置成员类型。对于自定义的类型，即使我们写了析构，但是里面的成员还是会调用析构函数，比如上面的~MyQueue()
    {}。依然会调用Stack的析构函数

class Date
{
public:
	//全缺省构造函数
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	//拷贝构造函数
	Date(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2024, 7, 13);
	d1.Print();

	Date d2(d1);//也可以写成Date d2 = d1;
	d2.Print();
	return 0;
}

需要注意的一点是，我们这里传参的是类类型的引用，如果我们不传这个，使用传值调用的话会报错:

class Stack
{
public:
    //初始化栈
	Stack(int n = 4)
	{
		_a = (STDataType*)malloc(sizeof(STDataType) * n);
		if (nullptr == _a)
		{
			perror("malloc申请空间失败");
			return;
		}
		_capacity = n;
		_top = 0;
	}
    //入栈
	void Push(STDataType x)
	{
		if (_top == _capacity)
		{
			int newcapacity = _capacity * 2;
			STDataType* tmp = (STDataType*)realloc(_a, newcapacity *
				sizeof(STDataType));
			if (tmp == NULL)
			{
				perror("realloc fail");
				return;
			}
			_a = tmp;
			_capacity = newcapacity;
		}
		_a[_top++] = x;
	}
    //销毁栈
	~Stack()
	{
		cout << "~Stack()" << endl;
		free(_a);
		_a = nullptr;
		_top = _capacity = 0;
	}
private:
	int* _a;
	size_t _capacity;
	size_t _top;
};

int main()
{
	Stack st1;
	st1.Push(1);
	st1.Push(2);
	// Stack不显示实现拷⻉构造，用自动生成的拷⻉构造完成浅拷⻉
	// 会导致st1和st2里面的_a指针指向同一块资源，析构时会析构两次，程序崩溃
	Stack st2 = st1;
    return 0;
}

比如这里我没有写拷贝构造函数，那么系统就会默认生成拷贝构造函数，这个拷贝构造函数是浅拷贝，下图是浅拷贝最终拷贝出来的st2，我们发现st1和st2里的_a的地址相同，因为_a的内存是我们动态申请的，所以最后_a的生命周期结束了之后，编译器会自动调用析构函数，因为是两个对象，所以这一块空间在析构了一次之后，还会再析构一次，这样相当于是释放一块不存在的空间。