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

最新推荐文章于 2024-07-31 14:30:49 发布

长颈鹿仙女

最新推荐文章于 2024-07-31 14:30:49 发布

阅读量2.9w

点赞数 40

分类专栏：毕业生-必看系列

本文链接：https://blog.csdn.net/dai_wen/article/details/80252818

版权

毕业生-必看系列专栏收录该内容

108 篇文章 19 订阅

订阅专栏

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

#####3.1测试结果图片展示
######（1）Array a1(10)
这里写图片描述