C++实验报告(类和对象 重载与继承 多态和模板 异常和流)

C++实验报告

目录

C++实验报告 (4)

实验一：类和对象 (4)

1． (4)

代码 (4)

运行结果 (5)

2 (5)

思路： (5)

代码 (5)

运行结果 (8)

3 (8)

思路 (8)

代码 (8)

运行结果 (9)

实验二重载和继承 (9)

1 (9)

思路 (10)

代码 (10)

运行结果 (13)

问题分析： (13)

2 (13)

思路： (13)

代码 (14)

运行结果 (15)

实验三多态与模板 (16)

思路 (16)

代码 (16)

运行结果 (17)

2 (17)

思路 (17)

代码 (18)

运行结果 (19)

3 (19)

思路 (19)

代码 (19)

运行结果 (21)

问题及分析 (21)

实验四异常和流 (21)

1 (21)

思路 (21)

代码 (21)

运行结果 (22)

2 (23)

思路 (23)

代码 (23)

运行结果 (27)

实验总结： (28)

C++实验报告

实验一：类和对象

实验目的：

能够根据软件需要，对客观实体进行抽象（封装）和代码实现。

实验环境：

Visual C++ 6.0

实验内容：

1．设计并测试一个名为Rectangle的矩形类，其属性为矩形的左下角与右上角两个点的坐标，能计算矩形的面积。

代码如下：

#include

using namespace std;

struct point

{

float x;

float y;

};

class Rectangle//矩形类

{

point lowerleft;//矩形左下角点的坐标

point upperright;//矩形右上角点的坐标

public:

void get();//输入矩形左下角点和右上角点的坐标

float area();//计算矩形面积

};

void Rectangle::get()

{

cout<<"输入坐标时：先输入横坐标，再输空格，再输入纵坐标\n\n";

cout<<"请输入矩形左下角坐标:";

cin>>lowerleft.x>>lowerleft.y;

cout<<"请输入矩形右上角坐标:";

cin>>upperright.x>>upperright.y;

}

float Rectangle::area()

{

return (upperright.x-lowerleft.x)*(upperright.y-lowerleft.y);

}

int main()

{

Rectangle juxing;

juxing.get();

float result;

result=juxing.area();

cout<<"矩形面积为："<

return 0;

}

运行结果如下：

2.设计并测试一个“人员”类。属性包括：编号、性别、出生日期、身份证号等等。其中“出生日期”定义为一个“日期”类内嵌子对象。用成员函数实现对人员信息的录入和显示。要求包括：构造函数和析构函数、拷贝构造函数、内联成员函数。

思路：

构造函数包括默认构造函数、带参构造函数、拷贝构造函数，在对象创建时调用构造函数，当用一个已存在的类实例去初始化另一个新创建的类实例时，系统会调用拷贝构造函数。在对象消除时调用析构函数。内联函数使用inline标识，在编译阶段，内联函数的函数体代码部分会被嵌入到每一个调用语句处，在程序执行阶段，不会发生程序的控制转移，而是直接运行在编译时嵌入的代码。

代码如下：

#include

#include

using namespace std;

class date //日期类

{

int year,month,day;

public:

date(){year=0;month=0;day=0;} //默认构造函数

date(int y,int m,int d) ; //带参构造函数

~date(){} ; //析构函数

date(date &datep); //拷贝构造函数

void in() //数据输入函数

{ cin>>year>>month>>day; }

void out() //显示输出函数

{ cout<

};

class person //人员类

{

string name;

int num;

string sex;

date birthday; //内嵌子对象

string ID;

public:

person(){name="Hello";num=0;sex="no";ID="0";} //默认构造person(string na,int nu,string se,date birth,string I);//带参构造函数

~person(){} //析构函数

person(person &p); //拷贝构造函数

void input(); //信息输入，内联函数

void show(); //信息输出，内联函数

};

date::date(int y,int m, int d) //date类构造函数的实现

{

year=y;

month=m;

day=d;

}

date::date(date &datep) //date类拷贝构造函数的实现

{

year=datep.year;

month=datep.month;

day=datep.day;

}

person::person(string na,int nu,string se,date birth,string I)//person构造函数的实现

{

num=nu;

sex=se;

ID=I;

birthday=date(birth);//使用拷贝构造函数

name=na;

}

person::person(person &p) //拷贝构造函数的实现{

num=p.num;

sex=p.sex;

ID=p.ID;

name=https://www.360docs.net/doc/a58314697.html,;

birthday=p.birthday;

}

