【C++】类和对象(二) -- 构造函数、析构函数

小年糕是糕手

发布于 2026-01-14 17:39:08

1280

文章被收录于专栏：C++学习C++学习

一、类的默认成员函数

默认成员函数就是用户没有显式实现，编译器会自动生成的成员函数称为默认成员函数。一个类，我们不写的情况下编译器会默认生成以下 6 个默认成员函数，需要注意的是这 6 个中最重要的是前 4 个，最后两个取地址重载不重要，我们稍微了解一下即可。其次就是 C++11 以后还会增加两个默认成员函数，移动构造和移动赋值，这个我们后面博客再讲解。默认成员函数很重要，也比较复杂，我们要从两个方面去学习：

第一：我们不写时，编译器默认生成的函数行为是什么，是否满足我们的需求。
第二：编译器默认生成的函数不满足我们的需求，我们需要自己实现，那么如何自己实现？

二、构造函数

构造函数是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任务并不是开空间创建对象(我们常使用的局部对象是栈帧创建时，空间就开好了)，而是对象实例化时初始化对象。构造函数的本质是要替代我们以前Stack和Date类中写的Init函数的功能，构造函数自动调用的特点就完美的替代的了Init。

构造函数的特点：

函数名与类名相同。
无返回值。(返回值啥都不需要给，也不需要写 void，不要纠结，C++ 规定如此)
对象实例化时系统会自动调用对应的构造函数。
构造函数可以重载。
如果类中没有显式定义构造函数，则 C++ 编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成。
无参构造函数、全缺省构造函数、我们不写构造时编译器默认生成的构造函数，都叫做默认构造函数。但是这三个函数有且只有一个存在，不能同时存在。无参构造函数和全缺省构造函数虽然构成函数重载，但是调用时会存在歧义。要注意很多同学会认为默认构造函数是编译器默认生成那个叫默认构造，实际上无参构造函数、全缺省构造函数也是默认构造，总结一下就是不传实参就可以调用的构造就叫默认构造。
我们不写，编译器默认生成的构造，对内置类型成员变量的初始化没有要求，也就是说是否初始化是不确定的，看编译器。对于自定义类型成员变量，要求调用这个成员变量的默认构造函数初始化。如果这个成员变量，没有默认构造函数，那么就会报错，我们要初始化这个成员变量，需要用初始化列表才能解决，初始化列表，我们下个章节再细细讲解。

说明：C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语言提供的原生数据类型，如：int/char/double/指针等，自定义类型就是我们使用class/struct等关键字自己定义的类型。

