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

【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)

（2） Array a2 = a1;

（3） a3 = a2;

（4） if (a2==a1)；if(a2 != a1)

（5）全部成员对比，为了区分明显，给重载后的函数赋值的时候，多+100

三、归纳总结

*
1、c++中不能重载的运算符有

*
2、特殊运算符
1、不可以使用全局函数以及其对应的友元函数来重载的操作符有 =、 ()、 [ ]、 ->
2、必须使用全局函数以及其对应的友元函数来重载的操作符为 <<

*
3、函数返回值当左值，需要返回一个引用 (赋值运算符)

热门工具换一换