C++中的Big Three

定义一个有序数组类来说明这个问题：

#include <iostream>
using namespace std;

#define MAXSIZE 20

class A {
public:
	A(void);					//	构造函数
	A (const A &);				//	复制构造函数
	A & operator= (const A &);	//	重载赋值运算符
	~A() {						//	析构函数
		cout << "析构函数" << endl;	
	}
	void Display(void);
	int Size(void);
	bool IsEmpty(void);
	bool IsFull(void);	
	void Insert(double);
	void Delete(double);

private:
	double arr[MAXSIZE];
	int length;
};

A::A(void)										//	构造函数
{
	cout << "构造函数" << endl;
	length = 0;
	memset(arr, 0, MAXSIZE * sizeof(double));
}

A::A (const A &Obj)								//	复制构造函数
{
	cout << "复制构造函数" << endl;
	for(int i = 0; i < Obj.length; i++) {
		arr[i] = Obj.arr[i];
	}
	length = Obj.length;
}

A & A::operator= (const A &Obj)					//	重载赋值运算符
{
	cout << "重载赋值运算符" << endl;
	if(this == &Obj)
		return *this;
	for(int i = 0; i < Obj.length; i++) {
		arr[i] = Obj.arr[i];
	}
	length = Obj.length;
	return *this;
}

void A::Display(void)
{
	if (IsEmpty()) {
		cout << "空" << endl;
		return;
	}
	for (int i = 0; i < length; i++)
		cout << arr[i] << endl;
	cout << endl;
}

int A::Size(void)
{
	return length;
}

bool A::IsEmpty(void)
{
	return ( length <= 0 ? true : false );
}

bool A::IsFull(void)
{
	return ( length >= MAXSIZE ? true : false );
}

void A::Insert(double x)				//  可以插入重复的元素
{
	if (IsFull()) {
		cout << "Full!" << endl;
		return;
	}		
	for (int i = 0; i < length; i++) {
		if (x < arr[i]) {				//	找到要插的位置，插在arr[i]之前
			double *p = arr + length;	//	p指向最后一个元素的后一位置
			int count = length - i;		//	将arr[i]及其之后的元素(共有length - i个)整体向后平移
			while(count--) {
				*p = *(p - 1);			//  从后往前移
				p--;
			}
			arr[i] = x;					//	将x插入，此时p = arr + i
			length++;
			return;
		}
	}
	arr[length] = x;					//  若x比原数组中所有元素都大，则插在最后
	length++;	
}

void A::Delete(double x)
{
	for (int i = 0; i < length; i++) {
		if (x == arr[i]) {
			for( int j = i; j < length - 1; j++ )
				arr[j] = arr[j + 1];
			length--;
			return;
		}
	}
	if( IsEmpty() )
		cout << "空" << endl;
	else
		cout << "找不到" << x << endl;
}

A Fun(void)
{
	cout << "进入Fun()函数体" << endl;
	A obj;
	obj.Insert(20);
	obj.Insert(30);
	cout << "return前" << endl;
	return obj;					//	obj的临时对象obj'的复制构造函数
								//	obj的析构函数
	cout << "return后" << endl;	//	不执行
}

int main(void)
{
	double _arr[] = {2,5,10,6,8,4,1,3,9,7};
	int _len = sizeof(_arr) / sizeof(*_arr);

	cout << "my" << endl;
	A myobj;
	for(int i = 0; i < _len; i++) {
		myobj.Insert(_arr[i]);
	}
	myobj.Display();

	cout << "your" << endl;
	A yourobj(myobj);
	yourobj.Display();

	cout << "his" << endl;
	A hisobj;
	hisobj = yourobj;
	hisobj.Display();

	cout << "her" << endl;
	A herobj = hisobj;
	hisobj.Display();

	cout << "调用Fun()前" << endl;
	hisobj = Fun();
	//	obj'的析构函数
	cout << "调用Fun()后" << endl;
	hisobj.Display();

	return 0;
}

运行结果：

my
构造函数
1
2
3
4
5
6
7
8
9
10

your
复制构造函数
1
2
3
4
5
6
7
8
9
10

his
构造函数
重载赋值运算符
1
2
3
4
5
6
7
8
9
10

her
复制构造函数
1
2
3
4
5
6
7
8
9
10

调用Fun()前
进入Fun()函数体
构造函数
return前
复制构造函数
析构函数
重载赋值运算符
析构函数
调用Fun()后
20
30

析构函数
析构函数
析构函数
析构函数

p.s.请强烈关注当类中含指针对象的成员时的情况！！！