C++类和对象(中)——类的6个默认成员函数(构造、析构、拷贝构造、赋值运算符重载)

港控/mmm° 2022-11-04 12:24 16阅读 0赞

### C++类和对象——类的6个默认成员函数（构造、析构、拷贝构造、赋值运算符重载） ###

*  一、类的6个默认成员函数
 *  二、构造函数
 *   *  2.1 构造函数概念
     *  2.2 构造函数特性
     *   *  <1> 函数名类名与相同。
         *  <2> 无返回值。
         *  <3> 对象实例化时编译器自动调用对应的构造函数。
         *  <4> 构造函数可以重载。多个构造函数就会有多种初始化的方式。
         *  <5> 如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成。
         *  <6> 无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。
         *  <7> 没写构造函数时，编译器会默认生成一个构造函数。这个构造函数什么事情都不做嘛？
 *  三、析构函数
 *   *  3.1 概念
     *  3.2 特性
     *   *  <1> 析构函数名是在类名前加上字符 ~
         *  <2> 无参数无返回值
         *  <3> 一个类有且只有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。
         *  <4> 对象生命周期结束时，C++编译系统系统自动调用析构函数。
         *  <5> 关于编译器自动生成的析构函数，是否会完成一些事情呢？
 *  四、拷贝构造函数
 *   *  4.1 概念
     *  4.2 特征
     *   *  <1> 拷贝构造函数是构造函数的一个重载形式
         *  <2> 拷贝构造函数的参数只有一个且必须使用引用传参，使用传值方式会引发无穷递归调用
         *  <3> 若未显示定义，系统生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝我们叫做浅拷贝，或者值拷贝
         *  <4>编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝了，我们还需要自己实现吗？
 *  五、赋值运算符重载
 *   *  5.1 运算符重载
     *  5.2 赋值运算符重载
 *  六、const成员
 *   *  6.1 const修饰类的成员函数
     *   *  Q1：四种const修饰的调用关系？
 *  七、取地址重载

# 一、类的6个默认成员函数 #

如果一个类中什么成员都没有，简称为空类。空类中什么都没有吗？并不是的，**任何一个类在我们不写的情况下，都会自动生成下面6个默认成员函数**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70]  
**简单来说上面6个默认成员函数就是，如果我们写了编译器就会使用我们写的，如果我们不写，编译器就会自动生成一份。** 针对不同的编译器，生成的默认成员函数也会有差异，因此我们需要掌握每个函数的含义。

# 二、构造函数 #

## 2.1 构造函数概念 ##

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

## 2.2 构造函数特性 ##

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

要牢记以下**特性：**

### <1> 函数名类名与相同。 ###

例如：日期类的构造函数就是Date()

### <2> 无返回值。 ###

### <3> 对象实例化时编译器自动调用对应的构造函数。 ###

### <4> 构造函数可以重载。多个构造函数就会有多种初始化的方式。 ###

实现日期类的构造函数，首先类名与函数名要相同，其次没有返回值，两种构造方式，无参和带参

class Date
    {
        
    public:
    	//1.无参构造函数
    	Date()
    	{
        }
    	//2.带参构造函数
    	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;
    };
    
    void Test1()
    {
        
    	Date d1;  //调用无参构造函数
    	d1.Print();
    	Date d2(2021, 3, 2); //调用带参构造函数
    	d2.Print();
    	// 注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明
    	// 以下代码的函数：声明了d3函数，该函数无参，返回一个日期类型的对象
    	Date d3();
    }

![在这里插入图片描述][20210306112015972.png]  
由结果可以看出，构造函数可以重载且可以带参或无参，对于无参构造函数编译器会给一个随机值

### <5> 如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成。 ###

