C++实验报告模版.docx
《C++实验报告模版.docx》由会员分享，可在线阅读，更多相关《C++实验报告模版.docx（43页珍藏版）》请在冰豆网上搜索。
C++实验报告模版
实验报告
实验课程：
C++语言程序设计
学生姓名：
学号：
61004102
专业班级：
计科103班
2012年12月12日
第2章C++简单程序设计
实验1面向对象C++简单程序相关测试3
第3章函数
实验2面向对象C++第三章‘函数’相关测试20
第4章类与对象
实验3.1类与对象37
实验3.2长方形类测试37
第5章C++程序的结构
实验4.1掌握静态成员41
实验4.2数组对象41
实验4.2友元类、友元函数41
第6章数组、指针与字符串
实验5.1掌握数组的基本使用方法53
实验5.2练习通过动态内存分配实现动态数组，并体会指针在其中的作用53
第7章继承与派生
实验6.1虚基类测试57
实验6.2派生类构造函数，析构函数57
实验6.3书上习题57
第8章多态性
实验7运算符重载实例64
南昌大学实验报告
---（3）第四章实验
学生姓名：
学号：
6100410235专业班级：
计科103班
实验类型：
□验证□综合■设计□创新实验日期：
实验成绩：
一．实验内容
1、类与对象
2、长方形类
二．实验环境
PC微机，Windows操作系统，VisualC++6.0
三．实验代码
类与对象：
#include
#include
usingnamespacestd;
classPoint
{
public:
Point（intxx=0,intyy=0）
{
X=xx;Y=yy;countP++;
cout<<"第"<cout<<""<}
Point（Point&p）;
~Point（）
{
countP--;
cout<<"第"<cout<<""<}
intGetX（）{returnX;}
intGetY（）{returnY;}
//voidGetC（）{cout<<"Objectid="<private:
intX,Y;
staticintcountP;
};
Point:
:
Point（Point&p）
{
X=p.X;
Y=p.Y;
countP++;
cout<<"第"<cout<<""<}
//类的组合
classLine
{
public:
Line（Pointxp1,Pointxp2）;
Line（Line&L）;
doubleGetLen（）{returnlen;}
private:
Pointp1,p2;
doublelen;
};
//组合类的构造函数
Line:
:
Line（Pointxp1,Pointxp2）:
p2（xp2）,p1（xp1）
{
cout<<"Line构造函数被调用"<doublex=double（p1.GetX（）-p2.GetX（））;
doubley=double（p1.GetY（）-p2.GetY（））;
len=sqrt（x*x+y*y）;
}
//组合类的拷贝构造函数
Line:
:
Line（Line&L）:
p2（L.p2）,p1（L.p1）
{
cout<<"Line拷贝构造函数被调用"<len=L.len;
}
intPoint:
:
countP=0;
//主函数
intmain（）
{
Pointmyp1（1,1）,myp2（4,5）;
Lineline（myp1,myp2）;
Lineline2（line）;
cout<<"Thelengthofthelineis：
";
cout<cout<<"Thelengthoftheline2is：
";
cout<getchar（）;
return0;
}
长方形类：
#include
#include
usingnamespacestd;
classPoint
{
public:
Point（intxx=0,intyy=0）{X=xx;Y=yy;}//Point类构造函数
Point（Point&p）{X=p.X;Y=p.Y;}//Point类拷贝构造函数
intGetX（）{returnX;}
intGetY（）{returnY;}
private:
intX,Y;
};
//类的组合
classRectangle
{
public:
Rectangle（Pointxp1,Pointxp2）;//组合类的构造函数
doubleArea（）;//求面积函数
private:
Pointp1,p2;
};
//组合类的构造函数
Rectangle:
:
Rectangle（Pointxp1,Pointxp2）:
p1（xp1）,p2（xp2）
{
}
//求面积函数
doubleRectangle:
:
Area（）
{
return（p1.GetX（）-p2.GetX（））*（p1.GetY（）-p2.GetY（））;
}
voidmain（）
{
Pointmyp1（8,5）,myp2（6,1）;//建立Point类的对象
RectangleRec（myp1,myp2）;//建立Rectangle类的对象
cout<<"长方形的面积为：
"<getchar（）;
}
四．实验结果
功能实现：
南昌大学实验报告
---（4）第五章实验
学生姓名：
学号：
6100410235专业班级：
计科103班
实验类型：
□验证□综合■设计□创新实验日期：
实验成绩：
一、实验内容
1、静态数据成员
2、静态函数成员
3、对象数组
4、友元类，友元函数测试
二、实验环境
PC微机，Windows操作系统，VisualC++6.0
三、实验代码
静态数据成员：
#include
#include
usingnamespacestd;
classPoint
{
public:
Point（intxx=0,intyy=0）{X=xx;Y=yy;countP++;}
Point（Point&p）;
~Point（）{countP--;}
intGetX（）{returnX;}
intGetY（）{returnY;}
voidGetC（）{cout<<"Objectid="<private:
intX,Y;
staticintcountP;
};
Point:
:
Point（Point&p）
{
X=p.X;
Y=p.Y;
countP++;
}
intPoint:
:
countP=0;
//主函数
intmain（）
{
PointA（4,5）;
cout<<"PointA,"<A.GetC（）;
PointB（A）;
cout<<"PointB,"<B.GetC（）;
getchar（）;
return0;
}
静态函数成员：
点类：
#include
usingnamespacestd;
classPoint
{
public:
Point（intxx=0,intyy=0）{X=xx;Y=yy;countP++;}
Point（Point&p）;
~Point（）{countP--;}
intGetX（）{returnX;}
intGetY（）{returnY;}
staticvoidGetC（）{cout<<"Objectid="<private:
intX,Y;
staticintcountP;
};
主文件1：
#include"point.h"
inti1=3;
staticinti2=3;
voidother1（）;
voidother2（）;
voidfun1（）;
externvoidfun2（）;
externvoidfun3（）;
voidfun3（）
{
cout<<"文件1中的函数fun3（）被调用！
"<}
intmain（）
{
PointA（4,5）;
cout<<"PointA,X="<A.GetC（）;
PointB（A）;
cout<<"PointB,X="<Point:
:
GetC（）;
cout<<"我在这个文件中定义了一个整型变量i1,它具有文件作用域，此时它的值为:
"<cout<<"接着调用函数other1（）"<other1（）;
cout<<"我在此还定义了一个整型变量i2,但给它加了static修饰，此时它的值为:
"<cout<<"接着调用函数other2（）"<other2（）;
fun1（）;
fun2（）;
fun3（）;
cout<<"为什么在这里输出的是‘文件2中的函数fun3（）被调用！
’而不是‘文件1中的函数’"<cout<<"fun3（）被调用！
因为文件2中fun3（）前加了static修饰，就将函数的作用域限制在了"<cout<<"当前的编译单元，在文件1中不可见！
也就不能被文件1中的main函数调用了，同时"<cout<<"我还在文件1中定义了一个同名函数fun3（）,但其输出的内容不一样，可用来判断"<cout<<"到底是哪个文件中函数被调用！
实验证明是文件1中函数被调用！
"<
cout<<"上面的两个例子说明了一个问题，那就是‘加了static修饰的变量和函数只能在本"<cout<<"文件中执行和调用，不能再在外部文件中被调用，即使是加了extern修饰也不行！
’"<getchar（）;
return0;
}
主文件2：
#include"point.h"
intPoint:
:
countP=0;
Point:
:
Point（Point&p）
{
X=p.X;
Y=p.Y;
countP++;
}
externinti1;
voidother1（）
{
i1++;
cout<<"函数other1（）被调用，i1的值为：
"<cout<<"（这里的函数other1（）是在另一个.cpp文件中定义的，对i1自加1）"<}
externinti2=2;
voidother2（）
{
i2++;
cout<<"函数other2（）被调用，i2的值为：
"<cout<<"（这里的函数other2（）是在另一个.cpp文件中定义的，对i2自加1）"<cout<<"为什么在这里i2的值是3而不是4呢？
"<cout<<"因为在other2（）这个文件中，给i2指定值为2，加1后当然为3了"<cout<<"那为什么在这里要给i2指定值呢？
"<cout<<"因为在这个文件中用extern声明i2连接时会出错,i2在文件1中声明为static类型，"<cout<<"不能被外部文件引用！
"<}
voidfun1（）
{
cout<<"文件2中的函数fun1（）被调用！
"<}
voidfun2（）
{
cout<<"文件2中的函数fun2（）被调用！
"<}
staticvoidfun3（）
{
cout<<"文件2中的函数fun3（）被调用！
"<}
对象数组：
员工类：
classemployee
{
protected:
intindividualEmpNo;
intgrade;
floataccumPay;
staticintemployeeNo;
public:
employee（）;
~employee（）;
voidpromote（int）;
voidSetaccumPay（float）;
intGetindividualEmpNo（）;
intGetgrade（）;
floatGetaccumPay（）;
};
Main1：
#include
#include"employee.h"
usingnamespacestd;
intemployee:
:
employeeNo=1000;
employee:
:
employee（）
{
individualEmpNo=employeeNo++;
grade=1;
accumPay=0.0;
}
employee:
:
~employee（）
{
}
voidemployee:
:
promote（intincrement）
{
grade+=increment;
}
voidemployee:
:
SetaccumPay（floatpa）
{
accumPay=pa;
}
intemployee:
:
GetindividualEmpNo（）
{
returnindividualEmpNo;
}
intemployee:
:
Getgrade（）
{
returngrade;
}
floatemployee:
:
GetaccumPay（）
{
returnaccumPay;
}
Main2：
#include
#include"employee.h"
usingnamespacestd;
voidmain（）
{
employeea[4];
floatpa;
for（inti=0;i<4;i++）
{
cout<<"请输入下一个雇员的月薪：
";
cin>>pa;
a[i].promote（i+1）;
a[i].SetaccumPay（pa）;
}
cout<<"\t编号\t级别\t月薪"<for（inti=0;i<4;i++）
{
cout<<"\t"<}
}
友元类测试：
Class类：
#include
usingnamespacestd;
classX;//前向引用声明
classY//定义一个类Y
{
public:
voidg（X&x）;
};
classX//定义一个类X
{
public:
friendvoidY:
:
g（X&x）;//类Y的成员函数是类X的友元函数
friendclassZ;//类Z是类X的友元类
friendvoidh（X&x）;//普通函数h（X&x）是类X的友元函数
X（intI）{i=I;}
intGeti（）
{
returni;
}
private:
inti;
};
//Y的成员函数f（X&x）的实现部分
voidY:
:
g（X&x）
{
x.i++;
cout<}
classZ//定义一个类Z
{
public:
voidf（X&x）;
};
//Z的成员函数f（X&x）（也是类Y的友元函数）的实现部分
voidZ:
:
f（X&x）
{
x.i+=5;
cout<}
//函数h（X&x）的实现部分
voidh（X&x）
{
x.i+=10;
cout<}
Main文件：
#include
usingnamespacestd;
#ifndefclass_h
#defineclass_h
#include"class.h"
#endif
intmain（）
{
Xmyx
（1）;
Ymyy;
Zmyz;
cout<<"myx.i的初始值：
"<cout<<"执行函数g（x）后,myx.i的值：
";
myy.g（myx）;
cout<<"执行函数f（x）后,myx.i的值：
";
myz.f（myx）;
cout<<"执行函数h（x）后,myx.i的值：
";
h（myx）;
getchar（）;
return0;
}
友元函数测试2：
Main文件：
#include
usingnamespacestd;
classcar;//前向引用声明
classboat//定义一个类boat
{
public:
friendinttotalweight（car&c,boat&b）;
boat（intw）{weight=w;}
private:
intweight;
};
classcar//定义一个类car
{
public:
friendinttotalweight（car&c,boat&b）;
car（intw）{weight=w;}
private:
intweight;
};
//boat和car的友元函数totalweight的实现，计算二者的重量和
inttotalweight（car&c,boat&b）
{
returnc.weight+b.weight;
}
intmain（）
{
carC（1000）;
boatB（1234）;
cout<<"Thetotalweightofthecarandtheboatis:
"<getchar（）;
return0;
}
四、实验结果
功能实现：
静态数据成员：
友元函数测试2：
静态函数成员：
对象数组：
友元函数测试1：
南昌大学实验报告
---（5）第六章实验
学生姓名：
某同学学号：
6100410235专业班级：
计科103班
实验类型：
□验证□综合■设计□创新实验日期：
实验成绩：
一、实验内容
1、掌握数组的基本使用方法。
2、练习通过动态内存分配实现动态数组，并体会指针在其中的作用。
二、实验环境
PC微机，Windows操作系统，VisualC++6.0
三、实验代码
使用对象数组的方法改造“employee”函数的对象。
代码如下：
//employee.h
classemployee
{
protected:
intindividualEmpNo;
intgrade;
floataccumPay;
staticintemployeeNo;
public:
employee（）;
~employee（）;
voidpromote（int）;
voidSetaccumPay（float）;
intGetindividualEmpNo（）;
intGetgrade（）;
floatGetaccumPay（）;
};
//employee.cpp
#include
#include"employee.h"
usingnamespacestd;
intemployee:
:
employeeNo=1000;
employee:
:
employee（）
{
individualEmpNo=employeeNo++;
grade=1;
accumPay=0.0;
}
employee:
:
~employee（）
{
}
voidemployee:
:
promote（intincrement）
{
grade+=increment;
}
voidemployee:
:
SetaccumPay（floatpa）
{
accumPay=pa;
}
intemployee:
:
GetindividualEmpNo（）
{
returnindividualEmpNo;
}
intemployee:
:
Getgrade（）
{
returngrade;
}
floatemployee:
:
GetaccumPay（）
{
returnaccumPay;
}
//5_11.cpp
#include
#include"employee.h"
usingnamespacestd;
voidmain（）
{
employeea[4];
floatpa;
for（inti=0;i<4;i++）
{
cout<<"请输入下一位雇员的月薪";
cin>>pa;
a[i].promote（i+1）;
a[i].SetaccumPay（pa）;
}
cout<<"\t编号\t级别\t月薪"<for（inti=0;i<4;i++）
升级会员 