用一个程序总结运算符重载

头文件

Array.h

#ifndef ARRAY
#define ARRAY
#pragma once
class Array
{
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&a1);//=重载
	bool operator==(Array &a2);//==重载
	bool operator!=(Array &a2);//!=重载
private:
	int mLength;//长度
	int *mSpace;//指针
};

#endif

Array.cpp//实现功能文件

注意:如果返回值需要作左值时,返回值应该为引用或者指针,

返回值为对象时,尽量返回引用,如果返回一个对象,将需要调用构造函数创建一个匿名对象,降低速度和效率

如果直接返回引用,则不需要调用构造函数创建匿名对象了,提高了效率

#include "Array.h"
#include<iostream>

Array::Array(int length)
{ 
	if (length < 0)
		length = 0;
	mLength = length;
	mSpace = new int[mLength];
}
Array::Array(const Array &obj)//拷贝构造函数
{
	
	this->mLength = obj.mLength;
	if (mSpace != NULL)//防止内存泄露,如果this->mSpace开始所指向的内存不为空,然后指向另外一片空间使得原来的内存泄露了
	{
		delete mSpace;
		mSpace = NULL;
	}
	mSpace = new int[mLength];
	for (int i = 0; i < mLength; i++)
	{
		mSpace[i] = obj.mSpace[i];
	}

}
int Array::length()
{
	return this->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;
}
int &Array::operator[](int i)//[]重载
{
	return this->mSpace[i];//返回值为引用的原因,返回值作为了左值,返回值要作为左值需引用
}
Array& Array::operator=(Array&a1)//=重载
{
	int i = 0;
	if (this->mSpace != NULL)
	{
		delete[] mSpace;
		this->mLength = 0;
	}
	this->mLength = a1.mLength;
	this->mSpace = new int[a1.mLength];
	for (i; i < this->mLength; i++)
	{
		mSpace[i] = a1[i];
	}
	return *this;//这里如果直接返回Array则将调用拷贝构造函数,降低了速度, 所以直接返回引用,提高效率
}
bool Array::operator==(Array&a2)//==重载
{
	if (this->mLength != a2.mLength)
	{
		return false;
	}
	for (int i = 0; i < this->mLength; i++)
	{
		if (this->mSpace[i] != a2[i])
		{
			return false;
		}
	}
	return true;
}
bool Array::operator!=(Array &a2)//!=重载
{
	return !(*this == a2);
}

main.cpp

  不提供=重载函数,系统浅拷贝,这样会使得=赋值的对象指向同一片内存,第一个对象析构时.delete已经释放
由于第2个也指向同一片内存空间,再次delete时将会报错,所以,如果一个类有指针变量,必须提供深拷贝
 如果没有指针变量,则可以直接使用系统提供的浅拷贝函数

#include<iostream>
#include"Array.h"

int main()
{
	Array a1(10);
	for (int i = 0; i < a1.length(); i++)
	{
		a1.setData(i, i);
		a1[i] = i;//[]操作符重载

	}
	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]);//功能
	}
	Array a2 = a1;//调用拷贝构造函数
	for (int i = 0; i < a2.length(); i++)
	{
		printf("array %d: %d\n", i, a2.getData(i));
	}
	Array a3(20);
	a2 = a3 = a1;//不提供=重载函数,系统将默认进行浅拷贝
	/*
	    不提供=重载函数,系统浅拷贝,这样会使得=赋值的对象指向同一片内存,第一个对象析构时.delete已经释放
		 由于第2个也指向同一片内存空间,再次delete时将会报错,所以,如果一个类有指针变量,必须提供深拷贝
		 如果没有指针变量,则可以直接使用系统提供的浅拷贝函数
	
	
	*/
	if (a1 == a2)
	{
		printf("相等\n");
	}
	else
	{
		printf("不相等");
	}


	system("pause");
	return 0;
}

读者通过自己单步调试,应该很快就能理解其运算符重载与匿名对象创建的含义了