inline void person::input() //信息输入函数

{

cout<<"请输入个人信息"<

cout<<"姓名：";

cin>>name;

cout<<"编号：";

cin>>num;

cout<<"性别: ";

cin>>sex;

cout<<"出生日期：";

birthday.in();

cout<<"身份证号: ";

cin>>ID;

cout<

}

inline void person::show() //信息输出函数

{

cout<<"人员信息显示如下："<

cout<<"姓名："<

cout<<"编号："<

cout<<"性别："<

cout<<"出生日期：";

birthday.out();

cout<

cout<<"身份证号："<

}

int main()

{

date a(1990,1,1);

person xie("谢端阳",1,"男",a,"1234567890");//调用构造函数person p;//调用默认构造函数

p.show();

p=person(xie);

p.show();

p.input();

p.show();

return 0;

}

运行结果：

3.声明一个Cat类，拥有静态数据成员HowManyCats，记录Cat的个体数目；静态成员函数GetHowMany( )，获取HowManyCats。设计程序测试这个类，体会静态数据成员和静态成员函数的用法。

思路：

默认HowManyCats为0。在类Cat的构造函数里将HowManyCats加1，用函数GetHowMany( )返回HowManyCats的值。创建Cat类的对象a,此时HowManyCats变为1。再创建对象b,在创建对象a后的HowManyCats基础上加1，变成2。说明类的所有对象共享同一个静态类成员。

静态成员函数只能访问静态数据成员。

代码如下：

#include

using namespace std;

class Cat

{

private:

static int HowManyCats;

public:

Cat(){ HowManyCats++; }

static int GetHowMany(){ return HowManyCats; }

void show();

};

int Cat::HowManyCats=0;

void Cat::show()

{

cout<<"There are "<

}

int main()

{

Cat a;

a.show();

Cat b;

b.show();

return 0;

}

运行结果如下：

实验二重载和继承

1. 实现如下字符串类String的各项功能，并编写测试程序。

class String{

private:

char *str;

public:

String(char *s=0);

String(const String&);

int strlenth(void)const;

int strcmpp(const String&)const; // 比较字符串

String& operator=(const String&); // 拷贝字符串

String& operator+=(const String&); // 连接字符串

operator const char *(void)const;

~String();

};

这题我写的的代码不好，请参考《C++Primer Plus第五版》第十二章

思路：

表示字符串的方式有三种：char数组；用引号括起的字符串常量；被设置为字符串的地址的char指针。在本题的类String中，成员str是一个char指针，被设置为字符串的地址。

编写函数代码时，在有关字符串的复制操作中使用strcpy（）函数，在比较操作中使用strcmp（）函数。重载*操作符后，可用于指向对象的指针。

代码如下：

#include

#include

#include

using namespace std;

class String{

private:

char *str;

public:

String(char *s);

String(const String&a);

int Strlenth()const;

int Strcmpp(const String&a)const; // 比较字符串

String& operator=(const String&a); // 拷贝字符串

String& operator+=(const String&a); // 连接字符串

operator const char *()const;

~String();

display();

};

String::String(char *s)//构造函数

{

if(s==NULL)

{

str=new char[1];

str[0]='\0';

}

else

{

str=new char[strlen(s) + 1];

strcpy(str,s);

}

}

String::String(const String&a)//拷贝构造函数{

str=new char[strlen(a.str)+1]; ;

strcpy(str,a.str);

}

int String::Strlenth()const

{

return strlen(str);

}

int String::Strcmpp(const String&a)const {

int x;

x=strcmp(str, a.str);

if(x>0) cerr<<">";

else if(x<0) cerr<<"<";

else cerr<<"=";

return x;

}

String& String::operator=(const String&a) {

str=new char[strlen(a.str)+1];

strcpy(str,a.str);

return *this;

}

String& String::operator+=(const String&a) {

char *p=str;

str=new char[strlen(a.str)+strlen(p)+1];

strcpy(str,p);

strcat(str,a.str);

return *this;

}

String::operator const char *()const

{

return str;

}

String::~String()

{

cerr<<"调用析构函数"<

delete []str;

}

String::display()

{

//cerr<<"字符串为：";

puts(str);

}

int main()

