C++语言程序设计

1、C++源程序文件的默认扩展名为（ ）。A cpp

2、能作为C++程序的基本单位是( )。C 函数

3、程序中主函数的名字为( )。A main

4、C++程序的基本模块为( )。D 函数

1、由C++源程序文件编译而成的目标文件的默认扩展名为( )。C obj

2、由C++目标文件连接而成的可执行文件的默认扩展名为( )。B exe

3、C++程序从上机到得到结果的几个操作步骤依次是( )。B 编辑、编译、连接、运行

1、不同数据类型的数据存储格式不同，所能实施的操作也不相同。A 正确

2、C++程序中的数据主要体现为常量和变量。A 正确

3、Name和name是同一个变量。B 错误

4、变量名可以由字母、数字和下划线组成，因此a、a_1、2_ab都是合法的变量名。B 错误

5、可用作C++变量名的一组标识符是( )。B a3_b3 _123 YN

1、常量32767比常量23所占用的存储空间大。B 错误

2、-365是有符号数,365是无符号数。B 错误

3、任一种C++语言都遵循short int型的长度小于等于int型长度，同时int型长度又小于等于long ing型长度的规定。A 正确

4、常量12和12L所占用的存储空间应该一样大。B 错误

5、从定义unsingned var;可以看出,var是一个( )变量。C 无符号整型

6、执行cout<<99+013；，显示在屏幕上的是（ ）。C 110

1、'A'和\"A\"所占的存储空间都是1字节。B 错误

2、字符串\"ABCDE\"占用( )字节的空间。B 6

3、字符串\"LineOne\\x0ALineTwo\\12\"的长度是( )。D 16

4、执行cout<<'A'+ 'B';显示在屏幕上的是（ ）。D 131

1、枚举类型是一种用户定义的类型，只有用户在程序中定义它后才能被使用。A 正确

2、假定一个枚举类型的定义为“enum RA{xa,xb,xc,xd}；”,则执行“cout<3、假定一个枚举类型的定义为“enum RB{ab,ac=3,ad,ae}x=ad；”则x的值为( )。D 4

1、3.24和3.24f，虽然数值相同，但分别代表一个双精度数和一个单精度数。A 正确

2、十进制数-3.26的类型为（ ）。A double

3、存储以下数据，占用存储字节最多的是（ ）。D 0

1、若需要定义一个标识符常量，并且使C++能够进行类型检查，则应在定义语句的开始用保留字（ ）。B const

2、下列的常值变量定义中，错误的是（ ）。C const double d

1、算数运算符“/”对于整型是整除操作，而对于实型才是一般意义上的除法。A 正确

2、表达式5%2的值为（ ）。C 1

3、设”int a=12;”，则执行完语句”a+=a*a;”后，a的值是( )。C 156

4、假定下列x和y均为int型变量，则不正确的赋值为（ ）。B x++=y++

5、执行int=4,y=5;y -=x--；后，x和y的值分别是（ ）。B x=3 y=1

6、执行int=5,y=4;y +=++x；后，x和y的值分别是（ ）。A x=6 y=10

7、

D 1.0/a/b/c

8、表达式float(25)/4和int(14.6)%5的值分别为（ ）。B 6.25 4

9、设x和y均为bool量，则x && y为真的条件是( )。A 它们均为真

10、设x和y均为bool量，则x || y为假的条件是( )。C 它们均为假

11、x>0 && x<=10的相反表达式为（ ）。A x<=0 || x>10

12、x>0 || y==5的相反表达式为（ ）。B x<=0 && y!=5

13、设x是一个bool型的逻辑量，y的值为10，则表达式 x && y的值为（ ）。C 与x值相同

14、若x是一个bool型变量，则x||5>3的值( )。A 为true

15、假定x=5，则执行“a=(x? 10:4*2)；”语句后a的值为（ ）。B 10

16、设”int a=15,b=26;”，则”cout<<(a,b);”的输出结果是( )。D 26

1、如果执行 if(x>3) cout<<'A'; else cout<<'B'; 后屏幕上显示的是B，说明x>3的值是（ ）。 C 假

