面向对象程序设计实验教学大纲.doc

《面向对象程序设计》实验教学大纲

课程总学时：64 　学分：4
实验学时：16 　 实验个数： 6个 实验学分：1分
课程性质：专业必修课 适用专业：计算机类专业
教材及参考书：《C++语言程序设计（第四版）》，郑莉、董渊编著，北京：清华大学出版社，2011
大纲执笔人： 　　大纲审定人：
一、实验课的性质与任务
本课程实验大纲是面向计算机专业学生开设的《C++程序设计》实验课计划指导大纲，是依据《面向对象程序设计》课程教学计划指导大纲编制。本课程主要讲述了利用C++进行程序设计的思想和方法，既有面向过程和面向对象的程序设计的理论知识，又包括极强的实践应用能力的培养。本实验大纲力求结合该课程教学计划大纲的相应内容，由浅入深的指导学生了解和掌握如何利用C++程序设计语言进行程序设计，提高学生的动手能力，做到理论和实践相结合，培养学生理解，分析程序，编写，调试程序的能力，使之能把程序设计应用到今后的专业学习中。
二、实验目的与要求
1．实验目的
通过本课程的学习，使学生掌握面向过程的程序设计思想和编程思路，初步掌握面向对象的程序设计思想，学会调试程序，能独立编写实用的小型程序。
2．实验要求
(1) 学生应该自始至终贯彻课程中所介绍的程序设计风格,养成良好的编程习惯；
(2) 应独立完成所布置习题。为保证尽量在统一安排的上机时间内编译运行通过程序，学生应事先设计好程序。
三、实验项目及内容提要

面向对象程序设计实验课程 （071016）
序号
实验编号
实验名称
学时
必做
选做
学分数
实验类型
内容提要
基本操作
验证
综合
设计
1
1
类与对象
4
√

 √
函数重载,类的设计与使用
2
2
C++程序的结构
2
√

 √
作用域与生存期，静态成员
3
3
数组、指针与字符串
4
√

 √
三种常见编程元素的使用
4
4
继承与派生
2
√

 √
派生类的设计与使用
5
5
多态性
2
√

 √
运算符重载、动态多态
6
6
模板和文件
2
√

√

模板，异常处理机制的设计

四、实验内容安排：

实验一 类与对象
（ 设计性实验 4学时）
1. 目的要求：
1) 掌握类的定义和使用；掌握类对象的声明；练习具有不同访问属性的成员的访问方式；观察构造函数和析构函数的执行过程；
2) 学习类组合使用方法；
3) 使用VC++的debug调试功能观察程序流程，跟踪观察类的构造函数、析构函数、成员函数的执行顺序。
2. 实验内容：
1) 编写重载函数Max1可分别求取两个整数，三个整数，两个双精度数，三个双精度数的最大值。
#include <iostream>
using namespace std;

int Max1(int a,int b)//两个整形求最大值
{
int c;
c=(a>b)?a:b;
cout<<c<<endl;
return c;
}

double Max1(double a,double b)//两个双精度数求最大值
{
double c;
c=(a>b)?a:b;
cout<<c<<endl;
return c;
}

int Max1(int a,int b,int c)//三个整形求最大值
{
int d;
d=(a>b)?((a>c)?a:c):((b>c)?b:c);
cout<<d<<endl;
cout<<"\n"<<endl;

return d;
}

double Max1(double a,double b,double c)//三个双精度数求最大值
{
double d;
d=(a>b)?((a>c)?a:c):((b>c)?b:c);
cout<<d<<endl;
cout<<"\n"<<endl;

return d;
}

void main()
{
int a=1,b=8,c=12;
double a1=4.2,b1=1.8,c1=6.7;

cout<<"原数为：\n"<<endl;
cout<<"a="<<a<<" "<<"b="<<b<<" "<<"c="<<c<<endl;
cout<<"\n"<<endl;

cout<<"a1="<<a1<<" "<<"b1="<<b1<<" "<<"c1="<<c1<<endl;
cout<<"\n"<<endl;

cout<<"(a,b)两个整形求最大值"<<endl;
Max1(a,b);
cout<<"\n"<<endl;

cout<<"(a,b,c)三个整形求最大值"<<endl;
Max1(a,b,c);

cout<<"(a1,b1)两个双精度数求最大值"<<endl;
Max1(a1,b1);
cout<<"\n"<<endl;

cout<<"(a1,b1,c1)三个双精度数求最大值"<<endl;
Max1(a1,b1,c1);

}