{

char *p="abcdefg";

char *q="hijkl";

String s1(p);

String s2(q);

String s3(s1);//拷贝构造函数

cerr<<"s1:";

s1.display();

cerr<<"字符串s1长度为："<

cerr<<"s2:";

s2.display();

cerr<<"字符串s2长度为："<

cerr<<"s3:";

s3.display();

cerr<<"字符串s3长度为："<

cerr<<"字符串比较结果(s1:s2)：s1";

s1.Strcmpp(s2);

cerr<<"s2\n";

cerr<<"将s2拷贝给s3:"<

s3=s2;

cerr<<"s3:";

s3.display();

cerr<<"连接s1与s2："<

s1+=s2;

cerr<<"s1:";

s1.display();

cerr<<"使用*操作符——String *s=new String(s1);"<

String *s=new String(s1);

cerr<<"s:";

cerr<<*s<

delete s;

return 0;

}

运行结果如下：

问题分析：

在写比较函数Strcmpp时，错误的理解了strcmp（s1,s2）函数的返回值情况, 返回值写成了strcmp(a.str,str)。实际上，当s1s2时，返回正值。所以在函数s. Strcmpp(a)里，应返回strcmp(str,a.str).

2.分别定义Teacher(教师)类和Cadre（干部）类，采用多重继承方式由这两个类派生出新类Teacher_Cadre（教师兼干部）。要求：

（1）在两个基类中都包含姓名、年龄、性别、地址、电话等数据成员。

（2）在Teacher类中还包含数据成员title(职称)，在Cadre类中还包含数据成员post（职务），在Teacher_Cadre类中还包含数据成员wages(工资)。

（3）对两个基类中的姓名、年龄、性别、地址、电话等数据成员用相同的名字，在引用这些数据成员时，指定作用域。

（4）在类体中声明成员函数，在类外定义成员函数。

（5）在派生类Teacher_Cadre的成员函数show中调用Teacher类中的display函数，输出姓名、年龄、性别、职称、地址、电话，然后再用cout语句输出职务与工资。

思路：

多重继承指派生类有多个基类。当两个基类中的数据成员有相同名字时，用：：操作符指定作用域，如cout<<"职务:"<

代码如下：

#include

#include

using namespace std;

class Teacher

{public:

Teacher(string nam,int a,string s,string tit,string ad,string t);

void display();

protected:

string name;

int age;

string sex;

string title;

string address;

string tel;

};

Teacher::Teacher(string nam,int a,string s,string tit,string ad,string t): name(nam),age(a),sex(s),title(tit),address(ad),tel(t){ }

void Teacher::display()

{cout<<"姓名:"<

cout<<"年龄:"<

cout<<"性别:"<

cout<<"职称:"<

cout<<"地址:"<

cout<<"电话:"<

}

class Cadre

{public:

Cadre(string nam,int a,string s,string p,string ad,string t);

void display();

protected:

string name;

int age;

string sex;

string post;

string address;

string tel;

};

Cadre::Cadre(string nam,int a,string s,string p,string ad,string t): name(nam),age(a),sex(s),post(p),address(ad),tel(t){}

void Cadre::display()

{cout<<"name:"<

cout<<"age:"<

cout<<"sex:"<

cout<<"post:"<

cout<<"address:"<

cout<<"tel:"<

}

class Teacher_Cadre:public Teacher,public Cadre

{public:

Teacher_Cadre(string nam,int a,string s,string tit,string p,string ad,string t,float w);

void show( );

private:

float wage;

};

Teacher_Cadre::Teacher_Cadre(string nam,int a,string s,string t,string p,string ad,string tel,float w):

Teacher(nam,a,s,t,ad,tel),Cadre(nam,a,s,p,ad,tel),wage(w) {}

void Teacher_Cadre::show( )

{

Teacher::display();

cout<<"职务:"<

cout<<"工资:"<

}

int main( )

{

Teacher_Cadre a("张三",50,"男","高级","教师","子虚国乌有市贾雨路5号","1234567",3000);

a.show( );

return 0;

}

运行结果如下：

实验三多态与模板

1.声明一个Shape抽象类，在此基础上派生出Rectangle和Circle类，二者都有GetArea（）

和GetPerim（）函数，GetArea用来计算对象的面积，GetPerim用来计算对象的周长。

封装上述各类，并编写测试程序。

思路：

虚函数是一种成员函数，它可以在该类的派生类中被重新定义并被赋予另外一种处理功能。将基类Shape、派生类Rectangle和Circle中的GetArea（）和GetPerim（）函数都声明为虚函数virtual。

