C++类的6个默认成员函数

JDSZGLLL

已于 2023-02-05 19:27:58 修改

阅读量806

点赞数 16

分类专栏： C++学习分享文章标签： c++ 开发语言学习

于 2022-07-23 23:08:45 首次发布

本文链接：https://blog.csdn.net/JDSZGLLL/article/details/125879293

版权

C++学习分享专栏收录该内容

27 篇文章 0 订阅

订阅专栏

引言

6个默认成员函数是学习C++绕不过去的一个坎，其中的知识相当的细碎繁琐，许多同学在学习的过程中往往又不求甚解，这对于我们深入理解和运用C++是非常不利的。本篇博客将会详细描述这六个函数，把它们剖析得明明白白。

默认成员函数的意思是即使我们不写，编译器也会自动生成，但是编译器自动生成的函数并不是那么好用，所以有许多情况下需要我们自己编写。

构造函数

构造函数是特殊的成员函数，需要注意的是，构造函数的虽然名称叫构造，但是需要注意的是构造函数的主要任务并不是开空间创建对象，而是初始化对象。

首先我们来创建一个日期类和一个栈类:

#include<iostream>
using std::cout;
using std::cin;
using std::endl;

class  date
{
public:
	void SetDate(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Display()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

class stack
{
private:
	int* _p;
	int _capacity;
	int _numbers;
};

接下来我们讲解六个函数都从这两个类型出发。

在我们学习默认构造函数之前，是怎么样初始化对象中的内容的，因为对象中的成员都是私有的，无法直接改变，显然需要运用的是类中的函数。

int main()
{
	class date d1;
	d1.SetDate(1, 1, 1);
	return 0;
}

但是，每创建一个对象都要单独调用一次，是不是显得比较麻烦。

铺垫了那么多，就是为了证明一件事，构造函数——牛逼！

其特征如下：
1. 函数名与类名相同。
2. 无返回值。
3. 对象实例化时编译器自动调用对应的构造函数。
4. 构造函数可以重载。

根据这些特点，我们来写两个重载的构造函数（一个带参，一个不带参）：

class  date
{
public:
	
	void Display()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
	// 1.无参构造函数
	date()
	{
		_year = 1;
		_month = 1;
		_day = 1;
	}
	// 2.带参构造函数
	date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};

从图中我们可以了解到构造函数的四个特征，可以重载，并且在创建的时候自动调用，使用起来十分方便。

其中无参的构造函数，全缺省的构造函数，以及编译器自动生成的构造函数，由于在创建时自动调用，被称为默认构造函数。如上图的d1就是调用的默认构造函数，d2调用的是带参数的构造函数。

其中要注意的是，我们如果已经写了构造函数了，不管是不是默认构造函数，编译器都不生成默认构造函数：

date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}

当我们在类中只写这一个构造函数时，这个类现在是没有默认构造函数的。

我们已经知道我们自己写的是可以使用的，但是它作为默认函数，也就是说即使我们不写，编译器也会自动生成并调用，让我们来看看它自动生成的构造函数的效果：

这个效果就有些让人迷惑了，默认的构造函数像是什么都没干，那么怎么会这样呢？

别着急，让我们对程序做一点小改动，先声明一个新的类：

class  _time
{
public:
	_time(int time = 100)
	{
		__a = time;
	}
private:
	int __a;
};

在class date类型中再添加一个私有成员变量_a:

class  date
{
public:
	