2) 写一个函数，具有一个引用作为形参参数，在函数中改变引用变量的值，观察实参变量的变化。
#include<iostream>
using namespace std;

swap(int &x);
void main()
{
int a;
cout<<"please input a number: a=";
scanf("%d",&a);
swap(a);
cout<<"now: ";
cout<<"a="<<a<<endl;
}
swap(int &x)
{
cout<<"please input a number: x=";
scanf("%d",&x);
return x;
}

3) 定义一个CPU类，包含等级（Rank）、频率（frequency）、电压(voltage)等属性，有两个公有成员函数run、stop。其中，rank为枚举类型CPU__Rank,定义为enum CPU_Rank{P1=1,P2,P3,P4,P5,P6,P7},frequency为单位是MHz的整型数，voltage为浮点型的电压值。观察构造函数和析构函数的调用顺序。
第一种：
#include<iostream>
using namespace std;

class CPU
{
public:
int run();
int stop();

CPU(int frequency1,float voltage1)
{
cout<<"build!"<<endl;

frequency=frequency1;
voltage=voltage1;
cout<<"frequency= "<<frequency<<" MHz"<<endl;
cout<<"voltage= "<< voltage<<endl;
}

~CPU()
{
cout<<"destory!"<<endl;
}
private:
int frequency;
float voltage;
};

enum CPU_Rank{P1=1,P2,P3,P4,P5,P6,P7};

void main()
{
CPU a(3500,30);
}

第二种：
#include<iostream>
using namespace std;

class CPU
{
public:
int run();
int stop();
CPU( int frequency1,float voltage1):frequency(frequency1),voltage(voltage1)
{
cout<<"build!"<<endl;
cout<<"frequency= "<<frequency<<" MHz"<<endl;
cout<<"voltage= "<< voltage<<endl;
}
~CPU()
{
cout<<"destory!"<<endl;
}
private:
int frequency;
float voltage;
};

enum CPU_Rank{P1=1,P2,P3,P4,P5,P6,P7};

void main()
{
int frequency;
float voltage;
cout<<"frequenc= ";
cin>>frequency;

cout<<"voltage= ";
cin>>voltage;
CPU a(frequency,voltage);
}

4) 定义一个简单的Computer类，有数据成员芯片(cpu)、内存(ram)、光驱(cdrom)等等，有两个公有成员函数run、stop。cpu为CPU类的一个对象，ram为RAM类的一个对象，cdrom为CDROM类的一个对象，定义并实现这个类，为以上的类编写构造和析构函数，观察组合类和内嵌类的构造函数和析构函数的调用顺序。
#include<iostream>
using namespace std;

class CPU{
public:
CPU(){
cout<<"cpu build!"<<endl;
}
~CPU(){
cout<<"cpu destory!"<<endl;
}
};

class RAM{
public:
RAM(){
cout<<"ram build!"<<endl;
}
~RAM(){
cout<<"ram destory!"<<endl;
}
};
class CDROM{
public:
CDROM(){
cout<<"cdrom build!"<<endl;
}
~CDROM(){
cout<<"cdrom destory!"<<endl;
}
};

class Computer{
private:
CPU cpu;
RAM ram;
CDROM cdrom;
public:
Computer(){
cout<<"Computer build!"<<endl;
}
~Computer(){
cout<<"Computer destory!"<<endl;
}

};

int main(){
Computer A;
}

5) 为题目2）的类编写复制构造函数，在主函数中利用复制构造的方式创建新的对象，观察对象的状态。
#include<iostream>
using namespace std;

class A
{
int a;
public:

A(int a1=0)
{
a=a1;
}
A(A &p);
int getA()
{
return a;
}
};

A::A(A &p)
{
a=p.a;
}
void main()
{
A a(2);
cout<<"原本结果："<<a.getA()<<endl;
A b(a);
cout<<"复制结果："<<b.getA()<<endl;
}

6) 思考并回答以下概念：函数重载，引用，类，对象，数据成员，函数成员，访问属性，构造函数，析构函数，类的组合，内嵌对象，初始化列表，复制构造函数。
3. 主要仪器设备及软件：PC+Windows 2000+VC 6.0