2、执行if(x||!x) cout<<”ABC”; else cout<<”XYZ”;屏幕上的是（ ）。A ABC

3、执行

cin>>k;

switch(k){

case 1:cout<<'G';

case 2:cout<<'L';

}

后，不可能出现的情况是（4、

#include

void SB (char ch) {

switch (ch) {

case 'A' :case 'a':

。A 显示G

）

cout <<”well!” ; break;

case ‘B': case ‘b':

cout <<”good!” ;break;

case ‘C': case ‘c':

cout <<”pass!” ;break;

default :

cout << “bad!” ; break;

}

}

void main (){

char al='b',a2='c',a3='f';

SB(al);SB(a2);SB(a3);SB(‘A');

cout <}

以上程序运行后的输出结果为（ ）。B good!pass!bad!well!

5、

B 8 240 3.2

1、循环语句“for(int i=0; i2、在下面循环语句中循环体执行的次数为（ ）。

。 ) for(int i=0; iif(i>n/2) break;

B n/2+1

3、

#include

void main (){

int s=0;

for (int I=1;I<6;I++)

s+=I*I;

cout <<”s=”<}

以上程序运行后的输出结果为（4、

。D s=55

）

# include

void main (){

int s=0;

for (int i=1;;i++){

if (s>50) break;

if (i%3= =0) s+=i;

}

cout <<”i,s=”<}

以上程序运行后的输出结果为（ ）。C i,s=19,63

5、

# include

void main (){

int s1=0,s2=0;

for (int I=0;I<10;I++)

if (I%2) s1+=I;

else s2 +=I;

cout <}

以上程序运行后的输出结果为（ ）。 6、在下面循环语句中内层循环体S语句的执行总次数为（ ）。

for(int i=0; ifor(int j=i; jD n(n+1)/2

7、在下面循环语句中循环体执行的次数为（ ）。

int i=0,s=0; while(s<20) {i++; s+=i;}

B 25 20

C 6

8、

# include

void main (){

int n=10,y=1;

while (n--){y++;++y;}

cout <<”y*y=”<}

y*y=441

以上程序运行后的输出结果为（ ）。

D y*y=441

9、在下面循环语句中循环体执行的次数为（。 ）

int i=0; do i++; while(i*i<10);

A 4

10、当处理特定问题时的循环次数已知时，通常采用（ ）来解决。A for循环

11、循环体至少被执行一次的语句为（ ）。C do循环

12、do语句能够改写为（ ）语句。D while

1、在下面的一维数组定义中，哪一个有语法错误。（ ）C int a[]

2、要定义一个int型一维数组art，并使其各元素具有初值，-23，0，0，0，错误的定义语句是（ ）。

B int art[ ]={，-23}

3、已知数组a定义为int a[5]={3，6，9}；，则a[1]的值为（ ）。B 6

4、#include

void main()

{

int a[8]={25,,38,40,75,66,38,54};

int max=a[0];

for(int i=1;i<8;i++)

if(a[i]>max) max=a[i];

cout<<\"max:\"<}

以上程序运行后的输出结果为（ ）。D 75

5、

＃include

void mian（）{

int a[10]= {12,39,26,41,55,63,72,40,83,95}；

int i0=0,i1=0,i2=0；

for（int i=0；i<10；i++）

switch（a[i]%3）{

case 0 : i0+ +；break；

case 1 : i1+ +；break；

case 2 : i2+ +；

}

cout<< i0<<' '<}

以上程序运行后的输出结果为（ ）。C 4 2 4

6、＃include

void main（）{

int a[8]= {36,73,48,14,55,40,32,66}；

int b1,b2；

b1=b2= a[0]；

for（int i=1；i<8；i+ +）

if（a[i]>b1）{

if（b1>b2）b2=b1；

b1= a[i]；

}

cout<}

以上程序运行后的输出结果为（ ）。C 73 36

7、＃include

void main（）{

int a[10] = {73,83,54,62,40,75,80,92,77,84}；

int b[4] = {60,70,90,101}；

int c[4] = {0}；

for（int i=0；i<10；i + +）{

int j = 0；

while（a[i] > =b[j]）j + +；

c[j] + +；

}

for（i =0；i <4；i + +）cout<cout<}

以上程序运行后的输出结果为（ ）。A 2 1 6 1

1、在下面的二维数组定义中，错误的是( )。D int r[][5];

2、假定一个二维数组的定义语句为“int a[3][4]={{3,4},{2,8,6}};”，则元素a[1][2]的值为（ ）。C 6

3、假定一个二维数组的定义语句为“int a[3][4]={{3,4},{2,8,6}};”，则元素a[2][1]的值为（ ）。A 0

4、

#include

const int M=3,N=4;

void main()

{

int a[M][N]={{7,5,14,3},{6,20,7,8},{14,6,9,18}};

int i,j;

for(i=0;ifor(j=0;jcout<cout<}

}

以上程序运行后的输出结果为（ ）。

B

5、

#include

void main()

{

int b[2][5]={{7,15,2,8,20},{12,25,37,16,28}};

int i,j,k=b[0][0];

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

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

if(b[i][j]>k) k=b[i][j];

cout<}

以上程序运行后的输出结果为（ ）。

C 37

6、

＃include

void main（）{

int a[3] [4] = {{1,2,7,8},{5,6,11,12},{24,10,3,4}}；

int m = a[0] [0]；

int ii =0,jj =0；

for（int i =0；i<3；i + +）

for（int j =0；j<4；j + +）

if（a[i] [j] >m）{m= a[i] [j]；ii=i；jj=j；}

cout<< ii << ' ' << jj << ' '<< a[ii] [jj]<}

以上程序运行后的输出结果为（ ）。B 2 0 24

1、'A'和“A”是完全不同的两个数据。（ ）A 正确

2、字符串“string”的长度为7。（ ）B 错误

3、char a[10]=”array”;和char a[10]={'a','r','r','a','y','\\0'};是完全等价的。（ ）A 正确

4、以下字符串的定义中，错误的是（ ）。D a=”struct”;

5、

＃include void main（）{ char a[ ]= ”aabcdaabacabfgacd”； int i1=0, i2=0, i=0； while（a[i]）{ if（a[i] = = 'a'）i1+ +； if（a[i] = = 'b'）i2+ +； i + +； } cout<6、

B 5 3 2 2 2

7、将两个字符串连接起来组成一个字符串时，选用（ ）函数。C strcat()

1、以下的函数定义中，错误的是（ ）A void f1（void）

2、以下的说明中，函数定义错误的是（ ）D double f（double d）{cou<3、C++中函数返回值的类型是由（ ）决定的。B 该函数定义时的类型

4、每一个形式参数就是一个（ ）。C 变量

5、无返回值的函数，在函数定义时没有类型修饰符。B 错误

6、从下列函数原形看，返回值类型为int的函数有（ ）。B int F2(char n);

1、如果一个函数作为表达式被调用，则该函数必须是（ ）。A 有返回值的函数

2、如果一个函数无返回值，则只能作为（ ）被调用。B 语句

3、函数调用不可以（ ）。D 作为一个函数的形参

4、以下正确的描述是（ ）。B 函数的定义不可以嵌套，函数的调用可以嵌套

5、已知int f（int）；和int g（int）；是函数f和g的原形。下列语句中，将函数f作为语句调用的是（ ）。D f（g（3））；

6、函数调用func((exp1,exp2),(exp3,exp4,exp5))中所含实参的个数为( )个。B 2

1、以下说法中正确的是（ ）。B C++程序总是从main函数开始执行

2、已知函数fun的原形是fun（char a，int b）；下列调用中正确的是（ ）。C fp(‘A',1)

3、对于某个函数调用，不给出被调用函数的原形的情况是（ ）。C 函数的定义在调用处之前

4、下列说法中正确的是( )。

B 函数原形的作用是提供函数调用所需的接口信息，因此必须位于调用处之前。

5、已知一函数的定义是：void ff（double d）{cout<< ) ff（double）;。(> A 正确

6、以下正确的函数原形语句是( )。C double fun(int,int);

7、函数原形语句正确的是（ ）。B void Function (int);

1、以下正确的描述是（ ）。C 设置参数的默认值时，应该设置右边的参数

2、已知函数fun的原形是fun（char a，int b=1）；下列调用中正确的是（ ）。A fun(‘A')

3、已知函数fp的原形是int fp(char c,int k=0,char *d=0);下列调用中正确的是（B fp(‘A',4,”ABC”)

4、

＃include

void LC（int a,int b）｛

int x = a；

a = b；b = x；

cout<< a << ' ' << b <｝

void main（）｛

。

）

int x =15,y =36；

LC（x,y）；

cout<< x << ' ' << y <｝

以上程序的运行结果是（ ）。

B

36└┘15

15└┘36

1、在程序中使用内联函数使程序的可读性变差。（ ）B 错误

2、为了提高程序的运行速度，可将不太复杂的功能用函数实现，此函数应选择（ ）。A 内联函数

1、以下叙述中不正确的是（ ）。C 函数必须有返回值

2、函数重载是指（ ）。A 两个或两个以上的函数取相同的函数名，但形参的个数或类型不同

3、采用重载函数的目的是（ ）。D 使用方便，提高可读性

4、已知系统中已定义函数fp，其原形是：int fp（char c，int k=0，double d=100.0）；则下列函数中可以加以重载的是（ ）。D int fp（char，int，int）；

1、关于局部变量，下面说法正确的是( )。

C 定义该变量的复合语句中的定义处以下的任何语句都可以访问

2、关于全局变量，下列说法正确的是（ ）。D 全局变量可用与函数之间传递数据。

3、

＃include

void main（）{

int a =10,b =20；

cout<< a << ' ' << b << endl；

{ a * = 4；

int b = a +35；

cout<< a << ' ' << b << endl；

}

cout<< a << ' ' << b << endl；

}

以上程序的运行结果是（ ）。

A

10 20

40 75

40 20

1、以下关于函数模板叙述正确的是（ ）。

C 通过使用不同的类型参数，函数模板可以生成不同类型的函数

1、假定变量m定义为“int m=7;”，则定义变量p的正确语句为（ ）。B int *p=&m;

2、假定k是一个double类型的变量，则关于变量p的正确定义语句为（ ）。D char *p=”Thank you!”;

3、若定义了函数 double *function(), 则函数function的返回值为（ ）。B 实数的

地址

1、若正常执行了语句int *pd,d;pd=&d; *pd=5; cout<<*pd<<' '<< 5。（> A 正确

2、假定p所指对象的值为28，p+1所指对象的值为62，则* p + +的值为 ( )。A 28

3、假定p所指对象的值为28，p+1所指对象的值为62，则* + + p的值为( )。C 62

4、假定p所指对象的值为25，p+1所指对象的值为50，则执行“（*p）+ +；”语句后，p所指对象的值为( )。B 26

5、假定p所指对象的值为25，p+1所指对象的值为50，则执行“*（p+ +）；”语句后，p所指对象的值为( )。C 50

1、假定一条定义语句为“int a[10], x, *pa=a;”，若要把数组a中下标为3的元素值赋给x，则不正确的语句为（ ）。D x=*pa+3;

2、假定变量a和pa定义为“double a[10], *pa=a;”，要将12.35赋值给a中的下标为5的元素，不正确的语句是（ ）。D *(a[0]+5)=12.35;

3、假定变量b和pb定义为“int b[10], *pb=b;”，要将24赋值给b[1]元素中，不正确的语句是（ ）。

C *++b=24;

4、

＃include

void main（）｛

int a[8]=｛7,9,11,13,3,8,15,17｝；

int *p = a；

for（int i =0；i<8；i + +）｛

cout<if（（i +1）%4 = =0）cout<｝

｝

以上程序的运行结果为（ ）。

A

└┴┴┴┘7└┴┴┴┘9└┴┴┘11└┴┴┘13 └┴┴┴┘3└┴┴┴┘8└┴┴┘15└┴┴┘17

5、

＃include

void main（）｛

int a[5]=｛3,6,15,7,20｝；

int *p = a；

for（int i = 0；i<5；i + +）

cout<cout<for（i =0；i<5；i + +）

cout<cout<｝

以上程序的运行结果为（ ）。

A

└┴┴┴┘3└┴┴┴┘6└┴┴┘15└┴┴┴┘7└┴┴┘20 └┴┴┘20└┴┴┴┘7└┴┴┘15└┴┴┴┘6└┴┴┴┘3

6、

＃include

void main（）｛

int a[8] =｛4,8,12,16,20,24,28,32｝；

int *p = a；

do｛

cout<< *p << ' '；

p + =3；

｝while（pcout<｝

以上程序的运行结果为（ ）。B 4└┘16└┘28

7、

＃include

void main（）｛

int x =20,y =40, * p；

p =&x；

cout<< * p<< ' '；

* p= x +10；

p =&y；

cout<< * p<* p = y +20；

cout<< x << ' ' << y <｝

以上程序的运行结果为（ ）。

A

20└┘40

30└┘60

8、

＃include

int LA（int * a,int n）｛

int s = 0；

for（int i =0；is + = a[i]；

return s；

｝

void main（）｛

int a[ ]=｛5,10,15,20,25,30｝；

int b =LA（a,5）；

int c =LA（a+3,2）；

cout<< b << ' ' << c << ' ' << b +2 * c<｝

以上程序的运行结果为（ ）。

D 75└┘45└┘165

9、变量s的定义为“char *s=”Hello world!”;”，要使变量p指向s所指向的同一个字符串，则应选取（ ）。A char *p=s;

10、假定p指向的字符串为”string”，则cout<<> C ing

11、以下函数的返回结果是（ ）。

int function(char *x) { char *p=x; while(*p++); return(p-x-1); }A 求字符串的长度

12、

设有如下函数定义

int f(char *s) {

char *p=s;

while(*p!='\\0') p++;

return(p-s);

}

在主函数中用cout<＃include

void LC（int *a,int *b）｛

int x = *a；

*a = *b；*b = x；

cout<< *a << ' ' << *b <｝

void main（）｛

。 B 4

）

int x =15,y =36；

LC（&x,&y）；

cout<< x << ' ' << y <｝

以上程序的运行结果是（ ）。

A

36└┘15

36└┘15

1、下列对引用的陈述中不正确的是（ ）。C 一旦定义了引用，一切针对其所引用对象的操作只能通过该引用间接进行

2、假定变量x定义为“int x=5;”，要使rx成为x的引用（别名），rx应定义为（ ）。D int &rx=x;

3、

＃include

void LF（int & x, int y）｛

x = x + y；//此时状态看图3

y = x + y；//此时状态看图4

cout<<”x =”<< x <<”,y =”<< y <｝

void main（）｛

int x =5,y =8；//此时状态看图1

cout<<”x =”<< x <<”,y =”<< y <LF（x,y）；//调用函数，跳转到子函数处进行参数传递，并参看状态图2

cout<<”x =”<< x <<”,y =”<< y <｝

运行以上程序的结果为：（ ）。

A x=5,y=8 x=13,y=21 x=13,y=8

4、

已知函数f1的原形是：viod f1（int &a，char *b）；，变量v1，v2的定义是：int v1；char v2[ ]=\"ABCDW\"；，把v1和v2分别作为第一参数和第二参数来调用函数f1，正确的调用语句是（ ）。 C f1（v1，v2）；

5、 已知函数f1的原形是：viod f2（int *a，long &b）；变量v1，v2的定义是：int v1；long v2；把v1和v2分别作为第一参数和第二参数来调用函数f2，正确的调用语句是（ ）。 B f1（&v1，v2）；

1、假定有定义“int b[10]; int *pb;”，则不正确的赋值语句为（ ）。D pb=b[5];

2、假定p是具有int**类型的指针变量，则给p赋值的正确语句为（ ）。B p=new int*;

3、假定指针变量p定义为“int *p=new int(100);”，要释放p所指向的动态内存，应使用语句（ ）。

A delete p;

4、用new运算符创建一个含10个元素的一维整型数组的正确语句是( )。C int *p=new int[10]; 5}

5、假定指针变量p定义为“int *p=new int[30];”，要释放p所指向的动态内存，应使用语句（ ）。

D delete []p;

6、

＃include

void LG（int * & a, int & m）｛

a = new int[m]；

int * p = a；

for（int i = 0；i* p + + =2 * i +1；

｝

void main（）｛

int * p, n =5；

LG（p,n）；

for（int i = 0；icout<< p[i]<< ' '；

cout<delete[ ]p；

｝

运行以上程序后的结果是（ ）。

B 1└┘3└┘5└┘7└┘9

1、不同于系统内定义的数据类型(int char double float等)可在程序中直接使用，结构是一种用户自定义的类型。（ ）A 正确

2、以下定义中 struct person { char name[10]; bool sex; int age; float pay }; 定义了一个person变量。（ ） B 错误

1、

定义struct Arith{

char op;

int a,b;

};

Arith x,y;

和定义struct Arith{

char op;

int a,b;

}x,y;

是等价的。（ ）A 正确

2、假定一个结构类型的定义为“struct A｛int a,b；short c；A*d；｝；”，则该类型的大小为（ ）字节。B 14

3、假定一个结构类型的定义为“struct B｛int a[8]；char* b；｝；”，则该类型的大小为 （ ）字节。

D 36

1、

＃include

＃include

struct Worker｛

char name[15]；/ /姓名

int age；/ /年龄

float pay；/ /工资

｝；

void main（）｛

Worker x；

char * t =”liouting”；

int d =46；float f =725；

strcpy（x. name, t）；

x. age = d；x. pay = f；

cout<< x. name<< ' ' <｝

以上程序的运行结果为（ 2、

＃include

struct Worker｛

char name[15]；/ /姓名

int age；/ /年龄

float pay；/ /工资

｝；

void main（）｛

。A liouting└┘46└┘725

）

Worker x =｛”weirong”,55,0｝；

Worker y, * p；

y = x；p =&x；

cout<< y. name<< ' ' <cout<< p－>name<< ' ' << p－>age+5<< ' ' << p－>pay－10<｝

以上程序的运行结果为（ ）。A weirong└┘55└┘0 weirong└┘60└┘630

3、假定有定义“struct BOOK{char title[40]； float price；}；”，则不正确的变量定义语句为（ ）。

D BOOK x=new BOOK；

1、假定一个结构类型的定义为“struct D｛int a；union｛int b；double c；｝；D*d[3]；｝；”，则该类型的大小为( )字节。D 24

1、在一个类的定义中，包含有（ ）成员的定义。C 数据和函数

2、在关键字public后面定义的成员为类的（ ）成员。B 公用

3、在关键字private后面定义的成员为类的（ ）成员。A 私有

4、在类作用域中能够通过直接使用该类的（ ）成员名进行访问。D 任何

5、假定AA为一个类，a为该类公有的数据成员，x为该类的一个对象，则访问x对象中数据成员a的格式为（ ）。D x.a

6、假定AA为一个类，a()为该类公有的函数成员，x为该类的一个对象，则访问x对象中函数成员a()的格式为（ ）。B x.a()

7、假定AA为一个类，a为该类公有的数据成员，px为指向该类对象的一个指针，则访问px所指对象中数据成员a的格式为（ ）。C px->a

8、假定AA为一个类，a为该类私有的数据成员，GetValue()为该类公有函数成员，它返回a的值，x为该类的一个对象，则访问x对象中数据成员a的格式为（ ）。D x.GetValue()

9、假定AA为一个类，int a()为该类的一个成员函数，若该成员函数在类定义体外定义，则函数头为（ ）。

A int AA::a()

10、假定AA为一个类，a为该类公有的数据成员，若要在该类的一个成员函数中访问它，则书写格式为（ ）。

A a

11、若需要把一个类外定义的成员函数指明为内联函数，则必须把关键字（ ）放在函数原型或函数头的前面。B inline

12、假定要对类AB定义加号操作符重载成员函数，实现两个AB类对象的加法，并返回相加结果，则该成员函数的声明语句为( )。B AB operator +(AB& a);

1、对于一个类的构造函数，其函数名与类名( )。A 完全相同

2、类的构造函数是在定义该类的一个( )时被自动调用执行的。C 对象

3、一个类的构造函数通常被定义为该类的( )成员。A 公用

4、假定AB为一个类，则执行 “AB x;”语句时将自动调用该类的( )。B 无参构造函数

5、假定AB为一个类，则执行 “AB x(a,5);”语句时将自动调用该类的( )。A 带参构造函数

6、假定AB为一个类，则执行 “AB *s=new AB(a,5);”语句时得到的一个动态对象为（ ）。D *s

7、

#include

class A{

int a, b;

public:

A( ) {a=b=0;}

A( int aa, int bb){

a=aa; b=bb;

cout<}

};

void main( ){

A x,y(6,3), z(8,10);

}

执行以上程序的输出结果为（A

）

6 3

8 10

8、

#include

class A

{

int a, b;

public:

A(int aa= 0, int bb= 0): a(aa),b(bb)

{

cout<<\"Constructor！\"<< a + b<}

};

void main(){

A x, y(2,5), z(y);

}

Constructor!0

Constructor!7

执行以上程序的输出结果为（ ）

B

Constructor!0

Constructor!7

9、假定一个类的构造函数为 “A(int aa, int bb) {a=aa; b=aa*bb;}”，则执行 x(4,5);”语句后，x.a和x.b的值分别为( )。C 4和20

10、 假定一个类的构造函数为 “A(int aa=1, int bb=0) {a=aa; b=bb;}”，则执行 x(4);”语句后，x.a和x.b的值分别为( )。D 4和0

11、假定AB为一个类，则( )为该类的拷贝构造函数的原型说明。B AB(AB& x); A A ““

12、假定一个类的构造函数为 “B(int ax, int bx): a(ax), b(bx) {}”，执行 “B x(1,2),y(3,4);x=y;”语句序列后x.a的值为( )。C 3

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

B 5

14、类中定义的成员和结构中定义的成员，隐含访问权限都是private。（ ）B 错误

15、对一个类中的数据成员的初始化只能通过构造函数中的函数体实现。（ ）B 错误

1、对于一个类的析构函数，其函数名与类名( )。C 只相差一个字符

2、类的析构函数是一个对象被( )时自动调用的。B 撤消

3、一个类的析构函数通常被定义为该类的( )成员。C 公用

4、假定AB为一个类，px为指向该类动态对象数组的指针，该数组长度为n，则执行“delete []px；”语句时，自动调用该类析构函数的次数为（ ）。B n

5、 当类中不实用动态存储空间时，通常不需要定义析构函数。（ ）A 正确

1、一个类的友元函数或友元类不能够通过成员操作符访问该类的所有成员。（ ）B 错误

2、一个类的友元函数或友元类具有直接访问该类的私有成员的。（ ）A 正确

3、若需要把一个函数“void f(); ”定义为一个类AB的友元函数，则应在类AB的定义中加入一条语句（ ）。C friend void f();

1、子类能够继承父类的全部数据成员和函数成员，并且还能定义父类所没有的属于自己的成员。（ ）

A 正确

2、采用private的继承方式，派生类可以访问基类中的私有成员。（ ）B 错误

3、在一个派生类中，对基类成员、类对象成员和非类对象成员的初始化次序的先类对象成员， ，后基类成员，最后非类对象成员。（ ）B 错误

4、当撤消一个含有基类和类对象成员的派生类对象时，将首先完成类对象成员的析构函数定义体的执行，接着完成派生类的析构函数定义体的执行，最后完成非类对象成员的析构函数定义体的执行。（ ）B 错误

1、在C++流类库中，根基类为（ ）。C ios

2、当需要使用ostrstream流类定义一个流对象并联系一个字符串时，应在文件开始使用#include命令，使之包含（ ）文件。A strstrea.h

3、当需要使用ifstream流类定义一个流对象并联系一个磁盘文件时，应在文件开始使用#include命令，使之包含（ ）头文件。D fstream.h

4、当需要对标准输入/输出设备进行输入/输出操作时，应在文件开始使用#include预处理命令，使之包含（ ）头文件。A iostream.h