代码如下：

#include

using namespace std;

static float pi=3.1415;

class Shape{

public:

Shape(){}

~Shape(){}

virtual float GetArea()=0;

virtual float GetPerim()=0;

};

class Rectangle:public Shape{

private:

float itsLength,itsWidth;

public:

Rectangle(float len,float wid):itsLength(len),itsWidth(wid){}

~Rectangle(){}

virtual float GetArea(){return itsLength*itsWidth;}

virtual float GetPerim(){return 2*(itsLength+itsWidth);}

};

class Circle:public Shape{

private:

float itsRadius;

public:

Circle(float r):itsRadius(r){}

~Circle(){}

virtual float GetArea(){return pi*itsRadius*itsRadius;}

virtual float GetPerim(){return 2*pi*itsRadius;}

};

int main()

{

Shape *s;

s=new Rectangle(5,2);

cout<<"矩形面积："<GetArea()<

cout<<"矩形周长："<GetPerim()<

delete s;

s=new Circle(10);

cout<<"圆形面积："<GetArea()<

cout<<"圆形周长："<GetPerim()<

delete s;

return 0;

}

运行结果如下：

2．有一种栈，这种栈是按数组索引减小的方向增长的。初始时栈为空且top=21。往栈中压入3个字符后，索引top=18，栈顶元素为list[top]=C。

在这个栈模型中，索引top在每次push索引操作后减小，而在pop操作后则增大。用此模型实现stack类模板。并编写测试程序。

思路：

使用stack类模板，将top初始化为最大值MAX，进行push操作时top减一，然后把值放入数组中top指向的位置。进行pop操作时返回top指向的数组元素，然后top加1。

#include

using namespace std;

template

class stack{

private:

int top;

T list[MAX];

public:

stack();

~stack(){}

void push(T e);//压栈

T pop();//弹栈

T stacktop()const;//获得栈顶的值

T couttop()const;

};

templatestack::stack()

{top=MAX;}

templatevoid stack::push(T e) {

if(top<=0)

cout<<"错误！"<

--top;

list[top]=e;

}

templateT stack::pop()

{

if(top>MAX)

cout<<"错误！"<

return list[top++];

}

templateT stack::stacktop()const {

if(top<0)

cout<<"错误！"<

return list[top];

}

templateT stack::couttop()const {

cout<<"索引值top="<

return top;

}

{

stackx;

x.push('A');

cout<<"栈顶元素："<

x.couttop();

x.push('B');

cout<<"栈顶元素："<

x.couttop();

x.push('C');

cout<<"栈顶元素："<

x.couttop();

cout<<"弹出栈顶元素";

x.pop();

cout<<"\n弹出后栈顶元素为："<

x.couttop();

cout<<"弹出栈顶元素";

x.pop();

cout<<"\n弹出后栈顶元素为："<

x.couttop();

return 0;

}

运行结果：

3．编写程序，它从文件中读取文本，对于所读取的每一个单词，显示该单词出现的行数。使用一个映射，它的每一个元素都是一个对偶(k, v)，其中关键值k是—个单词，值v是一个集合，这个集合包含该单词的行数。你可以使用如下定义的类型settype和maptype：typedef set settype;

typedef map maptype;

思路：一次从文件中读取一行，然后将这一行的字符逐个复制到新字符串b中，遇到空格时意味着复制了一个单词，将空格前的这个单词及其行数插入到maptype中，直至判断到行尾。然后行数加1，再读取一行。重复上述操作，直到文件读取完。

代码如下：

#include

#include

#include

#include

#include

using namespace std;

typedef set settype;

typedef map maptype;

int main()

{

maptype yingshe;

ifstream fin;

fin.open("XXX.txt");

int line=0;

string a;

string b="";

while(getline(fin,a))

{

for(int i=0;i

{

if(a[i]!=' ') b+=a[i];

else

{

yingshe[b].insert(line);

b="";

}

}

yingshe[b].insert(line);

line++;

b="";

}

maptype::iterator it;

ostream_iterator out(cout, " ");

cout<<"单词\t出现在第几行\n";

for (it = yingshe.begin(); it != yingshe.end(); ++it)

{

cout<< (*it).first << "\t";

copy((*it).second.begin(),(*it).second.end(),out);

cout<

}

fin.close();

return 0;