#include<iostream>
using namespace std;
class Date
{
public:
	// 1.⽆参构造函数 
	Date()
	{
		_year = 1;
		_month = 1;
		_day = 1;
	}
	// 2.带参构造函数 
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	// 3.全缺省构造函数 
	//全缺省可以直接替代无参和带参的构造函数
	//全缺省和无参不能同时存在，会造成调用歧意
	/*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;
};

class Stack 
{
public:
	Stack()
	{
		_a = nullptr;
		_top = 0;
		_capacity = 0;
	}
private:
	int* _a;
	int _top;
	int _capacity;
};

//用俩个栈实现一个队列
class MyQueue 
{
private:
	// 自定义类型
	Stack _pushst;
	Stack _popst;
};

int main()
{
	// 如果留下三个构造中的第⼆个带参构造，第⼀个和第三个注释掉 
	// 编译报错：error C2512: “Date”: 没有合适的默认构造函数可⽤ 
	Date d1; // 调⽤默认构造函数 
	Date d2(2025, 1, 1); // 调⽤带参的构造函数 
	// 注意：如果通过⽆参构造函数创建对象时，对象后⾯不⽤跟括号，否则编译器⽆法 
	// 区分这⾥是函数声明还是实例化对象 
	// warning C4930: “Date d3(void)”: 未调⽤原型函数(是否是有意⽤变量定义的?)
	// 这里无参数的函数调用不加括号，否则会报警告，有参数的话要给参数写全不能缺
	//Date d3();
	d1.Print();
	d2.Print();


	MyQueue q;
	//MyQueue这个类也没有写构造，编译器会自动生成一个构造
	//自动生成的构造对于自定义类型会去调用Stack的默认构造，栈刚好有默认构造

	return 0;
}

三、析构函数

析构函数与构造函数功能相反，析构函数不是完成对对象本身的销毁，比如局部对象是存在栈帧的，函数结束栈帧销毁，他就释放了，不需要我们管，C++规定对象在销毁时会自动调用析构函数，完成对象中资源的清理释放工作。析构函数的功能类比我们之前Stack实现的Destroy功能，而像Date没有 Destroy，其实就是没有资源需要释放，所以严格说Date是不需要析构函数的。

析构函数的特点：

析构函数名是在类名前加上字符～。
无参数无返回值。(这里跟构造类似，也不需要加 void)
一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。
对象生命周期结束时，系统会自动调用析构函数。
跟构造函数类似，我们不写编译器自动生成的析构函数对内置类型成员不做处理，自定类型成员会调用他的析构函数。
还需要注意的是我们显示写析构函数，对于自定义类型成员也会调用他的析构，也就是说自定义类型成员无论什么情况都会自动调用析构函数。
如果类中没有申请资源时，析构函数可以不写，直接使用编译器生成的默认析构函数，如 Date；如果默认生成的析构就可以用，也就不需要显示写析构，如 MyQueue；但是有资源申请时，一定要自己写析构，否则会造成资源泄漏，如 Stack。
一个局部域的多个对象，C++ 规定后定义的先析构。

#include<iostream>
using namespace std;
class Date
{
public:
	// 1.⽆参构造函数 
	Date()
	{
		_year = 1;
		_month = 1;
		_day = 1;
	}
	// 2.带参构造函数 
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	// 3.全缺省构造函数 
	//全缺省可以直接替代无参和带参的构造函数
	//全缺省和无参不能同时存在，会造成调用歧意
	/*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;
};

class Stack
{
public:
	Stack(int n = 4)
	{
		_a = (int*)malloc(sizeof(int) * n);
		//...
		_top = 0;
		_capacity = 0;
	}

	//析构函数
	~Stack()
	{
		if (_a)
		{
			free(_a);
			_a = nullptr;
			_top = 0;
			_capacity = 0;
		}
	}

private:
	int* _a;
	int _top;
	int _capacity;
};

//用俩个栈实现一个队列
class MyQueue
{
private:
	// 自定义类型
	Stack _pushst;
	Stack _popst;
};

int main()
{
	// 如果留下三个构造中的第⼆个带参构造，第⼀个和第三个注释掉 
	// 编译报错：error C2512: “Date”: 没有合适的默认构造函数可⽤ 
	Date d1; // 调⽤默认构造函数 
	Date d2(2025, 1, 1); // 调⽤带参的构造函数 
	// 注意：如果通过⽆参构造函数创建对象时，对象后⾯不⽤跟括号，否则编译器⽆法 
	// 区分这⾥是函数声明还是实例化对象 
	// warning C4930: “Date d3(void)”: 未调⽤原型函数(是否是有意⽤变量定义的?)
	// 这里无参数的函数调用不加括号，否则会报警告，有参数的话要给参数写全不能缺
	//Date d3();
	d1.Print();
	d2.Print();


	MyQueue q;
	//MyQueue这个类也没有写构造，编译器会自动生成一个构造
	//自动生成的构造对于自定义类型会去调用Stack的默认构造，栈刚好有默认构造
	

	//后定义的先析构，先析构s2再析构s1
	//可以简单的将析构理解为destroy
	Stack s1;
	Stack s2(10);

	return 0;
}

对比一下用C++和C实现的Stack解决之前括号匹配问题isValid，我们发现有了构造函数和析构函数确实方便了很多，不会再忘记调用Init和Destory函数了，也方便了不少。

下面举个例子（我们之前刷题时学过的括号匹配问题）：

#include<iostream>
using namespace std;
// ⽤最新加了构造和析构的C++版本Stack实现 
bool isValid(const char* s) {
	Stack st;
	while (*s)
	{
		if (*s == '[' || *s == '(' || *s == '{')
		{
			st.Push(*s);
		}
		else
		{
			// 右括号⽐左括号多，数量匹配问题 
			if (st.Empty())
			{
				return false;
			}
			// 栈⾥⾯取左括号 
			char top = st.Top();
			st.Pop();
			// 顺序不匹配 
				if ((*s == ']' && top != '[')
					|| (*s == '}' && top != '{')
					|| (*s == ')' && top != '('))
				{
					return false;
				}
		}
		++s;
	}
	// 栈为空，返回真，说明数量都匹配 左括号多，右括号少匹配问题 
	return st.Empty();
}
// ⽤之前C版本Stack实现 
bool isValid(const char* s) {
	ST st;
	STInit(&st);
	while (*s)
	{
		// 左括号⼊栈 
		if (*s == '(' || *s == '[' || *s == '{')
		{
			STPush(&st, *s);
		}
		else // 右括号取栈顶左括号尝试匹配 
		{
			if (STEmpty(&st))
			{
				STDestroy(&st);
				return false;
			}
			char top = STTop(&st);
			STPop(&st);
			// 不匹配 
			if ((top == '(' && *s != ')')
				|| (top == '{' && *s != '}')
				|| (top == '[' && *s != ']'))
			{
				STDestroy(&st);
				return false;
			}
		}
		++s;
	}
	// 栈不为空，说明左括号⽐右括号多，数量不匹配 
	bool ret = STEmpty(&st);
	STDestroy(&st);
	return ret;
}
int main()
{
	cout << isValid("[()][]") << endl;
	cout << isValid("[(])[]") << endl;
	return 0;
}

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2025-11-25，如有侵权请联系 cloudcommunity@tencent.com 删除

函数