C++默认成员函数与构造析构解析

用户11831438

发布于 2025-12-30 13:45:45

1100

一、类的默认成员函数

默认成员函数就是用户没有显示实现，编译器会自动生成的成员函数成为默认成员函数。

在一个类中，我们不写的情况下编译器会默认生成6个默认成员函数：

在这6个中最重要的是前4个，最后两个取地址重载不是很重要，我们稍微了解一下即可。其次就是C++11以后还会增加两个默认成员函数：移动构造和移动赋值，这个我们后面再讲解。默认成员函数很重要，也很复杂，我们要从两个方面去学习：

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

二、构造函数

有同学看到这个标题，就想说构造函数有什么好学的，不就是给对象开辟空间吗？不用学的，不用学的~~。

ok，构造函数虽然名称叫构造，但是构造函数的主要任务并不是开空间创建对象(我们常使用的局部对象是栈帧创建时，空间就开好了)，构造函数的主要任务是对象实例化时初始化对象。构造函数的本质是要替代我们以前Stack和Date类中写的Init函数（初始化函数）的功能，构造函数自动调用的特点就完美的替代了Init函数。构造函数完成初始化，初始化对象，不是开辟空间，并且构造函数是一个特殊的成员函数，接下来我们来看看它到底特殊在哪里。

构造函数的特点：

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

ok，我们先看构造函数的前四个特点，通过上面的四点，我们就可以写出一个构造函数了：

class Date
{
public:
	//不传参
	Date()
	{
		_year = 1;
		_month = 1;
		_day = 1;
	}
	//传参
	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 d1;
	d1.Print();

	Date d2(2025,8,4);
	d2.Print();
	return 0;
}

有同学看到上面的代码，就在想，怎么给出了两个函数名都是Date的函数？ 这是因为构造函数是可以重载的，构造函数的函数名可以相同，但是参数不相同，编译器会根据参数，匹配相应的函数。
这时候又有其他的小伙伴看到Date d2(2025,8,4);，这个构造函数在传参，并且有括号，就在想要不要给Date d1;的后面加个括号呢？其实这里是不需要的，原因如下：

注意：当构造函数有形参时加上括号，没有参数不需要加上括号

那这时候就会有同学要问了，那构造函数与我们之前写的Init函数的区别是什么？为什么不想要Init函数？

Init函数是分离的，也就是对象的定义和初始化是分离的，先定义，后初始化，这就会导致忘记初始化，C++这个机制是为了保证对象定义实例化出来就一定初始化，因为对象实例化时会自动调用对应的构造函数，也就意味着只要写了正确的构造函数，对象实例化出来一定

接下来，我们来看一下后三点（后三点比较重要）：

特点5：如果类中没有显示定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显示定义构造函数，编译器将不在生成

话不多说，直接看代码

代码1（类中没有显示定义的构造函数）：

class Date
{
public:
	void Print()
	{
		cout << _year << "/" << _month << "/" << _day<<endl;
	}
private:
	// 内置类型
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;
	d1.Print();
	return 0;
}

为什么我没有在类中定义构造函数，编译器默认生成的构造函数给我的d1初始化成了随机值呢？（后面再看）

代码2（类中显示定义构造函数）：

