C++试题及答案.docx

资源描述

C++试题及答案.docx

《C++试题及答案.docx》由会员分享，可在线阅读，更多相关《C++试题及答案.docx（23页珍藏版）》请在冰豆网上搜索。

C++试题及答案.docx

C++试题及答案

一、单选题

1、在每个C++程序中都必须包含有这样一个函数，该函数的函数名为。

A.main B.MAIN C.name D.function

2、设x和y均为bool量，则x&&y为真的条件是。

A.它们均为真 B.其中一个为真 C.它们均为假 D.其中一个为假

3、下面的哪个保留字不能作为函数的返回类型？

。

A.void B.int C.new D.long

4、假定a为一个整型数组名，则元素a[4]的字节地址为。

A.a+4 B.a+8 C.a+16 D.a+32

5、假定AB为一个类，则执行“AB a（4）,b[3],*p[2];”语句时，自动调用该类构造函数的次数为。

A.3 B.4 C.6 D.9

6、假定要对类AB定义加号操作符重载成员函数，实现两个AB类对象的加法，并返回相加结果，则该成员函数的声明语句为：

。

A.ABoperator+（AB&a,AB&b） B.AB operator+（AB &a）

C. operator+（AB a） D.AB &operator+（）

二、填空题）

1、C++语言中的每条基本语句以作为结束符，每条复合语句以作为结束符。

2、执行“cout <

3、float和double类型的大小分别为和。

4、算术表达式对应的C++表达式为。

5、关系表达式x+y>5的相反表达式为。

6、假定一个一维数组的定义为“char *a[8];”，则该数组所含元素的个数为，所占存储空间的字节数为。

7、变量分为全局和局部两种，变量没有赋初值时，其值是不确定的。

8、假定a是一个二维数组，则a[i][j]的指针访问方式为。

9、假定一个结构类型定义为

“struct D{int a; union{int b;double c;};D *d[2];};”，

则该类型的大小为字节。

10、对一个类中的数据成员的初始化可以通过构造函数中的实现，也可以通过构造函数中的实现。

11、假定AB为一个类，则执行“AB a[10];”语句时，系统自动调用该类的构造函数的次数为。

12、假定类AB中有一个公用属性的静态数据成员bb，在类外不通过对象名访问该成员bb的写法为。

三、给出下列程序运行后的输出结果

1、#include

voidSB（charch）{

switch（ch）{

case'A':

case'a':

cout<<"well!

";break;

case'B':

case'b':

cout<<"good!

";break;

case'C':

case'c':

cout<<"pass!

";break;

default:

cout<<"nad!

";break;

}

voidmain（）{

chara1='b',a2='C',a3='f';

SB（a1）;SB（a2）;SB（a3）;SB（'A'）;

cout<

}

2、#include

#include

voidmain（）{

char*a[5]={"student","worker","cadre","soldier","peasant"};

char*p1,*p2;

p1=p2=a[0];

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

if（strcmp（a[i],p1）>0）p1=a[i];

if（strcmp（a[i],p2）<0）p2=a[i];

}

cout<

}

3、#include

inta=5;

