【C++初阶】类和对象修炼中

ゝ一纸荒年。 2024-04-03 12:17 11阅读 0赞

#### 文章目录 ####

*  一.构造函数
 *   *  1.构造函数的简单认识
     *  2.内置类型和自定义类型的处理方式
     *  3.日期类和资源清理类
 *  二.析构函数
 *  三.拷贝构造
 *  四.赋值运算符重载

> 继上篇类和对象中的一些细碎知识点，这节我们要给大家讲一讲六大默认成员函数中的最常用的四大默认成员函数：构造函数，析构函数，拷贝构造函数，赋值运算符重载函数。

![\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0des6T1I-1665669398370)(C:\\Users\\21677\\AppData\\Roaming\\Typora\\typora-user-images\\image-20221012163505906.png)\]][img-0des6T1I-1665669398370_C_Users_21677_AppData_Roaming_Typora_typora-user-images_image-20221012163505906.png]

空类中真的什么都没有吗？实际上，空类中，编译器也会默认生成六大成员函数，并且完成自动调用，但是我们学习它们的成本并不是想象中的那么低的，因为编译器默认生成的六大默认成员函数有的极为相似，有的却大相径庭，**对于内置类型和自定义类型，对于简单的日期类和栈资源清理类的处理方式都有区别**，**这也是我们后面学习中重点关注的地方。**

## 一.构造函数 ##

> 首先给大家聊聊为什么C++中要设计出构造函数，构造函数完成的是对象的初始化Init()，因为在实际代码编写过程中，我们往往会忘记写对象的初始化函数Init(),甚至还会出现写了忘记调用的情形，这造成的影响就是成员变量还是天生的随机值，对于比如栈这种对象，带有指针的，如果指向内存中的一块随机地址，就会出现非法访问内存的大问题哦。所以C++中就出现了构造函数，如果你没写的话，编译器就帮我们写好初始化函数，并且在对象创建的时候自动调用。
> 
> PS：构造函数完成的是对象的初始化，而不是对象的创建，对象的创建是类的实例化这个行为完成的，只不过构造函数是在类的实例化，创建对象的过程中同步完成的对象的初始化。

### 1.构造函数的简单认识 ###

首先让我们来看看构造函数的特征：![image-20221012171302335][]

ps:这里可以通过调试看到函数调用的过程，自己试试吧

> 这里重点给大家讲讲特征中的第4点，构造函数可以重载，其实也就是函数重载，函数重载的话就要满足函数的参数的类型或个数不同。
> 
> 误区！！！默认构造函数**并不仅仅**指的是我们不写，编译器默认生成的；
> 
> 编译器默认生成的只是三种构造函数重载的默认构造函数的一种，也就是下图中我们显式写出来的无参构造函数.
> 
> 另外，由于函数重载，我们还可以写出全缺省构造函数和无参的构造函数，这三个都是默认构造函数，其中，我还顺便测试了一下，在类的实例化的三种方式中，得出了能调用两个默认构造函数是哪几个类实例化的结果。
> 
> 默认构造函数:不传参数就可以调用就可以调用的(想想构造函数设计出来的原因就可以理解),不传参的并不意味着就是无参的,还有可能是全缺省.

![image-20221012221959231][]

通过上面的测试结果我们可以得出结论：

1.  从左向右看：三种调用方式中如果哪一个种方式,如果能同时调动编译器自动生成的默认构造函数和全缺省的默认构造函数，就不能两个构造函数都写，不然会造成调用不明确—二义性。
2.  从右往左看：全缺省构造函数可以被三种调用方式调动，所以我们在自己写构造函数的时候，都是强烈推荐写成全缺省的构造函数。![image-20221012222607086][]

注意:下面的这中调用构造函数的方式是错误的,原因是容易和函数的声明混

A a();
    	int fun();

### 2.内置类型和自定义类型的处理方式 ###

1.  内置类型:int,char,double,int\*等语言本身内置的类型
2.  自定义类型:class,struct等自己定义的类型

规则:编译器自动生成的构造函数对于内置类型不处理,对于自定义类型会调用它的默认构造函数去构造.

class Time
    {
    public:
    	Time()
    	{
    		_hour = 0;
    		_minute = 0;
    		_second = 0;
    	}
    private:
    	int _hour;
    	int _minute;
    	int _second;
    };
    class Date
    {
    private:
    	// 内置类型
    	int _year;
    	int _month;
    	int _day;
    	// 自定义类型
    	Time _t;
    };
    int main()
    {
    	Date d;
    	return 0;
    }

![image-20221012210900698][]

另外,注意：C++11 中针对内置类型成员不初始化的缺陷，又打了补丁，即：内置类型成员变量在 类中声明时可以给默认值。

![image-20221012220925408][]

