【C++】[ ]、=、==、!= 运算符重载（以数组为例）

喜欢ヅ旅行 2022-05-25 06:14 239阅读 0赞

## 【0】目录 ##

*  一、数组
 *  《1》、一般形式
 *  《2》、数组的常见操作
 *  《3》实现
 *  二、定义数组类
 *  1、我们先定义成员函数
 *  2、实现成员函数
 *  3、测试用例
 *  3.1测试结果图片展示
 *  三、归纳总结
 *  1、 c++中不能重载的运算符有些？
 *  2、特殊运算符的重载方式
 *  3、数返回值当左值，需要返回一个引用 (赋值运算符)

\#\#一、数组\#\#  
\#\#\#\#**《1》、一般形式：**  
数组是由类型、数组名、\[ \]操作符和数组下标构成的，结构如下：  
**type name\[index\]; \*\*  
![这里写图片描述][70]  
\#\#\#\#**《2》、数组的常见操作\*\*

*  1、创建数组；如：int array\[10\];
 *  2、求数组的长度; 如：len = sizeof(array)/szieof(array\[0\]);
 *  3、为数组元素赋值; 如：array\[2\] =10;
 *  4、数组元素大小的比较，是否相等; 如：if( array\[1\] == array\[2\] )  
    **那么，针对内置类型，以上这些操作仿佛是家常便饭，很容易实现，那么如果是不是内置类型，而是自定义类型，该如何实现以上这些操作呢？**

**《3》那么，我们首先定义一个数组类，为了清晰明了，将声明、实现以及测试用例分开来写：**

## 二、定义数组类\#\# ##

#### **1、我们先定义成员函数** ####

\-1、 构造函数

*  2、拷贝构造函数
 *  3、求数组的长度函数
 *  4、设置数组元素值的函数
 *  5、去除数组元素值的函数
 *  6、析构函数
 *  7、\[\]运算符重载
 *  8、=运算符重载
 *  9、==运算符重载
 *  10！=运算符重载  
    **Array.h**

#ifndef _ARRAY_H_
    #define _ARRAY_H_
    class Array
    {
    private:
        int mLength;//数组的长度
        int* mSpace;//指向数组的指针
    
    public:
        Array(int length);//构造函数
        Array(const Array& obj);//拷贝构造函数
        int length();//数组长度
        void setData(int index, int value);//往数组中放元素
        int getData(int index);//从数组中取元素
        ~Array();//析构函数
    public:
    	int& operator[](int i);       //[]运算符重载
    	Array& operator=(Array &a2);  //=运算符重载
    	bool operator==(Array& a1);  //==运算符重载
    	bool operator!=(Array& a1); //！=运算符重载
    };
    #endif
    /*
    小知识：#ifndef,#define,#endif的作用是防止头文件被多次定义
    */

\#\#\#\#**2、实现成员函数**

*  下面是前六个函数具体的实现
 *  1、 构造函数
 *  2、拷贝构造函数
 *  3、求数组的长度函数
 *  4、设置数组元素值的函数
 *  5、去除数组元素值的函数
 *  6、析构函数  
    **Array.cpp**

#include "iostream"
    #include "Array.h"
    using namespace std;
    Array::Array(int length)//构造函数
    {
        if( length < 0 )
        {
            length = 0;
        }
        
        mLength = length;
        mSpace = new int[mLength];
    }
    
    Array::Array(const Array& obj)//拷贝构造函数
    {
        mLength = obj.mLength;
        
        mSpace = new int[mLength];
        
        for(int i=0; i<mLength; i++)
        {
            mSpace[i] = obj.mSpace[i];
        }
    }
    
    int Array::length()//获取数组长度
    {
        return mLength;
    }
    
    void Array::setData(int index, int value)//往数组中放元素
    {
        mSpace[index] = value;
    }
    
    int Array::getData(int index)//从数组中取元素
    {
        return mSpace[index];
    }
    
    Array::~Array()//析构函数
    {
        mLength = -1;
        delete[] mSpace;
    }

*  7、\[\]运算符重载

int& Array:: operator[](int i)
    {
    	 return mSpace[i];
    }

*  8、=运算符重载