	void Display()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
	class _time _a;
};

接下来我们再来看看自动生成的默认构造函数的效果：

很神奇，新加入的 class _time _a;可以被初始化。

这是因为C++自动生成的默认构造函数，对于内置类型（int、long等等）它是不会处理的，对于自定义类型（比如说 class _time类型）会调用自定义类型的默认构造函数。我们写了class _time 的构造函数就被调用了，如果我们没有写那么class _time 被调用的就是自动生成的默认构造函数，也是不会产生任何效果的。

析构函数

前面通过构造函数的学习，我们知道一个对象是怎么被初始化的，那一个对象又是怎么没呢的？
析构函数：与构造函数功能相反，析构函数不是完成对象的销毁，局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数，完成类的一些资源清理工作。

我们可以从具体的例子来认识析构函数的作用，比如我们上述的stack类型：

class stack
{
public:
	stack()
	{
		_p = (int *)malloc(10 * sizeof(int));
		_capacity = 10;
		_numbers = 0;
	}
private:
	int* _p;
	int _capacity;
	int _numbers;
};

我们已经写了一个默认构造函数了，创建stack类型的对象时自动调用：

我们可以看到，默认函数已经被调用，等到出作用域时s1会被销毁，但这时有一个问题，_p虽然被销毁了，但是_p指向的动态开辟的内存区域却并没有被free函数释放，而且没有一个指针可以有效管理这块动态区域，这是一件非常可怕的事情。相当于这块内存就被遗忘在角落了，等到这样的内存越来越多，我们能用的内存就越来越少，最后程序会发生崩溃。

那么有没有办法在编译器销毁s1之前释放内存呢，这就轮到析构函数粉墨登场了。我们来看一看析构函数的特点：
1. 析构函数名是在类名前加上字符 ~。
2. 无参数无返回值。
3. 一个类有且只有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。
4. 对象生命周期结束时，C++编译系统系统自动调用析构函数。

5.只要类中包含别的自定义成员，在运行完析构函数之后会调用自定义成员的析构函数。

~stack()
	{
		free(_p);
		_p = NULL;
		_capacity = 0;
		_numbers = 0;
	}

这是我在，stack类型下写的析构函数，印证了第一点和第二点。

class  _time
{
	friend class date;
public:
	_time(int time = 100)
	{
		__a = time;
	}
	~_time()
	{
		cout << "~time" << endl;
	}
private:
	int __a;
};
class  date
{
public:
	
	void Display()
	{
		cout << _year << "-" << _month << "-" << _day << "-" << _a.__a << endl;
	}
	// 1.无参构造函数
	date()
	{
		_year = 1;
		_month = 1;
		_day = 1;
	}
	// 2.带参构造函数
	date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
	class _time _a;
};

我写的是_time类型的析构函数，并没有写date类型的析构函数，但是在使用date d1 时，调用了_time的析构函数。

这说明了第三点，虽然没有写date类型的析构函数，但是编译器自动生成了，只是自动生成的析构函数和构造函数一样，对内置类型不做任何处理，对自定义类型调用相应的析构函数。

这就是析构函数，主要是为了解决内存泄露问题。

拷贝构造函数

在创建一些自定义类的对象时，我们想要这些对象的内容一致，按照目前的知识，我们只能在初始化时配置，但是当类中的成员变量很多时，这是一项非常烦人的工程。

那么有什么方法来解决这个问题呢？C++中的拷贝构造函数就是用来解决这个问题的。

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

date(date& d)
{
	_year = d._year;
	_month = d._month;
	_day = d._day;
	_a.__a = d._a.__a;
}

这是date类的拷贝构造函数，函数名和构造函数一致，两者之间构成函数重载。当我们只写拷贝构造函数时会发生什么。

我们发现，编译器不在自动生成默认构造函数了，也就是说，拷贝构造函数是一个特殊的构造函数。那么，构造函数是怎么用的呢？

如图，在创建对象时，在其后加（） ,把想要拷贝的类型加入其中就可以了。

我们来看看拷贝构造函数有哪些特点：
1. 拷贝构造函数是构造函数的一个重载形式。
2. 拷贝构造函数的参数只有一个且必须使用引用传参，使用传值方式会引发无穷递归调用。
3. 若未显示定义，系统生成默认的拷贝构造函数。默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝我们叫做浅拷贝，或者值拷贝

第一点已经被我们证明了，关于第二点，我们可以展开讲一讲，为什么拷贝构造函数要使用引用传参。

我们来通过上面这张图，来解读一下为什么不能拷贝传参。

当我们想要调用拷贝构造函数，把d1的内容拷贝给d2时，由于是拷贝传参，首先要把d1拷贝给d，然后再由d把内容赋给d2。

把d1拷贝给d的过程，也需要调用拷贝构造函数，由于是拷贝传参，首先要把d1拷贝给第二个d，然后再由第二个d把内容赋给第一个d。

要不停地传值调用拷贝构造函数，停不下来了，寄。

然后我们发现，我们只是想把d1的数据传给d2，但是这时候发现要先把值传给第一个d，在传给第一个d的过程中，发现要先把值传给第二个d，这就是个死递归。

由于拷贝的时候要先创建一个参数，并且要把值传给它，有点舍近求远的意思，为什么不去掉中间参数(没有中间商赚差价)，一步到位。

这就，用到了引用传值。

date(const date& d)
{
	_year = d._year;
	_month = d._month;
	_day = d._day;
	_a.__a = d._a.__a;
}

最后一点，在我没写拷贝构造函数时，编译器会默认生成，

class  date
{
public:
	
