C面向对象程序设计上机考试题库.docx

C面向对象程序设计上机考试题库.docx

《C面向对象程序设计上机考试题库.docx》由会员分享，可在线阅读，更多相关《C面向对象程序设计上机考试题库.docx（77页珍藏版）》请在冰豆网上搜索。

C面向对象程序设计上机考试题库

C++面向对象程序设计上机考试题库

一、第一类题目（20道，每题7分，在word中保留代码并将输出结果窗口保留）

1．定义盒子Box类，要求具有以下成员：

长、宽、高分别为x,y,z，可设置盒子形状；可计算盒子体积；可计算盒子的表面积。

#include

classBox

{private:

intx,y,z;intv,s;

public:

voidint（intx1=0,inty1=0,intz1=0）{x=x1;y=y1;z=z1;}

voidvolue（）{v=x*y*z;}

voidarea（）{s=2*（x*y+x*z+y*z）;}

voidshow（）

{cout<<"x="<

cout<<"s="<

}

};

voidmain（）

{Boxa;

a.init（2,3,4）;

a.volue（）;

a.area（）;

a.show（）;

}

2．有两个长方柱，其长、宽、高分别为：

（1）30，20，10；

（2）12，10，20。

分别求他们的体积。

编一个基于对象的程序，在类中用带参数的构造函数。

#include

usingnamespacestd;

classBox

{public:

Box（int,int,int）;//带参数的构造函数

intvolume（）;

private:

intlength;

intwidth;

intheight;

};

Box:

:

Box（intlen,inth,intw）

{length=len;

height=h;

width=w;

}

//Box:

:

Box（intlen,intw,int,h）:

length（len）,height（h）,width（w）{}

intBox:

:

volume（）

{return（length*width*height）;}

intmain（）

{

Boxbox1（30,20,10）;

cout<<"Thevolumeofbox1is"<

Boxbox2（12,10,20）;

cout<<"Thevolumeofbox2is"<

return0;

}

3．有两个长方柱，其长、宽、高分别为：

（1）12，20，25；

（2）10，30，20。

分别求他们的体积。

编一个基于对象的程序，且定义两个构造函数，其中一个有参数，一个无参数。

#include

usingnamespacestd;

classBox

{public:

Box（）;

Box（intlen,intw,inth）:

length（len）,width（w）,height（h）{}

intvolume（）;

private:

intlength;

intwidth;

intheight;

};

intBox:

:

volume（）

{return（length*width*height）;

}

intmain（）

{

Boxbox1（10,20,25）;

cout<<"Thevolumeofbox1is"<

Boxbox2（10,30,20）;

cout<<"Thevolumeofbox2is"<

return0;

}

4．声明一个类模板，利用它分别实现两个整数、浮点数和字符的比较，求出大数和小数。

#include

usingnamespacestd;

template//声明一个类模板

classCompare

{public:

Compare（numtypea,numtypeb）

{x=a;y=b;}

numtypemax（）

{return（x>y）?

x:

y;}

numtypemin（）

{return（x

x:

y;}

private:

numtypex,y;

};

intmain（）

{Comparecmp1（3,7）;

cout<

cout<

Comparecmp2（45.78,93.6）;

cout<

cout<

Comparecmp3（'a','A'）;

cout<

cout<

return0;

}

5．建立一个对象数组，内放5个学生的数据（学号、成绩），用指针指向数组首元素，输出第1，3，5个学生的数据。

初值自拟。

#include

usingnamespacestd;

classStudent

{public:

Student（intn,doubles）:

num（n）,score（s）{}

voiddisplay（）;

private:

intnum;

doublescore;

};

voidStudent:

:

display（）