实验二 C++程序的结构
（ 设计性实验 2学时）
1. 目的要求：
1) 观察程序运行中变量的作用域、生存期和可见性；
2) 学习类的静态成员的使用；
3) 学习多文件结构在C++程序中的使用。
2. 实验内容：
1) 实现客户机(CLIENT)类。定义字符型静态数据成员ServerName，保存其服务器名称；整型静态数据成员ClientNum，记录已定义的客户数量；定义静态函数ChangeServerName()改变服务器名称。
#include<iostream>
using namespace std;

class CLIENT
{
public:
static void ChangeServerName()//静态函数ChangeServerName()改变服务器名称
{
cout<<" the ClientNum:ClientNum="<<ClientNum<<endl;
cout<<" the ServerName:ServerName="<<ServerName<<endl;
cout<<"change the ServerName:ServerName=";
cin>>ServerName;
cout<<"\n"<<endl;

cout<<"now the ServerName:ServerName="<<ServerName<<endl;
}

private:
static char ServerName;//字符型静态数据成员ServerName,保存其服务器名称
static int ClientNum;//整型静态数据成员ClientNum,记录已定义的客户数量
};

char CLIENT::ServerName='t';
int CLIENT::ClientNum=0;

void main()
{
CLIENT A;

CLIENT::ChangeServerName();
}

2) 利用多文件结构实现题目1），在头文件client.h中定义类，在文件client.cpp中实现该类，在文件test.cpp 中测试这个类，观察相应的成员变量取值的变化情况，要求ClientNum能够实时记录客户机对象的数量。

在文件client.cpp中实现该类

#include"client.h"
#include<iostream>
using namespace std;

char CLIENT::ServerName='t';
int CLIENT::ClientNum=0;

void CLIENT::inputServerName() //静态函数ChangeServerName()改变服务器名称
{
cout<<"input the ServerName:ServerName=";
cin>>ServerName;

// cout<<"now the ServerName:ServerName="<<ServerName<<endl;
ClientNum++;
cout<<"now the ClientNum:ClientNum="<<ClientNum<<endl;
}
CLIENT::~CLIENT()
{
ClientNum--;

cout<<"now the ClientNum:ClientNum="<<ClientNum<<endl;
}

在文件test.cpp 中测试这个类
#include"client.h"
#include<iostream>
using namespace std;

void main()
{
cout<<"begain!!!!!!"<<endl;
CLIENT A;

CLIENT::inputServerName();

CLIENT B;
CLIENT::inputServerName();

cout<<"end!!!!!!"<<endl;
}

在头文件client.h中定义类
class CLIENT
{
public:
static void inputServerName();
~CLIENT();

private:
static char ServerName;//字符型静态数据成员ServerName,保存其服务器名称
static int ClientNum;//整型静态数据成员ClientNum,记录已定义的客户数量
};

3) 思考并回答以下概念： 类的静态数据成员，类的静态函数成员，多文件结构，文件包含。

3. 主要仪器设备及软件：Windows 2000+VC 6.0

实验三 数组、指针与字符串实验
（设计性实验 4学时）
1. 目的要求：
1) 学习使用数组；学习字符串数据的组织和处理；学习标准C++库的使用；
2) 掌握指针的使用方法；练习通过debug观察指针的内容及其所指的对象的内容；练习通过动态内存分配实现动态数组，并体会指针在其中的作用；
3) 分别使用字符数组和标准C++库练习处理字符串的方法。
2. 实验内容：
1) 编写一个类用于处理3×3矩阵转置，测试转置的效果，输出转置前后的矩阵。
#include<iostream>
using namespace std;

class Point
{
public:

Point()//构造函数里赋值
{
for(i=0;i<3;i++)
{
for(j=0;j<3;j++)
{
cin>>a[i][j];
}
}
}
move()//转置
{
for(i=0;i<3;i++)
{
for(j=0;j<3;j++)
{
b[i][j]=a[j][i];
}
}
}
void show()//显示转置结果
{
for(i=0;i<3;i++)
{
for(j=0;j<3;j++)
{
cout<<b[i][j];
}
cout<<'\t'<<endl;
}
}

private:
int i;//行
int j;//列
int a[3][3];//原数组
int b[3][3];//转置数组
};

int main()
{
int i,j;
int x;

cout<<"assignment begin!!!"<<endl;
cout<<"Please enter the values"<<endl;

Point a1;

a1.move();

cout<<"result:"<<endl;
a1.show();

return 0;
}

2) 定义一个具有构造函数和析构函数的类，如实验一的CPU类，定义一个CPU的对象数组，观察构造函数的析构函数的调用过程。
#include<iostream>
using namespace std;