> 所以一般是成员变量全部都是自定义类型才不自己写,比如MyQueue,不然只要有内置类型就要自己写构造函数.

### 3.日期类和资源清理类 ###

对于日期类,编译器默认生成的构造函数啥也没干,所以日期类的默认构造函数需要自己写:

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;
    }

![image-20221012211230631][]

对于资源清理类,编译器默认生成的构造函数也是啥也没干,所以资源清理类的默认构造函数也需要自己写:

> 综合就是:对于日期类还是资源清理类的构造函数都需要自己写,一般就是自定义类型才不用自己写,但是还得具体看需求.

## 二.析构函数 ##

> 其实析构函数完成的是资源清理工作Destory()，和构造函数的功能恰恰相反，一个初始化，一个资源清理，但是析构函数被设计出来的原因却是和构造函数一模一样，都是为了避免忘记写了，或者写了忘记调用了，资源清理工作往往是更多人容易忽略的地方，C++中的析构函数就这样诞生了，如果你没写的话，编译器就帮我们写好析构函数，并且在对象销毁(函数返回)的时候同步把对象利用到的资源清理。

![image-20221012205424312][]

> 析构函数的调用时机:对象的生命周期结束的时候调用,也就是对象销毁的时候,析构函数同步被调用.

析构函数的细节比构造函数的细节相对较少,不过值得注意的是对象与对象之间析构的顺序:后构造的先析构

> 构造函数和析构函数针对的都是对象的成员变量,也就是成员变量的赋值和去值,官方的说就是对象的初始化和资源清理.下面是析构函数结合构造函数写的一个资源清理类.

#include<iostream>
    using namespace std;
    class Stack
    {
    public:
    	Stack(int capacity)
    	{
    		_a = (int*)malloc(sizeof(int) * capacity);
    		_capacity = capacity;
    		_size = 0;
    	}
    	void Push(int x)
    	{
    		if (_capacity == _size)
    		{
    			int newcapacity = 2 * _capacity;
    			int* temp = (int*)realloc(_a,sizeof(int)*newcapacity);
    			if (temp == NULL)
    			{
    				perror("push::realloc");
    				exit(-1);
    			}
    			_capacity = newcapacity;
    			_a = temp;
    		}
    		_a[_size++] = x;
    	}
    	void Print()
    	{
    		for (int i = 0; i < _size; i++)
    		{
    			cout << _a[i] << endl;
    		}
    	}
    	~Stack()
    	{
    		free(_a);
    		_a = NULL;
    		_capacity = _size = 0;
    	}
    private:
    	int* _a;
    	int _capacity;
    	int _size;
    };
    
    int main()
    {
    	Stack st(4);
    	st.Push(1);
    	st.Push(2);
    	st.Push(3);
    	st.Push(4);
    	st.Push(5);
    	st.Print();
    	return 0;
    }

规则:日期类的析构函数不用自己写,但是资源清理类一般都需要自己写,除非都是自定义类型,比如MyQueue里都是自定义类型,他会调用它的析构函数去析构.

> 综合:一切都需要看去需求,日期类构造函数要自己写,资源清理类构造和析构函数都要自己写,MyQueue类的构造和析构都不需要自己写.(这里不要死记硬背,还是得把握规律)

## 三.拷贝构造 ##

> 设计出拷贝构造函数的目的是为了适应一些我要形成一个对象的副本,去做一些运算,这也就是拷贝对象的过程.

首先拷贝构造也是一种构造函数,也就是说也是一种在创建对象的时候同步调用拷贝构造函数,去初始化一个对象,只不过这一次不再是用与传入的成员变量同类型的参数,而是一个同类型的对象去初始化.

传入的是一个同类型的对象,同时结合我们之前学过的构造函数的特征,就可以写出这样的“拷贝构造函数”,但是这样的拷贝构造是错误的,因为会引发无穷递归.

class Date
    {
    public:
    	Date(int year=2022, int month=10, int day=12)
    	{
    		_year = year;
    		_month = month;
    		_day = day;
    	}
    
    	//错误的拷贝构造:
    	Date(Date d)
    	{
    		_year = d._year;
    		_month = d._month;
    		_day = d._day;
    	}
    private:
    	// 内置类型
    	int _year;
    	int _month;
    	int _day;
    };
    int main()
    {
    	Date d1(2022, 2, 2);
    	//拷贝构造
    	Date d2(d1);
    	return 0;
    }

> 错误的拷贝构造:写拷贝构造函数如果使用得是传值传参,由于形参是实参得一种拷贝,所以就得在实参向形参传递得时候完成拷贝构造,然后拷贝构造又要传参,传参又是拷贝构造,这样就引发了无穷递归.

![image-20221012232652604][]