{cout<

intmain（）

{Studentstud[5]={

Student（101,78.5）,Student（102,85.5）,Student（103,98.5）,

Student（104,100.0）,Student（105,95.5）};

Student*p=stud;

for（inti=0;i<=2;p=p+2,i++）

p->display（）;

return0;

}

6．建立一个对象数组，内放5个学生的数据（学号、成绩），设立一个函数max，用指向对象的指针作函数参数，在max函数中找出5个学生中成绩最高者，并输出其学号。

初值自拟。

#include

usingnamespacestd;

classStudent

{public:

Student（intn,floats）:

num（n）,score（s）{}

intnum;

floatscore;

};

voidmain（）

{Studentstud[5]={

Student（101,78.5）,Student（102,85.5）,Student（103,98.5）,

Student（104,100.0）,Student（105,95.5）};

voidmax（Student*）;

Student*p=&stud[0];

max（p）;

}

voidmax（Student*arr）

{floatmax_score=arr[0].score;

intk=0;

for（inti=1;i<5;i++）

if（arr[i].score>max_score）{max_score=arr[i].score;k=i;}

cout<

}

7．用new建立一个动态一维数组，并初始化int[10]={1,2,3,4,5,6,7,8,9,10},用指针输出，最后销毁数组所占空间。

#include

#include

usingnamespacestd;

voidmain（）{

int*p;

p=newint[10];

for（inti=1;i<=10;i++）

{

*（p+i-1）=i;

cout<<*（p+i-1）<<"";

}

cout<

delete[]p;

return;

}

8．定义一个复数类Complex，重载运算符“+”，使之能用于复数的加法运算。

将运算符函数重载为非成员、非友元的普通函数。

编写程序，求两个复数之和。

初值自拟。

#include

usingnamespacestd;

classComplex

{public:

Complex（）{real=0;imag=0;}

Complex（doubler,doublei）{real=r;imag=i;}

doubleget_real（）;

doubleget_imag（）;

voiddisplay（）;

private:

doublereal;

doubleimag;

};

doubleComplex:

:

get_real（）

{returnreal;}

doubleComplex:

:

get_imag（）

{returnimag;}

voidComplex:

:

display（）

{cout<<"（"<

Complexoperator+（Complex&c1,Complex&c2）

{

returnComplex（c1.get_real（）+c2.get_real（）,c1.get_imag（）+c2.get_imag（））;

}

intmain（）

{Complexc1（3,4）,c2（5,-10）,c3;

c3=c1+c2;

cout<<"c3=";

c3.display（）;

return0;

}

9．定义一个复数类Complex，重载运算符“＋”，“—”，使之能用于复数的加，减运算，运算符重载函数作为Complex类的成员函数。

编程序，分别求出两个复数之和，差。

初值自拟。

usingnamespacestd;

classComplex

{public:

Complex（）{real=0;imag=0;}

Complex（doubler,doublei）{real=r;imag=i;}

Complexoperator+（Complex&c2）;

Complexoperator-（Complex&c2）;

voiddisplay（）;

private:

doublereal;

doubleimag;

};

ComplexComplex:

:

operator+（Complex&c2）

{Complexc;

c.real=real+c2.real;

c.imag=imag+c2.imag;

returnc;}

ComplexComplex:

:

operator-（Complex&c2）

{Complexc;

c.real=real-c2.real;

c.imag=imag-c2.imag;

returnc;}

voidComplex:

:

display（）

{cout<<"（"<

intmain（）

{Complexc1（3,4）,c2（5,-10）,c3;

c3=c1+c2;

cout<<"c1+c2=";

c3.display（）;

c3=c1-c2;

cout<<"c1-c2=";

c3.display（）;

return0;

}

10．定义一个复数类Complex，重载运算符“*”，“/”，使之能用于复数的乘，除。

运算符重载函数作为Complex类的成员函数。

编程序，分别求出两个复数之积和商。

初值自拟。

提示：

两复数相乘的计算公式为：

（a+bi）*（c+di）=（ac-bd）+（ad+bc）i。

两复数相除的计算公式为：

（a+bi）/（c+di）=（ac+bd）/（c*c+d*d）+（bc-ad）/（c*c+d*d）i。

#include

usingnamespacestd;

classComplex

{public:

Complex（）{real=0;imag=0;}

Complex（doubler,doublei）{real=r;imag=i;}

Complexoperator*（Complex&c2）;

Complexoperator/（Complex&c2）;

voiddisplay（）;

private:

doublereal;

doubleimag;

};

ComplexComplex:

:

operator*（Complex&c2）

{Complexc;

c.real=real*c2.real-imag*c2.imag;

c.imag=imag*c2.real+real*c2.imag;

returnc;}

ComplexComplex:

:

operator/（Complex&c2）

{Complexc;

c.real=（real*c2.real+imag*c2.imag）/（c2.real*c2.real+c2.imag*c2.imag）;

c.imag=（imag*c2.real-real*c2.imag）/（c2.real*c2.real+c2.imag*c2.imag）;

returnc;}

voidComplex:

:

display（）

{cout<<"（"<

intmain（）

{Complexc1（3,4）,c2（5,-10）,c3;

c3=c1*c2;

cout<<"c1*c2=";

c3.display（）;

c3=c1/c2;

cout<<"c1/c2=";

c3.display（）;

return0;

}

11．定义一个复数类Complex，重载运算符“＋”，使之能用于复数的加法运算。

参加运算的两个运算量可以都是类对象，也可以其中有一个是整数，顺序任意。

例如：

c1+c2，i+c1，c1+i均合法（设i为整数，c1，c2为复数）。

编程序，分别求两个复数之和、整数和复数之和。

初值自拟。

#include

classComplex

{public:

Complex（）{real=0;imag=0;}

Complex（doubler,doublei）{real=r;imag=i;}

Complexoperator+（Complex&c2）;

Complexoperator+（int&i）;

friendComplexoperator+（int&,Complex&）;

voiddisplay（）;

private:

doublereal;

doubleimag;

};

ComplexComplex:

:

operator+（Complex&c）

{returnComplex（real+c.real,imag+c.imag）;}

ComplexComplex:

:

operator+（int&i）

{returnComplex（real+i,imag）;}

voidComplex:

:

display（）

{cout<<"（"<

Complexoperator+（int&i,Complex&c）

{returnComplex（i+c.real,c.imag）;}

intmain（）

{Complexc1（3,4）,c2（5,-10）,c3;

inti=5;

c3=c1+c2;

cout<<"c1+c2=";

c3.display（）;

c3=i+c1;

cout<<"i+c1=";

c3.display（）;

c3=c1+i;

cout<<"c1+i=";

c3.display（）;

return0;

}

12．有两个矩阵a和b，均为2行3列。

求两个矩阵之和。

重载运算符“+”，使之能用于矩阵相加。

如c=a+b。

初值自拟。

#include

classMatrix

{public:

Matrix（）;

friendMatrixoperator+（Matrix&,Matrix&）;

voidinput（）;

voiddisplay（）;

private:

intmat[2][3];

};

Matrix:

:

Matrix（）

{for（inti=0;i<2;i++）

for（intj=0;j<3;j++）

mat[i][j]=0;

}

Matrixoperator+（Matrix&a,Matrix&b）

{Matrixc;

for（inti=0;i<2;i++）

for（intj=0;j<3;j++）

{c.mat[i][j]=a.mat[i][j]+b.mat[i][j];}

returnc;

}

voidMatrix:

:

input（）

{cout<<"inputvalueofmatrix:

"<

for（inti=0;i<2;i++）

for（intj=0;j<3;j++）

cin>>mat[i][j];

}

voidMatrix:

:

display（）

{for（inti=0;i<2;i++）

{for（intj=0;j<3;j++）

{cout<

cout<

}

intmain（）

{Matrixa,b,c;

a.input（）;

b.input（）;

cout<

"<

a.display（）;

cout<

"<

b.display（）;

c=a+b;

cout<

"<

c.display（）;

return0;

}

13．将运算符“＋”重载为适用于复数加法，重载函数不作为成员函数，而放在类外，作为Complex类的友元函数。

初值自拟。

#include

classComplex

{public:

Complex（）{real=0;imag=0;}

Complex（doubler）{real=r;imag=0;}

Complex（doubler,doublei）{real=r;imag=i;}

friendComplexoperator+（Complex&c1,Complex&c2）;

voiddisplay（）;

private:

doublereal;

doubleimag;

};

Complexoperator+（Complex&c1,Complex&c2）

{

returnComplex（c1.real+c2.real,c1.imag+c2.imag）;

}

voidComplex:

:

display（）

{cout<<"（"<

intmain（）

{Complexc1（3,4）,c2（5,-10）,c3;

c3=c1+c2;

cout<<"c1=";c1.display（）;

cout<<"c2=";c2.display（）;

cout<<"c1+c2=";c3.display（）;

return0;

}

14.定义一个字符串类String，用来存放不定长的字符串，重载运算符“＝＝”，，用于两个字符串的等于比较运算。

初值自拟。

#include

#include

classString

{public:

String（）{p=NULL;}

String（char*str）;

friendbooloperator==（String&string1,String&string2）;

voiddisplay（）;

private:

char*p;

};

String:

:

String（char*str）

{p=str;

}

voidString:

:

display（）

{cout<

booloperator==（String&string1,String&string2）

{if（strcmp（string1.p,string2.p）==0）

returntrue;

else

returnfalse;

}

voidcompare（String&string1,String&string2）

{if（operator==（string1,string2）==1）

{string1.display（）;cout<<"=";string2.display（）;}

cout<

}

intmain（）

{Stringstring1（"Hello"）,string2（"Hello"）;

compare（string1,string2）;

return0;

}

15.定义一个字符串类String，用来存放不定长的字符串，重载运算符"<"，用于两个字符串的小于的比较运算。

初值自拟。

#include

#include

classString

{public:

String（）{p=NULL;}

String（char*str）;

friendbooloper