class CPU
{
public:
CPU(int xx,int yy,int tt)
{
x=xx;
y=yy;
t=tt;
cout<<t<<" build !!!"<<endl;
}
~CPU()
{
cout<<t<<" No !!!"<<endl;
}
private:
int x,y,t;
};
int main()
{
CPU cpu[3]={CPU(1,2,1),CPU(3,4,2),CPU(5,6,3)};
return 0;
}

3) 利用动态内存分配的方式重新完成题目2）。
#include<iostream>
using namespace std;

class CPU
{
public:
CPU():x(0),y(0),t(0){cout<<"begain !!!"<<endl;}
CPU(int xx,int yy,int tt):x(xx),y(yy),t(tt){}
void move(int xx,int yy,int tt)
{
x=xx;
y=yy;
t=tt;
cout<<t<<" build !!!"<<endl;
}
~CPU()
{
cout<<t<<" No !!!"<<endl;
}
private:
int x,y,t;
};
int main()
{
CPU *p=new CPU[3];
p[0].move(1,2,1);
p[1].move(3,4,2);
p[2].move(5,6,3);
cout<<"end !!!"<<endl;
delete [] p;

return 0;
}

4) 使用系统提供的string类定义字符串对象并初始化，实现从原始字符串中提取一个子串。
#include<iostream>
#include<string>
using namespace std;

int main()
{
int i,j;
string A="abcdefghijklnm";
string B="123456789";

cout<<"A="<<A<<endl;
cout<<"起始位置：";
cin>>i;
cout<<"元素个数：";
cin>>j;
string a=A.substr(i-1,j);//从位置三开始的九个字符
cout<<a<<endl;
cout<<"\n"<<endl;

cout<<"B="<<B<<endl;
cout<<"起始位置：";
cin>>i;
cout<<"元素个数：";
cin>>j;
string b=B.substr(i-1,j);//从位置七开始的两个字符
cout<<b<<endl;
return 0;
}
5) 选做：定义一个Point（二维点类）的对象数组，利用该数组实现直线的线性拟合。
Point.h
#ifndef _POINT_H
#define _POINT_H

class Point
{
public:
Point(float x=0,float y=0):x(x),y(y){}
float getX() const {return x;}
float getY() const {return y;}
private:
float x,y;
};

#endif
3_5.cpp
/*定义一个Point（二维点类）的对象数组，利用该数组实现直线的线性拟合。*/
#include"Point.h"
#include<iostream>
#include<cmath>
using namespace std;

float lineFit(const Point points[],int nPoint)
{
int i;
float avgX=0,avgY=0;
float lxx=0,lyy=0,lxy=0;
for(i=0;i<nPoint;i++)
{
avgX+=points[i].getX()/nPoint;
avgY+=points[i].getY()/nPoint;
}
for(i=0;i<nPoint;i++)
{
lxx+=(points[i].getX()-avgX)*(points[i].getX()-avgX);
lyy+=(points[i].getY()-avgY)*(points[i].getY()-avgY);
lxy+=(points[i].getX()-avgX)*(points[i].getY()-avgY);
}
cout<<"This line can be fitted by y=ax+b."<<endl;
cout<<"a="<<lxy/lxx<<" ";
cout<<"b="<<avgY-lxy*avgX/lxx<<endl;
return static_cast<float>(lxy/sqrt(lxx*lyy));
}

int main()
{
Point p[10]={Point(6,10),Point(14,20),Point(26,30),Point(33,40),Point(46,50),
Point(54,60),Point(67,70),Point(75,80),Point(84,90),Point(100,100)};
float r=lineFit(p,10);
cout<<"Line coefficient r="<<r<<endl;
return 0;
}

6) 选做：定义一个动态数组类。
#include<iostream>
#include<cassert>
using namespace std;

class Point
{
public:
Point():x(0),y(0)
{
cout<<"Build !1!"<<endl;
}
Point(int x,int y):x(x),y(y)
{
cout<<"Build !2!"<<endl;
}
~Point()
{
cout<<"Destructor !3!"<<endl;
}
void move(int newx,int newy)
{
x=newx;
y=newy;
}
private:
int x,y;
};

class ArrayOfPoints
{
public:
ArrayOfPoints(int size):size(size)
{
points=new Point[size];
}
~ArrayOfPoints()
{
cout<<"Delete !4!"<<endl;
delete [] points;
}
Point &element(int index)
{
assert(index>=0 && index<size);
return points[index];
}
private:
Point *points;
int size;
};