	void Display()
	{
		cout << _year << "-" << _month << "-" << _day << "-" << _a.__a << endl;
	}
	//1.无参构造函数
	date()
	{
		_year = 1;
		_month = 1;
		_day = 1;
	}
	// 2.带参构造函数
	date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
	class _time _a;
};

编译器默认生成的拷贝构造函数，依然成功把d1的内容拷贝给d2了。

并且，自动生成的拷贝构造函数对内置类型是直接拷贝，对于自定义类型则是调用默认的相应拷贝构造函数。

class  _time
{
	friend class date;
public:
	_time(int time = 100)
	{
		__a = time;
	}
	~_time()
	{
		cout << "~time" << endl;
	}
	_time(const _time& t)
	{
		__a = t.__a * 20;
	}
private:
	int __a;
};

写了_time 类型的拷贝构造函数，在使用自动生成的date类型的拷贝构造函数时被调用。

既然系统默认的拷贝构造已经可以把值拷贝完成，我们还有必要自己写拷贝构造函数吗？我们刚刚写的，和编译器自动生成的拷贝构造函数都是浅拷贝，或者说是值拷贝。对于日期类当然是完全够用了。

但是我们还有一个类，让我们来看看stack类型：

class stack
{
public:
	stack()
	{
		_p = (int *)malloc(10 * sizeof(int));
		_capacity = 10;
		_numbers = 0;
	}
	~stack()
	{
		free(_p);
		_p = NULL;
		_capacity = 0;
		_numbers = 0;
	}
private:
	int* _p;
	int _capacity;
	int _numbers;
};

乍一看好像没什么问题啊，两个stack对象的内容都一样，但是仔细想想就能知道问题所在。我们创建两个stack是想要创建管理两个栈，但是现在的结果是两个对象中成员_p指向的空间是同一块，也就是说创建了两个对象，但是却只有一个能用的栈，这显然不是我们想要的。

我们想要的是深拷贝，所以需要我们自己写拷贝构造函数。在拷贝时，开辟一个同样大小的空间，不再是追求值一样，而是追求指向的空间相同。

而且从程序准确性的角度，这个函数还有一个大问题，就是两个栈指向的空间一样时，在销毁前，都会调用析构函数，会对同一块空间释放两次，造成编译器报错。

赋值运算符重载函数

C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。

有如下特点

1. 参数类型
2. 返回值
3. 检测是否自己给自己赋值
4. 返回*this
5. 一个类如果没有显式定义赋值运算符重载，编译器也会生成一个，完成对象按字节序的值拷贝。

函数名字为：关键字operator后面接需要重载的运算符符号。
函数原型：返回值类型 operator操作符(参数列表)。

注意：
1. 不能通过连接其他符号来创建新的操作符：比如operator@。
2. 重载操作符必须有一个类类型或者枚举类型的操作数。
3. 用于内置类型的操作符，其含义不能改变，例如：内置的整型+，不能改变其含义。
4. 作为类成员的重载函数时，其形参看起来比操作数数目少1成员函数的。
5. 操作符有一个默认的形参this，限定为第一个形参。
6. .* 、:: 、sizeof 、?: 、. 注意以上5个运算符不能重载。这个经常在笔试选择题中出现。

我们来看看赋值运算符重载函数是怎么写，怎么用的。

class  date
{
public:
	