Array& Array::operator=(Array &a2)//注意：这里返回的是引用，为了支持 “连等”
    {
    	if(&a2 == this)
    	{
    		return *this;
    	}
    	if(this->mSpace != NULL)
    	{
    		delete[] mSpace;
    		mLength = 0;
    	}
    	this->mLength = a2.mLength;
    	this->mSpace = new int[this->mLength];
    	for(int i = 0;i< this->mLength ;i++)
    	{
    		mSpace[i] = a2[i];
    	}
    	return *this;
    }

*  9、==运算符重载

bool Array::operator==(Array& a1)
    {
    //判断a1和a2的长度是否相等
    
    	if(this->mLength !=a1.mLength )
    	{
    		return false;
    	}
    //判断a1,a2的每一个数组元素是不是相等
    	for(int i = 0;i<this->mLength;i++)
    	{
    		if(this->mSpace[i] != a1[i])
    		{
    			return false;
    		}
    	}
    	return true;
    }

*  10！=运算符重载

bool Array::operator!=(Array &a1)//因为9刚好实现了==操作，所以取反就是!=操作
    {
    	return !(*this == a1);
    }

\#\#\#\#**3、测试用例**

#include "iostream"
    #include "Array.h"
    using namespace std;
    
    int main()
    {
        Array a1(10);
        for(int i=0; i<a1.length(); i++)
        {
            a1.setData(i, i); 
    		//a1[i] = i+100;
    		//重载函数返回类型为对象的引用
        }
        
        for(int i=0; i<a1.length(); i++)
        {
           printf("array %d: %d\n", i, a1.getData(i));
    		//printf("array %d: %d\n", i, a1[i]);
    	}
    	
    	cout<<"创建对象a2,使用a1初始化a2"<<endl;
        Array a2 = a1;
        
        for(int i=0; i<a2.length(); i++)
        {
            printf("array %d: %d\n", i, a2.getData(i));
        }
    //执行=操作
    //如果a3已经分配内存需要释放
    //根据a2开辟内存空间，把a2的值copy到a3中
     	Array a3(100);
     	 a3 = a2;
    	printf("a3:len %d",a3.length());
    	printf("\n");
    	for(int i = 0;i<a3.length();i++)
    	{
    		printf("array %d :  %d\n",i,a3[i]);
    	}
    	 a1 = a3 = a2;
    
     	if (a2==a1)
     	{
     		printf("相等\n");
     	}
     	else
     	{
     		printf("不相等\n");
     	}
    	if(a2 != a1)
    	{
     		printf("不相等\n");
     	}
     	else
     	{
     		printf("相等\n");
     	}
        return 0;
    }

\#\#\#\#\#**3.1测试结果图片展示**  
\#\#\#\#\#\#**（1）Array a1(10)**  
![这里写图片描述][70 1]

###### **（2） Array a2 = a1;** ######

![这里写图片描述][70 2]  
\#\#\#\#\#\#**（3） a3 = a2;**  
![这里写图片描述][70 3]  
\#\#\#\#\#\#**（4） if (a2==a1)；if(a2 != a1)**  
![这里写图片描述][70 4]  
\#\#\#\#\#\#**（5）全部成员对比，为了区分明显，给重载后的函数赋值的时候，多+100**  
![这里写图片描述][70 5]

## 三、归纳总结 ##

*  1、c++中不能重载的运算符有  
    ![这里写图片描述][70 6]
 *  2、特殊运算符  
    \*\*1、不可以使用全局函数以及其对应的友元函数来重载的操作符有 =、 ()、 \[ \]、 -> \*\*  
    **2、必须使用全局函数以及其对应的友元函数来重载的操作符为 <<**
 *  3、函数返回值当左值，需要返回一个引用 (赋值运算符)

[70]: /images/20220525/d1ddf3e568e34675875605cf459f7960.png
[70 1]: /images/20220525/2f239f8ee55a431ca360ac2c5a1210a2.png
[70 2]: /images/20220525/adfee9e7248c481fb7d6f5133c613385.png
[70 3]: /images/20220525/33a2af298312411888029f376f0bf11c.png
[70 4]: /images/20220525/6a9fb8d22fa4425aa3731806e437057e.png
[70 5]: /images/20220525/0c5ae8aa390b46919784c7afab0d05bf.png
[70 6]: /images/20220525/df1f30b5ab294c79aefb7ee94fe86e89.png