voidmain（）{

inta=10,b=20;

cout<

{ inta=0,b=0;

for（inti=1;i<6;i++）{

a+=i;b+=a;

}

cout<

}

cout<

4、#include

intLB（int*a,intn）{

ints=1;

for（inti=0;i

s*=*a++;

returns;

}

voidmain（）{

inta[]={1,2,3,4,5,6,7,8};

intb=LB（a,5）+LB（&a[3],3）;

cout<<"b="<

}

5、#include

#include

structWorker{

charname[15]; //姓名

intage; //年龄

floatpay; //工资

};

voidmain（）{

Workerx;

char*t="liouting";

intd=38;floatf=493;

strcpy（x.name,t）;

x.age=d;x.pay=f;

cout<

}

6、#include

classA{

inta;

public:

A（intaa=0）{a=aa;}

~A（）{cout<<"DestructorA!

};

classB:

publicA{

intb;

public:

B（intaa=0,intbb=0）:

A（aa）{b=bb;}

~B（）{cout<<"DestructorB!

};

voidmain（）{

Bx（5）,y（6,7）; //后定义的变量将先被释放

}

四、写出下列每个函数的功能

1、#include

intSA（inta,intb）{

if（a>b）return1;

elseif（a==b）return0;

elsereturn-1;

}

2、floatFI（intn）{

//n为大于等于1的整数

floatx,y=0;

do{

cin>>x;

n--;y+=x*x;

}while（n>0）;

return y;

}

3、template

voidWE（Typea[],Typeb[],intn）{

for（inti=0;i

b[n-i-1]=a[i];}

4、structStrNode{

charname[15]; //字符串域

StrNode*next; //指针域

};

voidQB（StrNode*&f,intn）{

if（n==0）{f=NULL;return;}

f=newStrNode;

cin>>f->name;

StrNode*p=f;

while（--n）{

p=p->next=newStrNode;

cin>>p->name;

}

p->next=NULL;

}

五、编写程序，把从键盘上输入的一批整数（以-1作为终止输入的标志）保存到文本文件“a:

xxk1.dat”中。

*******************************************************************************

C++语言程序设计试题

答案及评分标准

一、单选题（每小题1分，共6分）

评分标准：

选对者得1分，否则不得分。

1、A 2、A 3、C 4、C 5、B 6、B

二、填空题（每小题2分，共24分）

评分标准：

每题与参考答案相同者得2分，否则不得分。

1、；}

2、C

3、48

4、（x*y*y）/（3*a）+4*b-1

5、 x+y<=5

6、8 32

7、局部

8、 *（a[i]+j）或 *（*（a+i）+j）

9、 20

10、初始化表函数体

11、 10

12、 AB:

三、给出下列程序运行后的输出结果（每小题6分，共36分）

评分标准：

每题与参考答案的数据和显示格式完全相同者得6分，否则酌情给分。

1、 good!

pass!

bad!

well!

2、 worker cadre

3、10 20

15 35 5

10 20

4、 b=240

5、 liouting 38 493

6、 Destructor B!

Destructor A!

Destructor B!

Destructor A!

四、写出下列每个函数的功能（每小题6分，共24分）

评分标准：

每题与参考答案的叙述含义相同者得6分，否则酌情给分。

1、比较两个整数a和b的大小，若a>b则返回1，若a==b则返回0，若a

2、求出从键盘上输入的n个常数的平方和并返回。

3、模板函数，把数组a的每个元素按逆序放入数组b中。

4、建立一个具有n个结点的链表，每个结点的字符串值由键盘输入，链表的表头指针由引用变量f带回。

五、编写程序，把从键盘上输入的一批整数（以-1作为终止输入的标志）保存到文本文件“a:

xxk1.dat”中。

（10分）

评分标准：

见参考程序中的注释。

#include //使用此命令得1分

#include

voidmain（）{

ofstreamfout（"a:

xxk1.dat"）; //定义输出文件流并打开文件得2分

if（!

fout）{

cerr<<"文件没有打开！

exit

（1）;

} //可有可无

intx;

cin>>x;

while（x!

=-1）{

fout<

cin>>x;

} //能够从键盘向文件正确输出数据得6分

fout.close（）; //关闭输出文件流得1分

}

C++语言程序设计

期末考试试题及答案

一、填空

1．在类中必须声明成员函数的原型，成员函数的实现部分可以写在类外。

2．如果需要在被调函数运行期间，改变主调函数中实参变量的值，则函数的形参应该是引用类型或指针类型。

3．抽象类只能作为基类使用，而不能声明它的对象。

4．进行函数重载时，被重载的同名函数如果都没有用const修饰，则它们的形参个数或类型必须不同。

5．通过一个常对象只能调用它的常成员函数，不能调用其他成员函数。

6．函数的递归调用是指函数直接或间接地调用自身。

7．拷贝构造函数的形参必须是本类对象的引用。

二、阅读下列程序，写出其运行时的输出结果

如果程序运行时会出现错误，请简要描述错误原因。

1．请在以下两题中任选一题，该题得分即为本小题得分。

如两题都答，则取两题得分之平均值为本小题得分。

（1）程序：

#include

classBase

{private:

charmsg[30];

protected:

intn;

public:

Base（chars[],intm=0）:

n（m）

{strcpy（msg,s）;

}

voidoutput（void）

{cout<

}

};

classDerived1:

publicBase

{

private:

intn;

public:

Derived1（intm=1）:

Base（"Base",m-1）

{n=m;}

voidoutput（void）

{cout<

Base:

output（）;

}

};

classDerived2:

publicDerived1

{

private:

intn;

public:

Derived2（intm=2）:

Derived1（m-1）

{n=m;}

voidoutput（void）

{cout<

Derived1:

output（）;

}

};

intmain（）

{

BaseB（"BaseClass",1）;

Derived2D;

B.output（）;

D.output（）;

}

运行结果：

BaseClass

Base

（2）程序：

#include

classSamp

{public:

voidSetij（inta,intb）{i=a,j=b;}

~Samp（）

{cout<<"Destroying.."<

}

intGetMuti（）{returni*j;}

protected:

inti;

intj;

};

intmain（）

{

Samp*p;

p=newSamp[5];

if（!

p）

{cout<<"Allocationerror\n";

return1;

}

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

p[j].Setij（j,j）;

for（intk=0;k<5;k++）

cout<<"Muti["<

delete[]p;

return0;

}

运行结果：

Muti[0]is:

Muti[1]is:

Muti[2]is:

Muti[3]is:

Muti[4]is:

Destroying..4

Destroying..3

Destroying..2

Destroying..1

Destroying..0

2．请在以下两题中任选一题，该题得分即为本小题得分。

如两题都答，则取两题得分之平均值为本小题得分。

（1）程序：

#include

classVector

{

public:

Vector（ints=100）;

int&Elem（intndx）;

voidDisplay（void）;

voidSet（void）;

~Vector（void）;

protected:

intsize;

int*buffer;

};

Vector:

Vector（ints）

{

buffer=newint[size=s];

}

int&Vector:

Elem（intndx）

{

if（ndx<0||ndx>=size）

{

cout<<"errorinindex"<

exit

（1）;

}

returnbuffer[ndx];

}

voidVector:

Display（void）

{

for（intj=0;j

cout<

}

voidVector:

Set（void）

{

for（intj=0;j

Elem（j）=j+1;

}

Vector:

~Vector（void）

{

delete[]buffer;

}

intmain（）

{

Vectora（10）;

Vectorb（a）;

a.Set（）;

b.Display（）;

}

运行结果：

最后出现错误信息，原因是：

声明对象b是进行的是浅拷贝，b与a共用同一个buffer，程序结束前调用析构函数时对同一内存区进行了两次释放。

（2）程序：

#include

classCAT

{

public:

CAT（）;

CAT（const&CAT）;

~CAT（）;

intGetAge（）{return*itsAge;}

voidSetAge（intage）

{*itsAge=age;}

protected:

int*itsAge;

};

CAT:

CAT（）

{

itsAge=newint;

*itsAge=5;

}

CAT:

~CAT（）

{

deleteitsAge;

itsAge=NULL;

}

intmain（）

{

CATa;

cout<<"a'sage:

a.SetAge（6）;

CATb（a）;

cout<<"a'sage:

cout<<"b'sage:

a.SetAge（7）;

cout<<"a'sage:

cout<<"b'sage:

}

运行结果：

a'sage:

b'sage:

a'sage:

b'sage:

最后出现错误信息，原因是：

声明对象b是进行的是浅拷贝，b与a共用同一个buffer，程序结束前调用析构函数时对同一内存区进行了两次释放。

三、阅读下列程序及说明和注释信息，在方框中填写适当的程序段，使程序完成指定的功能

程序功能说明：

从键盘读入两个分别按由小到大次序排列的整数序列，每个序列10个整数，整数间以空白符分隔。

用这两个序列分别构造两个单链表，每个链表有10个结点，结点的数据分别按由小到大次序排列。

然后将两个链表合成为一个新的链表，新链表的结点数据仍然按由小到大次序排列。

最后按次序输出合并后新链表各结点的数据。

程序运行结果如下，带下划线部分表示输入内容，其余是输出内容：

135791113151719

2468101214161820

1234567891011121314151617181920

#include

//类定义部分

template

classNode

{

private:

Node*next;//指向后继节点的指针

public:

Tdata;//数据域

Node（constT&item,Node*ptrnext=NULL）;//构造函数

voidInsertAfter（Node*p）;//在本节点之后插入一个同类节点p

Node*DeleteAfter（void）;//删除本节点的后继节点,返回其地址

Node*NextNode（void）const;//获取后继节点的地址

};

template

classLinkedList

{

private:

Node*front,*rear;//表头和表尾指针

Node*prevPtr,*currPtr;//记录表当前遍历位置的指针,由插入和删除操作更新

intsize;//表中的元素个数

intposition;//当前元素在表中的位置序号。

由函数Reset使用

Node*GetNode（constT&item,Node*ptrNext=NULL）;

//生成新节点，数据域为item，指针域为ptrNext

voidFreeNode（Node*p）;//

展开阅读全文