C++上机考试题上机练习东南大学C++上机实验.docx

上传人:b****6 文档编号:9178709 上传时间:2023-02-03 格式:DOCX 页数:51 大小:401.19KB
下载 相关 举报
C++上机考试题上机练习东南大学C++上机实验.docx_第1页
第1页 / 共51页
C++上机考试题上机练习东南大学C++上机实验.docx_第2页
第2页 / 共51页
C++上机考试题上机练习东南大学C++上机实验.docx_第3页
第3页 / 共51页
C++上机考试题上机练习东南大学C++上机实验.docx_第4页
第4页 / 共51页
C++上机考试题上机练习东南大学C++上机实验.docx_第5页
第5页 / 共51页
点击查看更多>>
下载资源
资源描述

C++上机考试题上机练习东南大学C++上机实验.docx

《C++上机考试题上机练习东南大学C++上机实验.docx》由会员分享,可在线阅读,更多相关《C++上机考试题上机练习东南大学C++上机实验.docx(51页珍藏版)》请在冰豆网上搜索。

C++上机考试题上机练习东南大学C++上机实验.docx

C++上机考试题上机练习东南大学C++上机实验

 

C++上机考试题,上机练习,东南大学C++上机实验

/*

定义一个复数类,通过重载运算符:

=、+=、-=、+、-、*、/、==、!

=,

直接实现两个复数之间的各种运算。

编写一个完整的程序(包括测试各运算符的程序部分)。

*/

#include"stdio.h"//标准输入输出头文件

#include"iostream.h"

classComplex

