运算符重载为友元函数

·通常，将运算符重载为类的成员函数
·重载为友元函数的情况
    ·成员函数不能满足使用要求
    ·普通函数，又不能访问类的私有成员

class Complex{
	double real, imag;
	public:
		Complex(double r, double i):real(r), imag(i){};
		Complex operator+(double r);
};
Complex Complex::operator+(double r){//能解释c + 5
	return Complex(real + r, imag);
}

·经过上述重载后：
    Complex c;
    c = c + 5;//有定义，相当于c = c.operator + (5)
·但是
    c = 5 + c;//编译出错
·为了使上述表达式成立，需要将+重载为普通函数
Complex operator+(double r, const Complex & c){
    //能结束5 + c
    return Complex(c.real + r, c.imag); 
}

·普通函数不能访问私有成员
-->将运算符+重载为友元函数

class Complex{
	double real, imag;
	public:
		Complex(double r, double i):real(r), imag(i){};
		Complex operator+(double r);
		friend Complex operator+(double r, const Complex & c);
};

运算符重载实例：可变长整型数组
 

int main(){//要编写可变长整型数组类，使之能如下使用
	CArray a;//开始里的数组是空的
	for(int i = 0; i < 5; i++)
		a.push_back(i);//要用动态分配的内存来存放数组元素，需要一个指针成员变量
	CArray a2, a3;
	a2 = a;//要重载“=”
	for(int i = 0; i < a.length(); i++)
		cout << a2[i] << " ";//需要重载[]
	a2 = a3;//a2是空的
	for(int i = 0; i < a2.length(); i++)//a2.length()返回0
		cout << a2[i] << " ";
	cout << endl;
	a[3] = 100;
	CArray a4(a);//要自己写复制构造函数
	for(int i = 0; i < a4.length(); i++)
		cout << a4[i] << " ";
	return 0;
}
程序的输出结果是：
0 1 2 3 4
0 1 2 100 4
要做哪些事情？

考虑：一个肯定有构造函数、析构函数、push_back(),length()、考虑数组存在哪里？肯定要有一个动态分配的存储空间（要用动态分配的内存来存放数组元素，需要一个指针成员变量）、要重载“=”、对象名加[]也成立需要重载[]、要自己写复制构造函数

class CArray{
	int size;//数组元素的个数
	int *ptr;//指向动态分配的数组
	public:
		CArray(int s = 0);//s代表数组元素的个数
		CArray(CArray & a);
		~CArray();
		void push_back(int v);//用于在数组尾部添加一个元素v
		CArray & operator=(const CArray & a);//用于数组对象之间的赋值
		int length(){return size;}//返回数组元素个数
		int & CArray::operator[](int i){//应该考虑返回值是什么类型？返回值为int不行！不支持a[i] = 4
			//非引用的函数返回值，不可以作为左值使用---修改a[i]的值，则是ptr[i],则=左边应该是ptr[i]的引用
			//用于支持根据下标访问数组元素
			//如n = a[i] 和 a[i] = 4这样的语句
			return ptr[i];
		}	
};
CArray::CArray(int s):size(s){
	if(s == 0)
		ptr = NULL:
	else
		ptr = new int[s];
}
CArray::CArray(CArray & a){//复制构造函数
	if(!a.ptr){
		ptr = NULL:
		size = 0;
		return ;
	}
	ptr = new int[a.size];
	memcpy(ptr, a.ptr, sizeof(int)*a.size);
	size = a.size;
}

若不自己去写复制构造函数，调用默认构造函数指向了同一片内存，a2的ptr和a1的ptr都指向了同一片存储空间，此图可以清晰的展示。

CArray::~CArray(){//释放动态分配的存储空间
	if(ptr)
		delete []ptr;
}
CArray & CArray::operator=(const CArray & a){
	//赋值号的作用是使"="左边对象里存放的数组，大小和内容都和右边的对象一样
	if(ptr == a.ptr)//防止a=a这样的赋值导致出错
		return *this;
	if(a.ptr == NULL){//如果a里面的数组是空的
		if(ptr)
			delete []ptr;
		ptr = NULL;
		size = 0;
		return *this;
	}
	if(size < a.size){//如果原有空间够大，就不用分配新的空间
		if(ptr)
			delete []ptr;
		ptr = new int[a.size];
	}
	memcpy(ptr, a.ptr, sizeof(int) * a.size);
	size = a.size;
	return *this;
}
void CArray::push_back(int v){
	//给数组尾部添加一个元素
	if(ptr){
		int * tmpPtr = new int[size + 1];//重新分配空间
		memcpy(tmpPtr, ptr, sizeof(int) * size);//拷贝原数组内容
		delete []ptr;
		ptr = tmpPtr;
	}
	else//数组本来是空的
		ptr = new int[1];
	ptr[size++] = v;//加入新的数组元素
}