正确的拷贝构造方法是利用传引用传参,使用的是d2的别名,就不用在实参向着形参传递的时候先拷贝(拷贝构造)了,同时使用const修饰,防止被误操作修改了d2对象的成员变量的值,一旦发生,也可以很快的检查出来.

![image-20221012231447414][]

编译器自动生成的拷贝构造函数对于内置类型会进行处理,完成拷贝,对于自定义类型,会调用它的拷贝构造函数.

> 到这里你是不是想起了编译器自动生成的构造函数对于内置类型是不进行处理的,所以对于日期类和资源清理类都要自己写,但是这里既然编译器自动生成的拷贝构造函数对内置类型会进行处理,自定义类型也会主力,那这是不是意味着拷贝构造函数我们就完全不用自己写了呐?实则不然,这里对内置类型会处理,但这处理的结构可能并非是我们想要的结果,得分日期类和资源清理类进行分类讨论.

class Stack
    {
    public:
    	Stack(int capacity)
    	{
    		_a = (int*)malloc(sizeof(int) * capacity);
    		_capacity = capacity;
    		_size = 0;
    	}
    	void Push(int x)
    	{
    		if (_capacity == _size)
    		{
    			int newcapacity = 2 * _capacity;
    			int* temp = (int*)realloc(_a,sizeof(int)*newcapacity);
    			if (temp == NULL)
    			{
    				perror("push::realloc");
    				exit(-1);
    			}
    			_capacity = newcapacity;
    			_a = temp;
    		}
    		_a[_size++] = x;
    	}
    	void Print()
    	{
    		for (int i = 0; i < _size; i++)
    		{
    			cout << _a[i] << endl;
    		}
    	}
    	~Stack()
    	{
    		cout << "析构函数" << endl;
    		free(_a);
    		_a = NULL;
    		_capacity = _size = 0;
    	}
    private:
    	int* _a;
    	int _capacity;
    	int _size;
    };
    
    int main()
    {
    	//构造
    	Stack st1(4);
    	//拷贝构造
    	Stack st2(st1);
    	return 0;
    }

![image-20221013000240114][]

> 我们会发现,这里得对于日期类,编译器默认生成的拷贝构造函数就够我们使用,但是如果是上面的资源清理类,拷贝的结果明显是一种浅拷贝,对于成员变量\_a的拷贝明显不是我们想要的结果.

![image-20221013001032237][]

> 需要写析构函数的，比如栈,默认生成的拷贝构造(浅拷贝)都不能满足我们的拷贝需求,都需要写深拷贝

对于自定义类型 ，拷贝的时候，编译器会调用自定义类型的拷贝构造，比如MyQueue()不用自己写。

## 四.赋值运算符重载 ##

> 讲赋值运算符重载之前得先给大家讲讲什么是运算符重载.

C++为了增强程序代码的可读性，使得自定义类型和内置类型一样，能够让自定义类型使用运算符。比如实现两个日期类的对象相加，将运算的结果存到另一个对象中,因为运算符重载的存在,代码可以通俗易懂成这样：

Date d1(2022,1,1);
    Date d2(2022,12,31);
    Date d3=d1+d2;//两个日期类对象相加
    //同理日期类对象+100天
    Date d4=d3+100;

这里因为日期+天数或者日期+日期的函数写起来麻烦一点,所以我们用判断两个日期类对象是否相等来给大家演示:

这里我给大家演示的是将函数定义成了全局的,这样第一个参数就不是this指针,但是C++编译器同样支持把调用函数的方式处理成我们从小到大都熟悉的形式:d1==d2,而非

operator==(d1,d2);

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

但是注意:这里的调用方式可以写成内置类型使用运算符的形式,但是运算符重载函数函数名必须是operator加上运算符,返回值和参数个数都参照运算符的规则.

这里因为在类外面,也就是全局要能访问到成员变量,所以我们将成员变量的访问限定符改为了public,给大家一步一步讲:

class Date
    {
    public:
    	Date(int year = 2022, int month = 10, int day = 12)
    	{
    		_year = year;
    		_month = month;
    		_day = day;
    	}
    
    
    	Date(Date& d)
    	{
    		_year = d._year;
    		_month = d._month;
    		_day = d._day;
    	}
    
    
    //private:
    	// 内置类型
    	int _year;
    	int _month;
    	int _day;
    };
    
    bool operator==(const Date& d1,const Date& d2)
    {
    	return d1._year == d2._year
    		&& d1._month == d2._month
    		&& d1._day == d2._day;
    }
    
    int main()
    {
    	Date d1(2022, 1, 1);
    	Date d2(2022, 12, 31);
    	if (d1 == d2)
    	{
    		cout << "d1==d2" << endl;
    	}
    	else
    	{
    		cout << "d1!=d2" << endl;
    	}
    	return 0;
    }

