面向对象程序设计实验指导书版.doc

《面向对象程序设计》课程实验指导书

LIAOCHENG UNIVERSITY

面向对象程序设计
实验指导书

聊城大学计算机学院
2011年3月

38
目　录
《面向对象程序设计》课程实验教学大纲 1
实验一　C++对C的扩充 1
基本信息 1
实验预习 1
实验过程 2
实验数据和实验结果记录 8
实验结果分析 8
实验二　类和对象 8
基本信息 8
实验预习 8
实验过程 9
实验数据和实验结果记录 13
实验结果分析 13
实验三　继承和组合 13
基本信息 13
实验预习 13
实验过程 14
实验数据和实验结果记录 19
实验结果分析 19
实验四　多态、友元、 虚函数、模板 19
基本信息 19
实验预习 19
实验过程 20
实验数据和实验结果记录 37
实验结果分析 37
实验五　课程设计 37
基本信息 37
实验预习 37
实验过程 38
实验数据和实验结果记录 38
实验结果分析 38

《面向对象程序设计》课程实验教学大纲
课程名称：
面向对象程序设计
英文名称：
Object Oriented Programming
设置形式：
非独立设课
课程模块：
专业核心课
实验课性质：
专业基础实验
课程编号：
609324
课程负责人：
王玉亭
大纲主撰人：
王玉亭
大纲审核人：
左风朝

一、学时、学分
课程总学时：
54
实验学时：
16
课程学分：
3
二、适用专业及年级
计算机科学与技术、信息管理与信息系统、电子商务、软件工程、网络工程三年级
三、课程目标与基本要求
《面向对象程序设计》是计算机技术专业的一门必修课程，面向对象软件开发方法是吸收了软件工程领域有益概念和有效的方法而发展起来的一种软件开发方法，它集抽象性、封装性、继承性和多态性于一体，可以帮助人们开发出模块化、数据抽象程度高的，体现信息隐蔽、可复用、易修改、易扩大等特性的程序。本课程主要介绍面向对象程序设计的方法和C++语言的基本概念以及基本Windows编程技术，其中以C++语言中的面向对象机制为主。学习者在学习过程中可以通过大量的程序实例和相关练习，逐步掌握C++的面向过程和面向对象的功能，从而掌握面向对象程序设计的基本知识和基本技能。在学习本课程中，只有通过大量的上机实验，才能使学生更好的掌握面向对象程序设计的方法，提高学生运用C++语言和面向对象思想进行编程来解决实际问题的能力。
课程目标: 使学生把在理论课程中所学知识融会贯通，在培养学生理论联系实际、实际动手能力的同时，着重培养学生思考问题、解决问题的能力和创造能力。面向对象程序设计实验教学中一贯提倡以学生为主体、教师为主导，充分发挥学生的主观能动性。
基本要求: 本课程实验要求学生通过对各部分实验的具体操作练习，能够熟练的掌握C++的基本内容，包括控制结构、基本数据类型、表达式、函数、指针和引用、类与对象的概念以及封装、继承和多态等面向对象程序设计的基础理论，在这些基础理论的基础上，掌握初步的Windows编程技术，包括消息传递机制、MFC应用程序框架、文档视图结构等。通过实验还要培养学生实事求是、踏实细致、严肃认真的科学态度和克服困难、坚韧不拔的工作作风，以及科学、良好的实验素质和习惯。
四、主要仪器设备
装有C++集成开发环境的微型计算机。。
五、实验项目及教学安排
序号
实验项目名称
实验基本方法和内容
项目 学时
项目
类型
每组
人数
教学 要求
1
C++对C的扩充
使用集成开发环境开发简单C++程序；通过编写求斐波那契数列的第n项和前n项之和等简单程序，学习C++中的各种程序控制结构；通过解决Josephus问题，学习C++中各种运算符的功能、优先级和结合性；编写一个复杂的程序来学习自定义头文件的方法，学会调试多文件程序；分析五子棋游戏程序，学习指针的基本用法；编写简单程序学习动态内存的分配和释放，理解内存泄漏的危害。
2
基础
1
必修
2
类和对象
分析完整的Person类的定义，学习类和对象的概念、定义和使用方法；实现一个带有头结点的单链表，学习用类和对象解决实际问题。
4
基础
1
必修
3
继承和组合
分析完整的Person类和Employee类的定义，学习继承和派生概念；利用继承和组合的概念实现一个计算图形面积的类库。。
4
基础
1
必修
4
多态、友元、 虚函数、模板
利用抽象类设计一个计算图形面积的类库，学习动态联编的概念；分析Complex类的实现，理解重载运算符的意义；实现分数类，学习重载运算符方法，理解C++中的异常处理机制；用类模板实现一个带有头结点的单链表。
4
基础
1
必修
5
课程设计
学习Windows程序的消息处理机制和编程模式，分析设计自动取款机模拟系统，学习面向对象编程方法的思想，练习用面向对象编程方法解决实际问题。
2
综合
1
选修
六、考核方式及成绩评定
根据学生实验出勤情况、实验态度、实验报告成绩、实验考核成绩等评定实验成绩。 实验报告（含实验理论）占实验成绩的30%，实验技能（含实验态度）占实验成绩的30%，实验考核占实验成绩的40%。最终实验成绩占该课程考核总成绩的20％—30%。
七、实验教科书、参考书
1．实验教科书
自编实验指导书。
2．实验参考书

