C面向对象的实验报告要点.doc

C++实验报告

专业：网络工程

班级：113班

学号：119074361

姓名：管庶龙

实验三 函数的应用
一、 实验目的
1、 掌握函数的定义和调用方法。
2、 练习重载函数使用
3、 练习函数模版的使用
4、 练习使用系统函数
二、 实验任务
1、 编写一个函数把华氏温度转化为摄氏温度，转换公式为：C=(F-32)*5/9.
2、 编写重载函数Max1可分别求取两个整数。三个整数，两个双精度数，三个双精度数的最大值。
3、 使用重函数模版重新实现上小题中的函数Max1.
4、 使用系统函数pow(x,y)计算想xy的值，注意包含头文件math.h。
5、 用递归的方法编写函数求Fibonacci级数，观察递归调用的过程。
三、 实验步骤
1、 编写函数float Convert(float TempFer)，参数的返回值都为float类型，实现算法C=(F32)*5/9,在main()函数中实现输入、输出。程序名为lab3_1.cpp。
2、 分别编写四个同名函数max1，实现函数重载，在main()函数中测试函数功能。程序名：lab3_2.cpp。
3、 使用函数模版实现求任意类型数的最大值，针对不同的参数个数，编写两个同名的函数模版max1,其参数个数不同，实现函数重载，在main()函数中测试函数的功能。程序名：lab3_3.cpp。
4、 在main()函数中提示输入两个整数x,y，使用cin语句得到x,y的值，调用pow(x,y)函数计算x的y次幂的结果，再显示出来。程序名：lab3_4.cpp。
5、 编写递归函数int fib(int n),在主程序中输入n的值，调用fib函数计算Fibonacci级数。公式为fib(n)=fib(n-1)+fib(n-2),n>2;fib(1)=fib(2)=1。使用if语句判断函数的出口，在程序中用cout语句输出提示信息。程序名：lab3_5.cpp。
四、 体会
1、 初步掌握C++中函数调用。
2、 与C语言中函数调用并没有多大区别。
五、 程序代码
Lab3_1.cpp
#include
using namespace std;
double FtoC(double F)
{
return (F-32)*5/9;
}
int main()
{
double F,c;
cout<<"input F:";
cin>>F;
c=FtoC(F);
cout<
using namespace std;
int max(int a,int b)
{
return((a>b)? a:b);
}
int max(int a,int b,int c)
{
int d=max(a,b);return((c>d)? c:d)
}
double max(double a,double b)
{
return(a>b? a:b);
}
double max(double a,double b,double c)
{
double d=max(a,b);return(c>d? c:d);
}
int main()
{
int a,b,c;
double x,y,z;
cout<<"input three int:";
cin>>a;cin>>b;cin>>c;
cout<<"input three double:";
cin>>x;cin>>y;cin>>z;
cout<
#include
using namespace std;
int main()
{
double x;
int y;
cout<<"请输入两个数：";
cin>>x>>y;
cout<<"x的y次方="<
#include
using namespace std;
template
T cmax(T a,T b)
{
return (a>b?a:b);
}
template
A cmax(A a,A b,A c)
{

A d=a>b?a:b;
return (c>d?c:d);
}
int main()
{
int a,b,c;
double x,y,z;
cout<<"input three int:";
cin>>a;cin>>b;cin>>c;
cout<<"input three double:";
cin>>x;cin>>y;cin>>z;
cout<
using namespace std;
int fib(int n);
int main()
{
int n,answer;
cout<<"Enter number:";
cin>>n;
cout<<"\n\n";
answer=fib(n);
cout< return fib(n-2)+fib(n-1);
}

实验四 类与对象
一、 实验目的
3、 掌握类的声明和使用。
4、 掌握类的声明和对象的声明。
5、 复习具有不同访问属性的成员的访问方式。
6、 观察构造函数和析构函数的执行过程。
7、 学习类的组合使用方法。
8、 使用VC++的debug调试功能观察程序流程，跟踪观察类的构造函数、析构函数、成员函数的执行顺序。
二、 实验任务
1、 声明一个CPU类，包含等级（rank）、频率（frequency）、电压（voltage）等属性，有两个公有成员函数run、stop。其中，rank为枚举类型CPU_Rank，声明为enum CPU_Rank{P1=1,P2,P3,P4,P5,P6,P7}，frequency为单位是MHz的整型数，voltage为浮点型的电压值。观察构造函数和析构函数的调用顺序。
2、 声明一个简单的Computer类，有数据成员芯片（cpu）、内存（ram）、光驱（cdrom）等等，有两个公有成员函数run、stop。cpu为CPU类的一个对象，ram为RAM类的一个对象，cdrom为CDROM类的一个对象，声明并实现这个类。
3、 （选作）设计一个用于人事管理的People（人员）类。考虑到通用性，这里只抽象出所有类型人员都具有的属性：number（编号）、sex（性别）、birthday（出生日期）、id（身份证号）等等。其中“出生日期”声明为一个“日期”类内嵌子对象。用成员函数实现对人员信息的录入和显示。要求包括：构造函数和析构函数、拷贝构造函数、内联成员函数、组合。
三、 实验步骤
1、 首先定义枚举类型CPU_Rank,例如 enum CPU_Rank{P1=1,P2,P3,P4,P5,P6,P7},再定义CPU类，包含等级(Rank)，频率(frequency)，电压(volatage),等私有数据成员，定义成员函数run、stop，用来输出提示信息，在构造函数和析构函数中也可以输出提示信息。在主程序中定义一个CPU类的对象，调用其成员 函数，观察类对象的构造与析构顺序，以及成员函数的调用。程序名：lab4_1.cpp.
2、 首先依次定义CPU类，RAM类，CDROM类，run、stop作为她们的成员函数，然后定义Computer类，cpu,ram,cdrom为Computer的内部成员。程序名：lab4_2.cpp.
3、 首先安定义一个Date类，内含私有成员year,month,day。再定义一个Peolple类，内含私有成员num，sex，ID，Date birthday。再调用构造函数，析构函数，拷贝构造函数程序名：lab4_3.cpp。
四、 体会
1、 清楚的明白了类的定义和对象的声明。
2、 了解了构造函数，析构函数，拷贝构造函数的执行过程。
五、 程序代码
Lab4_1.cpp
#include
using namespace std;
class CPU
{
public:
CPU(int fre,float vol):frequency(fre),voltage(vol)
{
cout<<"成功调用构造函数"< ~CPU(){
cout<<"成功调用析构函数"<"<
using namespace std;
class CPU
{
public:
CPU(int fre,float vol):frequency(fre),voltagevol)
{cout<<"成功调用构造函数"<"等级:"< cout<<"成功调用析构函数"<frequency<
int rate;
int cache;
};
void CDROM::run()
{
cout<<"倍速:"<ut<<"析构了一个Computer!"<};

int main()
{

CPU cpu(60,220);
RAM ram(2048,667);
CDROM cdrom(18,2);
Computer Computer(cpu,ram,cdrom);
Computer.Run();
Computer.Stop();
return 0;
}
Lab4_3.cpp
#include
#include
using namespace std;

class Date //日期类
{
private:
int year;
int month;
int day;
public:
Date(){} //默认构造
Date(int y,int m,int d) //带参构造
{
year=y;
month=m;
day=d;
}
void set() //设置数据函数
{
cin>>year>>month>>day;
}
void display()
{
cout<day;
char ID[18];
public:
Person(){} //默认构造
Person(int n,int y,int m,int d,char id[18],char s='m'):birthday(y,m,d)
{
num=n;
sex=s;
strcpy(ID,id);
} //有默认值的带参构造
Person(Person& p) //拷贝构造
{
num=p.num;
sex=p.sex;
birthday=p.birthday;
strcpy(ID,p.ID);
}
void input() //输入函数
{
cout<<"录入数据："<>num;
cout<<"性别(m/f)：";
cin>>sex;
cout<<"生日：";
birthday.set();
cout<<"身份证号：";
cin>>ID;
ID[18]='\0';
cout<
}
~Person() //析构函数
{
cout<<" "<cpp

3、 实现客户机（CLIENT）类。定义字符型静态数据成员ServerName，保存其服5.务器名称：整型静态数据成员ClientNum，记录已定义的客户数量；定义静态函数ChangeServerName（）改变服务器名称。在头文件client.h中定义类，10在文件client.cpp中实现，在文件test.cpp中测试这个类，观察相应的成员变量取值的变化情况。
三、 实验步骤
1、 运行程序lab5_1,观察程序输出。全局变量的作用域，在整个程序运行期间有效，但如果在局部模块中定义了同名的变量，则在局部模块中，可见的是局部变量，此时全局变量不可见；而局部变量的生存期只限于相应的程序模块中，离开相应的程序模块，局部变量x，y就不再存在，此时同名的全局变量重新可见。
2、 新建一个空的项目lab5_2,添加头文件client.h，在其中定义类CLIENT，注意使用编译预处理命令；再添加源程序文件client.cpp，在其中实现CLIENT类，注意静态成员变量的使用方法，再添加文件lab5_2.cpp。在其中定义main()函数，测试CLIENT类，观察相应的成员变量取值的变化情况。
四、 体会
1、 初步了解静态成员的使用。
2、 学习多文件在C++结构的应用。
五、 程序代码
Lab5_2.cpp
#include

#include
using namespace std;
class CLIENT
{
private:
static char ServerName;
static int ClientNum;
public:
CLIENT();
~CLIENT();
static int GetClientNum();
static void ChangServerName(char name);
static char GetServerName();
};
CLIENT::CLIENT()
{

ClientNum++ ;
}
CLIENT::~CLIENT()
{
ClientNum-- ;
}
int CLIENT::GetClientNum()
{
return ClientNum;
}
void CLIENT::ChangServerName(char name)
{
ServerName=name;
}
char CLIENT::GetServerName()
{
return ServerName;
}
#include
int CLIENT::ClientNum = 0;
char CLIENTServerName= 'A';
int main()
{
CLIENT a;
CLIENT b;
cout << "服务器名称为：" << CLIENT::GetServerName() << endl;
CLIENT::ChangServerName('G');
cout << "客户机数量为：" << CLIENT::GetClientNum() << endl;
cout << "服务器名称为：" << CLIENT::GetServerName() << endl;
}

实验六 数组、指针和字符串
一、实验目的
1、学习使用数组。
2、学习字符串数据的组织和处理。
3、掌握指针的使用方法。
4、练习通过debug观察指针的内容及其所指的对象的内容。
5、练习通过动态内存分配实现动态数组，并体会指针在其中的作用。
二、实验任务
1、编写并测试3*3矩阵转置函数，使用数组保存3*3矩阵。
2、使用动态内存分配生成动态数组来重新设计一个3X3矩阵转置函数，使用指针实现函数的功能。
3、编程实现两字符串的连接。要求使用字符数组保存字符串，不要使用系统函数。
4、使用String类定义字符串对象，重新实现上一小题。
5、（选作）定义一个Employee类，其中包括姓名、街道地址、城市和邮编等属性，以及change_name（ ）和display（）等函数。display(）显示姓名、街道地址、城市和邮编等属性，change_name（）改变对象的姓名属性。实现并测试这个类。（提示：对字符数组的赋值可以使用字符串拷贝函数strcpy（char *，char*，name））。
6、（选作）定义包含个5元素的对象数组，每个元素都是Employee类型的对象。
三、实验步骤
1、编写矩阵转置函数，输入参数为3*3整型数组，使用循环语句实现矩阵元素的行列对调，注意在循环语句中究竟需要对哪些元素进行操作，编写main()函数实现输出。程序名：lab6_1.cpp。
2、改写矩阵转置函数，参数为整型指针，使用指针对数组元素进行操作，在main()函数中new操作符分配内存生成动态数组。程序名：lab6_2.cpp。
3、编程实现两字符串的连接，定义字符数组保存字符串，在程序中提示用户输入两个字符串，实现两个字符串的连接，最后用cout语句输出。程序名：lab6_3.cpp。用cin实现输入，注意，字符串的结束标志是ASCII码0，使用循环语句进行字符串间的字符拷贝。
4、使用string类定义字符串对象，编程实现两字符串的连接。在string类中已重载了运算符“+ =”实现字符串的连接，可以使用这个功能。程序名：lab6_4.cpp。
5、在employee.h文件中定义Employee类，Employee类具有姓名、街道地址、城市和邮遍等私有数据成员，都可以用字符型数组来表示，在成员函数中，构造函数用来初始化所有成员数组，对字符数组的赋值可以使用字符串拷贝函数 strcpy(char *,char * name);display()中使用count显示姓名、街道地址、城市和邮遍等属性，chang_name()改变类中表示姓名属性的字符数组类型的数据成员。在主程序中定义这个类的对象并对其进行操作。程序名： lab6_5.cpp。
6、使用上一小题中定义的Employee类定义对象数组enp[5]，使用循环语句把数据显示出来。程序名：lab6_6.cpp。
四、体会
1、初步了解数组，指针和字符串在C++中编译方式。
2、与C语言有一定的不同之处，但也有相同的地方。
3、更好的应用数组，指针和字符串问题的编译。
五、程序代码
Lab6_1.cpp
#include
using namespace std;
void move (int juzhen[3][3])
{
int i, j, k;
for(i=0; i<3; i++)
for (j=0; jen[i][j] = juzhen[j][i];
juzhen[j][i] = k;
}
}
int main()
{
int i, j;
int data[3][3];
cout << "输入矩阵的元素" << endl;
for(i=0; i<3; i++)
for (j=0; j<3; j++)
{
cout << "第" << i+1 << "行第" << j+1
<<"个元素为：";
cin >> data[i][j];
}
cout << "输入的矩阵的为：" << endl;
for(i=0; i<3; i++)
{
for (j=0; j<3; j++)
cout << data[i][j] << " ";
cout << endl;
}
move(data);
cout << "转置后的矩阵的为：" << endl;
for(i=0; i<3; i++)
{
for (j=0; j<3; j++)
cout << data[i][j] << " ";
cout << endl;
}
}
Lab6_2.cpp
#include
using namespace std;
void move (int *juzhen)
{
int i, j, k;
for(i=0; i<3; i++)
for (j=0; j for (j=0; j<3; j++)
{
cout << "第" << i+1 << "行第" << j+1
<<"个元素为：";
cin >> p[i*3+j];
}
cout << "输入的矩阵的为：" << endl;
for(i=0; i<3; i++)
{
for (j=0; j<3; j++)
cout << p[i*3+j] << " ";
cout << endl;
}
move(p);
cout << "转置后的矩阵的为：" << endl;
for(i=0; i<3 i++)
{
for (j=0; j<3; j++)
cout << p[i*3+j] << " ";
cout << endl;
}
}
Lab6_3.cpp
#include
using namespace std;
int main()
{
int i=0,j=0;
char s1[100],s2[50];
cout<<"请输入第一个字符串:";
cin>>s1;
cout<<"请输入第二个字符串:";
cin>>s2;
while(s1[i])
i++;
while(s2[j])
s1[i++]=s2[j++];
s1[i]='\0';
cout<<"连接后的字符串为:"<
#include
using namespace std;
int main()
{
int i=0,j=0;
string s1;
string s2;
cout<<"请输入第一个字符串s1:";
cin>>s1;
cout<<"请输入第二个字符串s2:";
cin>>s2;
s1+=s2;
cout<<"连接后的字符串为:"<
#include
using namespace std;
class Employee
{
private:
char name[20];
char address[30];
char city[20];
char zip[6];
public:
Employee(char *n,char *add,char *ct,char *z);
void change_name(char *n);
void display();
};
Employee::Employee(char *n,char *add,char *ct,char *z)
{
strcpy(name,n);
strcpy(address,add);
strcpy(city,ct);
strcpy(zip,z);
}
void Employee::change_name(char *n)
{
strcpy(name,n);
}
void Employee::display()
{
cout<tream>
using namespace std;
class Employee
{
private:
char name[10];
char address[30];
char city[20];
char zip[10];
public:
Employee(char name[],char address[],char city[],char zip[]);
void change_name(char name[]);
void display();
};
Employee::Employee(char n[],char add[],char ct[]char z[]){
strcpy(name,n);
strcpy(address,add);
strcpy(city,ct);
strcpy(zip,z);
}
void Employee::change_name(char n1[]){
strcpy(name,n1);
}
void Employee::display()
{
cout<<"name :"<p<