c++实验六总结（自用）

实验目的          

        掌握派生类的声明方法和派生类构造函数的定义方法

        掌握不同方式下，构造函数与析构函数的执行顺序与构造规则

程序如下：

#include
#include
using namespace std;
class MyArray {
public:
	MyArray(int length);
	~MyArray();
	void Input();
	void Display(string);
protected:
	int* alist;
	int length;
};
MyArray::MyArray(int leng)
{
	length = leng;
	if (leng <= 0)
	{
		cout << "error length";
		exit(1);
	}
	alist = new int[length];
	if (alist == NULL)
	{
		cout << "assign failure";
		exit(1);
	}
	cout << "MyArray类对象已创建!" << endl;
}
MyArray::~MyArray()
{
	delete[] alist;
	cout << "MyArray类对象已撤销!" << endl;
}
void MyArray::Display(string str)
{
	int i;
	int* p = alist;
	cout << str << length << "个整数：";
	for (i = 0; i < length; i++, p++)
		cout << *p << "";
	cout << endl;
}
void MyArray::Input()
{
	cout << "请从键盘输入" << length << "个整数：";
	int i;
	int* p = alist;
	for (i = 0; i < length; i++, p++)
		cin >> *p;
}

class SortArray : public MyArray 
{
public:
	void Sort();
	SortArray(int leng) :MyArray(leng) 
	{
		cout << "SortArray类对象已创建!" << endl;
	}
	~SortArray();
};
SortArray:: ~SortArray() 
{
	cout << "SortArray类对象已撤销!" << endl;
}
void SortArray::Sort()
{
	int i, j, temp;
	for (i = 0; i < length - 1; i++)
		for (j = 0; j < length - i - 1; j++)
		{
			if (alist[j] > alist[j + 1])
			{
				temp = alist[j]; 
				alist[j] = alist[j+1];
				alist[j + 1] = temp;
			}
		}
}
int main()
{
	
	SortArray s(5);
	s.Input();
	s.Display("显示排序以前的");
	s.Sort();
	s.Display("显示排序以后的"); 
	return 0;
}

实验内容：

声明一个storyarray继承类myarray，在该类中定义一个函数，具有将输入的整数从小到大进行排序的功能

class SortArray : public MyArray 
{
public:
	void Sort();
	SortArray(int leng) :MyArray(leng) 
	{
		cout << "SortArray类对象已创建!" << endl;
	}
	~SortArray();
};
SortArray:: ~SortArray() 
{
	cout << "SortArray类对象已撤销!" << endl;
}
void SortArray::Sort()
{
	int i, j, temp;
	for (i = 0; i < length - 1; i++)
		for (j = 0; j < length - i - 1; j++)
		{
			if (alist[j] > alist[j + 1])
			{
				temp = alist[j]; 
				alist[j] = alist[j+1];
				alist[j + 1] = temp;
			}
		}
}

排序程序段:

int i, j, temp;
	for (i = 0; i < length - 1; i++)
		for (j = 0; j < length - i - 1; j++)
		{
			if (alist[j] > alist[j + 1])
			{
				temp = alist[j]; 
				alist[j] = alist[j+1];
				alist[j + 1] = temp;
			}
		}

运行结果：

构造函数的调用严格地按照先调用基类的构造函数，后调用派生类的构造函数的顺序执行。析构函数的调用顺序与构造函数的调用顺序正好相反，先调用派生类的析构函数，后调用基类的析构数。

派生类构造函数的一般格式为：
派生类名(参数总表):基类名(参数表) {
    派生类新增数据成员的初始化语句
}
-----------------------------------------------------------------
含有子对象的派生类的构造函数：
派生类名(参数总表):基类名(参数表0),子对象名1(参数表1),...,子对象名n(参数表n)
{
    派生类新增成员的初始化语句
}

在定义派生类对象时，构造函数的调用顺序如下：

调用基类的构造函数，对基类数据成员初始化。

调用子对象的构造函数，对子对象的数据成员初始化。

调用派生类的构造函数体，对派生类的数据成员初始化。