实验一　C++对C的扩充
基本信息
实验课程：面向对象程序设计 设课形式：非独立
课程学分：2 实验项目：C++对C的扩充
项目类型：基础 项目学时：2
实验预习
实验目的和要求：
1、了解在面向过程程序设计中C++对C语言的扩充与增强，并善于在编写程序过程中应用这些新的功能；
2、熟悉在Eclipse集成开发环境下编辑、编译、连接和运行C++程序的方法；
3、熟悉C++程序的结构和编程方法。
实验内容和原理或涉及的知识点：
1、验证大于等于4小于等于10000的偶数均可分解微量素数之和，并打印分解形式。
2、编写程序进行模拟仿真。在码头酒馆和游船之间搭了一条长20米，宽4米的跳板，醉酒的船员和游客回艇时必须通过这个跳板。通过跳板时，有三种可能的结果：向前走，回到游船上休息，不再出来；转身回到酒馆，重新开始喝酒，不再出来；左右乱晃，落入水中淹死。果醉酒者每次走一步，一步走1米。而且他们向前走的概率是0.7，向左走、向右走和向后走的概率各为0.1。现在假设开始时他们都是站在酒馆的门口，编写程序模拟出若干个醉酒者的最终行为结果。
3、编写程序解决Josephus问题。Josephus问题是说，一群小孩围坐成一圈，现在任意取一个数n，从当前编号为一的孩子开始数起，依次数到n（因为围成了一圈，所以可以不停的数下去），这时被数到n的孩子离开，然后圈子缩小一点。如此重复进行，小孩数不断减少，圈子也不断缩小。最后所剩的那个小孩就是胜利者。请找出这个胜利者。
4、编写程序实现五子棋棋游戏。五子棋的规则为：双方各执一色棋子，轮流下子（将子放在棋盘的任一未下子的点上），直到有一方的棋子有5个排成一线（无论是横、竖还是斜均可），则棋局结束，该方胜利。
实验条件：
1、装有Windows操作系统的微型计算机；
2、Eclipse集成开发环境和CDT插件；
3、MinGW编译环境。
实验设计方案：
1、熟悉在Eclipse集成开发环境下编辑、编译、连接和运行C++程序的方法。
2、借助流程图对程序进行“自顶向下、逐步求精”的结构化分析。
3、熟悉C++中const、引用、new、delete的用法。
4、利用“筛法”生成素数表。
5、实现模拟仿真要利用随机值函数。
实验过程
1、根据实验预习阶段的实验设计方案，编写应用程序。参考代码如下。
#include <iostream>
#include <cmath>
const int M = 10001; // 定义验证范围
// 函数 CreatPrimeList(): 生成素数表
void CreatPrimeList(int *PrimeList, int n)
{
int i, j;
// 将PrimeList的各元素设置为从0开始的正整数
for (i = 0; i < n; i = i + 1)
{
PrimeList[i] = i;
}
// 分别从表中去掉已经确定的各素数的倍数(将其置为0)
i = 2;
while (i <= sqrt(n))
{
for (j = i + 1; j < n; j = j + 1)
{
if (PrimeList[j] != 0 && PrimeList[j] % PrimeList[i] == 0)
{
PrimeList[j] = 0;
}
}
// 确定下一个素数的位置
i = i + 1;
while (PrimeList[i] == 0)
{
i = i + 1;
}
}
}
// 函数 NextPrimeNumber(): 求下一个素数
int NextPrimeNumber(int p, int *PrimeList)
{
p = p + 1;
while (PrimeList[p] == 0)
{
p = p + 1;
}
return PrimeList[p];
}
// 主函数: 在从4到M的范围内验证哥德巴赫猜想
int main()
{
int PrimeList[M]; // 说明存放素数表的数组
int x, p; // 变量x: 偶数, p: 素数
// 建立素数表
CreatPrimeList(PrimeList, M);
// 对从4到M的所有偶数验证哥德巴赫猜想
x = 4;
while (x < M)
{
// 检查偶数减去一个素数后的剩余部分是否仍为素数
p = PrimeList[2];
while (p <= x / 2 && PrimeList[x - p] == 0)
{
p = NextPrimeNumber(p, PrimeList);
}
// 输出检查结果
if (p > x / 2) // 找到了一个不能分解为两个素数和的偶数
{
std::std::cout << "Great discovery: Goldbach is wrong!" << std::endl;
}
else // PrimeList[x-p]≠0, 分解成功
{
std::std::cout << "The even number " << x << "=" << p << " + " << x - p
<< std::endl;
}
// 检查下一个偶数
x = x + 2;
}
return 0;
}
2、根据实验预习阶段的实验设计方案，编写应用程序。参考代码如下。
#include <iostream>
#include <ctime>
#include <cmath>
#include <cstdlib>
const int SHIP = 1;
const int BAR = 2;
const int WATER = 3;
//一个醉酒者行为的模拟仿真
int drunkard()
{
int x = -10; //记录醉酒者的x坐标，开始时在酒馆门口
int y = 0; //记录醉酒者的y坐标，开始时在跳板的中央
int step = 0; //记录醉酒者一共走了多少步
while (abs(x) <= 10 && abs(y) <= 2)
{
switch (rand() % 10)
{
case 0: //向左走
y = y - 1;
break;
case 1: //向右走
y = y + 1;
break;
case 2: //向后走
x = x - 1;
break;
case 3: //向前走
case 4:
case 5:
case 6:
case 7:
case 8:
case 9:
x = x + 1;
}
step = step + 1;
}
if (x < -10)
{
std::std::cout << "After " << step
<< " steps, the man returned to the bar and drunk again"
<< std::endl;
return BAR;
}
else
{
if (x > 10)
{
std::cout << "After " << step << " steps, the man returned to the ship"
<< std::endl;
return SHIP;
}
else
{
std::cout << "After " << step << " steps, the man dropped into the water"
<< std::endl;
return WATER;
}
}
}
//反映若干个醉酒者最终行为的模拟仿真的主函数
int main()
{
srand(time(0)); //初始化随机种子
int drunkardnumber; //醉酒者总数
int shipnumber = 0; //到达船上的人数
int barnumber = 0; //返回酒馆的人数
int waternumber = 0; //掉进水中的人数
std::cout << "Please input the number of drunkard" << std::endl;
std::cin >> drunkardnumber;
for (int i = 0; i < drunkardnumber; i = i + 1)
{
switch (drunkard())
{
case SHIP:
shipnumber = shipnumber + 1;
break;
case BAR:
barnumber = barnumber + 1;
break;
case WATER:
waternumber = waternumber + 1;
break;
}
}
std::cout << "******************************" << std::endl;
std::cout << "Of all the " << drunkardnumber << " drunkards:" << std::endl;
std::cout << shipnumber << " returned to the ship" << std::endl;
std::cout << barnumber << " went to the bar and drunk again" << std::endl;
std::cout << waternumber << " dropped into the water" << std::endl;
return 0;
}
3、根据实验预习阶段的实验设计方案，编写应用程序。参考代码如下。
#include <iostream>
int main()
{
const int Total = 7; //小孩总数，可以改动。
int ChooseNum; //用户随机选取的数
int boy[Total]; //表示小孩的数组
for (int i = 0; i < Total; i++)
{
boy[i] = i + 1; //给小孩编号
}
std::cout << " Please input the number which is to be eliminated: ";
std::cin >> ChooseNum; //用户随机输入一个剔除的数
std::cout << " Before eliminating, the boys are:" << std::endl;
for (i = 0; i < Total; i++)
{
std::cout << boy[i] << "\t";
}
std::cout << std::endl;
int k = 1; //第k个离开的小孩
int n = -1; //数组下标，下一个为0表示从第一个孩子开始数数
while (true)
{
//在圈中开始剔除
for (int j = 0; j < ChooseNum;)
{
n = (n + 1) % Total;
if (boy[n] != 0) //如果该小孩还在圈中，则参加计数
{
j++;
}
}
if (k == Total) //如果已经全部剔除完成，则跳出循环
{
break;
}
boy[n] = 0;
std::cout << "After " << k << " times elimination, the boys left are:"
<< std::endl;
for (i = 0; i < Total; i++)
{
if (boy[i] != 0)
{
std::cout << boy[i] << "\t";
}
}
std::cout << std::endl;
k++;
}
// break语句跳转至此，输出胜利者编号
std::cout << "The No." << boy[n] << " boy is the winner." << std::endl;
return 0;
}
4、根据实验预习阶段的实验设计方案，编写应用程序。参考代码如下。
#include <iostream>
#include <cstdlib>
const int M = 7; //规定棋盘大小
const int N = 5; //玩几子棋
void InitChess(char*);
void HumanMove(char*);
void ComputerMove(char*);
void ShowChess(char*);
char WinCheck(char*);
int main()
{
char *chess = new char[M * M];if( NULL == chess )
{
return 0;
}
char done;
std::cout<<"---Game of Chess---"<<std::endl;
std::cout<<"Human against the stupid computer"<<std::endl;
done ='*';
InitChess(chess);
do
{
ShowChess(chess);
HumanMove(chess);
done = WinCheck(chess); //检查是否有赢家
if(done!= '*')
{
break; //如有赢家，则跳出循环
}
ComputerMove(chess);
done = WinCheck(chess); //检查是否有赢家
}while(done== '*');
ShowChess(chess); //显示棋局最终状态
if(done=='H')
{
std::cout<<"Human won!"<<std::endl;
}
else
{
std::cout<<"Computer won!!!!"<<std::endl;
}
delete[] chess;
return 0;
}
//初始化棋盘
void InitChess(char *chess)
{
for (int i = 0; i < M; i++)
{
for (int j = 0; j < M; j++)
{
chess[i + M * j] = '*';
}
}
}
//下棋人的落子
void HumanMove(char *chess)
{
int x, y;
std::cout << "Enter X,Y coordinates for your move: ";
std::cin >> x >> y;
std::cout << std::endl;
x--;
y--;
if (chess[x + M * y] != '*')
{
std::cout << "Invalid move, try again." << std::endl;
HumanMove(chess);
}
else
chess[x + M * y] = 'H';
}
//计算机落子
void ComputerMove(char *chess)
{
int i, j;
for (i = 0; i < M; i++)
{
for (j = 0; j < M; j++)
{
if (chess[i + M * j] == '*')
{
break;
}
}
if (chess[i + M * j] == '*')
{
break;
}
}
if (i * j == M * M)
{
std::cout << "Diamond cut diamond" << std::endl;
exit(0);
}
else
{
chess[i + M * j] = 'C';
}
}
//在屏幕上显示棋局
void ShowChess(char *chess)
{
for (int i = 0; i < M; i++)
{
for (int j = 0; j < M; j++)
{
std::cout << chess[i + M * j] << "\t";
}
std::cout << std::endl << std::endl;
}
}
//检查是否有赢家
char WinCheck(char *chess)
{
for (int i = 0; i < M; i++)
{
for (int j = 0; j < M; j++)
{
char t = chess[i + M * j];
int count = 1;
for (int a = i + 1, b = j + 1;
chess[a + M * b] == t && a < M && b < M; a++, b++)
{
count++;
}
if (count >= N)
{
return t;
}
count = 1;
for (a = i, b = j + 1; chess[a + M * b] == t && b < M; b++)
{
count++;
}
if (count >= N)
{
return t;
}
count = 1;
for (a = i + 1, b = j; chess[a + M * b] == t && a < M; a++)
{
count++;
}
if (count >= N)
{
return t;
}
count = 1;
for (a = i + 1, b = j - 1; chess[a + M * b] == t && a < M && b >= 0;
a++, b--)
{
count++;
}
if (count >= N)
{
return t;
}
}
}
return '*';
}
实验数据和实验结果记录
根据程序运行情况如实记录实验结果。
实验结果分析
1、分析生成素数表的“筛法”。
2、分析机构化程序设计方法。
3、写出自己的心得体会。
实验二　类和对象
基本信息
实验课程：面向对象程序设计 设课形式：非独立
课程学分：3 实验项目：类和对象
项目类型：基础 项目学时：4
实验预习
实验目的和要求：
1、掌握声明类的方法，类和类的成员的概念以及定义对象的方法。
2、初步掌握用类和对象编制基于对象的程序。
3、学习检查和调试基于对象的程序。
4、掌握类的构造函数和析构函数的概念和使用方法。
5、掌握对象数组、对象的指针及其使用方法。
实验内容和原理或涉及的知识点：
1、用类实现顺序栈。
2、用类实现循环队列栈。
3、实现一个带有头结点的单链表，该链表可以插入整型元素。
实验条件：
1、装有Windows操作系统的微型计算机；
2、Eclipse集成开发环境和CDT插件；
3、MinGW编译环境。
实验设计方案：
1、熟悉C++程序中源文件的组织方式。
2、首先分析类的属性和行为，然后通过封装实现类。
3、实现栈时，考虑栈容量的自动增长问题。
实验过程
1、根据实验预习阶段的实验设计方案，编写应用程序。参考代码如下。
//Stack.h的内容
#ifndef STACK_H_
#define STACK_H_
class Stack
{
int *m_Elem;
int m_nTop;
const int m_nSize;
public:
Stack(int size) :
m_nTop(0), m_nSize(size)
{
m_Elem = new int[size];
}
~Stack()
{
delete[] m_Elem;
}
bool IsEmpty()
{
return m_nTop == 0;
}
bool IsFull()
{
return m_nTop == m_nSize;
}
bool Push(int e);
bool Pop(int &e);
};
#endif /* STACK_H_ */

