四川师范大学C++实验报告(含截图)

更新时间：2024-04-29 01:26:01 阅读量：综合文库文档下载

说明：文章内容仅供预览，部分内容可能不全。下载后的文档，内容与下面显示的完全一致。下载之前请确认下面内容是否您想要的，是否完整无缺。

实验编号：四川师大《面向对象程序设计》实验报告 2015年9

月14 日

计算机科学学院 2014 级 1 班实验名称：模板和文件姓名：宋亚梅学号：2014110127 指导老师：杨军实验成绩：____ __ 实验一类与对象（设计性实验 4学时）

1. 目的要求：

1) 掌握类的定义和使用；掌握类对象的声明；练习具有不同访问属性的成员的访问方式；观察构造函数和析构函数的执行过程；

2) 学习类组合使用方法；

3) 使用VC++的debug调试功能观察程序流程，跟踪观察类的构造函数、析构函数、成员函数的执行顺序。

2. 实验内容：

1) 编写重载函数Max1可分别求取两个整数，三个整数，两个双精度数，三个双精度数的最大值。

#include using namespace std; int Max1(inta,int b) { if(a>b) { return a; } else { return b; } }

int Max1(inta,intb,int c) { if(a>b) { if(a>c) { return a; }

注：实验成绩分为（90——100分）优，（80——89分）良，（70——79）中，（60——69分）及格，（59分）不及格。

else { return c; } } else if(b>c) { return b; } else { return c; } }

double Max1(double a,double b) { if(a>b) { return a; } else { return b; } }

double Max1(double a,doubleb,double c) { if(a>b) { if(a>c) { return a; } else { return c; } } else if(b>c) { return b; } else {

注：实验成绩分为（90——100分）优，（80——89分）良，（70——79）中，（60——69分）及格，（59分）不及格。

return c; } }

int main() { inta,b,c; cout<<\输入两个整数：\ cin>>a>>b; cout<<\两数中最大的是：\ cout<<\输入三个整数：\ cin>>a>>b>>c; cout<<\三数中最大的是：\ double x,y,z; cout<<\输入两个双精度数：\ cin>>x>>y; cout<<\两数中最大的是：\ cout<<\输入三个双精度数：\ cin>>x>>y>>z; cout<<\三数中最大的是：\ return 0; }

2) 写一个函数，具有一个引用作为形参参数，在函数中改变引用变量的值，观察实参变量的变化。

#include #include using namespace std; void fiddle(inta,int&b) { a=a+100;

注：实验成绩分为（90——100分）优，（80——89分）良，（70——79）中，（60——69分）及格，（59分）不及格。