int main()
{
int count;
cout<<"Please enter the cout of points: ";
cin>>count;
ArrayOfPoints points(count);
points.element(0).move(5,0);
points.element(1).move(15,20);

return 0;
}

7) 思考并回答：数组，指针，对象数组，动态内存分配，默认构造函数，标准类库，字符串类 string，线性拟合。
3. 主要仪器设备及软件：Windows 2000+VC 6.0

实验四 继承与派生
（设计性实验 2学时）
1. 目的要求：
1) 学习定义和使用类的继承关系，定义派生类；熟悉不同继承方式下对基类成员的访问控制；
2) 学习利用虚基类解决二义性问题。
2. 实验内容：
1) 定义一个基类Animal，有私有整型成员变量age，构造其派生类dog，在其成员函数SetAge(int n)中直接给age赋值，看看会有什么问题，把 age改为公有成员变量，还会有问题吗？编程试试看。
#include<iostream>
using namespace std;

class Animal{

//private:
public:
int age;

};

class dog:public Animal{

public:
SetAge(int n)
{
age=n;
cout<<"age="<<age<<endl;
}
};

int main()
{
dog a;
int n;
cout<<"n= ";
cin>>n;
a.SetAge(n);
return 0;
}

2) 定义一个基类BaseClass,有整型成员变量Number，构造其派生类DerivedClass,定义该派生类的对象,观察构造函数和析构函数的执行情况。
#include<iostream>
using namespace std;

class BaseClass{
private:
int Number;
public:
BaseClass(int number)
{
Number=number;
// cout<<"BaseClass.Number="<<Number<<endl;
cout<<"build BaseClass"<<endl;
}
~BaseClass()
{
cout<<"destroied BaseClass"<<endl;
}
};

class DerivedClass:public BaseClass{
private:
int a;
public:
DerivedClass(int aa):BaseClass(aa)
{
a=aa;
// cout<<"DerivedClass.a="<<a<<endl;
cout<<"build DerivedClass"<<endl;
}
~DerivedClass()
{
cout<<"destroied DerivedClass"<<endl;
}

};

int main()
{
DerivedClass derived(5);
return 0;
}

3) 定义一个车（vehicle）基类，具有MaxSpeed、Weight等成员变量，Run、Stop等成员函数，由此派生出自行车（bicycle）类，汽车（motorcar）类。自行车（bicycle）类有高度（Height）等属性，汽车（motorcycle）类有座位数（SeatNum）等属性。从bicycle和motorcycle派生出摩托车(Motorcar)类，在继承过程中，注意把vehicle设置为虚基类。如果不把vehicle 设置为虚基类，会有什么问？编程实验及分析原因。
#include<iostream>
using namespace std;

class vehicle{
private:
int MaxSpeed;
int Weight;
public:
void Run(){cout<<"1 vehicle Run !!!"<<endl; }
void Stop(){cout<<"1 vehicle Stop !!!"<<endl;}
vehicle(int MaxSpeed1=0,int Weight1=0):MaxSpeed(MaxSpeed1),Weight(Weight1){cout<<"1 vehicle start !!!"<<endl;}
~vehicle(){cout<<"1 vehicle end !!!"<<endl;}
};

class bicycle:virtual public vehicle{
private:
int Height;
public:
bicycle(int Height1=0):Height(Height1){cout<<"2 bicycle start !!!"<<endl;}
~bicycle(){cout<<"2 bicycle end !!!"<<endl;}
};

class motorcycle:virtual public vehicle{
private:
int SeatNum;
public:
motorcycle(int SeatNum1=0):SeatNum(SeatNum1){cout<<"3 bicycle start !!!"<<endl;}
~motorcycle(){cout<<"3 motorcycle end !!!"<<endl;}
};

class Motorcar:public bicycle,public motorcycle{
public:
Motorcar(){cout<<"4 Motorcar start !!!"<<endl;}
~Motorcar(){cout<<"4 Motorcar end !!!"<<endl;}
};

int main()
{
Motorcar Motorcar1;
return 0;
}

若没有设为虚基类，截图为：

4) 思考并回答：继承，派生，子类对基类成员的访问权限，继承方式，继承时的构造函数和析构函数的调用顺序，虚基类

3. 主要仪器设备及软件：PC+Windows 2000+VC 6.0

实验五 多态和运算符重载
（ 设计性实验 2学时）
1. 目的要求：
掌握