//Stack.cpp的内容
#include "Stack.h"
bool Stack::Push(int e)
{
if (IsFull())
{
return false;
}
else
{
m_Elem[m_nTop] = e;
++m_nTop;
return true;
}
}
bool Stack::Pop(int &e)
{
if (IsEmpty())
{
return false;
}
else
{
--m_nTop;
e = m_Elem[m_nTop];
return true;
}
}
2、根据实验预习阶段的实验设计方案，编写应用程序。参考代码如下。
//Queue.h的内容
#ifndef QUEUE_H_
#define QUEUE_H_
class Queue
{
int front, rear
int *data;
const int size;
public:
Queue(int s) :
front(0), rear(0), size(s)
{
data = new int[size + 1];
}
bool IsEmpty()
{
return rear == front;
}
bool IsFull()
{
return (rear+1)%(size+1) == front;
}
bool EnQueue( int v );
bool DeQueue( int &v );
~Queue()
{
delete[] data;
}
};
#endif /* QUEUE_H_ */

//Queue.cpp的内容
#include "Queue.h"
bool Queue::EnQueue(int v)
{
if (IsFull() == true)
{
return false;
}
else
{
data[rear] = v;
rear = (rear + 1) % (size + 1);
return true;
}
}
bool Queue::DeQueue(int &v)
{
if (IsEmpty() == true)
{
return false;
}
else
{
v = data[front];
front = (front + 1) % (size + 1);
return true;
}
}
3、根据实验预习阶段的实验设计方案，编写应用程序。参考代码如下。
//list.h的内容
#ifndef LIST_H_
#define LIST_H_
#include <iostream>
#include <cstddef>
class List //定义整型链表类
{
private:
class Node
{
public:
Node(const int &data = 0, Node *next = NULL) :
m_nData(data), m_pNext(next)
{
}
Node *m_pNext; //指向下一个结点的指针成员
int m_nData; //指向本结点数据的指针成员
};
public:
List(); //构造函数
~List(); //析构函数
bool Append(const int &e, int index = 0); //在inedex位置后增加节点
bool Prepend(const int &e, int index = 1); //在inedex位置前增加节点
bool Remove(int &e, int index = 1); //删除inedex位置处的节点
bool Find(int &e, int index = 1); //查找inedex位置处的节点　
void PrintList(); //打印链表
protected:
Node *m_pFirst; //头节点
};