	void Display()
	{
		cout << _year << "-" << _month << "-" << _day << "-" << _a.__a << endl;
	}
	//1.无参构造函数
	date()
	{
		_year = 1;
		_month = 1;
		_day = 1;
	}
	// 2.带参构造函数
	date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
		_a.__a = 10;
	}
	//拷贝构造函数
	date(const date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
		_a.__a = d._a.__a;
	}
	//赋值运算符重载函数
	date& operator=(const date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
		_a.__a = d._a.__a;
		return *this;
	}
private:
	int _year;
	int _month;
	int _day;
	class _time _a;
};

我们可以看到，赋值运算符重载函数和其他运算符重载是差不多的，但是赋值运算符函数是默认成员函数，就是说我们不写，编译器也会自动生成，我们来看看编译器自动生成的赋值运算符函数的效果。

赋值运算符号函数和拷贝构造函数还是有不少相似之处的，编译器生成的默认赋值重载函数已经可以完成字节序的值拷贝了，但是在有些情况下我们还是要自己写的。

我们还有一个类，让我们来看看stack类型：

和上述拷贝构造函数一样的问题，我想要的是两个堆，结果赋值之后就只有一个堆了。并且两个栈指向的空间一样时，在销毁前，都会调用析构函数，会对同一块空间释放两次，造成编译器报错。完全就有问题，得自己写。

取地址及const取地址操作符重载

这两个默认成员函数一般不用重新定义，编译器默认会生成。

//取地址及const取地址操作符重载
	date* operator&()
	{
		return this;
	}

	const date* operator&() const
	{
		return this;
	}

这两个运算符一般不需要重载，使用编译器生成的默认取地址的重载即可，只有特殊情况，才需要重载，比如想让别人获取到指定的内容。

也就是说，没什么用，用编译器生成的就行！

小知识点

const修饰类的成员函数

将const修饰的类成员函数称之为const成员函数，const修饰类成员函数，实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改。

比如：

void Display()const
{
	cout << _year << "-" << _month << "-" << _day << "-" << _a.__a << endl;
}

友元类

友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。
友元关系是单向的，不具有交换性。
比如上述Time类和Date类，在Time类中声明Date类为其友元类，那么可以在date类中直接访问Time类的私有成员变量，但想在Time类中访问Date类中私有的成员变量则不行。
友元关系不能传递:如果B是A的友元，C是B的友元，则不能说明C时A的友元。

为什么我们上面可以在date类中直接访问Time类的私有成员变量，就是因为date是Time的友元。

class  _time
{
	friend class date;
public:
	_time(int time = 100)
	{
		__a = time;
	}
	~_time()
	{
		cout << "~time" << endl;
	}
	_time(const _time& t)
	{
		__a = t.__a * 20;
	}
private:
	int __a;
};

在time类的任何位置加上friend class date; 就可以了。

JDSZGLLL

关注

16
点赞
踩
8

收藏

觉得还不错? 一键收藏
打赏
16
评论
C++类的6个默认成员函数

6个默认成员函数是学习C++绕不过去的一个坎，其中的知识相当的细碎繁琐，许多同学在学习的过程中往往又不求甚解，这对于我们深入理解和运用C++是非常不利的。本篇博客将会详细描述这六个函数，把它们剖析得明明白白。......
复制链接

扫一扫