120-C++学习第四弹(拷贝构造，重载）

我就是我 2022-12-31 01:30 111阅读 0赞

## 1.拷贝构造函数 ##

缺省的拷贝构造函数 按位拷贝  
下面这段代码是按位拷贝

using namespace std;
    
    class Object
    {
        
    	int value;
    	int* ip;
    	int ar[100];
    
    public:
    	Object():value(0),ip(nullptr)
    	{
        
    		for(int i=0;i<100;++i)
    		{
        
    			ar[i]=i;
    		}
    	}
    };
    
    int main()
    {
        
    	Object obja;
    	Object objb(obja);//memmove(&objb,&obja,sizeof(obja));
    
    	return 0;
    }

**按位拷贝**：把obja的地址抓住，把objb的地址抓住，然后把obja里面的一个字节一个字节地拷贝到objb里。系统相当于执行memmove(&objb,&obja,sizeof(obja));

**缺省的拷贝构造函数如下**

Object(const Object&obj)
    		:value(obj.value),ip(obj.ip)
    	{
        
    		for(int i=0;i<100;++i)
    		{
        
    			ar[i]=obj.ar[i];
    		}
    	}

**在什么情况下必须要写自己的拷贝构造函数？**  
一旦这个类型有申请资源，这些资源不局限于动态内存，比如说打开一个文件，申请一个线程，申请一个信号量，要注意释放这个资源，那么拷贝构造的时候，你就会发现你的资源转移了呢还是进行深拷贝还是浅拷贝的问题。  
看以下这个例子：

class String
    {
        
    private:
    	char *str;
    
    public:
    	String(const char *s)
    	{
        
    		if(s!=nullptr)
    		{
        
    			int len=strlen(s)+1;
    			str=new char[len];
    			strcpy_s(str,len,s);
    		}
    		else
    		{
        
    			str=new char[1];
    			*str='\0';
    		}
    	}
    	~String()
    	{
        
    		if(str!=nullptr)
    		{
        
    			delete[]str;
    		}
    		str=nullptr;
    	}
    };
    int main()
    {
        
    	String s1="linzeyu";
    	String s2(s1);
    	return 0;
    }

主函数运行时，开辟栈帧，在主函数的栈区定义了一个s1对象，s1里有str指针，调用其构造函数，s!=nullptr,算出长度，在堆区开辟空间(“linzeyu”)，并且把空间的地址给str,s1的str指向这个空间（“linzeyu”）,当我们去构建s2，给s2也开辟了一个空间，它里面也有一个str指针，缺省的构造函数只是把s1中的内容给s2，s1空间的内容是指针str，只是把这个指针赋值给s2的str  
它的缺省构造函数就是

String(const String&s)
    	{
        
    		str=s.str;
    	}

这个缺省构造函数就是按位拷贝  
当主函数结束时，先析构s2，s2的str指针此时不为空，delete\[\]str把空间还给堆区，标志位未使用，再接着把其s2的str变为空，然后去析构s1的时候，s1的str指针不为空，仍然指向这个空间（“linzeyu”），此时这种指针称为空悬指针，因为其指向的内容已经被释放了，导致再去释放一个空悬指针，已经释放的空间再去释放，导致程序崩溃!  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center]  
**下面是深拷贝**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 1]

String(const String&s)
    {
        
         int len=strlen(s.str)+1;
         str=new char[len];
         strcpy_s(str,len,s.str);
    }

class Complex
    {
        
    private:
    	double Real,Image;
    public:
    	Complex(double r=0.0,double i=0.0)
    		:Real(r),Image(i)
        {
        
    	}
    	~Complex(){
        }
    	Complex(const Complex&com)
    		:Real(com.Real),Image(com.Image)
    	{
        
    	}
     
    };
    int main()
    {
        
    	Complex c1(12,23);
    	Complex c2(45,56);
    	Complex c3;
    
    	c3=c1.Add(c2);//不改变c1和c2的值
    	c3.operator=(c1);
    	c3=c1;
    	return 0;
    }

Add作为类的成员函数，编译器编译会添加this指针，指向c1的地址  
**情况1**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 2]  
此方法把c2去初始化c,this指针指向c1，c1的实部与c2的实部相加，c1的虚部和c2的虚部相加，相加后结果产生一个tmp对象，然后把tmp返回  
当我们调动这个Add函数时，在这个函数里，**一共产生了3个对象**，因为;c2初始化c,产生一个对象，当我们的实部与实部相加，虚部与虚部相加，我们在这里产生一个tmp，这就是产生第二个对象，当我们return tmp;要返回tmp对象时，但是不能把tmp直接给c3，这时候得产生一个临时的对象（将亡值），当子函数结束时，c对象销毁，tmp对象销毁，把临时对象给c3，然后临时对象销毁，临时对象是将亡值。  
**怎样让产生的对象比较少呢？**  
**看如下情况2：**  
1.加上一个引用& c2初始化c，c是c2的别名，这里就不会再构建对象  
2.return 无名对象（将亡值）这个无名对象构建在主函数的栈帧中，然后子函数Add销毁，然后把构建的对象返回给c3，之后这个对象也销毁，

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 3]  
以上这种写法产生了1个对象，但是不安全（有可能对c的实部进行修改，从而导致c2被改变）  
**接下来看情况3**  
**这是第一个安全性**，Complex&c的前面加上const，虽然c是c2的别名，但是在这个函数中，我们只是用c2的数据，并不进行改变，安全性加强  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 4]  
**这是第二个安全性**  
我们程序运行的时候，我们把c1的地址给this指针，this指针指向c1的实部和虚部，对于Add函数，是把c1和c2的相加的结果给c3，在Add函数中，我们明确不改变c1和c2的值，所以在Complex&c后再加上一个const,这样是我们的指针指向你，不能改变你，这里的c虽然是一个引用，也加了一个const，保障Add函数的安全性。也就是说，无论谁调动这个Add,都不能让自身改变，也不能对传入的参数的改变  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 5]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 6]  
这个方法会发生内存泄漏，无论如何也产生了一个对象