b=b=100; cout<<\ cout<int main() { inta,b; cout<<\输入两个数：\ cin>>a>>b; cout<<\ \ cout<<\ cout<

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 using namespace std;

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

class CPU{ //CPU类的定义 public: //外部接口 CPU (intNrank,intNfrequency,floatNvoltage); //构造函数 void run();

注：实验成绩分为（90——100分）优，（80——89分）良，（70——79）中，（60——69分）及格，（59分）不及格。

void stop(); ~CPU(){cout<<\成功调用析构函数\ private: CPU_Rank rank; int frequency; float voltage; };

void CPU::run() { cout<<\程序开始执行\}

void CPU::stop() { cout<<\程序停止执行\}

CPU::CPU (intNrank,intNfrequency,floatNvoltage) { rank=(CPU_Rank)Nrank; frequency=Nfrequency; voltage=Nvoltage; cout<<\成功调用构造函数\ cout<<\等级（Rank） :\ cout<<\频率（frequency） :\ cout<<\电压(voltage) :\}

int main() { CPU_Rank rank; intr,f; float v; cout<<\输入等级，频率，电压：\ cin>>r>>f>>v; cout<<\ \ \ CPU CPU(r,f,v); CPU.run(); CPU.stop(); return 0; }

注：实验成绩分为（90——100分）优，（80——89分）良，（70——79）中，（60——69分）及格，（59分）不及格。

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

#include using namespace std;

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

class CPU{ //CPU类的定义 public: //外部接口 CPU (int i) { cpu=i; cout<<\成功调用CPU构造函数\ } ~CPU(){cout<<\成功调用CPU析构函数\ private: float cpu; };

class RAM{ //CPU类的定义 public: //外部接口 RAM (int i) { ram=i; cout<<\成功调用RAM构造函数\ } ~RAM(){cout<<\成功调用RAM析构函数\ private: float ram; };

class CDROM{ //CPU类的定义 public: //外部接口

注：实验成绩分为（90——100分）优，（80——89分）良，（70——79）中，（60——69分）及格，（59分）不及格。

CDROM (int i) { cdrom=i; cout<<\成功调用CDROM构造函数\ } ~CDROM(){cout<<\成功调用CDROM析构函数\ private: float cdrom; };

class Computer{ //CPU类的定义 public: //外部接口 Computer(CPU Ncpu,RAMNram,CDROMNcdrom); void run(); void stop(); ~Computer(){cout<<\成功调用Computer析构函数\ private: CPU cpu;RAMram;CDROMcdrom; };

Computer::Computer(CPU

Ncpu,RAMNram,CDROMNcdrom):cpu(Ncpu),ram(Nram),cdrom(Ncdrom) { cpu=Ncpu; ram=Nram; cdrom=Ncdrom; cout<<\}

void Computer::run() { cout<<\程序开始执行\}

void Computer::stop() { cout<<\程序停止执行\}

int main() { inti,j,k; cin>>i>>j>>k; CPU a(i); RAM b(j); CDROM c(k); Computer com(a,b,c); com.run(); com.stop(); return 0; }

注：实验成绩分为（90——100分）优，（80——89分）良，（70——79）中，（60——69分）及格，（59分）不及格。

5) 为题目2）的类编写复制构造函数，在主函数中利用复制构造的方式创建新的对象，观察对象的状态。

#include #include using namespace std; class FIDDLE{ public: FIDDLE(int xx=0,int yy=0) //构造函数 { x=xx; y=yy; } FIDDLE(FIDDLE &f); //复制构造函数 intgetX(){ return x; } intgetY(){ return y; } private: intx,y; };

FIDDLE::FIDDLE(FIDDLE &f)

注：实验成绩分为（90——100分）优，（80——89分）良，（70——79）中，（60——69分）及格，（59分）不及格。

{ x=f.x; y=f.y; cout<<\}

void fiddle(inta,int&b) { a=a+100; b=b=100; cout<<\ cout<int main() { inta,b; cout<<\输入两个数：\ cin>>a>>b; cout<<\ \ cout<<\ cout<

注：实验成绩分为（90——100分）优，（80——89分）良，（70——79）中，（60——69分）及格，（59分）不及格。

6) 思考并回答以下概念：函数重载，引用，类，对象，数据成员，函数成员，访问属性，构造函数，析构函数，类的组合，内嵌对象，初始化列表，复制构造函数。

函数重载：两个以上的函数，具有相同的函数名，但是形参个数或类型不同，编译器根据实

参和形参的类型和个数的最佳匹配，自动确定调用哪个函数

引用：是一种特殊类型的变量，可以被认为是另一个变量的别名类：是对逻辑上相关的函数与数据的封装，是对问题的抽象描述对象：该类的某一特定实体数据成员：类中直接定义的变量函数成员：类中直接定义的函数

访问属性：私有成员只能被本类的成员函数访问，来自类外部的任何访问都是非法的构造函数：在对象被创建时利用特定的值构造对象，将对象初始化为一个特定的状态析构函数：完成对象被删除前的一些清理工作

类的组合：一个类内嵌其他类的对象作为成员的情况，是一种包含与被包含的关系内嵌对象：内嵌类的对象

初始化列表：对所有内嵌对象进行初始化

复制构造函数：使用一个已经存在的对象，去初始化同类的一个新对象

实验二 C++程序的结构（设计性实验 2学时）

1. 目的要求：

1) 观察程序运行中变量的作用域、生存期和可见性； 2) 学习类的静态成员的使用；

3) 学习多文件结构在C++程序中的使用。

2. 实验内容：

7) 实现客户机(CLIENT)类。定义字符型静态数据成员ServerName，保存其服务器名称；整型静态数据成员ClientNum，记录已定义的客户数量；定义静态函数ChangeServerName()改变服务器名称。

#include using namespace std;

class CLIENT{

注：实验成绩分为（90——100分）优，（80——89分）良，（70——79）中，（60——69分）及格，（59分）不及格。

{ }

cout<<\int pos,n,l;

string str = \cout<

cout<<\cin>>pos;

if( pos<1 || pos>l ) { cout<<\ return 0; }

cout<<\cin>>n;

if( n<1 || pos+n>l ) { cout<<\ return 0; }

string str2=str.substr(pos,n); cout<

cout<<\return 0;

14) 选做：定义一个Point（二维点类）的对象数组，利用该数组实现直线的线性拟合。

注：实验成绩分为（90——100分）优，（80——89分）良，（70——79）中，（60——69分）及格，（59分）不及格。

#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

#include\#include #include using namespace std;

float lineFit(const Point points[],int nPoint) { float avgX=0,avgY=0; float lxx=0,lyy=0,lxy=0; int i=0; for( i=0; i(lxy/sqrt(lxx*lyy)); }

int main() {

注：实验成绩分为（90——100分）优，（80——89分）良，（70——79）中，（60——69分）及格，（59分）不及格。

}

Point p[10]={Point(6,10),Point(3,5),Point(12,10),Point(6,5),Point(23,46), Point(4,29),Point(12,32),Point(84,90),Point(100,100),Point(73,88)}; float r = lineFit(p,10);

cout<<\return 0;

15) 选做：定义一个动态数组类。

16) 思考并回答：数组，指针，对象数组，动态内存分配，默认构造函数，标准类库，字符串类 string，线性拟合。

数组：是具有一定顺序的若干对象的集合体，（相同类型变量的集合体）指针：通过指针得到存储地址

对象数组：数组里的每个元素都是类的对象，赋值时先定义对象，然后直接将对象直接赋值给数组动态内存分配：在程序执行中按照实际需要申请适量的内存，使用后还可以释放默认构造函数：类中没有写构造函数，编译器自动生成一个默认构造函数标准类库：Ｃ＋＋标准库里用来存储和处理数据的类的集合字符串类 string：提供对字符串进行处理所需要的操作线性拟合：求线的特性

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

实验四继承与派生（设计性实验 2学时）

1. 目的要求：

1) 学习定义和使用类的继承关系，定义派生类；熟悉不同继承方式下对基类成员的访问控制；

