类和对象（类的6个默认成员函数）

一叶丨之秋

已于 2023-04-20 11:18:36 修改

阅读量416

点赞数 3

分类专栏： C++初阶文章标签： c++

于 2023-04-14 13:34:51 首次发布

本文链接：https://blog.csdn.net/yiyezhiqiuer/article/details/129869827

版权

C++初阶专栏收录该内容

5 篇文章 0 订阅

订阅专栏

1.类的6个默认成员函数：

如果一个类中什么成员都没有，简称空类。

但是不是空类里什么都没有呢？

并不是，在类中什么都不写时，编译器会自动帮我们生成6个默认成员函数。

默认成员函数：用户没有显示实现时，编译器自动帮我们生成的成员函数称作默认成员函数。

2.构造函数：

2.1概念：

我们实现一个日期类，里面有初始化和打印日期两个功能

class Date 
{
public:

	void Init(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.Init(2023, 3, 30);
	d1.print();

	Date d2;
	d2.Init(2023, 4, 1);
	d2.print();
	return 0;
}

我们发现对于Date类我们可以通过初始化函数来对日期对象设置日期，但是如果每次创建对象时都调用初始化函数未免有些麻烦，那能否在对象创建时就将日期信息输入进去呢？这时候就要用到构造函数了。

构造函数是一个特殊的成员函数，名字与类名相同,创建类类型对象时由编译器自动调用，以保证每个数据成员都有一个合适的初始值，并且在对象整个生命周期内只调用一次。

2.2 特性：

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

构造函数的具有以下特性：

1.函数名与类名相同。

2.无返回值。

3.对象实例化编译器会自动调用对应的构造函数。

4.构造函数可以重载。

2.2.1无参构造函数和带参构造函数

在定义构造函数时用户给不给函数形参，构造函数分为无参构造函数和带参构造函数

我们可以看到这分别是一个无参的构造函数，一个是带参的构造函数，他们都满足构造函数的定义，并构成函数重载。

我们来看看他们的初始化方式

这是运行结果：

d1满足我们无参的构造函数设定的默认值。

d2也是我们带参构造函数给的日期。

2.2.2 全缺省带参构造函数

我们给带参构造函数所有形参给上缺省值就像这样

那我们这里就有两个问题：

1.他们构成函数重载吗？

答案是他们构成函数重载，因为他们满足函数重载函数名相同参数不同的定义。

2.那么这么写我们可以成功调用吗？

我们发现在构造d1时编译器说对重载函数调用不明确，因为他不明确要调用无参构造函数还是全缺省构造函数，如果要成功编译那么我们需要屏蔽其中一个。

2.2.3 无构造函数

这里我们试想如果我们并没有写构造函数，那么我们的程序会怎么样呢？

我们综合程序运行结果和反汇编来看，程序在构造d1时，调用了函数，对d1进行初始化，但数值却是一个随机值。

那我们就对系统自己生成的构造函数就有些疑问了，他有什么用呢？

这里我们要了解C++把类型分为内置类型以及自定义类型，内置类型就是语言自己提供的数据类型（如int char.... ），自定义类型就是我们自己定义的类型（如我们自己写的 struct/class/union等）。

看下面的程序我们就会发现默认构造函数在面对自定义类型时会自己调用自定义类型的构造函数

class Time
{
public:
	Time()
	{
		_hour = 1;
		_minute = 30;
		_second = 30;
	}
private:
	int _hour;
	int _minute;
	int _second;
};

class Date
{
private:
	int _year;
	int _month;
	int _day;
	Time _time;
};

int main()
{
	Date d1;
	return 0;
}

我们发现对于自定义类型，默认构造函数会调用自定义类型的构造函数

这里我们可以得知，如果我们没有显示提供默认构造函数，那编译器会自动帮我们生成一个，但和我们预期有所差距，所以还是建议我们自己写。

3.析构函数

3.1概念：

通过前面构造函数的学习，我们知道一个对象是怎么来的，那一个对象又是怎么没呢的？

我们知道在c语言写的栈 stack中，在栈初始化后要记得销毁栈调用destroy函数，但我们常常忘记调用，所以C++为了方便使用，自动在程序结束时调用析构函数。

析构函数：与构造函数功能相反，析构函数不是完成对对象本身的销毁，局部对象销毁工作是由
编译器完成的。而对象在销毁时会自动调用析构函数，完成对象中资源的清理工作。

3.2特性：

析构函数是特殊的成员函数，其特征如下：

1.析构函数是类名前加上 ~。

2.函数无返回值无参数。

3.一个类只能有一个析构函数，不能重载，如果未显式定义，那么编译器会自动生成一个。

4.对象生命周期结束时，编译器会自动调用析构函数。

自动调用：

我们来看看加上析构函数后怎么使用：

class Date
{
public:

	Date()
	{
		_year = 1900;
		_month = 1;
		_day = 1;
	}

	~Date()
	{
		cout << "~Date" << endl;
	}
private:
	int _year;
	int _month;
	int _day;

};

int main()
{
	Date d1;
	return 0;
}

我们发现程序打印出了 ~Date，说明他确实调用了析构函数，但我们没有显示调用啊。

我们在转到反汇编看看

原理编译器在退出主函数时会自动调用析构函数来销毁对象，因为析构函数在对象生命周期结束时自动调用。

我们提到析构函数和构造函数一样，在用户未显示调用时，系统会自动生成一个默认的析构函数，对于只有内置类型的类，它同样写不写都一样，但是对于自定义类型中有申请资源的类，我们一定要自己实现，否则会造成资源泄露。

class Stack {

public:

	Stack()
	{
		_a = (int*)realloc(_a, sizeof(int) *4);
		if (_a == nullptr)
		{
			perror("realloc");
			exit(-1);
		}
		_top = 0;
		_capacity = 4;
		
	}

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

	void Push(const int& x)
	{
		_a[_top++] = x;
	}

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

};

对于上段代码，我们在堆上手动申请了资源空间，如果在析构函数中没有手动释放，那么这块空间的资源就丢失了，造成资源泄露的问题。

而且对于自定义类型，默认析构函数会自动调用所包含类型的析构函数。

我们写一个包含刚才Stack类的myqueue类：

class Stack {

public:

	Stack()
	{
		_a = (int*)realloc(_a, sizeof(int) *4);
		if (_a == nullptr)
		{
			perror("realloc");
			exit(-1);
		}
		_top = 0;
		_capacity = 4;
		
		cout << "stack()" << endl;
	}

	~Stack()
	{
		free(_a);
		_a = nullptr;
		_top = 0;
		_capacity = 0;
		cout << "~Stack()" << endl;
	}