## 重载+ ##

使我们去看程序更加简洁明确  
运算符的重载实际上是一种特殊的函数重载，必须定义一个函数，并告诉C++编程，当遇到该重载的运算符时调用此函数，这个函数叫做运算符重载函数，通常为类的成员函数  
**定义运算符重载函数的一种格式**  
返回型类型 类名：：operator 重载的运算符（参数表）  
\{…\}  
operator是关键字，它与重载的运算符一起构成函数名。因函数名的特殊性，C++编译器可以将这类函数识别出来。  
![在这里插入图片描述][20201227202810867.png_pic_center]  
**c=a+b的实现（对象和对象相加）**

Int operator+(const Int&x)const
    {
        
    	return Int(this->value+x.value);
    }//c=a+b; c=a.operator+(b);//c=operator+(&a,b);

**c=a+x的实现（对象加变量）**

Int operator+(const int x)const
    {
        
    	return Int(this->value+x);
    }//c=a+x; c=a.operator+(x);//c=operator+(&a,x);

**c=x+a的实现（变量加对象）**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 7]  
上面这个方法编译不通过  
原因：1.因为这个+法作为成员函数，x是一个变量，x这个变量里没有这个成员函数2.我们知道所谓的加法，二目运算符，里面有两个参数，但是这个函数里面有3个参数，作为类的成员函数，还有this指针，编译器编译有检查，是单目还是双目

**要定义成全局函数**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 8]

## 重载= ##

在类定义中如果没有显式给出赋值运算符重载函数，并不是不用赋值函数，而是由系统自动调用缺省的赋值函数  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 9]

void operator=(const Int&x)
    {
        
    	if(this!=&x)
    	{
        
    		this->value=x.value;
    	}
    }//b=a;//b=b

**如何实现c=b=a?**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 10]  
**任何一个类型，假如你写了一个空类型，这个空类型有6个缺省函数：缺省构造函数，缺省析构函数，缺省拷贝构造函数，缺省的赋值函数，缺省的取地址函数（2个）**

## 重载取地址符& ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 11]  
**注意下图**  
![在这里插入图片描述][2020122721084785.png_pic_center]

这里的delete并不是删除的意思，这里的delete是C11的标准，它告诉编译器，将把这两个取地址的缺省函数删掉，运行的时候就不能给取地址了！缺省的函数都可以加delete,这是C11新的玩法  
![在这里插入图片描述][20201227211237512.png_pic_center]

## 重载++ ##

前置++  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 12]  
前置++  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 13]  
**后置++  
三个版本**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 14]  
看下面这题  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 15]  
**前者，i=2  
后者，i=1**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 16]  
**纠正一下：一旦重载运算符，这个就不是运算符了，是类的成员函数，调用规则和结合性都是按照函数的规则进行，不能作为运算符来用**  
对于内置类型 ++ 和+是运算符  
对于自定义类型，这里的++和 +重载了运算符，不是运算符了，是函数，调用规则语法结构按照函数规则来执行

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/e706a2a7c5444311b16d8ae510f7acad.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221120/945f382dd2bb4356a9b6945bbf598a68.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221120/3661f387a4ee43ff88e401d4f7458ecc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221120/6834600b128c4ce88b929398186fbc5c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221120/e6567d8dd02c4a3f8a5cfd50fb839265.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20221120/aa9cabc70141493fb49e463a026ce56e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 6]: /images/20221120/62c6d7107185447bb30222a6f1081550.png
[20201227202810867.png_pic_center]: /images/20221120/15706afd470c4b959b2fb867543c4f09.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 7]: /images/20221120/42916be5346d44438b6e6b7513d7e4f5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 8]: /images/20221120/53abd3b44ff74461a17bc3816bc59e03.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 9]: /images/20221120/5ab869f35d844469a7b0b383b1938432.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 10]: /images/20221120/16b41e4808c246e98987fc20f3c2fd4c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 11]: /images/20221120/6198e02c22be4baaac57932bb3150a18.png
[2020122721084785.png_pic_center]: /images/20221120/2b28c6069576462b863f2a0828768700.png
[20201227211237512.png_pic_center]: /images/20221120/57c77dea83934b36a1b8aa9af54ba6ce.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 12]: /images/20221120/b3f601583c67414e9e052c25deecb240.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 13]: /images/20221120/a7f032aad6d345cebe06b282d0af18d2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 14]: /images/20221120/8bac2d7e693841e38bee3e6fad6e50de.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 15]: /images/20221120/be0737b400834e07bb616dfba829b4d1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 16]: /images/20221120/112e7abb21dd429d82ca3de5d216d53d.png