class Date
    {
        
    public:
    	/*
    	// 如果用户显式定义了构造函数，编译器将不再生成
    	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;
    };
    void Test2()
    {
        
    	// 没有定义构造函数，对象也可以创建成功，因此此处调用的是编译器生成的默认构造函数
    	Date d;
    	d.Print();
    }

![在这里插入图片描述][20210306112504905.png]

### <6> 无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。 ###

**注意**：  
无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认成员函数

// 默认构造函数
    class Date
    {
        
    public:
    	Date()
    	{
        
    		_year = 1900;
    		_month = 1;
    		_day = 1;
    	}
    	Date(int year = 1900, int month = 1, int day = 1)
    	{
        
    		_year = year;
    		_month = month;
    		_day = day;
    	}
    private:
    	int _year;
    	int _month;
    	int _day;
    };
    // 以下测试函数能通过编译吗？
    void Test()
    {
        
    	Date d1();
    }

![在这里插入图片描述][20210302164743155.png]  
可以看到编译失败，原因是无参构造函数和全缺省构造函数都是默认成员函数，且只能存在一个，因此编译失败！

### <7> 没写构造函数时，编译器会默认生成一个构造函数。这个构造函数什么事情都不做嘛？ ###

//2.2.7
    class Time
    {
        
    public:
    	Time()
    	{
        
    		cout << "Time()构造函数" << endl;
    		_hour = 0;
    		_minute = 0;
    		_second = 0;
    	}
    private:
    	int _hour;
    	int _minute;
    	int _second;
    };
    
    class Date
    {
        
    
    private:
    	//基本内置类型
    	int _year;
    	int _month;
    	int _day;
    	//自定义类型
    	Time _t;
    };
    
    void Test3()
    {
        
    	Date d;
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 1]

**解答：**  
C++把类型分成**内置类型(基本类型)和自定义类型**。  
内置类型就是语法已经定义好的类型：如int/char…，  
自定义类型就是我们使用class/struct/union自己定义的类型  
**上述程序可以看出编译器生成默认的构造函数会对自定类型成员\_t调用的它的默认成员函数**

# 三、析构函数 #

## 3.1 概念 ##

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

## 3.2 特性 ##

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

### <1> 析构函数名是在类名前加上字符 ~ ###

### <2> 无参数无返回值 ###

### <3> 一个类有且只有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。 ###

### <4> 对象生命周期结束时，C++编译系统系统自动调用析构函数。 ###

对于前面实现的日期类，我们不要释放任何资源，因此不需要编写，使用C++默认生成的析构函数即可  
而对于开辟空间的类则需要自己实现析构函数，释放资源，例如：栈Stack

//3.2.1234
    class Stack
    {
        
    public:
    	Stack(int capacity = 4)
    	{
        
    		_a = (int *)malloc(sizeof(int)*capacity);
    		_size = 0;
    		_capacity = capacity;
    	}
    
    	//栈的析构函数
    	~Stack()
    	{
        
    		free(_a);	//释放堆上的空间
    		_a = nullptr;	//指针置空
    		_size = _capacity = 0;
    		cout << "~Stack()析构函数" << endl;
    	}
    private:
    	int* _a;
    	int _size;
    	int _capacity;
    };
    
    void Test4()
    {
        
    	Stack s;
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 2]

### <5> 关于编译器自动生成的析构函数，是否会完成一些事情呢？ ###

下面的程序我们会看到，编译器生成的默认析构函数，对会自定类型成员调用它的析构函数

//3.2.5
    class Stack
    {
        
    public:
    	Stack(int capacity = 4)
    	{
        
    		_a = (int *)malloc(sizeof(int)*capacity);
    		_size = 0;
    		_capacity = capacity;
    	}
    
    	//栈的析构函数
    	~Stack()
    	{
        
    		free(_a);	//释放堆上的空间
    		_a = nullptr;	//指针置空
    		_size = _capacity = 0;
    		cout << "~Stack()析构函数" << endl;
    	}
    private:
    	int* _a;
    	int _size;
    	int _capacity;
    };
    
    class Person
    {
        
    private:
    	int _age;
    	Stack _s;
    };
    
    void Test5()
    {
        
    	Person p;
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 3]

# 四、拷贝构造函数 #

## 4.1 概念 ##

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

## 4.2 特征 ##

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

### <1> 拷贝构造函数是构造函数的一个重载形式 ###

### <2> 拷贝构造函数的参数只有一个且必须使用引用传参，使用传值方式会引发无穷递归调用 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 4]

//4.2.2
    class Date
    {
        
    public:
    	
    	Date(int year=1900, int month=1, int day=1)
    	{
        
    		_year = year;
    		_month = month;
    		_day = day;
    	}
    
    	//拷贝构造
    	Date(const Date& d)
    	{
        
    		_year = d._year;
    		_month = d._month;
    		_day = d._day;
    	}
    
    	void Print()
    	{
        
    		cout << _year << "-" << _month << "-" << _day << endl;
    	}
    
    private:
    	int _year;
    	int _month;
    	int _day;
    };
    
    void Test6()
    {
        
    	Date d1(2021,3,7);
    	Date d2(d1);
    	Date d3 = d1;
    	d1.Print();
    	d2.Print();
    	d3.Print();
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 5]

### <3> 若未显示定义，系统生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝我们叫做浅拷贝，或者值拷贝 ###

### <4>编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝了，我们还需要自己实现吗？ ###

当然像日期类这样的类是没必要的。但是像Stack这样关注着内存块资源的类浅拷贝是不能解决的，需要自己实现拷贝构造，即深拷贝！  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 6]

# 五、赋值运算符重载 #

## 5.1 运算符重载 ##

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

**注意**：

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

//5.1
    class Date
    {
        
    public:
    
    	Date(int year = 1900, int month = 1, int day = 1)
    	{
        
    		_year = year;
    		_month = month;
    		_day = day;
    	}
    
    	//bool operator==(Date* this, const Date& d2)
    	//这里需要注意的是，左操作数是this指向的调用函数的对象
    	bool operator==(const Date& d2)
    	{
        
    		return _year == d2._year
    			&& _month == d2._month
    			&& _day == d2._day;
    	}
    
    	void Print()
    	{
        
    		cout << _year << "-" << _month << "-" << _day << endl;
    	}
    
    private:
    	int _year;
    	int _month;
    	int _day;
    };
    
    void Test7()
    {
        
    	Date d1(2021, 3, 7);
    	Date d2(2021, 3, 6);
    	Date d3(2021, 3, 7);
    	cout << (d1 == d2) <<endl;
    	cout << (d1 == d3) << endl;
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 7]

## 5.2 赋值运算符重载 ##

赋值运算符主要有四点：

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

//5.2
    class Date
    {
        
    public:
    
    	Date(int year = 1900, int month = 1, int day = 1)
    	{
        
    		_year = year;
    		_month = month;
    		_day = day;
    	}
    
    	//如果用户没有显式定义赋值运算符重载，编译器器也会自动生成一个
    	bool operator=(const Date& d)
    	{
        
    		if (this != &d)
    		{
        
    			_year = d._year;
    			_month = d._month;
    			_day == d._day;
    		}
    	}
    
    	void Print()
    	{
        
    		cout << _year << "-" << _month << "-" << _day << endl;
    	}
    
    private:
    	int _year;
    	int _month;
    	int _day;
    };
    
    void Test8()
    {
        
    	Date d1(2021, 3, 7);
    	Date d2 = d1;
    	d1.Print();
    	d2.Print();
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 8]  
同样对于日期类来说我们只需要使用编译器默认生成的复制重载函数就可以了，但是对于像Stack这样的类来说则需要使用深拷贝去解决了！

# 六、const成员 #

## 6.1 const修饰类的成员函数 ##

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

首先来看以下为什么要使用const修饰类的成员函数，如下问题  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 9]  
这个时候我们就使用const修饰类的成员函数，实际上就是修饰this指针  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 10]

//6.1
    class Date
    {
        
    public:
    
    	Date(int year = 1900, int month = 1, int day = 1)
    	{
        
    		_year = year;
    		_month = month;
    		_day = day;
    	}
    
    	void Print() const
    	{
        
    		cout << _year << "-" << _month << "-" << _day << endl;
    	}
    
    private:
    	int _year;
    	int _month;
    	int _day;
    };
    
    void Test8()
    {
        
    	const Date d1(2021, 3, 7);
    	d1.Print();
    }

结果  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 11]

### Q1：四种const修饰的调用关系？ ###

1.  const对象可以调用非const成员函数吗？  
    **不可以** ， 原因：this指针被传递给非const成员函数，权限被扩大
2.  非const对象可以调用const成员函数吗？  
    **可以**，原因：this指针被传递给const成员函数，权限被缩小
3.  const成员函数内可以调用其它的非const成员函数吗？  
    **不可以**，原因：const修饰的成员函数其实就是修饰this指针，在const修饰的成员函数内调用非const成员函数，**就是将const 修饰的this指针传递传递给了非const成员函数**，权限被扩大
4.  非const成员函数内可以调用其它的const成员函数吗？  
    **可以**，原因同3相反，非const成员函数将this指针传递给了const成员函数，**就是对非const修饰的this指针加了const修饰**，权限被缩小

**总结：**

> 能否调用看的就是this指针是否被传过去！  
> 能否传过去就是要看权限被放大还是缩小，权限只能缩小不能放大！

# 七、取地址重载 #

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

//7
    class Date
    {
        
    public:
    	Date* operator&()
    	{
        
    		return this;
    	}
    	const Date* operator&()const
    	{
        
    		return this;
    	}
    private:
    	int _year; // 年
    	int _month; // 月
    	int _day; // 日
    };

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70]: /images/20221023/d85b1c98bf554b958167639a6b9fd477.png
[20210306112015972.png]: /images/20221023/09579224c07341e98fbdf1baf3bceddc.png
[20210306112504905.png]: /images/20221023/2f23ac1f608649788466d93493625973.png
[20210302164743155.png]: /images/20221023/3354095c16c6437cadf00f5833d7f71f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 1]: /images/20221023/cb58a429cca04f23844734e3b50800e1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 2]: /images/20221023/6266b798048f4892aab52072f09bc5ee.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 3]: /images/20221023/87ebc86dd26341b9ac4f40649c72763a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 4]: /images/20221023/2b499cb000e543b99544e931872e2c3f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 5]: /images/20221023/5e2a97039d104cda90363cf9da68580d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 6]: /images/20221023/e5a940712c234dc593efb68a3cc836b8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 7]: /images/20221023/0f6a7381ba0841f5967928fe3387290f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 8]: /images/20221023/c338138281a043d0af1122e00a966be5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 9]: /images/20221023/71760df68fdf4072844ee33ab7fe195a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 10]: /images/20221023/d28c5478c2c94426b7c13666478d051e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 11]: /images/20221023/71fcd46acf2d4069b0e11748fa2e2f0e.png