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

【0】目录

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

一、数组

《1》、一般形式：

数组是由类型、数组名、[ ]操作符和数组下标构成的，结构如下：
type name[index];
这里写图片描述

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