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

定义一个复数类，通过重载运算符：=、+=、—=、+、一、*、/、==、！=,

直接实现两个复数之间的各种运算。编写一个完整的程序(包括测试各运算符的程序部分)。

*/

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

#include"iostrcam.h"

classComplex

]

floatReal,Image;

public:

Complcx(floa(r=0.floati=0)

(

Real=r;Image=i;

)；

floatGetR()(retuniReal;}

floatGetl(){returnImage：}〃后面主函数要直接调用私有成员数据

voidshow()(cout«"ReaI="«Rcal«'\t,«"hnagc="«Imagc«cndl;}

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

voidoperator+=(Complcx&)”自加运算，返回值为void

Complexoperator-(Complex&);

voidoperator—(Complex&);

Complexoperator"(Complex&);

Complexoperator/(Complex&);

voidoperator=(Complex&);

intoperator!=(Complex&);

intoperator==(Complcx&);〃返回真假

)；

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

{

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

t.Real=Real+c.Real;

t.Image=Image+c.Image;

returnt;

}

voidComplex"operator+=(Complex&c)

Real=Real+c.Real;

1mage=Image+c.Image;

ComplexComplex::operator-(Complex&c)

(

Complext;

t.Real=Real-c.Real;

t.Image=Imagc-c.Image;

returnt;

)

voidComplex"operator—(Complex&c)

(

Rcal=Rcal-c.Rcal;

Image=Iniage-c.lmage;

}

ComplexComplex::operator"(Complex&c)

(

Complext;

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

t.Imagc=Rcal*c.Imagc+Imagc*c.Rcal;

returnt;

ComplexComplex::operator/(Complex&c)

I

Complext;

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

1.1mage=-Real*c.Image-Image*c.Real:

floatval=c.Rcal*c,Rcal+c.lmagc*c.linage;

t.Real=t.Real/val;

t.Image=t.Image/vak

rciurnt;

)

voidComplex::opcrator=(Complcx&c)

(

Real=c.Real;

Iinagc=c.Image:

)

intComplcx::operator!=(Coinp.ex&c)

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

res=(c.ReaI!=Real)&&(c.Iinage!=Image);

returnres;

intComplex"operator==(Complex&c)

{

intres;

res=(c.Real==Real)&&(c.hiage==lmage);

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;

coul«cndlvv”输出c和d：\n";

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

c=b;

d=a;

cout«endlv<"输出c和d:\n";

if(c!=d){c.show();d.show():cout«"c!=d":}

//

cout«endl;

cout«"a*b:

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

cout«"\nii/b:

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

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

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

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

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

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

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

下标运算符[]的重载关键是将下标值做为一个操作数。它的实现非常简单，

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

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

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

*/

#includc<iostrcam.h>

#include<string.h>

classWord{

private:

char*str;

intlen;

public:

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

{

len=strlcn(s)+l;

str=newchar[len];

strcpy(str,s);

}

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

{是口的操作数，即下标

if(n>=O&&n<lcn-l)

retumstr(n);

else{

coul«n<<“越界”；

retumstr(len-l];

}

}

voiddisp(){

cout«str«endl;

)

~Word()

delete[]str:

}；

voidmain()

{

char*s="china";

Wordw(s);〃用字符串的指针做形参，做构造函数WordC'china")

w.disp();

in(n=strlcn(s);

while(n>0)

(

w[n-l]=w[n-11-32;

n--;

I

w.disp();

cout«w[7];

//14-3.cpp

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

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

*/

#include<iostream.h>

#includc<string.h>

classObject

I

public:

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

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

virtualintIsBiggcr(Objcct*)=0;〃形参为&,实参直接为变量名

〃形参为",实参为指针或地址

virtualvoidShow()=0;

virtual~Objcct(){};

)；

classIntObj:publicObject

(

intdata;〃工资

char*namc:

char*address;

public:

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

data=x;

if(s)

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

strcpy(nanie.s);

)

elsename=NULL;

if(a)

(

addrcss=ncwchar[strlcn(a)+l];

strcpy(address,a);

}

elseaddrcss=NULL;

)

-IntObjO

(

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

if(address)delete[]address;

)

voidSetData(char*s,char4a,inlx)〃修改数据

{

data=x;

if(s)

(

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

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

name=newchar[strlen(s)+l|;

s(rcpy(namc,s);

}

elsename=NULL;

if(a)

(

delete[]address;

addrcss=ncwchar[strlen(a)+l];

strcpy(address,a);

}

elseaddress=NULL;

)

intIsEqual(Object&obj)

(

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

if(strcmp(name,)!=O)return0;〃用stremp函数比较字符串是否相同

if(strcmp(addrcss.tcmp.address)!=O)return0;

if(data!=temp.data)return0;

returnI;

intIsBigger(Object*obj)

(

IntObj*temp=(IntObj*)obj;

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

elsereturn1;

)

voidShow()

(

coutvv"姓名："«narr.e«'\t'«"hllht:"«address«,\t,«',ZE^="«data«'\t,«endl;

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

〃的类的数据成员

(

private:

Objccl定义类object的指针

Node*Prev,*NexlW定义节点类型的指针，一前一后

public:

Nodc()(Info=0;Prev=Ncx(=0;}〃定义的指针在构造函数中初始化为0

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

(

Info=nodc.Info;

Prev=node.Prev;

Next=node.Next;

}

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

friendclassList:

)；

classIJst

{

Node*Head,*Tail;

public:

List(){Tail=Head=O;}

~List(){DeleteList();)

voidAddNode(Node*);

Node*DclctcNo<lc(Nodc*):

Node*LookUp(Object&);

voidShowList();

voidDclelcLis(();

voidInsertNode(Node*);

｝；

voidList::AddNodc(Node*node)

(

if(Head==0){

Head=Tail=nodc;

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

)

clsc(

Tail->Next=node;

node->Prev=Tail;

Tail=nodc;

node->Nex(=0;

Node*List::DeleteNode(Node*node)

{

if(node==Head)

if(nodc==Tail)

Hcad=Tail=O;

else{

Head=node->Next;

Hcad->Prcv=O;

}

else(

nodc->Prcv->Ncx(=n(Kie->Ncx(;

if(n(xle!=Tail)n(xle->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->IsEquai(obj))returnpn;

pn=pn->Next:

)

return0;

voidList::ShowList()

Node*p=Head;

whilc(p)

(

p->Infb->Show();

p=p->Ncxt;

}

}

voidList::DeleteList()

{

Node*p、*q:

p=Head:

while(p)

(

deletep->Info;

q=p；

p=p->Ncxt;

deleteq;

I

)

voidIJst::1nsertNode(Node*p)

{

Node*pn=Head,*pl;

if(Head==0)〃空表

(

Head=Tail=p;

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

return;

)

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

(

p->Next=Head;

Head->Prev=p;

Head=p:

return;

I

pn=pl=Hcad;

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

pl=pn:pn=pn->Next;

)

if(pn->Inft>・>IsBigger(p->Info)==0)〃最末尾

(

Tail->Next=p;

p->Prcv=Tail;

Tail=p;

p->Next=();〃注意

)

else〃一般情况〃插入pl和pn之间

(

p->Prcv=pI;

pl->Next=p;

pn->Prev=p;

p->Ncxt=pn;

)

voidmain。

{

IntObj*p;

Node*pn,*pt,node;

Listlist;

char*name[]={"jack","toir.',,"john'\"mary","Sun");

char*address|]={"sh"；'bj',；,nj,,；,sz"；,gz"};

for(inti=l:i<6;i++)

(

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

pn=ncwNode;

pn->FillInfo(p);

list.lnsertNode(pn);

}

list.ShowList();

cout«,,\n,1;

IntObjda;

da.SetData("tomw,MbjM04);

pn=list.LookUp(da);

if(pn)pt=list.DclctcNo<ic(pn):

list.ShowList();

cout«,,\n,1;

if(pn)Iist.Inser(Node(pt);

list.ShowList();

cout«'^\n^^;

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

有空间，重新开辟.

*/

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

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

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

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

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

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

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

大于等于90：优：80-90：良：70-79：60-69：及格；小于60：不及格。

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

*/

#includc"stdio.h"

#includc"iostrcam.h"

#include"string.h"

classStud

(

intid;

char*namc;

intcpp;

public:

staticfloalsum.num;〃定义两个静态成员数据，数值需耍不断累加的sum,可以定义

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

Stud()

(

name=NULL;

num++;

)；

~Stud()

{

iftnainc)delete[]name:

num—;

voidsetdata(char*mjd.intm_cpp);

voidprint();

staticfloatavg();

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

〃访问类的任何成员

)；

floatStud::sum=0:〃定义静态变量，原型说明和定义型说明

floatStud::num=O:

voidStud::setdata(char*s,intm_id,intm_cpp)

]

name=newchar(strlen(s)+l|;

strcpy(name,s);

id=m_id;

cpp=m_cpp;

sum+=cpp;

)

floatSlud::avg()〃静态函数的定义型说明，此时不用加static对函数进行原型说明

{

floatres;

if(num>0)rcs=sum/nuni;

elsecout«"没有学生对象广;

returnres;

}

voidStud::piint()

I

cout«"学号："«id«"姓名：”《namcv<”C++成绩："«cpp«cndl;

voidprintgrade(Stud&stu)

(

〃coul<<"学号姓名"v<slu.namc«"C++成绩等级：

cout«"C++成绩等级："；

if(stu.cpp>=90)cout«"ttr«endl;

elseif(stu.cpp>=80)cout«"^"«endl;

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

elseif(stu.cpp>=70)cout«"riT,"«endl;

elseif(stu.cpp>=60)coutvv"及格"<<endl:

elsecoutvv"不及格"wend;

voidmain()

inti.n;

charname|1(X)J;

intid.cpp；

coul<<”请输入学生个数：；

cin»n;

Stud*ps(u=ncwS(ud[n];

for(i=0;i<n;i++)

(

COUt<<”请分别输入学号,姓名和C++成绩"；

cin»id»name»cpp;

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

)

for(i=0;i<n;i++){pstu[i].print();piintgrade(pstii[i]);}

cout«Stud::num«"个学生平均分："«Stud::avg()«endl;

1.实现描述超市的的类Suppennacket类，记录系统中现有商品（用指针实现），定义增加

商品的函数Append,删除商品的函数Delete,查询商品的函数Query,

并显示查询结果；

2.定义商品类Goods,具有商品名称Name,商品价格Price,商品数量number等属性，

操作Sale（销售商品，余额不足时给予提示）、Add（商品上架操作）

和ShowMe（显小商品信息）。

3.编写main函数，测试以上所要求的各种功能，完成商品的增加、删除和查询商品，以

及商品销售和商品上架的操作。

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

*/

#include<iostream.h>

#include<string.h>

classSuppennacket:

classGoods{

floatPrice;

intnumber;

charName[10];

public:

Goods(){Add();};

voidSale();

voidAdd();

voidShowMeO；

friendSuppermacket;

friendvoidSale(Suppermacket&);

)；

classSuppermacket(

Goods*PGoods[IO];

public:

Suppermacket(){

for(inti=0;i<10;i++)PGoods[i]=0;

)

voidAppend();

voidDclctcO;

voidQueryO;

friendvoidSalc(Suppcrmackct&);

)；

voidSale(Suppermacket&Goocs);

voidmain(){

SuppermacketGoods;

Goods.Append();

Goods.Append();

Goods.AppendO；

Goods.DcletcO;

Goods.QueryO；

Sale(Goods);

)

voidGoods::Sale(){

intn;

ShowMe();

cout<〈"请输入购买的商品数量："；

cin»n:

if(nuniber>n)number-=n;

elsecoui<<"货物数量不足！

)

voidGoods::Add(){

cout<<”请输入新上架商品的名称，单价和数量：”;

cin»Name»Price»number;

)

voidGoods::ShowMe(){

cout«"品名："«Name«"数量："<<number<<"单价："<〈Price«endl;

)

voidSuppcnnacket::Append(){

intn=0;

while(PGoods[n]!=0&&n<10)n++;

if(n<10)PGoods[n]=ncwGoods;

)

voidSuppermacket::Delete(){

charname[10];

COUKV”请输入待删除的商品名称：”；

cin»name;

for(inti=0;i<10;i++){

if(PGoods|i]==0)continue;

if(strcmp(PGoods(i]->Name,nanie)==0)break;

)

if(i<10){

coutvv"删除"vvnamc<<"商品\n";

deletePGoods[i];PGoods[i]=0;

)

elsecoutvv"没有此类商品!\n";

)

voidSuppermacket::Query(){

charname[10];

couivv”请输入待查询的商品名称：

cin»name;

for(inti=0;i<10;i++){

if(PGoods[i]==0)continue;

if(stremp(PGo()ds(i]->Name,nanie)==0)break;

I

if(i>=10){cout«”没有此类商品!\n";

elsePGoods[i]->ShowMe(i;

)

voidSale(Suppermacket&Goocs){

charnamcllO]:

inti=0;

cout<〈”请输入待买的商品名称："；

cin»namc;

while(i<10){

if(Goods.PGoods[i]==0){i++;continue;}

if(strcmp(Goods.PGoods[i]->Name.name)==0)break;

i++；

if(i>=IO)coutcv"没有此类商品!\n";

elseGoods.PGoods|i|->Sale();

【程序功能】找出给定范围内的和亲数。

对于两个正整数，如果其中的一个整数是另一个整数的全部真因子之和，反之亦然，则称这

两个数为"和亲数”。例如，220有真因子"1,2,4,5,10,11,20,22,44,

55,110",其和为284,而284有真因子"1,2,4,71,142”,其和为220,因此220和284就

是一对和亲数。

【编程要求】

1.试建立一个类NNM

私有数据成员

intnl,n2〃查找数据的范围

in【a[10][2];〃存储mn(m<n)之间的所有和亲数对，并存储到a数组中

intnum:〃统计和亲数对的个数

公有成员函数

I)缺省构造函数：初始化数据成员nl,n2为0。

2)带参构造函数NNM(intm,intn,inta[n2])：用参数初始化数据成员nl.n2o

3)voidfind。函数用于查找nln2之间的所有和亲数对并存储到数组中

4)打印函数voidprint(),将结果输出到屏幕

*/

#include<iostream.h>

classNNM{

ininl,n2;

inta[10][2J;

intnum:

public:

NNM(){n1=0;n2=0;num=C;}

NNM(inta,intb){

nl=a.n2=b.nujn=0:

voidfind():

voidprint();

｝；

voidmain(){

NNMa(2,500);

a.find();

a.print();

)

voidNNM::find(){

intsuml=0,sum2=0;

inti,n;

for(i=nl;i<=n2u++){

for(sum1=0.n=1:n<i/2+1;n++)

if(i%n==O)suml+=n;

fbr(sum2=0,n=1;n<sum1/2+1;n++)

if(suml%n==0)sjm2+=n;

if(sum2!=i||suml==iicontinue;

a[num][O]=i,a[num++][l]=sum1;

)

)

voidNNM:;print(){

for(inti=0:i<num;i++)

cout«a(iUO]«','«a|i][1]«endl;

二.【要求】试建立一个类Student用于描述学生信息，具体要求如下：

私有数据成员

intid:学生学号。

charyuwen:语文成绩（五级分制：A、B、C、D和E,其它无效）。

floatshuxue:数学成绩（百分制）。

公有成员函数

1）缺省构造函数：初始化数据成员为。或NULL值。

2）带参构造函数：用参数初始化数据成员（需判断参数是否有效）。

3）voidPrin（（）:输出本对象的学号、语文成绩（优，良，中，及格，不及格）和数学成绩。

4）修改函数voidChange（）：从键盘输入新的学号、语文成绩和数学成绩，修改相应数据

成员的值。接受输入前屏幕上显示提示输入哪些信息。

5）比较函数voidComp（Studcnt&a,Student&b）:比较本学生、a学生和b学生的数学成绩,

找出数学成绩最高和最低的学生，输出他们的信息。

主程序：定义三个以上的对象，并且每个成员函数至少被调用--次。

*/

#includc<iostrcam.h>

classStudent{

intid;〃学生学号。

charyuwen;〃语文成绩(五级分制：A、B、C、D和E,其它无效)。

floatshuxue;//数学成绩(百分制)。

public:

Studenl(){id=O,yuwen=NULL;shuxue=O;}

Studenl(int,char,float);

voidPrin(();

voidChange();

voidComp(Student&a,Student&b);

)；

voidmain(){

StudentA(78：E;86),B(84.,D,,82),C;

C.Change();

A.Comp(B,C);

Student::Student(inta,charb,floatc){

id=a,yuwen=b;shuxue=c;

)

voidStudent::Prin((){

cout«"学号："«id<<",语文成绩:"

<<yuwen〈v”,数学成绩："«shuxue«endl;

}

voidStudent::Change(){

cout<<”请输入学生的学号、语文成绩(五级分制：A/B/C/D/E,其它无效)和数学成绩:

\n";

cin»id»yuwen»shuxue;

}

voidStudent::Comp(Student&ILStudent&b){

Studentmax,min;

max=shuxuc>a.shuxue?(shuxue>b.shuxue?*this:b):(a.shuxuc>b.shuxuc?a:b);

min=shuxue<a.shuxue?(shuxue<b.shuxue?*this:b):(a.shuxue<b.shuxue?a:b);

cout<<"数学成绩最高和最低的学生分别是：\n”；

max.Print();

min.Print();

I.实现描述超市的的类Sup.Dermacket类，记录系统中现有商品(用指针实现)，定义增加商

品的函数Append,删除商品的函数Delete,查询商品的函数Query,

显示查询结果：

2.定义商品类Goods,具有商品名称Name,商品价格Price,商品数量number等属

性，操作Sale(销售商品，余额不足时给予提示)、Add(商品上架操作)

和ShowMe(显示商品信息)。

3.编写main函数，测试以上所要求的各种功能，完成商品的增加、删除和查询商品，以

及商品销售和商品上架的操作。

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

*/

#include<iostream.h>

#include<string.h>

classSuppermacket;

classGoods{

charnamc[10];

intPrice;

intnumber;

public:

Goods(){

strcpy(name,"");Price=O;number=O;J

voidSale(intn);

voidAdd();

voidShowME(){

coutw"商品:"vvnamevv",价格:"«Price«".有"vvnumbervv”件。\n\n";

I；

friendSuppennackcc

)；

classSuppcrmacket{

Goods*PGoods;

intnum;

public:

Suppermacket(intn=10){

PGoods=ncwGoods[n];

num=n;

)

voidAppcndO;

voidDelete();

voidQuery();

~Suppcrmackct(){

delete[]PGocxls;}

voidmain(){

SuppcrmackctA(3);

A.Append();

A.Append();

A.DclctcO;

A.Query。；

)

voidSuppermacket::Append(){

for(inti=0;i<num;i+4-){

if(PGoods[i].numbcr=0){

PGoods[i].Add():

PGoods[i].ShowME();

return;

}

I

coul<<"没有空货架上货了！\n";

voidSuppermacket::Delete(){

charname[10];intn;

coul«”请输入需要销售商品名称和数量:

cin»name»n;

for(inti=0;i<num;i4-4-)(

if(strcmp(PGoods[i].)==0){

PGoods[i].Sale(n);

return;

)

)

cout<<"查无此商品!\n";

voidSuppermacket::Quer)r(){

charnamc[10];

coul<〈”请输入需要查询的商品名称；

cin»name;

for(inti=0;i<num;i++){

if(strcmp(PGoods(il.nanie,name)==0){

PGoodsli].ShowME();

return;

}

I

cout<v"查无此商品!\n";

voidGoods::Sale(inln){

if(n<number){

numbcr-=n;

ShowMEO;

)

else

cout<<"商品数量不够，无法销售！\n";

}

voidGoods::Add(){

cout<<”请输入上架的商品名称、价格及数量:

cin»namc»Pricc»numbcr;

I.建立一个类NUM,求指定范围内的所有素数（质数）。具体要求如下：

1）私有数据成员。

intdata[25]；依次存放指定范围内的所有素数。

intspanl,span2；存放要求计算的素数的范围。

intnum；存放spanl与span2之间的素数个数。

2）公有成员函数。

构造函数NUM（inta,intb）；初始化所要求的素数的范围spankspan2及num（值为0）。

voidprocess():求出指定范围内的所有素数，把它们依次存放在数组dala中，并将求出的素

数的个数赋给num。

voidprint()：输出求出的所有素数。

3)在主程序中对该类进行测试。使用测试数据span1=100,span2=200。即求100~200

之间的所有素数。

*/

#includc<iosircani.h>

#include<math.h>

classNUM{

intdata[25];〃依次存放指定范围内的所有素数。

intspanl,span2;〃存放要求计算的素数的范围。

intnum;//存放spanl与span2之间的素数个数。

public:

NUM(inta,intb);

voidproccss();

voidprint();

}；

voidmain(){

NUMa(100,200);

cess();

a.print();

}

NUM::NUM(inta,intb){

spanl=a;

span2=b;

num=0;

}

voidNUM::proccss(){

inti,n,f=O;

for(i=spanI;i<=span2;i++)；

for(n=2.f=0;n<=sqrt(ii;n++)

if(i%n==O){f=l;break;}

if(f==l)continue;

data|nuin++]=i;

)

}

voidNUM::print(){

for(inti=0;i<num;){

cout«data[i]«'\t';

if(++i%6==0)cout«endl;

cout«cndl;

已知由一个数组派生出另一个数组的派生规则如下：假定原始数组为a(10],新数组为b(10],

则b[i]的值为数组a中大于a[i]的元素的个数。

例如，对于说明"inta[]={1,2,3,4,5)；intb[5]；"，其中a[l]=2,数组a中有3个元素比a[1]

大,则b[l]=3。试建立一个实现此功能的类ARRAY。

具体要求如下：

1)私有数据成员。

inta[10],b[10]；a存放原始数组,b存放派生数组。

2)公有成员函数。

构造函数ARRAY(intdata[10])；初始化成员数组a。

voidprocess()：由数组a根据上述派生类规则，用循环语句计算数组b的各元素。

voidprint()：屏幕显示数组a和b。

*/

#includc<iostrcam.h>

classARRAY{

inta[10].b[10];

public:

ARRAY(intdata[10])；〃初始化成员数组a。

voidproccss();〃由数组a根据上述派生类规则，用循环语句计算数组b的各元素。

voidprint();//屏幕显示数组a和b。

}；

voidmain(){

inta[]={7,4,9,23,56,44,18,33,21,17};

ARRAYarray(a):

array.pnxress();

array.print();

ARRAY::ARRAY(intdata[IO]){

for(inti=0;i<10;i++){

a[i]=datalij;

b[i]=O;

)

)

voidARRAY::proccss(){

for(inli=0;i<10;i++){

for(intk=0;k<10;k++)

if(a[k]>a[i])b[i]++;

}

}

voidARRAY::print(){

cout«"a[10]=

for(inti=O;i<IO;i++)

cou(«a[i]«'\

cout«endl;

cout«"b[10]=

for(i=0;i<10;i++)

cout«b[i]«'

cout«cndl;

【要求】按以卜描述和要求建立一个类Boxes,执行主函数对其测试。

私有成员：

in(*box;〃指向保管箱数组，下标为箱号，元素值为0表示空箱；大于0表示该箱中存

入的物品数量。

char*flag;〃指向客户标识符数组(下标为箱号，与box数组配对使用)

staticintsum;〃累计存入物品数量

公有成员：

Boxes(intnum=IO);〃构造函数，动态分配box和flag数组空间，长度为num。

~Boxes():〃析构函数，释放分配的内存

voidput(intn,charm);//选择一个空箱存入n件物品，填写客户标识符，并将物品数量累

加到sum：若找不到空箱则输出提示信息。

voidgeKcharm);〃根据客户标识符(元素下标)查找存储的物品，找到后取出并清空保管

箱(置0)。若找不到指定则输出提示信息。

voiddisplayO；〃输出保管箱类所有数据，统计占用箱个数和空闲箱个数。最后输出存入

物品数量

头文件包含语句为:#include<iostream.h>

在类定义外面对静态成员做定义性说明并赋初值为零：in【Boxes::sum=O;

主函数要求：

1)定义Boxes类对象A,B(2)。数组元素初始值为零。

2)调用函数put为对象A和B做存储操作：

A.put(5,'R');B.put(9,'K');

A.put(8,P);

B.put(15,'H');

B.put(40,'F');

调用函数display输出对象A司B的全部数据。

3)调用函数put和get为对象A和B做存储和取出操作：

B.get(H);

B.put(40,'F');

A.gci(S);

A.get('R');

A.put(12,*M');

4)调用函数display输出对象A和B的全部数据。

*/

#include<iostream.h>

classBoxes{

int"box;〃指向保管箱数组，下标为箱号，元素值为0表示空箱：大于0表示该箱

中存入的物品数量。

char*flag:〃指向客户标识符数组(下标为箱号，与box数组配对使用)

staticintsum;〃累计存入物品数量

intxh：

public:

Boxes(intnum=10);〃构造函数，动态分配box和flag数组空间，长度为num。

-Boxes();〃析构函数，释放分配的内存

voidput(in(n,charm)；〃选择一个空箱存入n件物品，填写客户标识符，并将物品数

量累加到sum：若找不到空箱则输出提示信息。

voidget(charm);〃根据客户标识符(元素下标)查找存储的物品，找到后取出并清空

保管箱(置0)。若找不到指定则输出提示信息。

voiddisplay();〃输出保管箱类所有数据，统计占用箱个数和空闲箱个数。最后输出

存入物品数量

}：

intBoxes::sum=0;

voidmain(){

BoxesA,B(2);〃数组元素初始值为零。

A.put(5,'R');

B.put(9；K');

A.put(8,'P');

B.pu((l5.'H');

B.put(40.'F);

cout«"A库：\n'*;A.display();

cout«"B库：\n";B.display();

B.gel(H);

B.put(40,'F);

A.gc(CS');

A.get('R');

A.put(12,'M');

cout«"A库：\n";A.display();

cout«"B库：\n";B.display。；

}

Boxes::Boxes(intnum){

box=newint(num];

flag=ncwchar[numl;

xh=num;

for(inti=O;i<num;i++)

box[i]=flag[i]=0;

)

Boxes::-Boxes(){

delete[]box;

delete[]fiag;

)

voidBoxes::put(intn,charm){

inti=0;

whilc(box[i]!=0&&i++<xh);

if(i<xh&&box[i]=0){

box[i]=n;flag[ij=ni;sum4-=n;

}

elsecoutvv"无空箱存放客户的物品!\n\n”;

}

voidBoxes::gct(charm){

inti=0;

while(flag[i]!=m&&i<xh)i++;

if(flag[i]!=m)

coutvv”没有找到客户物品!\n\n";

}

voidBoxes::display(){

intn=0;

for(inti=0;i<xh;i++)

if(box[i]>0)

cout«"客户"<vflag[iKv"：存放物品数量："<<box[ik<"件。\n";

elsen++;

coul«”占用箱个数：”《xh-n«”个,空闲箱个数：个。\n存入物品总数量有:

,,«sum«,,\n\n";

1.建立一个矩阵类Array,存储一个nXn矩阵并能完成矩阵转置运算。要求如下：

(1)私有成员数据

int*x：指向存储一个nXn矩阵值的内存区域(二维数组作为一维数组存储)

intn：存储矩阵行数

(2)公有成员函数

构造函数：用参数指定的值或缺省值3初始化n,并用n的值为矩阵动态申请内存空间；

析构函数：释放对象存储矩阵时占用的内存空间：

viodinput(int*a):将一个矩阵赋值给对象中的数组。

voidprint()：按行输出矩阵的值。

voidchange()：转置矩阵。

编写一个程序测试该类。定义对象A,将一个矩阵存入A中，并输出矩阵的值，转置对象A

中的矩阵并输出，使用以下测试数据：

A=A转置后的矩阵=

1234

5678

9101112

13141516

*/

#include<iostream.h>

#defineN4

classArray{

int*x;〃指向存储•个nXn矩阵值的内存区域(二维数组作为•维数组存储)

inin;〃存储矩阵行数

public:

Array(ints=3){

n=s;

x=newint[N*N];

I

voidinput(ini*a)W将一个矩阵赋值给对象中的数组。

voidprint。，按行输出矩阵的值。

voidchange。;〃转置矩阵。

~Array。(

if(x)delete[Jx;

)

)；

voidmain(){

inta[N][4];

inti,j;

cout«"请输入”<<N«'*'<<NV<”的矩阵"<<cndl;

for(i=0;i<N;i++){

for(j=0;j<N;j++)

cin»a[i][jl；

)

A