class Date
{
public:
	Date()//无参构造函数
	{
		_year = 2025;
		_month = 8;
		_day = 3;
	}
	void Print()
	{
		cout << _year << "/" << _month << "/" << _day<<endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;
	d1.Print();
	return 0;
}

ok啊，当我们在类中显示定义了构造函数，编译器没有自动生成一个无参的默认构造函数

我们知道构造函数是默认成员函数中的一种，默认成员函数是我们不写编译器自动生成。那这时就有同学想说了，默认构造函数不就是我们不写编译器自动生成的构造函数吗？这种想法是错误的

特点6：默认构造函数包括无参构造函数、全缺省构造函数、我们不写时编译器默认生成的构造函数

在这三个默认构造函数中，当我们写构造函数时，有且只有一个存在，不能同时存在。无参构造函数和全缺省构造函数虽然构成函数重载，但是调用时会存在歧义。

注意的是很多同学会认为默认构造函数是编译器默认生成的那个叫默认构，实际上无参构造、全缺省构造也是默认构造

总结：不传实参就可以调用的构造就是默认构造

class Date
{
public:
	//全缺省构造函数
	Date(int year=2025, int month=8, int day=1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	//无参构造函数
	Date()
	{
		_year = 2025;
		_month = 8;
		_day = 3;
	}
	void Print()
	{
		cout << _year << "/" << _month << "/" << _day<<endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;
	d1.Print();
	return 0;
}

注意：无参构造和全缺省构造不能同时出现

补充：

通过上面的学习，我们知道如何写一个构造函数了，那默认生成的构造会怎么处理成员呢？ok，接下来我们接着看：

特点7：我们不写，编译器默认生成的构造，对内置类型成员变量的初始化没有要求，也就是说是否初始化是不确定的，要看编译器，但是对于这种模棱两可的行为，我们要当成内置类型不被处理。对于自定义类型成员变量，要求调用这个成员变量的默认构造函数初始化。如果这个成员变量，没有默认构造函数，那么就会报错，我们要初始化这个成员变量，需要用初始化列表才能解决，初始化列表，我们下个章节再细细讲解。上面这两段话中，对内置类型的处理很好理解，这对自定义类型成员变量的处理是啥意思？

总结：绝大多数情况下，构造函数都要我们自己写，一般写全缺省参数构造函数 但是对于上面的MyQueue这个自定义类型，里面的Stack的自定义类型中有构造函数，MyQueue中就可以不用写构造函数，用编译器默认自动生成的构造函数就可以！！！

解答一下前面的问题：

三、析构函数

析构函数与构造函数功能相反，析构函数不是完成对对象本身的销毁，比如：局部对象是存在栈帧的，函数结束栈帧销毁，他就释放了，不需要我们管。C++规定对象在销毁时会自动调用析构函数，完成对象中资源的清理释放工作。

析构函数的功能可以类比我们之前Stack实现的Destroy功能，而像我们上面写的Date就没有Destroy，其实就是没有资源需要释放，所以严格说Date是不需要析构函数的。 我们可以简单的理解，析构函数是对类中所申请的空间进行释放

析构函数的特点：

析构函数名是在类名前加上字符 ~。
无参数无返回值。 (这里跟构造类似，也不需要加void)
⼀个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。
对象生命周期结束时，系统会自动调用析构函数。
跟构造函数类似，我们不写编译器自动生成的析构函数对内置类型成员不做处理，自定类型成员会调用他的析构函数。
还需要注意的是我们显示写析构函数，对于自定义类型成员也会调用他的析构，也就是说自定义类型成员无论什么情况都会自动调用析构函数。
⼀个局部域的多个对象，C++规定后定义的先析构。

ok，我们先来看前四点，通过前四点，我们就知道如何写一个析构函数了：

class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day =day;
	}
	~Date()
	{
		cout << "~Date()" << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;
	return 0;
}

当函数结束时，系统自动调用析构函数

class Stack
{
public:
	Stack(int n = 4)
	{
		_a = (int*)malloc(n * sizeof(int));
		_top = 0;
		_capacity = n;
	}
	~Stack()
	{
		cout << "~stack()" << endl;
		if (_a)
		{
			free(_a);
			_a = nullptr;
			_top = 0;
			_capacity = 0;
		}
	}
private:
	int* _a;
	int _top;
	int _capacity;
};
int main()
{
	Stack s1;
	return 0;
}

特点5：跟构造函数类似，我们不写编译器自动生成的析构函数对内置类型成员不做处理，自定类型成员会调用他的析构函数。 上面操作对内置类型成员的处理很简单，我们来看看对自定义类型的处理是啥意思：

特点6：我们显示写析构函数，对于自定义类型成员也会调用他的析构，也就是说自定义类型成员无论什么情况都会自动调用析构函数。

演示代码：

class Stack
{
public:
	Stack(int n = 4)
	{
		_a = (int*)malloc(n * sizeof(int));
		_top = 0;
		_capacity = n;
	}
	~Stack()
	{
		cout << "~stack()" << endl;
		if (_a)
		{
			free(_a);
			_a = nullptr;
			_top = 0;
			_capacity = 0;
		}
	}
private:
	int* _a;
	int _top;
	int _capacity;
};
class MyQueue
{
public:
	~MyQueue( )
	{
		cout << "~myqueue()" << endl;
	}
private:
	Stack _pushst;
	Stack _popst;
};
int main()
{
	MyQueue q;
	return 0;
}