#endif /* LIST_H_ */

//List.cpp的内容
#include "List.h"
List::List() //构造函数
{
m_pFirst = new Node();
}
List::~List() //构造函数
{
Node * p = m_pFirst;
Node * q;
while (NULL != p) //寻找inedex位置前一个节点
{
q = p;
p = p->m_pNext;
delete q;
}
}
bool List::Append(const int &e, int index) //在inedex位置后增加节点
{
if (index < 0)
{
return false;
}
Node *p = m_pFirst;
int i = 0;
while (NULL != p && i < index) //寻找inedex位置处节点
{
++i;
p = p->m_pNext;
}
if (NULL == p)
{
return false;
}
Node *q = new Node(e, p->m_pNext);
p->m_pNext = q;
return true;
}
bool List::Prepend(const int &e, int index) //在inedex位置前增加节点
{
if (index < 1)
{
return false;
}
Node *p = m_pFirst;
int i = 0;
while (NULL != p && i < index - 1) //寻找inedex位置前一个节点
{
++i;
p = p->m_pNext;
}
if (NULL == p)
{
return false;
}
Node *q = new Node(e, p->m_pNext);
p->m_pNext = q;
return true;
}
bool List::Remove(int &e, int index) //删除inedex位置处的节点
{
if (index < 1)
{
return false;
}
Node *p = m_pFirst;
int i = 0;
while (NULL != p && i < index - 1) //寻找inedex位置前一个节点
{
++i;
p = p->m_pNext;
}
if (p == NULL || NULL == p->m_pNext)
{
return false;
}
Node *q = p->m_pNext;
p->m_pNext = q->m_pNext;
e = q->m_nData;
delete q;
return true;
}
bool List::Find(int &