2) 学习利用虚基类解决二义性问题。

注：实验成绩分为（90——100分）优，（80——89分）良，（70——79）中，（60——69分）及格，（59分）不及格。

2. 实验内容：

17) 定义一个基类Animal，有私有整型成员变量age，构造其派生类dog，在其成员函数SetAge(int n)中直接给age赋值，看看会有什么问题，把 age改为公有成员变量，还会有问题吗？编程试试看。

#include using namespace std;

class Animal { public: };

void Animal::SetAge(int n) { }

class dog:public Animal { public: };

int main() {

Animal(){cout<<\构造函数调用！！！\<

~Animal(){cout<<\析构函数调用！！！\<

private:

age = n;

cout<<\<

dog(){cout<<\构造函数调用！！！\<

~dog(){cout<<\析构函数调用！！！\<

age = n;

cout<<\<

private:

Animal A; dog d; A.SetAge(3); d.SetAge(5); return 0;

注：实验成绩分为（90——100分）优，（80——89分）良，（70——79）中，（60——69分）及格，（59分）不及格。

}

在其成员函数SetAge(int n)中直接给age赋值，程序不会有问题，把 age改为公有成员变量，也没有问题

不过当age为私有成员变量的时候不能通过对象打点的形式在主函数中赋值，而为公有成员变量是便可以。

18) 定义一个基类BaseClass,有整型成员变量Number，构造其派生类DerivedClass,定义该派生类的对象,观察构造函数和析构函数的执行情况。

#include using namespace std; class BaseClass {

public: BaseClass(){cout<<\构造函数调用！！！\ ~BaseClass(){cout<<\析构函数调用！！！\private: int Number; };

class BaseClass1 {

public: BaseClass1(int i){cout<<\构造函数调用！！！\ \ ~BaseClass1(){cout<<\析构函数调用！！！\private: int Number; };

class DerivedClass:public BaseClass,public BaseClass1

注：实验成绩分为（90——100分）优，（80——89分）良，（70——79）中，（60——69分）及格，（59分）不及格。

{

public: DerivedClass(int a,int b):BaseClass1(a),number1(b) {} ~DerivedClass(){cout<<\析构函数调用！！！\private: BaseClass number; BaseClass1 number1; };

int main() { DerivedClass d(1,2); return 0; }

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

#include using namespace std; class vehicle {

public: vehicle(int m,int w):MaxSpeed(m),Weight(w){cout<<\构造函数调用！！！\ void Run(){cout<<\车开始以最大速度开始行驶\

注：实验成绩分为（90——100分）优，（80——89分）良，（70——79）中，（60——69分）及格，（59分）不及格。

void Stop(){cout<<\车停止 \ ~vehicle(){cout<<\析构函数调用！！！\ int MaxSpeed; int Weight; };

class bicycle:virtual public vehicle {

public: bicycle(int m,int w,int h):vehicle(m,w),Hight(h){cout<<\构造函数调用！！！\ void Run(){cout<<\自行车高度是\ void Stop(){cout<<\自行车停止 \ ~bicycle(){cout<<\析构函数调用！！！\ int Hight; };

class motorcar:virtual public vehicle {

public: motorcar(int m,int w,int s):vehicle(m,w),SeatNum(s){cout<<\构造函数调用！！！\ void Run(){cout<<\汽车座位数是\ void Stop(){cout<<\汽车停止 \ ~motorcar(){cout<<\析构函数调用！！！\ int SeatNum; };

class motorcycle:public bicycle,public motorcar {

public: motorcycle(int m,int w,int h,int s):vehicle(m,w),bicycle(m,w,h),motorcar(m,w,s){} void Run(){cout<<\摩托车的速度：\ 重量：\ 高度：\ 座位数为：\ void Stop(){cout<<\摩托车停止 \ ~motorcycle(){cout<<\析构函数调用！！！\};

int main() { vehicle v(2,4); v.Run(); v.Stop(); bicycle b(2,5,7); b.Run(); b.Stop(); motorcar mc(7,9,4); mc.Run();

注：实验成绩分为（90——100分）优，（80——89分）良，（70——79）中，（60——69分）及格，（59分）不及格。

}

mc.Stop();

motorcycle m(20,300,4,1); m.Run(); m.Stop(); return 0;

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

继承：从基类继承所有的属性（构造函数和析构函数除外）派生：产生新类的过程

子类对基类成员的访问权限：不能访问私有成员。共有继承：不变；私有继承：共有和保护作为私有出现；保护继承：共有和保护作为保护出现继承方式：共有、私有、保护继承

继承时的构造函数和析构函数的调用顺序：完全相反

注：实验成绩分为（90——100分）优，（80——89分）良，（70——79）中，（60——69分）及格，（59分）不及格。

构造：被继承时的声明顺序 -> 内嵌对象的定义顺序析构：新增的类型的成员 -> 内嵌对象 -> 继承的

虚基类：解决二义性（菱形结构）问题的（同一基类继承多次而产生的二义性问题）

实验五多态和运算符重载（设计性实验 2学时）

1. 目的要求：

掌握运算符重载的方法；学习使用虚函数实现动态多态性。

2. 实验内容：

21) 定义Point类，有坐标x,y两个私有成员变量;对Point类重载“+”（相加）、“-”（相减）和“==”（相等）运算符，实现对坐标的改变，要求用友元函数和成员函数两种方法实现。对Point类重载<<运算符，以使得代码 Point p; cout<

#include using namespace std; class Point {

private: int x,y; public:

Point(int x,int y):x(x),y(y){

cout<<\构造函数调用---\endl; }

~Point(){cout<<\析构函数调用---\endl;} int getX() const {return x;} int getY() const {return y;}

//Point operator + (Point &point2); //Point operator - (Point &point2); //Point operator == (Point &point2); inline void Display(){

cout<<\x<<\y<<\endl;

注：实验成绩分为（90——100分）优，（80——89分）良，（70——79）中，（60——69分）及格，（59分）不及格。

}

friend Point operator + (Point &point1, Point &point2); friend Point operator - (Point &point1, Point &point2); friend Point operator == (Point &point1, Point &point2); friend ostream & operator << (ostream &out,Point &point); }; /*

Point Point:: operator + (Point &point2) {

Point temp(0,0);

temp.x = this->x + point2.x; temp.y = this->y + point2.y; return temp; }

Point Point:: operator - (Point &point2) {

Point temp(0,0);

temp.x = this->x - point2.x; temp.y = this->y - point2.y; return temp; }

Point Point:: operator == (Point &point2) {

if ((this->x == point2.x) && (this->y == point2.y)) {

return point2; }

else cout<<\ }*/

Point operator + (Point &point1, Point &point2){ Point temp(0,0);

temp.x = point1.x + point2.x; temp.y = point1.y + point2.y; return temp; }