![image-20221013211455142][]

但是显然这里是共有的成员变量肯定是不行的,所以我们采用将全局的运算符重载函数写成成员函数的形式,这样在同一个类里面就可以访问到成员变量了,这样的话,运算符重载函数的第一个参数就是隐含的this指针了,可以少写一个参数,但是既然写成了成员函数,第一个参数就一定要是运算符的第一个操作数,第二个参数一定是运算符的第二个操作数,顺序不能反,因为有一些操作数的顺序是不能反的,比如比较大小运算符.

![image-20221013211922002][]

这里如果有一个全局的和一个类里的成员函数都是判断对象是否相等的运算符重载函数,那么编译器的查找策略是先在类里面找,然后再去全局找,也就是类里优先,其实这也是在告诉我们C++推荐将运算符重载函数定义成成员函数,而非全局的函数(也没法定义成全局的,因为成员变量几乎都是私有访问的)

> 有了运算符重载得铺垫,我们就可以给大家讲什么是赋值运算符重载了.

对于不同的类,每一种类实例化出来的多个对象之间可能不能比较对象的大小,比如带有字符串的;但是几乎大部分的类实例化出来的对象都是支持对象之间相互赋值的,所以C++就把赋值运算符重载加到了六大默认成员函数的中.

class Date
    {
    public:
    	Date(int year = 2022, int month = 10, int day = 12)
    	{
    		_year = year;
    		_month = month;
    		_day = day;
    	}
    
    	Date(Date& d)
    	{
    		_year = d._year;
    		_month = d._month;
    		_day = d._day;
    	}
        
        //注意这里返回的是引用类型,函数结束后局部变量this不存在了,但是*this还是存在的
    	Date& operator=(const Date& d2)
    	{
    		    _year = d2._year;
    			_month = d2._month;
    		    _day = d2._day;
    		 return *this;
    	}
    
    	void Print()
    	{
    		cout << _year << "-" << _month << "-" << _day << endl;
    	}
    
    private:
    	// 内置类型
    	int _year;
    	int _month;
    	int _day;
    };
    
    
    int main()
    {
    	Date d1(2022, 1, 1);
    	Date d2(2022, 12, 31);
    	Date d3 = d2 = d1;
    	d2.Print();
    	d3.Print();
    	return 0;
    }

![image-20221013213832954][]

> ps:因为内置类型的赋值运算符的结合顺序是从右向左,而且是支持a=b=c连续赋值的,所以赋值运算符函数必须做到和内置类型的功能一致.

赋值好像和拷贝的意义是差不多的,也就是说赋值重载和拷贝构造的特性是一样的.

等等,这里的Date d3=d2这部分,这里也是赋值运算符重载吗?

实则不是的,这里是拷贝构造,这里一定要注意拷贝构造和赋值重载的区别:

> 拷贝构造是用一个已经存在的对象,去给一个正在创建的对象进行初始化,
> 
> 赋值重载是用一个已经存在的对象,去给另一个已经创建的对象进行赋值,

这里的d3显然是正在创建的对象,而d2是已经存在的对象,这是拷贝构造,所以Date d3=d2=d1这里既有赋值重载和拷贝构造.

![image-20221013215120154][]

[img-0des6T1I-1665669398370_C_Users_21677_AppData_Roaming_Typora_typora-user-images_image-20221012163505906.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/68ee8093ab9d4687a3afabd68af69d06.png
[image-20221012171302335]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/45b6a06f77bf4c9192ef187b65a39afe.png
[image-20221012221959231]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/6127d2c8f5ce4147aa8b94866245d061.png
[image-20221012222607086]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/54b7c05e6f2849e4a319ba53e7e8b086.png
[image-20221012210900698]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/28fdee4bd47741f9915f9cb799dad011.png
[image-20221012220925408]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/7aff5c3e755343ed9c6cfdd57e1840fa.png
[image-20221012211230631]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/d203a45e285b4219866b654e2498f585.png
[image-20221012205424312]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/0fbbc4922e4e4c0786d701fcaace9c24.png
[image-20221012232652604]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/c4d72a70b8224461afbcae78998e8cad.png
[image-20221012231447414]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/000b8337fdf047ab853c32aa66616a89.png
[image-20221013000240114]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/5f1c9fe9c701471aa89190dfe0b5231d.png
[image-20221013001032237]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/88743ace75234a5780ca46b27471d74f.png
[image-20221013211455142]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/b779ad53f36249d2b45ca056702343e6.png
[image-20221013211922002]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/8ce9a59817fa4c669056d03c6e6fe80d.png
[image-20221013213832954]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/58cb2cd0e3e540b0999ed43f315a6ab7.png
[image-20221013215120154]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/348f96b1b56e410abfa9900c8411b114.png