	void Push(const int& x)
	{
		_a[_top++] = x;
	}

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

};

class myqueue {
public:
private:
	Stack _pushst;
	Stack _popst;

};


int main()
{
	myqueue q1;
	return 0;
}

我们可以看到结果他自动调用了stack的构造函数和析构函数。

面向需求：编译器默认生成就可以满足，就不用自己写，不满足就需要自己写
Date Stack的构造函数需要自己写

MyQueue构造函数就不需要自己写，默认生成就可以用

Stack的析构函数，需要我们自己写
MyQueue Date就不需要自己写析构函数，默认生成就可以用

4.拷贝构造函数

4.1概念：

在生活中，可能存在一个和你一样的自己，我们称之为双胞胎。

那么在创建对象时能不能创建一个相同的对象呢。

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

4.2特性

拷贝构造函数也是特殊的成员函数，其特征如下：

1.拷贝构造函数时构造函数的一种重载方式

2.拷贝构造的参数只有一个，并且只能是类类型的引用，不能使用传值方式传参，否则会引发无穷递归。

class Date
{
public:
	Date(int year,int month,int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
		
	Date(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}


	~Date()
	{
		cout << "~Date" << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1(2023,4,14);
	Date d2(d1);
	return 0;
}

我们发现d2的值确实和d1的相同。

这里我们用的参数确实是传引用的方式，那么为什么不能使用传值的操作呢？

因为我们要理解，传值操作我们需要用d1构造出一个中间变量d，但变量d也要使用拷贝构造构造出来，所以为了构造d我们需要构造中间变量d‘，但d’也需要拷贝构造，所以就会造成无限递归。所以我们要记得使用传引用就好。

4.3 浅拷贝和深拷贝

若用户未显式定义拷贝构造函数，编译器会生成默认的拷贝构造函数。默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。

同样对于日期类这种，我们可以不写他的拷贝构造函数因为系统自动生成的默认拷贝构造函数足够了，但是对于有资源管理的类，例如我们的Stack类我们如果不写会有什么问题呢？

class Stack {

public:

	Stack()
	{
		_a = (int*)realloc(_a, sizeof(int) *4);
		if (_a == nullptr)
		{
			perror("realloc");
			exit(-1);
		}
		_top = 0;
		_capacity = 4;
		
		cout << "stack()" << endl;
	}

	~Stack()
	{
		free(_a);
		_a = nullptr;
		_top = 0;
		_capacity = 0;
		cout << "~Stack()" << endl;
	}

	void Push(const int& x)
	{
		_a[_top++] = x;
	}

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

};

int main()
{
	Stack st1;
	Stack st2(st1);
	return 0;
}

我们发现程序直接发生了崩溃，那是什么原因呢？

我们在debug中发现在执行到拷贝构造的时候程序还能运行并将st2的值也拷贝成了st1的值

然而在系统调用析构函数的时候，st2成功析构，在析构st1中释放st1空间时，程序发生崩溃，这里是因为同一块空间只能被释放一次，由于浅拷贝的原因，他们指向同一块空间，析构st2时当然不会有问题但析构st2时就会引发程序崩溃。

对于如何解决浅拷贝的问题呢？我们提出了深拷贝的方式，但解决方法我们以后在讲，首先了解到这个问题。

4.4拷贝构造的典型调用场景

1.使用已存在对象构造新对象

2.函数参数类型为类类型对象

3.函数返回值类型为类类型对象

我们写一个程序来验证一下

class Date
{
public:
	Date(int year,int month,int day)
	{
		cout << "Date(int ,int, int)" << this << endl;
	}
		
	Date(const Date& d)
	{
		cout << "Date(const Date& d)" << this << endl;
	}


	~Date()
	{
		cout << "~Date()" <<this<< endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

Date test(Date d)
{
	Date temp(d);
	return temp;
}
int main()
{
	Date d1(2023,4,14);
	test(d1);
	return 0;
}

我们直观的看到首先构造d1对象，在用d1拷贝构造参数d，d再去创建temp，最后返回temp时也要使用拷贝构造来构造临时对象。最后随他们的生命周期结束分别析构。

5.赋值运算符重载

5.1运算符重载

C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其
返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。
函数名字为：关键字operator后面接需要重载的运算符符号。
函数原型：返回值类型 operator操作符(参数列表)

注意：
1.不能通过连接其他符号来创建新的操作符：比如operator@
2.重载操作符必须有一个类类型参数
3.用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不能改变其含义
4.作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐
藏的this
5. .* :: sizeof ?: . 注意以上5个运算符不能重载。

我们先看一个场景看看两个日期类日期是否相同

我们发现编译器并没有让我们通过，报出没有匹配的操作符，这是为什么呢？

因为编译器根本不知道如何比较两个自定义类型的大小，是比较年大小呢还是月大小呢？

所以我们需要重载运算符来告诉编译器如何比较两个自定义类型的大小。

只有重载了==运算符，告诉编译器怎么比较我们的对象才能比较成功。

5.2赋值运算符的重载

赋值运算符重载格式：
参数类型：const T&，传递引用可以提高传参效率
返回值类型：T&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值
检测是否自己给自己赋值
返回*this ：要复合连续赋值的含义

我们先来试着写一下赋值运算符的重载

void operator=(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}

我们分别构造了d1和d2，他们的日期并不相同，之后我们用d1给d2赋值并判断他们是否相等，发现他们确实相同，说明赋值成功。

那么我们的赋值运算符重载完成了吗？

我们可以和普通内置类型比较一下

我们能清楚的知道a，b，c的值都会是10。那我们的日期类现在能否这样赋值？

我们发现编译器告诉我们没有与操作数匹配的运算符。我们明明重载了运算符=，那为什么还会出现这种情况呢？

因为我们函数的返回值是void我们需要比较相同类型的对象，所以我们需要将返回值类型改为类类型。

Date operator=(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
        return *this;
	}

这样就可以成功运行了。

注意：

同样的在用户没有显示提供赋值运算符重载的时候，系统会自动帮我们生成，但同样只适用于没有资源管理的类，对有资源管理类的类型同样存在浅拷贝的问题。

今天我们主要讲解了四种默认函数

分别是构造，拷贝构造，析构和赋值运算符重载

如有纰漏，不吝赐教

一叶丨之秋

关注

3
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
1
评论
类和对象（类的6个默认成员函数）

默认成员函数
复制链接

扫一扫

专栏目录

类和对象（类的6个默认成员函数）

1.类的6个默认成员函数：

2.构造函数：

2.1概念：

2.2 特性：

2.2.1无参构造函数和带参构造函数

2.2.2 全缺省带参构造函数

3.析构函数

3.1概念：

3.2特性：

4.拷贝构造函数

4.1概念：

4.2特性

4.3 浅拷贝和深拷贝

4.4拷贝构造的典型调用场景

5.赋值运算符重载

5.1运算符重载

5.2赋值运算符的重载

“相关推荐”对你有帮助么？