定义一个有序数组类来说明这个问题:
#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.请强烈关注当类中含指针对象的成员时的情况!!!