{

floatReal,Image;

public:

Complex(floatr=0,floati=0)

{

Real=r;Image=i;

};

floatGetR(){returnReal;}

floatGetI(){returnImage;}//后面主函数要直接调用私有成员数据

voidshow(){cout<<"Real="<

Complexoperator+(Complex&);//把形参定义为引用,调用时更方便

voidoperator+=(Complex&);//自加运算,返回值为void

Complexoperator-(Complex&);

voidoperator-=(Complex&);

Complexoperator*(Complex&);

Complexoperator/(Complex&);

voidoperator=(Complex&);

intoperator!

=(Complex&);

intoperator==(Complex&);//返回真假

};

ComplexComplex:

:

operator+(Complex&c)//此时的函数名变为Complex:

:

operator

{

Complext;//在函数体内可以定义新的类,并把这个临时的类返回,同样用打点来访问

t.Real=Real+c.Real;

t.Image=Image+c.Image;

returnt;

}

voidComplex:

:

operator+=(Complex&c)

{

Real=Real+c.Real;

Image=Image+c.Image;

}

ComplexComplex:

:

operator-(Complex&c)

{

Complext;

t.Real=Real-c.Real;

t.Image=Image-c.Image;

returnt;

}

voidComplex:

:

operator-=(Complex&c)

{

Real=Real-c.Real;

Image=Image-c.Image;

}

ComplexComplex:

:

operator*(Complex&c)

{

Complext;

t.Real=Real*c.Real-Image*c.Image;

t.Image=Real*c.Image+Image*c.Real;

returnt;

}

ComplexComplex:

:

operator/(Complex&c)

{

Complext;

t.Real=Real*c.Real+Image*c.Image;

t.Image=-Real*c.Image-Image*c.Real;

floatval=c.Real*c.Real+c.Image*c.Image;

t.Real=t.Real/val;

t.Image=t.Image/val;

returnt;

}

voidComplex:

:

operator=(Complex&c)

{

Real=c.Real;

Image=c.Image;

}

intComplex:

:

operator!

=(Complex&c)

{

intres;//函数体内定义临时变量

res=(c.Real!

=Real)&&(c.Image!

=Image);

returnres;

}

intComplex:

:

operator==(Complex&c)

{

intres;

res=(c.Real==Real)&&(c.Image==Image);

returnres;

}

voidmain()

{

Complexa(3,4),b(6,8),c,d;

c=a;//赋值=

c.show();

d=a+b;//+

d.show();

c=b-a;//-

c.show();

c=b;

c+=a;//+=

c.show();

d=b;

d-=a;//-=

d.show();

//

c=a;

d=a;

cout<

\n";

if(c==d){c.show();d.show();cout<<"c==d";}

c=b;

d=a;

cout<

\n";

if(c!

=d){c.show();d.show();cout<<"c!

=d";}

//

cout<

cout<<"a*b:

";

c=a*b;c.show();

cout<<"\na/b:

";

d=b/a;d.show();

}

//在函数体内可以定义新的类,并把这个临时的类返回,同样用打点来访问

/*

四、下标运算符[]通常用于取数组中某个元素,可以实现数组下标越界的检测等。

本题要求通过下标运算符的重载,实现读取数组中某个元素的作用。

它具有如下公有成员函数:

1.voidWord(char*s);动态生成字符数组空间,用形参s来对其进行初始化。

2.char&operaror[](intn)给下标值为n的数组元素赋值。

下标运算符[]的重载关键是将下标值做为一个操作数。

它的实现非常简单,

就是用字符指针的首地址str加下标值n,然后将相加后的地址返回。

3.voiddisp();实现将字符指针str指向的字符串输出到屏幕上。

4.用~Word()析构函数来释放动态申请的堆空间。

*/

#include

#include

classWord{

private:

char*str;

intlen;

public:

Word(char*s)//voidWord(char*s)把原题的void去掉,做构造函数

{

len=strlen(s)+1;

str=newchar[len];

strcpy(str,s);

}

char&operator[](intn)//重载[],用operator,返回值为引用类型

{//n是[]的操作数,即下标

if(n>=0&&n

returnstr[n];

else{

cout<

returnstr[len-1];

}

}

voiddisp(){

cout<

}

~Word()

{

delete[]str;

}

};

voidmain()

{

char*s="china";

Wordw(s);//用字符串的指针做形参,做构造函数Word("china")

w.disp();

intn=strlen(s);

while(n>0)

{

w[n-1]=w[n-1]-32;

n--;

}

w.disp();

cout<

}

//14-3.cpp

/*建立一个双向链表,节点数据包括姓名、地址和工资,按工资从小到大的顺序排序。

参见教材P281例12.7和教材P192页

*/

#include

#include

classObject

{

public:

Object(){};//可以定义空的构造函数

virtualintIsEqual(Object&)=0;//纯虚函数

virtualintIsBigger(Object*)=0;//形参为&,实参直接为变量名

//形参为*,实参为指针或地址

virtualvoidShow()=0;

virtual~Object(){};

};

classIntObj:

publicObject

{

intdata;//工资

char*name;

char*address;

public:

IntObj(char*s=NULL,char*a=NULL,intx=0)

{

data=x;

if(s)

{

name=newchar[strlen(s)+1];//strlen的参数是指针

strcpy(name,s);

}

elsename=NULL;

if(a)

{

address=newchar[strlen(a)+1];

strcpy(address,a);

}

elseaddress=NULL;

}

~IntObj()

{

if(name)delete[]name;//析构前预判,很重要

if(address)delete[]address;

}

voidSetData(char*s,char*a,intx)//修改数据

{

data=x;

if(s)

{

delete[]name;//name本来指向另一个字符串,它开辟的空间长度

//需要人为改变,赋新的值之前要删除原有空间,重新开辟

name=newchar[strlen(s)+1];

strcpy(name,s);

}

elsename=NULL;

if(a)

{

delete[]address;

address=newchar[strlen(a)+1];

strcpy(address,a);

}

elseaddress=NULL;

}

intIsEqual(Object&obj)

{

IntObj&temp=(IntObj&)obj;//为它起个别名

if(strcmp(name,temp.name)!

=0)return0;//用strcmp函数比较字符串是否相同

if(strcmp(address,temp.address)!

=0)return0;

if(data!

=temp.data)return0;

return1;

}

intIsBigger(Object*obj)

{

IntObj*temp=(IntObj*)obj;

if(data<=temp->data)return0;

elsereturn1;

}

voidShow()

{

cout<<"姓名:

"<

"<

}

};

classNode//此处Node定义为类,前面都是定义为struct,这个节点当中包含为上面定义

//的类的数据成员

{

private:

Object*Info;//定义类object的指针

Node*Prev,*Next;//定义节点类型的指针,一前一后

public:

Node(){Info=0;Prev=Next=0;}//定义的指针在构造函数中初始化为0

Node(Node&node)//定义拷贝的构造函数

{

Info=node.Info;

Prev=node.Prev;

Next=node.Next;

}

voidFillInfo(Object*obj){Info=obj;}

friendclassList;

};

classList

{

Node*Head,*Tail;

public:

List(){Tail=Head=0;}

~List(){DeleteList();}

voidAddNode(Node*);

Node*DeleteNode(Node*);

Node*LookUp(Object&);

voidShowList();

voidDeleteList();

voidInsertNode(Node*);

};

voidList:

:

AddNode(Node*node)

{

if(Head==0){

Head=Tail=node;

node->Next=node->Prev=0;

}

else{

Tail->Next=node;

node->Prev=Tail;

Tail=node;

node->Next=0;

}

}

Node*List:

:

DeleteNode(Node*node)

{

if(node==Head)

if(node==Tail)

Head=Tail=0;

else{

Head=node->Next;

Head->Prev=0;

}

else{

node->Prev->Next=node->Next;

if(node!

=Tail)node->Next->Prev=node->Prev;

elseTail=node->Prev;

}

node->Prev=node->Next=0;

return(node);

}

Node*List:

:

LookUp(Object&obj)

{

Node*pn=Head;

while(pn)

{

if(pn->Info->IsEqual(obj))returnpn;

pn=pn->Next;

}

return0;

}

voidList:

:

ShowList()

{

Node*p=Head;

while(p)

{

p->Info->Show();

p=p->Next;

}

}

voidList:

:

DeleteList()

{

Node*p,*q;

p=Head;

while(p)

{

deletep->Info;

q=p;

p=p->Next;

deleteq;

}

}

voidList:

:

InsertNode(Node*p)

{

Node*pn=Head,*p1;

if(Head==0)//空表

{

Head=Tail=p;

Head->Next=Tail->Prev=0;

return;

}

if(Head->Info->IsBigger(p->Info))//小于头节点

{

p->Next=Head;

Head->Prev=p;

Head=p;

return;

}

pn=p1=Head;

while(pn->Next&&pn->Info->IsBigger(p->Info)==0)//寻找插入位置

{

p1=pn;pn=pn->Next;

}

if(pn->Info->IsBigger(p->Info)==0)//最末尾

{

Tail->Next=p;

p->Prev=Tail;

Tail=p;

p->Next=0;//注意

}

else//一般情况//插入p1和pn之间

{

p->Prev=p1;

p1->Next=p;

pn->Prev=p;

p->Next=pn;

}

}

voidmain()

{

IntObj*p;

Node*pn,*pt,node;

Listlist;

char*name[]={"jack","tom","john","mary","Sun"};

char*address[]={"sh","bj","nj","sz","gz"};

for(inti=1;i<6;i++)

{

p=newIntObj(name[i-1],address[i-1],6-i+100);

pn=newNode;

pn->FillInfo(p);

list.InsertNode(pn);

}

list.ShowList();

cout<<"\n";

IntObjda;

da.SetData("tom","bj",104);

pn=list.LookUp(da);

if(pn)pt=list.DeleteNode(pn);

list.ShowList();

cout<<"\n";

if(pn)list.InsertNode(pt);

list.ShowList();

cout<<"\n";

}

/*1.name本来指向另一个字符串,它开辟的空间长度需要人为改变,赋新的值之前要删除原

有空间,重新开辟.

*/

/*

编写一个程序,输入N个学生数据,包括学号、姓名、C++成绩,

要求输出这些学生的数据、平均分与成绩等级。

提示:

设计一个学生类Stud,除了包括id(学号)、name(姓名)和C(成绩)数据成员外,

还有两个静态成员数据sum和num,分别存放总分和人数,

另有两个普通成员函数setdata()和print(),分别用于给数据成员赋值和输出数据成员的值,

另有一个静态成员函数avg(),它用于计算平均分,并输出平均分。

同时设计一个友元函数,输出成绩对应的等级:

大于等于90:

优;80~90:

良;70~79:

中;60~69:

及格;小于60:

不及格。

在main()函数中定义了一个对象数组用于存储输入的学生数据,设计一个完整的程序。

*/

#include"stdio.h"

#include"iostream.h"

#include"string.h"

classStud

{

intid;

char*name;

intcpp;

public:

staticfloatsum,num;//定义两个静态成员数据,数值需要不断累加的sum,可以定义

//为静态,使每次修改的值都可以被保留,相对地,定义它的静态成员函数

Stud()

{

name=NULL;

num++;

};

~Stud()

{

if(name)delete[]name;

num--;

};

voidsetdata(char*s,intm_id,intm_cpp);

voidprint();

staticfloatavg();

friendvoidprintgrade(Stud&stu);//按题目要求,定义友元函数输出,可以

//访问类的任何成员

};

floatStud:

:

sum=0;//定义静态变量,原型说明和定义型说明

floatStud:

:

num=0;

voidStud:

:

setdata(char*s,intm_id,intm_cpp)

{

name=newchar[strlen(s)+1];

strcpy(name,s);

id=m_id;

cpp=m_cpp;

sum+=cpp;

}

floatStud:

:

avg()//静态函数的定义型说明,此时不用加static对函数进行原型说明

{

floatres;

if(num>0)res=sum/num;

elsecout<<"没有学生对象!

";

returnres;

}

voidStud:

:

print()

{

cout<<"学号:

"<

"<

"<

}

voidprintgrade(Stud&stu)

{

//cout<<"学号"<

";

cout<<"C++成绩等级:

";

if(stu.cpp>=90)cout<<"优"<

elseif(stu.cpp>=80)cout<<"良"<

elseif(stu.cpp>=70)cout<<"中"<

elseif(stu.cpp>=70)cout<<"中"<

elseif(stu.cpp>=60)cout<<"及格"<

elsecout<<"不及格"<

}

voidmain()

{

inti,n;

charname[100];

intid,cpp;

cout<<"请输入学生个数:

";

cin>>n;

Stud*pstu=newStud[n];

for(i=0;i

{

cout<<"请分别输入学号,姓名和C++成绩";

cin>>id>>name>>cpp;

pstu[i].setdata(name,id,cpp);

}

for(i=0;i

cout<

:

num<<"个学生平均分:

"<

:

avg()<

}

/*

1.实现描述超市的的类Suppermacket类,记录系统中现有商品(用指针实现),定义增加商品的函数Append,删除商品的函数Delete,查询商品的函数Query,

并显示查询结果;

2.定义商品类Goods,具有商品名称Name,商品价格Price,商品数量number等属性,操作Sale(销售商品,余额不足时给予提示)、Add(商品上架操作)

和ShowMe(显示商品信息)。

3.编写main函数,测试以上所要求的各种功能,完成商品的增加、删除和查询商品,以及商品销售和商品上架的操作。

4.可以利用对象成员来实现。

*/

#include

#include

classSuppermacket;

classGoods{

floatPrice;

intnumber;

charName[10];

public:

Goods(){Add();};

vo

展开阅读全文
相关资源
猜你喜欢
相关搜索
资源标签

当前位置:首页 > 医药卫生 > 预防医学

copyright@ 2008-2022 冰豆网网站版权所有

经营许可证编号:鄂ICP备2022015515号-1