C/C++面试题目一

C/C++开发工程师面试题目（一）（附答案分析）

推荐：自己根据在面试中碰到做过的一些题目以及总结的题目，希望对面试的同学有所帮助。

一、 选择题

1． 下列类中(  )不是输入输出流类iostream的派生类。

A、 fstream      B、 ofstream     C、 strstream    D、 ostrstream

答案：BD

解析：ofstream和ostrstream派生自ostream，而不是iostream。

                                                                                  

2． 在下列选项中(  )不是ostream类的对象。

A、 cin          B、 cerr          C、 clog          D、 cout

2 答案：A
　解析：cin是istream对象。

3．read函数的功能是从输入流中读取（）。

A、一个字符     B、当前字符    C、一行字符      D、指定若干个字节

3 答案：D
　解析：read函数可以通过指定参数的方式读取若干个字符。

4．下列选项中，用于清除基数格式位设置以十六进制输出的语句是（   ）。

A、cout<<setf(ios::dec,ios::basefield);

B、cout<<setf(ios::hex,ios::basefield);

C、cout<<setf(ios::oct,ios::basefield);

D、cin>>setf(ios::hex,ios::basefield);

答案：B

解析：

1.使用控制符控制输出格式
控制符                  作用 
dec                     设置整数的基数为10   
hex                     设置整数的基数为16   
oct                     设置整数的基数为8   
setbase(n)              设置整数的基数为n(n只能是16，10，8之一)   
setfill(c)              设置填充字符c，c可以是字符常量或字符变量   
setprecision(n)         设置实数的精度为n位。在以一般十进制小数形式输出时，n代表有效

数字。在以fixed(固定小数位数)形式和scientific(指数)形式输出时， n为小数位数。

setw(n)                          设置字段宽度为n位。
setiosflags(ios::fixed)          设置浮点数以固定的小数位数显示。   
setiosflags(ios::scientific)     设置浮点数以科学计数法(即指数形式)显示。   
setiosflags(ios::left)           输出数据左对齐。   
setiosflags(ios::right)          输出数据右对齐。   
setiosflags(ios::shipws)         忽略前导的空格。   
setiosflags(ios::uppercase)      在以科学计数法输出E和十六进制输出字母X时，以大写 表示。

setiosflags(ios::showpos)        输出正数时，给出“+”号。   
resetiosflags                    终止已设置的输出格式状态，在括号中应指定内容。

2.用流对象的成员控制输出格式
流成员函数         与之作用相同的控制符           作用   
precision(n)       setprecision(n)                设置实数的精度为n位。   
width(n)           setw(n)                        设置字段宽度为n位。   
fill(c)            setfill(c)                     设置填充字符c。   
setf( )            setiosflags( )                 设置输出格式状态，括号中应给出格式状态，内容与控制符setiosflags括号中内容相同   

ubsetf( )          resetiosflags( )               终止已设置的输出格式状态。   

cout.width(10); 
cout.setf(ios::hex);

3.设置格式状态的格式标志
格式标志               作用   
ios::left              输出数据在本域宽范围内左对齐   
ios::right             输出数据在本域宽范围内右对齐   
ios::internal          数值的符号位在域宽内左对齐，数值右对齐，中间由填充字符填充   
ios::dec               设置整数的基数为10   
ios::oct               设置整数的基数为8   
ios::hex               设置整数的基数为16   
ios::showbase          强制输出整数的基数(八进制以0打头，十六进制以0x打头)   
ios::showpoint         强制输出浮点数的小点和尾数0   
ios::uppercase         在以科学计数法输出E和十六进制输出字母X时，以大写表示   
ios::showpos           输出正数时，给出“+”号。   
ios::scientific        设置浮点数以科学计数法(即指数形式)显示   
ios::fixed             设置浮点数以固定的小数位数显示   
ios::unitbuf           每次输出后刷新所有流   
ios::stdio             每次输出后清除stdout，stderr   
以小数形式，保留三位小数输出：
cout<<setprecision(3)<<setiosflags(ios::fixed)<<3.1415926<<endl;

5．下列格式控制符，在iostream.h中定义的是（ ），在iomanip.h中定义的是（ ）。

A、endl      B、 setfill          C、 setw          D、 oct

答案：AD 、BC

6．包含类fstream定义的头文件是（ ）。

A、fstream.h B、 ofstream.h     C、 ifstream.h        D、 iostream.h

7．要求可打开文件 “D:\file.dat”写入数，正确的语句是（   ）。

A、 ifstream infile(“D:\file.dat”,ios::in);

B、 ifstream infile(“D:\\file.dat”,ios::in);

C、 ofstream infile(“D:\file.dat”,ios::out);

D、 fstream infile(“D:\\file.dat”,ios::in | ios::out);

8．假定已定义浮点型变量 data ，以二进制方式把 data 的值写入输出文件对象 outfile中去，正确的

语句是（）。

A、outfile.write((float *)&data, sizeof(float));
B、outfile.write((float *)&data, data);
C、outfile.write((char *)&data, sizeof(float));
D、outfile.write((char *)&data, data);

9. 系统为每个类提供一个this指针，在类的成员函数内，通过this指针可以间接访问这个类的（   ）。

A、在public段中声明的友元

B、所有成员

C、友元类的public成员

D、所有派生类中的public成员

10. 关于动态分配的对象，下面的说法（）是正确的？

A、对于数组A[N]，如果是静态分配,N必须是常量；如果是动态分配，N可以是变量。

B、动态分配的对象必须由同类型的指针指出，不管该指针是局部的还是全局的，动态分配对象的生命周期随指针的生命期结束而结束。

C、静态和动态分配的对象在生命期结束时，都自动调用析构函数进行析构。

D、如果在某个函数内动态分配了一个对象，那么这个对象只有在这个函数内才能被访问。

11. 在继承关系中，虚基类的作用是（）。

A、实现重载

C、消除二义性

D、使得派生类可以再也不必考虑二义性问题

12.  对于有继承关系的父类的构造函数，下面的（）是正确的。

A、构造函数可以通过虚基类的形式被继承。

B、public的构造函数可以被继承。

D、构造函数必须定义成非私有成员。

13.  对于指针，下（）是正确的。

A、声明为void类型的指针可以指向任何类型的对象，并且通过该指针可以间接访问它所指向的对象。

B、如果两个指针的类型不是同一个类型，它们就不能相互赋值。（void类型的指针可以与其它类型的指针相互赋值）

C、一个int 类型的指针既可以指向int类型的对象，又可以指向int类型的函数。

D、数组名就是指针。

14.  有关析构函数的错误的说法是（   ）。

A、一个类的析构函数有且只有一个。

B、析构函数无函数类型。

C、析构函数和构造函数一样，可以有形参。

D、析构函数的作用是在对象生命期结束时，收回分配给其的内存空间。

15.  对于操作符重载，下面（）的说法是正确的。

A、用户每定义一个类，系统会自动提供一个赋值运算符重载函数，所以完全不必考虑重载赋值运算符函数。

B、运算符重载函数可能既不是成员函数，也不是友元函数。

C、运算符如果被重载为非成员函数，那么对象就不能利用这个运算符重载函数进行操作。

16.  关于类的友元函数的下述描述中，（）是正确的。

A、友元函数可以被继承。

B、一个类的友元函数可以访问这个类的所有成员。

C、一个类的友元函数必须在这个类中定义成内联函数。

D、一个类的友元函数的返回类型必须是这个类的类型标识符。

答案：B

17.   类B的数据成员中“有一个”A类的对象，这种类之间的关系是 （   ）。

A、继承关系                   B、间接关系

C、复合关系                   D、直接关系

答案：C

18.  下列C++标点符号中表示行注释开始的是(    )。

A、#             B、;

C、//       D、}

答案：C

19.  下列字符串中可以用作C++标示符的是（    ）。

A、_256          B、class

C、delete         D、5char

答案：A

解析：B、C是关键字，D不能以数字开头

20.   下列关于C++函数的描述中正确的是（    ）。

A、主函数是程序的入口，它是由用户定义的函数调用。

B、函数是C++中面向对象程序设计框架的基本组成元素。

C、函数在调用前必须先被声明。

D、每个用户定义函数只能被其他函数调用一次。

答案：C

解析：A运行时库会调用主函数

B 类

D 可以被随意调用

21.   下列关于C++关键字的说法中正确的是（    ）。

A、关键字是用户为程序中各种需要命名的“元素”所起的名字。

B、关键字是对程序中的数据进行操作的一类单词。

C、关键字是在程序中起分割内容和界定范围作用的一类单词。

D、关键字是C++中预先定义并实现一定功能得一类单词。

答案：D

22.   每个C++程序都必须由且仅有一个（    ）。

A、预处理命令           B、主函数

C、函数              D、语句

答案：B

23.   下面关于对象概念的描述中，（    ）是错误的。

A、对象就是C语言中的结构变量

B、对象代表着正在创建的系统中的一个实体

C、对象是一个状态和操作（或方法）的封装体

D、对象之间的信息传递是通过消息进行的

答案：A

24.   C++对C语言做了很多改进，下列描述中（    ）使得C语言发生了质变，即从面向过程变成面向对象。

A、增加了一些新的运算符

B、允许函数重载，并允许设置默认参数

C、规定函数说明必须用原型

D、引进类和对象的概念

答案：D

25.   下面关于类概念的描述中，(    )是错误的。

A、类是抽象数据类型的实现

B、类是具有共同行为的若干对象的统一描述体

C、类是创建对象的样板

D、类就是C语言中的结构体类型

答案：D

解析：参见C++类和C结构体之间的区别

26.   C++语言是以(    )语言为基础逐渐发展而演变而成的一种程序设计语言。

A、Pascal B、C

C、Basic D、Simula67

答案：B

27.   C++语言中规定函数的返回值的类型是由（    ）。

A、return语句中的表达式类型所决定的

B、调用该函数式的主调用函数类型所决定的

C、调用该函数式系统临时确定的

D、在定义该函数式所指定的数据类型所决定的

答案：D

28.   下列关于C++与C语言关系的描述中错误的是（    ）。

A、C++是C语言的超集

B、C++是C语言进行了扩充

C、C++是C语言都是面向对象的程序设计语言

D、C++包含C语言的全部语法特征

答案：C

解析：C语言是面向过程的程序设计语言

29.   下列字符串中可以用做C++标示符的是（    ）。

A、 521       B、computer~1    C、case       D、3var

答案：A

30.   面向对象程序设计思想的主要特征中不包括(    )。

A、封装性        B、多态性

C、继承性        D、功能分解，逐步求精

答案：D

31.   下列C++标点符号中表示一条预处理命令开始的是     A         。

A、#      B、//          C、}     D、；

答案：A

32.   下列关于C++类的描述中错误的是（    ）。

A、类与类之间可以通过一些手段进行通信和联络

B、类用于描述事物的属性和对事物的操作

C、类与类之间必须是平等的关系，而不能组成层次关系

D、类与类之间可以通过封装而具有明确的独立性

答案：C

33.   下列C++标点符号中表示一条语句结束的是（    ）。

A、；

B、//

C、#

D、{

答案：A

34.   下列C++标点符号中表示复合语句结束的标记符是（     ）。

A、#

B、//

C、}

D、；

答案：C

35.   下列C++标点符号中表示复合语句开始的标记符是(      )。

A、{

B、//

C、}

D、；

答案：A

36.   下列关键字中，（     ）即在C语言中使用，又在C++语言中使用。

A、inline

B、break

C、private

D、public

答案：B

37.   下列字符串中不可以用作C++标示符的是（     ）。

A、 521

B、computer123

C、int

D、flower

答案：C

38.   下列不正确的选项是()    。

A、C++语言是一种面向对象的程序设计语言，它支持面向对象思想中的3个主要特征

B、标点符号是在程序中起分割内容和界定范围作用的一类单词

C、iostream 是一个标准的头文件，定义了一些输入输出流对象

D、类与类之间不可以进行通信和联络

答案：D

39.   下列不正确的选项是

A、封装是一种信息隐藏技术

B、标识符是由字母、数字、下划线组成的字符串，必须以数字或下划线开头

C、编译是由源程序文件转换到目标文件的过程

D、一个C++程序可以认为是函数串

答案：B

40.   下列与流程控制有关的关键字是（    ）。

A、goto

B、static

C、int

D、sizeof

答案：A

41.   下列正确的选项是（    ）。

A、继承是创建一个具有别的类的属性和行为的新类的能力

B、C语言支持面向对象的程序设计

C、空白符是一种可以被编译的符号

D、标示符不宜过长，一般设定为16个字符

答案：A

解析：C 空白符被忽略掉

D 标识符具体支持的长度根据编译器的不同而不同

42.   下列关于C++语言的发展说法错误的是（    ）。

A、C++语言起源于C语言

B、C++语言最初被称为“带类的C”

C、在1980年C++被命名

D、在1983年C++被命名

答案：C

43.   下面说法错误的选项是（     ）。

A、引用表达式是一个左值表达式，因此它可以出现在形参和实参的任何一方

B、若一个函数返回了引用，那么该函数的调用也可以被赋值

C、所有函数都可以返回引用

D、引用返回值时，不生成值的副本

答案：C

解析：比如析构函数

44.   下列表示引用的方法中，（     ）是正确的。

已知：int k=1000;

A、int &x=k;      B、char &y;    C、int &z=1000;  D、float &t=&k;

答案：A

解析：B声明引用时必须赋值

C非const引用不能用常量赋值

D 类型不同

45.   下列程序的执行结果为（     ）。

#include<iostream.h>

void mian()

{

int n=10;

int* pn=&n;

int* &rn=pn;

(*pn)++;

cout<<"n="<<n<<endl;

(*rn)++;

cout<<”n=”<<n<<endl;

}

A、 n=11          n=12

B、 n=11          n=11

C、 n=10          n=11

D、 n=11          n=10

答案：A

解析：(*pn)++ 相当于 n++ ，所以n的值被修改为11

接下来，同理，(*rn)++ 相当于再一次的n++，所以n的值被修改为12

46.   下列引用的定义中，（     ）是错误的。

A、int i;      int &j=i;

B、int i;      int &j;      j=i;

C、float i;      float &j=i;

D、char d;        char &k=d;

答案：B

解析：引用被声明时必须初始化

47. （     ）是给对象取了一个别名，他引入了对象的同义词。

A、指针

B、引用

C、枚举

D、结构

答案：B

48.   下列表示引用的方法中，（     ）是正确的。

已知：int m=10;

A、int &x=m;

B、int &y=10;

C、int &z;

D、float &t=&m;

答案：A

解析：同样是对引用的考察

49.   下面程序的运行结果是（     ）。

#include<iostream.h>

void fun(int &a,int &b)

{

int p;

p=a;

a=b;

b=p;

}

void exchange(int &a,int &b,int &c)

{

if(a<b)fun(a,b);

if(a<c)fun(a,c);

if(b<c)fun(b,c);

}

void main()

{

int a,b,c;

a=12;

b=639;

c=78;

exchange(a,b,c);

cout<<"a="<<a<<",b="<<b<<",c="<<c<<endl;

}

A、a=639,b=78,c=12

B、a=12,b=639,c=78

C、a=639,b=12,c=78

D、a=78,b=12,c=639

答案：A

解析：fun()函数交换传入的两个参数的值

exchange()函数把传入的参数按照从大到小的顺序排列

50.   下面的程序输出结果为（    ）。

#include<iostream.h>

void main()

{

int *ir;

int i;

ir=&i;

i=17;

cout<<"int i="<<i<<endl;

cout<<"int ir="<<*ir<<endl;

}

A、int i=17      int ir=0

B、int i=0       int ir=17

C、int i=17      int ir=17

D、程序语法错误，没有输出结果

答案：C

解析：对指针的简单考察

51.   对定义重载函数的下列要求中，( )是错误的。

A、要求参数的个数不同

B、要求参数中至少有一个类型不同

C、要求参数个数相同时，参数类型不同

D、要求函数的返回值不同

答案：D

解析：重载规则：

1）必须在同一作用域中

2）基于形参表不同而构成重载。

3）基于指针（或引用）形参是否为const也可以构成重载

4）在类中，基于成员函数是否为const可以构成重载（成员函数的const就是把隐含

的this指针const了）

52.   下面函数调用语句中实参的个数是()。

xxx((v1,v2),(v3,v4,v5),v6);

A、3     B、4            C、5         D、6

答案：A

解析：括号操作符

53.   系统在调用重载函数时往往根据一些条件确定哪个重载函数被调用，在下列选项中，不能作为依据

的是（ ）。

A、参数个数    B、参数的类型       C、函数名称              D、函数的类型

答案：D

54.   若要定义一个只允许本源文件中所有函数使用的全局变量，则该变量需要使用的存储类别是()

A、extern      B、register        C、auto         D、static

答案：D

55.   在C++中，关于下列设置参数默认值的描述中，正确的是()

A、不允许设置设置参数的默认值

B、设置参数默认值只能在定义函数时设置

C、设置参数默认值时，应该实现设置右边的再设置左边的

D、设置参数默认值时，应该全部参数都设置

答案：C

56.   若有下面函数调用语句：

fun(a+b,(x,y),fun(n+k,d,(a+b)));

在此函数调用语句中实参的个数是( )。

A、3      B、4        C、5      D、6

答案：A

57.   下列对重载函数的描述中，( )是错误的。

A、重载函数中不允许使用默认参数

B、重载函数中编译时根据参数表进行选择

C、不要使用重载函数来描述毫无相干的函数

D、构造函数重载将会给初始化带来多种方式

答案：A

58.   在函数声明时，下列（ ）项是不必要的。

A、函数的类型     B、函数参数类型     C、函数的名字      D、返回值表达式

答案：D

59.   在函数的返回值类型与返回值表达式的类型的描述中，错误的是（）。

A、函数返回值的类型是在定义函数时确定，在函数调用时是不能改变的

B、函数返回值的类型就是返回值表达式的类型

C、函数返回值表达式类型与返回值类型不同时，函数表达式类型应转换成返回值类型

D、函数返回值类型确定了返回值表达式的类型

答案：B

解析：可隐式转换的类型

60.   下面变量和函数说明：

#include<iostream.h>

char ch='*';

void sub(int x,int y,char ch,double *z)

{

switch(ch)

{

case '+':*z=x+y;break;

case '-':*z=x-y;break;

case '*':*z=x*y;break;

case '/':*z=x/y;break;

}

}

下面合法的函数调用语句是( ) 。

A、sub(10,20,ch,y);

B、sub(1.2+3.2,'+',&z);

C、sub(sub(1,2,'+',&y),sub(3,4,'+',&x),'-',&y);

D）sub(a,b,&x,ch);

答案：B

解析：A，最后一个参数应该传指针

C 前两个参数是函数的返回值，sub函数的返回值是void

D 参数错乱

61.   下列程序的输出结果是( )。

#include<iostream.h>

void sub1(char a,char b)

{

char c;

c=a;

a=b;

b=c;

}

void sub2(char *a,char b)

{

char c;

c=*a;

*a=b;

b=c;

}

void sub3(char *a,char *b)

{

char c;

c=*a;

*a=*b;

*b=c;

}

void main()

{

char a,b;

a='A';

b='B';

sub1(a,b);

putchar(A);

putchar(b);

a='A';

b='B';

sub2(&a,b);

putchar(a);

putchar(b);

a='A';

b='B';

sub3(&a,&b);

putchar(a);

putchar(b);

putchar('\n');

}

A、ABABAB     B、ABBBBA        C、ABBABA     D、ABABBA

答案：B

解析：考察指针值传递和地址传递问题

62. 下面程序的正确执行结果为。

＃include<iostream.h>

int f(int);

void main()

{

int a=2,i;

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

cout<<f(A)<<" ";

cout<<endl;

}

int f(int A)

{

int b=0;

static int c=3;

b++;

c++;

return (a+b+c);

}

A、7 7 7      B、7 10 13      C、7 9 11      D、7 8 9

答案：D

解析：static的变量的声明周期问题，生命周期一直到程序结束

63.   下面程序的正确执行结果为( )。

＃include<iostream.h>

void fun(char **m)

{

m++;

cout<<*m<<endl;

}

void main()

{

static char *a[]={"MORNING","AFTERNOON","EVENING"};

char **n;

n=a;

fun(n);

}

A、为空      B、MORNING         C、AFTERNOON         D、EVENING

答案：C

解析：m++相当于a+1，指向数组的下一个元素

64.   下面程序的输出结果（ ）。

＃i nclude<iostream.h>

int fun(char *s)

{

char *p=s;

while(*p!='\0')

p++;

return (p-s);

}

void main()

{

cout<<fun("ABCDEF")<<endl;

}

A、3    B、6    C、8    D、0

答案：B

解析：函数fun的作用是：传入一个带有’\0’的字符串，然后获取字符个数

65.   当一个函数无返回值时，函数的类型应定义为( )。

A、void     B、任意     C、int    D、无

答案：A

66.   下面叙述中不正确的是（ ）。

A、在函数中，通过return语句传回函数值

B、在函数中，可以有多条return语句

C、主函数名main()后面的一对圆括号中也可以带有形参

D、调用函数必须在一条独立的语句中完成

答案：D

解析：可以在任意地方完成函数调用

67.   下列( )的调用方式是引用调用。

A、形参是指针，实参是地址值

B、形参和实参都是变量

C、形参是数组，实参是变量

D、形参是引用，实参是变量

答案：D

解析：函数参数是引用时，传递类型相同的实参时，相当于给实参起了一个别名

68.   在C++中，函数原型不能标识(  )。

A、函数的返回类型

B、函数参数的个数

C、函数参数类型

D、函数的功能

答案：D

解析：函数可以先声明，不实现

69.   下列标识符中，（ ）是文件级作用域的。

A、函数形参

B、语句标号

C、外部静态类标识符

D、自动类标识符

答案：C

70.   在传值调用中，要求( )。

A、形参和实参类型任意，个数相等

B、实参和形参类型都完全一致，个数相等

C、实参和形参对应的类型一致，个数相等

D、实参和形参对应的类型一致个数任意

答案：C

71.   有一个int型变量，在程序中频繁使用，最好定义它为( )。

A、register    B、auto     C、extern     D、static

答案：A

72.   考虑下面的函数原型：void testDefaulParam(int a,int b=7,char z='*');

下面函数调用中不合法的( )。

A、testDefaulParam(5);

B、testDefaulParam(5,8);

C、testDefaulParam(5,'#');

D、testDefaulParam(0,0,'*');

答案：C

解析：因为有默认参数，所以调用testDefaulParam函数时只需要传递一个实参就可以了。如果传递

了更多的参数，仍然需要遵守参数传递原则。

73.   采用函数重载的目的在于。

A、实现共享    B、减少空间     C、提高速度     D、使用方便，提高可靠性

答案：D

74.   要求通过函数来实现一种不太复杂的功能，并且要加快执行速度，选用()。

A、内联函数    B、重载函数   C、递归函数     D、嵌套函数

答案：A

解析：注意内联函数所实现的功能应该尽量简单，太复杂的功能不适合用内联函数

75.   下面程序的输出结果是( )。

＃i nclude<iostream.h>

void fun(int i);

int main()

{

int n=2;

fun(n);

return 0;

}

void fun(int i)

{

static int x=1;

int y=1;

if(i>0)

{

++x;

++y;

cout<<x<<' '<<y<<' ';

fun(i-1);

}

}

A、语法错误，不能输出正确结果

B、2 2 2 2

C、2 2 3 3

D、2 2 3 2

答案：D

解析：static变量的生命周期

76.   下面程序的输出结果为( )。

＃i nclude<iostream.h>

void prt(int *x,int *y,int *z)

{

cout<< ++*x << "," << ++*y << "," << *(z++) << endl;

}

int a=10;

int c=20;

int b=40;

void main()

{

prt(&a,&b,&c);

prt(&a,&b,&c);

}

A、11,42,31      12,21,41       B）11,41,20      12,42,20

C、11,21,40      11,21,41     D、11,41,21      12,42,22

答案：B

解析：每一次输出都是先自加1后再输出

77.   下面程序的正确运行结果为( )。

＃include<iostream.h>

fun(int a,int B)

{

static int m=1,i=2;

i+=m+1;

m=i+a+b;

return(m);

}

void main()

{

int k=5,m=2,p;

p=fun(k,m);

cout<<p<<",";

p=fun(k,m);

cout<<p<<endl;

}

A、11,22    B、12,23     C、11,23     D、10,23

答案：C

解析：static变量的生命周期问题

78.   下面程序的输出结果是( )。

＃include<iostream.h>

void fun(int *s,int *y)

{

static int t=3;

*y=s[t];

t--;

}

void main()

{

int a[]={1,2,3,4};

int i,x=10;

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

{

fun(a,&x);

cout<<x<<",";

}

cout<<endl;

}

A、1,2,3,4    B、0,0,0,0     C、4,4,4,4   D、4,3,2,1

答案：D

解析：static变量的生命周期问题。

79.   下面程序的输出结果是( )。

＃include<iostream.h>

int fun(char *s)

{

char *p=s;

while(*p!='\0')

p++;

return (p-s);

}

void main()

{

cout<<fun("ABCDEFGHIJKLMNIPQRST")<<endl;

}

A、20    B、6     C、19    D、0

答案：A

解析：函数fun的作用时，传入一个带有’\0’的字符串，然后获取字符个数

80.   下面程序的输出结果是( )。

＃i nclude<iostream.h>

int x=10;

void fun(int c);

void main()

{

fun(x);

cout<<"x="<<x<<endl;

}

void fun(int x)

{

x=1;

}

A、x=0   B、x=1   C、x=10    D、语法错误，不能输出正确结果

答案：C

解析：值传递不会修改传入的实参的值

81.   下面程序的执行结果是( )。

＃include<iostream.h>

void main()

{

void swap();

extern int a,b;

a=3;

b=10;

swap();

cout<<"a="<<a<<",b="<<endl;

}

int a,b;

void swap()

{

int temp;

temp=a;

a=b;

b=temp;

}

A、a=3,b=10   B、a=10,b=3  C、a=temp,b=temp   D、语法错误，不能输出正确结果

答案：B

解析：函数swap是无参，所以修改是是main()函数下面的的a,b的值，而不是main()函数体内

a，b的值

82.   下列程序的输出结果是（ ）。

＃include<iostream.h>

void f()

{

static int i=15;

i++;

cout<<"i="<<i<<endl;

}

void main()

{

for(int k=0;k<2;k++)

f();

}

A、i=16     i=17

B、i=16     i=15

C、i=15     i=16

D、i=15     i=17

答案：A

解析：static变量的生命周期

83.   在横线处填上适当的语句( )，使下面程序执行结果是13，18，23。

＃include<iostream.h>

int add(int x,int y=8);

void main()

{

;

cout<<add(a)<<",";

cout<<add(a,add(a)<<",";

cout<<add(a,add(a,add(a))<<endl;

}

int add(int a,int B)

{

int s=a+b;

return s;

}

A、int a=3   B、int b=3   C、int a=5   D、int b=5

答案：C

解析：在参数中调用函数时，实参是函数的返回值

83.   在横线处填上适当的语句（ ），使下面的程序的执行结果是19 24 30 37 45。

＃i nclude<iostream.h>

int fun(int A)

{

static int x=10;

int y=1;

x+=a;

a++;

y++;

return(x+y+A);

}

void main()

{

int i=3;

while(i<8)

;

cout<<endl;

}

A、cout<<fun(i++)<<" "

B、cout<<fun(i)<<" "

C、cout<<fun(i++)<<" ,"

D、cout<<fun(i)<<" ,"

答案：A

解析：static变量的生命周期

84.   在C++语言中，局部变量的隐含存储类型是( )。

A、auto   B、static   C、extern   D、无存储类型

答案：D

85.   下面程序的输出结果为（）

＃include<iostream.h>

int fun(char *s);

int main()

{

cout<<fun("hello");

return 0;

}

int fun(char *s)

{

char *t=s;

while(*t!='\0')

t++;

return(t-s);

}

A、语法错，不能输出正确结果   B、0   C、6   D、5

答案：D

解析：传入一个带有’\0’的字符串，然后获取字符个数

86．   有关类的说法不正确的是( )。

A、类是一种用户字定义的数据类型.

B、只有类中的成员函数才能存取类中的私有成员.

C、在类中，如果不做特别说明，所指的数据均为私有类型.

D、在类中，如果不做特别说明,所指的成员函数均为公有类型。

答案：D

解析：class声明的类的成员默认是private权限，struct声明的类默认是public权限

87.   类A是类B的友元,类B是类C的友元,则( )是正确的.

A、类B是类A的友元

B、类C是类A的友元

C、类A是类C的友元

D、以上都不对

答案：D

88.   有下面类的说明，有错误的语句是（ ）。

class X

{

A、 int a=2;

B、 X();

public:

C、 X(int val):

D、 ~X();

};

答案：A

解析：类定义中不能给成员变量赋值

88.  有关析构函数的说法不正确的是( )。

A、 析构函数有切仅有一个

B、 析构函数和构造函数一样可以有形参

C、 析构函数的功能是用来释放一个对象

D、 析构函数无任何函数类型

答案：B

解析：析构函数不能有形参

89.   已知一个类X, ( )是定义指向类X成员函数的指针,假设类有3个公有成员: void f1(int), void f2(int)和int a.

A、X*P

B、 int X::*pc=&X::a

C、 void(X::*pA)()

D、X*p[10]

答案：C

90.   下列的各类函数中，( )不是类的成员函数

A、构造函数

B、析构函数

C、友元函数

D、拷贝构造函数

答案：C

91.   下列定义中，X是一个类, ( )是定义指向对象数组的指针p.

A、x*p[4]

B、x(*p)[4]

C、(x*)p[4]

D、x*p[]

答案：B

解析：

数组指针的定义方法：

第一步：写一个该类型的数组

第二步：把数组名前面加上*

第三步：把*和数组名一起用小括号括起来

92.   已知p是一个指向类X数据成员m的指针,s是类X的一个对象。如果要给m赋值为3,( )

是正确的.

A、s.p=3

B、s - >p=3

C、s.*p=3

D、*s.p=3

答案：C

93.   已知f1(int)是类X的公有成员函数,p是指向成员f1()的指针，采用它赋值, ( )是正

确的.

A、p=f1

B、p=X::f1

C、p=x::f1

D、p=f1()

答案：B

解析：需要指定类作用域

94.   已知类X中的一个成员函数说明如下:

Void Set(X &a);

其中,X&a的含义是( ).

A、指向类X的指针为a

B、将a的地址赋给变量Sst

C、a是类X的对象引用，用来做为Set()的形参

D、变量X是a按位相与作为函数Set()的参数

答案：C

95.   一个类的友元函数能够访问该类的( ).

A、私有成员

B、保护成员

C、公有成员

D、所有成员

答案：D

96.   有关类和对象的说法不正确的是( ).

A、对是类的一个实例

B、一各类只能有一个对象

C、任何一个对象只能属于一个具体的类

D、类与对象的关系和数据类型和变量的关系相似

答案：B

97.   下列静态数据成员的特性中，( )是错误的.

A、说明静态数据成员时前边要加关键字static来修饰

B、静态数据成员在类体外进行初始化

C、引用静态数据成员时,要在静态数据成员名前加<类名>和作用域运算符

D、静态数据成员不是所有对象所共有的

答案：D

98.   类模板的使用实际上是类模板实例化成一个具体的( ).

A、类

B、对象

C、函数

D、模板类

答案：A

99.  通常拷贝构造函数的参数表是( ).

A、某个对象名

B、某个对象的成员名

C、某个对象的引用名

D、某个对象的指针名

答案：C

解析：防止递归调用死循环

100.   关于常数据成员的说法不正确的是( ).

A、常数据成员的定义形式与一般常量的定义形式相同，只不过常数据成员的定义必须出现在类体中.

B、常数据成员必须进行初始化,并且不能被更新

C、常数据成员通过构造函数的成员初始化列表进行初始化

D、常数据成员可以在定义时直接初始化

答案：D

101.   已知X类.则当程序执行到语句

X  array[3];时,调用了（ ）次构造函数.

A、0

B、1

C、2

D、3

答案：D

解析：每一个数组元素都会调用类的构造函数

102.  类模板的模板参数( ).

A、只可作为数据成员的类型

B、只可作为成员函数的返回类型

C、只可作为成员函数的参数类型

D、以上三者皆可

答案：D

103.   下列（ ）不是构造函数的特征

A、构造函数的函数名与类名相同

B、构造函数可以重载

C、构造函数可以设置默认参数

D、构造函数必须指定类型说明

答案：D

104.   下列程序中说明的公有成员是( ).

class Location{

int X;

public:

void init(int initX,int initY);

private:

int Y;

public:

int GetX();

int GetY();

}

A、X

B、init(int initX,int initY)

C、GetX(),GetY()

D、B、和C、都是

答案：D

解析：只要有public访控属性的成员都是共有成员，跟在类定义中的位置没有任何关系。

105.   类定义的内容允许被其他对象无限制地存取是( C ).

A、private 部分

B、protected 部分

C、public 部分

D、以上都不对

答案：C

106.   关于下面程度段说法正确的是( ).

class X

{

private:

int n;

punblic:

X(X&);

}

X::X(X&x)

{n=x.n}

X obj1,obj2;

obj2(obj1);

A、语句obj2（obj1）；的功能是用对象obj1初始化具有相同类类型的对象obj2

B、语句obj2（obj1）；的功能是用对象obj2初始化具有相同类类型的对象obj1

C、 X(X&x)也可以不使用引用参数而仍然是拷贝构造函数

D、 X(X&x)不能访问对象的私有成员

答案：A

107.   this指针是C++实现( )的一种机制.

A、抽象

B、封装

C、继承

D、重载

答案：B

108．   下面程序段中是内联函数的是（ ）。

chass location

{

private:

int x ,y;

public:

void init(int initx,int inity)

{

x=initx;

y=inity;

}

int getx(){return x;}

int gety();

};

inline int location::gety(){return y;}

A、 init (int initx,int inity)

B、 getx(),gety()

C、 A和B都是

D、 A和getx()

答案：C

解析:在类定义时实现的成员函数，默认为inline函数

109．   关于对象成员的构造函数的调用顺序，说法正确的是( C )。

A、与他们在成员初始化列表中给出的顺序相同

B、与折构函数的调用顺序相同

C、与他们在类中说明顺序相同

D、以上说法都不对

答案：C

110．   类摸板trmplate<class T>classX{……},其中，友元函数f()成为该类模板实例化的每个模板类的友元，则其说明应为( ).

A、friend voidf()

B、frieng void f(X<T>&);

C、friend void A::f();

D、friend void C<T>::f(X<T>&);

答案：A

111.运算符—>*的功能是( )。

A、用来表示指向对象指针对指向类成员指针的操作。

B、用来表示对象类成员的操作。

C、用来表示指向对象指针对类成员的操作。

D、用来表示对象指向类成员指针的操作。

答案：A

112.下列说明中

const char * ptr;

ptr 应该是( )。

A、指向字符的指针

B、指向字符的常量指针

C、指向字符串常量的指针

D、指向字符串的常量指针

答案：C

113.下面关于友元的描述中，错误的是( )。

A、友元函数可以访问该类的私有数据成员。

B、一个类的友元类中的成员函数都是这个类的友元函数。

C、友元可以提高程序的运行效率。

D、类与类之间的友元关系可以继承。

答案：D

114．一个( )允许拥护为类定义一种模式，使得类中的某些数据成员、某些成员函数底参数和

返回值可以取任意数据类型。

A、函数模板

B、模板函数

C、类模板

D、模板类

答案：C

115．有关构造函数说法不正确的是( )

A、构造函数的名字和类的名字一样。

B、在创建对象时，系统自动调用构造函数

C、构造函数无任何函数类型

D、构造函数有且只有一个

答案：D

116．下面对模板的声明，正确的是（ ）

A、template<T>

B、template<class T1,T2>

C、template<classT1,classT2>

D、template<classT1;classT2>

答案：C

117. （ ）是析构函数的特征。

A、析构函数可以有一个或多个参数

B、析构函数定义只能在类体内

C、析构函数名与类名不同

D、一个类中只能定义一个析构函数

答案：D

118．类模板template<class T>class X{…..};,其中友元函数f对特定类型T（如 int），使函数f(X<int>&)成为X<int>模板类的友元，则其说明应为（）

A、friend coid f();

B、friend coid f(X<T>&);

C、friend coid A::f();

D、friend coid C<T>::f(X<T>&);

答案：B

119. 若函数是在运行激活的，则该函数称为（ ）

A、内联函数

B、非内联函数

C、成员函数

D、静态成员函数

答案：B

120．在C++程序中，对象之间的象话通信通过（ ）

A、继承实现

B、调用成员函数实现

C、封装实现

D、函数重载实现

答案：B

121．在类的定义形式中，数据成员、成员函数和（    ）组成了类定义体。

A） 成员的访问控制信息

B） 公有消息

C） 私有消息

D）保护消息

答案：A

122．对于任意一个类，析构函数的个数最多为（        ）

A） 0

B） 1

C） 2

D）3

答案：B

123．（      ）的功能是对对象进行初始化。

A） 析构函数

B） 数据成员

C） 构造函数

D）静态数据成员

答案：C

124．友元关系不能（        ）

A） 继承

B） 是类与类之间是关系

C） 是一个类的成员函数与另一个类的关系

D）提高程序的运行效率

答案：A

继承是类与类之间的关系

125．（      ）只能访问静态成员变量，静态成员函数和类以外的函数和数据不能访问类中的非静态成员变量。

A） 静态函数

B） 虚函数

C） 构造函数

D）析构函数

答案：A

126．下面说法正确的是（     ）

A） 内联函数在运行时是将该函数的目标代码插入每个调用该函数的地方

B） 内联函数在编译时是将该函数的目标代码插入每个调用该函数的地方

C） 类的内联函数必须在类体内定义

D）类的内联函数必须在类体外关键字inline定义

答案：B

127.下列关于成员访问权限的描述中，不正确的是（     ）

A） 公有数据成员和公有成员函数都可以被类对象直接处理

B） 类的私有数据成员只能被公有成员函数以及该类的任何友元类或友元函数访问

C） 保护成员在派生类中可以被访问，而私有成员不可以

D）只有类或派生类的成员函数和友元类或友元函数可以访问保护成员

答案：B

128．局部变量可以隐藏全局变量，那么在有同名全局变量和局部变量的情形时，可以用（     ）

提供对全局变量的访问

A） 域运算符

B） 类运算符

C） 重载

D）引用

答案：A

129．缺省析构函数的函数体是（     ）

Ａ）不存在

Ｂ）随机产生的

Ｃ）空的

Ｄ）无法确定的、

答案：C

130．在下列关键字中，用以说明类中共有成员的是（        ）

A） public

B） private

C） protected

D）friend

答案：A

131．下面说法中正确的是（    ）

A） 一个类只能定义一个构造函数，但可以定义多哥析构函数

B） 一个类只能定义一个析构函数，但可以定义多个构造函数

C） 构造函数与析构函数同名，知识名字前加了一个求反符号（~）

D）构造啊函数可以指定返回类型，而析构函数不能指定任何返回类型，即使是void类型也不可以

答案：B

132．关于delete 运算符的下列描述中，（    ）是错误的。

A） 它必须用语new返回的指针

B） 它也适用于空指针

C） 对一个指针可以使用多次该运算符

D）指针名前只用一队方括号符，不管所删除数组的维数

答案：C

133．关于成员函数的特征的下述描述中，错误的是（      ）

A） 成员函数一定是内联函数

B） 成员函数可以重载

C） 成员函数可以设置参数的默认值

D）成员函数可以是静态的

答案：A

134．假定x为一个类，执行Xa[3],*p[2];语句时会只动调用该类的构造函数（    ）次

A） 2

B） 3

C） 4

D）5

答案：B

135．由于数据隐藏的需要，静态，数据成员通常被说明为（   ）

A） 私有的

B） 公有的

C） 保护的

D）不可访问的

答案：A

136．假定X为一个类，则该类的拷贝构造函数的声明语句为（     ）

A） My Class(My Class x)

B） My Class&(My Class x)

C） My Class(My Class &x)

D）My Class(My Class *x)

答案：C

137．Main()函数在执行之前不可以调用其构造函数的（    ）

A） 全局对象

B） 静态对象

C） 在main()函数体内说明的对象

D）全局对象数组

答案：C

138．对于常成员函数，下列描述正确的是（   ）

Ａ）常成员函数只能修改常数据成员

B）常成员函数只能修改一般数据成员

C）常成员函数不能修改任何数据成员

D、_成员函数只能通过常对象调用

答案：C

139．友元的作用是（     ）

Ａ）提高程序是运行效率

B）加强类的封装性

C）实现数据的隐藏性

D、增加成员函数的种类

答案：A

140.一个类的友元函数或友元类能够通过成员操作符访问该类的（     ）

A） 私有成员

B） 公有成员

C） 保护成员

D）公有成员、保护成员和私有成员

答案：D

141．下面说法中正确的是（     ）

A） 当声明的内容不同时，声明同一个名字的两个类是允许的

B） 不完全生命的类也可以实例化

C） 声明同一个名字的两个类时，要求声明的内容也相同

D）生命同一个名字的两个类是错误的

答案：D

142．下面对静态数据成员的描述中，正确的是（     ）

A） 静态数据成员是类的所有对象共享的数据

B） 类的没个对象都有自己的静态数据成员

C） 类的不同对象有不同的静态数据成员值

D）静态数据成员不能通过类的对象调用

答案：A

143．下列关于对象数组的描述中，错误的是（    ）

A） 对象数组的下标是从0开始的

B） 对象数组的数组名是一个常量指针

C） 对象数组的没个元素是同一个类的对象

D）对象数组只能赋初值，而不能在定义后赋值

答案：D

144．对于下面定义的类A在函数f()中将对象成员n的值修改为60的语句应该是（     ）

class A

{

public:

A(int x){n=x;}

coid SetNum(int n1){n=n1;}

private

int n;

}

int f()

}

a*ptr=new A(60);

}

A） A(60)

B） SetNum(60)

C） Ptr->SetNum(60)

D）Ptr->n=60

答案：C

145.关于使用const关键字修饰的对象的说法正确的是（     ）

A） 不能用一般的成员函数来访问

B） 可以用一般的成员函数来访问

C） 可以访问const成员函数及colatile成员函数

D）不能访问const 成员函数

答案：A

146．下面是类MyClass的定义，对定义 中各语句描述正确的是（     ）

class MyClass

{

private:

int X,y,Z;

public;

coid MyClass(int A、{X=a;}         file://①

int f(int a,int B)                   file://②

{

X=a;

Y=b;}

Int f(int a,int b,int c=0)                file://③

{a;

Y=b;

Z=c;}

Static coid g() {X=10;}             file://④

A） 语句①是类MyClass的构造函数定义

B） 语句②和语句③实现类成员函数的重载

C） 语句④实现对类成员变量X的更新操作

D）语句①②③和④都不正确

答案：D

63．友元访问类的对象的成员时使用（       ）

A） 类的成员名

B） this指针指向成员名

C） “类名：：成员名”的形式

D）“对象名.成员名”的形式

答案：D

147.下列程序输出的结果正确的是（      ）

＃i nclude<iostream.h>

coid fun()

{static int n=10;

n++;

cout <<”n=”<<n<<endl;

}

void main()

{

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

cun();

}

A）n=11    n=11

B、  n=11    n=12

C、  n=10     n=11

D、  n=10     n=10

答案：B

148. 下面类模板的定义中，不正确的是（    ）

A） tempate<class T>

class A{T x,y;};

B） tempate<class T>

class A{private:t x;};

C） tempate<class T>

class A{public:T x;};

D）tempate<class T>

class A{protected:t x;};

答案：C

149. 静态成员遵循类的其他成员所遵循的访问限制，除了（     ）

A） 静态成员函数

B） 静态数据成员初始化

C） 私有静态数据成员

D）公有静态成员函数

答案：B

150. 空类的声明（     ）是正确

A） class类名；

B） class类名{}；

C） class类名{}

D）class类名

答案：B

151. 可以用“px->*p”来访问类A的对象a 的数据成员，则下面正确的是（     ）

A） px是指向类数据成员的指针

B） p是指向类数据成员的指针

C） p是指向类的对象的指针

D）无法确定指针类型

答案：B

152. 关于类中数据成员的生存期的说法正确的是（      ）

A） 与对象的生存期无关

B） 比对象的生存期长

C） 比对象的生存期短

D）有对象的生存期决定

答案：D

153. 类example 的析构函数为（     ）

Ａ）example（）；

Ｂ）example（）

Ｃ）~example（）；

D）~example（）

答案：D

154. 以知AA是一个类，则执行语句Aaa；后（     ）

Ａ）自动调用无参构造函数

B）自动调用有参构造函数

C、 自动调用拷贝构造函数

D、产生一个对象a,但不调用任何函数

答案：A

155.对于类模板tanytemp,执行语句tanytemp<int>iobject(23,32);后(    )

A、产生的模板类为 tanytemp

B、产生的模板类为 iobject

C、产生的模板类为 tanytemp<int>

D、类模板实例化对象

答案：C

156. 下列说法正确的是(     )

Ａ）类定义中只能说明函数成员的函数头，不能定义函数体

B、类中的函数成员只能可以在类体内定义,不可能在类体外定义

C、类中的函数成员在类体外定义时必须要与类声明在同一文件中

D、在类体外定义的函数成员不能操作该类的私有数据成员

答案：C

157.类的构造函数被自动调用执行的情况是在定义该类的(    )

A、 成员函数时

B、 数据成员时

C、 对象时

D、 友元函数时

答案：C

158.说明友元函数使用关键字(    )

A、 friend

B、 static

C、 const

D、 colatile

答案：A

159. 有关类的作用域.下了说法中不正确的是(    )

A、 说明类时所使用的一对花括号形成所谓的类作用域

B、 类作用域不

C、 包含类汇总成员函数的作用域

D、 类作用域中说明的标E) 识符只在类中可见

F) 在可能出现两义性的情况下,必须使用作用域限定符”::”

答案：B

160. 类的静态成员(     )

A、 是指B、 静态数据成员

C、 是指D、 静态函数成员

E) 为该类的所有对象共享

F) 遵循类的其他成员做遵循的所有访问权限

答案：C

161. 允许访问类的所有对象的私有成员,公有成员和保护成员的是(    )

A、 友元函数

B、 成员函数

C、 内联函数

D、 重载函数

答案：A

162. 形如X::X(X&)的构造函数称为(   )

A、 拷贝函数

B、 复

C、 制函数

D、 初始化函数

E) 拷贝初始化构造函数

答案：D

163.以知example是已定义的类,则程序结束前,共存在(    )个对象.

＃i nclude<example.h>

main()

{example x(5);    example arr[2]={1,2};

x=10;

x.print();

x=example(15);

x.print();

}

A、 3

B、 4

C、 7

D、 8

答案：B

164. 所有在函数中定义的变量,连同形式参数,都属于(   )

A、 全局变量

B、 局部变量

C、 静态变量

D、 寄存器变量

答案：B

165.在C++中,封状是借助于(    )达到的.

A、 结构

B、 类

C、 数组

D、 函数

答案：B

166. 下面不属于类的存取权限的是(   )

A、 public

B、 static

C、 protected

D、 pricate

答案：B

167. 指向类X中类型为type的数据成员的指针的说明形式为(    )

A、 type X::*pointer

B、 x::type*pointer

C、 type *X::pointer

D、 X::*tyoe pointer

答案：A

168. 已知:print()函数是一个类的常成员函数,它无返回值,下列表示中,(   )是正确的

A、 coid print() const

B、 const coid print()

C、 viod const print()

D、 coid print(const)

答案：A

169. 关于new运算符的下列描述中,(   )是错误的.

A、 它可以用来动态创建对象和对象数组

B、 使用它创建对象或对象数组,可以使用运算符DELETE删除

C、 使用它创建对象时要调用构造函数

D、 使用它调用对象数组时不E) 许指F) 定初始值

答案：D

170. 下列关于构造函数的描述中,错误的是(    )

A、 构造函数可以设置默认参数

B、 构造函数在说明类变量时自动执行

C、 构造函数可以对静态数据成员进行初始化

D、 够找函数可以重载

答案：C

172. 运算符delete删除一个动态对象时(     )

A、 首先为该动态对象调用构造函数,在释放其占用的内存

B、 首先释放该动态对象占用的内存,在为其调用构造函数

C、 首先为该动态对象调用析构函数,在释放其占用的内存

D、 首先释放动态对象占用的内存,在为其调用析构函数

答案：C

174． 下面关于纯虚函数和抽象类的描述中，（   ）是错误的。

A） 纯虚函数是一种特殊的虚函数，B） 它没有具体意义

C） 一个基类中说明有纯虚函数，D） 该基类的派生类一定不E） 再是抽象类

F） 抽象类只能作为基类来使用，G） 其纯虚函数的定义由派生类给出

H） 抽象类是指I） 具有纯虚函数的类

答案：B

175． 对虚函数的调用（    ）。

A） 一定使用动态联编

B） 一定使用静态联编

C） 必须使用动态联编

D） 不一定使用动态联编

答案：D

176． 若类A和类B的定义如下：

class A

{

int i,j;

public:

void get();

file://…

};

class B:A//默认为私有派生

{

int k;

public;

void make();

file://…

};

void B:: make()

{

k=i*j;

}

则上述定义中，（     ）是非法的表达式。

A）void get();

B）int k;

D）void make();

D）k=i*j;

答案：D

177．下列描述中，（    ）是抽象类的特性。

A）可以说明虚函数

B）可以定义友元函数

C）可以进行构造函数重载

D）不能说明其对象

答案：D

178．在多继承中，公有私生和私有派生对于基类成员的派生类中的可访问性与单继承的规则（     ）。

A）完全相同

B）完全不同

C）部分相同，部分不同

D）以上都不对

答案：A

179．（    ）是一个在基类中说明虚函数，它在该基类中没有定义，但要求任何派生类中的可访问性的规定是相同的。

A）纯虚函数

B）虚析构函数

C）虚构造函数

D）静态成员函数

答案：A

180．下列对派生类的描述中，（     ）是错误的。

A）一个派生类可以作另一个派生类的基类

B）派生类至少有一个基类

C）派生类的成员除了它自己的成员外， 包含了它的基类的成员

D）派生类中继承的基类成员的访问权限到派生类保持不变

答案：D

181．实现运行时的多态性要使用（     ）。

A）构造函数

B）析构函数

C）重载函数

D）虚函数

答案：D

182．派生类的对象对它的基类成员中（    ）是可以访问的。

A）公有继承的公有成员

B）公有继承的私有成员

C）公有继承的保护成员

D）私有继承的公有成员

答案：A

183．关于函数的描述中，（     ）是正确的。

A）派生类的虚函数与基类的虚函数具有不同的参数个数和类型

B）基类中说明了虚函数后，派生类中其对应的函数一定要说明为虚函数

C）虚函数是一个成员函数

D）虚函数是一个static类型的成员函数

答案：C

184．对基类和派生类的关系描述中，（     ）是错误的。

A）派生类是基类的具体化

B）派生类是基类的子集

C）派生类是基类定义的延续

D）派生类是基类的组合

答案：B

185．关于动态联编的下列叙述中，（     ）是错误的。

A）动态联编是以虚函数为基础的

B）动态联编调用虚函数操作是指向对象的指针或引用

C）动态联编是在运行时确定所调用的函数代码的

D）动态联编是在编译时确定操作函数的

答案：D

186．派生类的构造函数的成员初始化列表中，不能包含（    ）。

A）基类的构造函数

B）派生类中子对象的初始化

C）基类的子对象初始化

D）派生类中一般数据成员的初始化

答案：C

187．如果一个类至少有一个纯虚函数，那么就称该类为（     ）。

A）抽象类

B）派生类

C）纯基类

D）以上都不对

答案：A

188．设置虚基类的目的是（    ）。

A）简化程序

B）消除二义性

C）提高运行效率

D）减少目标代码

答案：B

189．在下面程序中，编译时出现的错误是（    ）。

class A                             file://(1)

{

public;                           file://(2)

A()

{

func();                         file://(3)

}

virtual void func()=0;               file://(4)

};

A）(1)

B）(2)

C）(3)

D）(4)

答案：C

190．关于多继承二义性的描述中，错误的是（    ）。

A）一个派生类的基类中都有某个同名成员，在派生类中对这个成员的访问可能出现二义性

B）解决二义性的最常用的方法是对成员名的限定法

C）基类和派生类同时出现的同名函数，也存在二义性问题

F） 一个派生类是从两个基类派生出来的，G） 而H） 这两个基类又有一个共同I） 的基类，J） 对该基类成员进行访问时，K） 可能出现二义性

答案：C

191．用于类中虚成员函数说明的关键字（    ）

A．virtual    B．public   C．protected   D．private

答案：A

192．下列对派生类的描述中，错误的是（     ）

A． 派生类的缺省继承方式是PRIVATE

B． 派生类至少有一个基类

C． 一个派生类可以作为另一个派生类的基类

D． 派生类只继承了基类的公有成员和保密成员

答案：D

193．编译时的多态性通常使用（    ）获得。

A．继承     B．虚函数   C．重载函数    D．析构函数

答案：C

194．下列说法中错误的是（     ）

A． 公有继承时基类中的public成员在派生类中是public的

B． 公有继承时基类中的private成员在派生类中是private的

C． 私有继承时基类中的public成员在派生类中是private的

D． 私有继承时基类中的public成员在派生类中是protected的

答案：D

195．下面哪个基类中的成员函数表示纯虚函数（     ）

A． virtual  void  vf(int)  B．void  vf(int)=0 C．virtual  void  vf( )=0  D．virtual  void  vf(int)

答案：C

196．下面叙述不正确的是（     ）

A． 基类的公有成员在派生类中仍然是公有的

B． 派生类一般都用公有派生

C． 对基类成员访问必须是无二义性的

D． 赋值兼容规则也使用于多重继承的组合

答案：C

197．下列虚基类的声明中正确的是（   ）

A． class virtual B:public A  B．virtual class B:public

B． class B:public A virtual  D．class B: virtual public A

答案：D

198．下面叙述不正确的是（    ）

A． 基类的保护成员在派生类中仍然是保护的

B． 基类的保护成员在公有派生类中仍然是保护的

C． 基类的保护成员在私有派生类中仍然是私有的

D． 对基类成员的访问必须是无两义性

答案：A

199．带有虚基类的多层派生类构造函数的成员初始化列表中都要列出虚基类构造函数，这样将对虚基类的子对象初始化（      ）

A．与虚基类下面的派生类个数有关  B．多次  C．二次   D．一次

答案：D

200．关于保护成员的说法正确的是（    ）

A． 在派生类中仍然是保护的

B． 具有私有成员和公有成员的双重角色

C． 在派生类中是私有的

D． 在派生类中是公有的

答案：B

201．下列关于子类型的描述中，错误的是（   ）

A． 子类型关系是可逆的

B． 公有派生类的对象可以初始化基类的引用

C． 只有在公有继承下

D． 派生类是基类的子类型

E． 子类型关系是可传递的

答案：A

202．若要强制C++对虚函数的调用使用静态联编，则在调用中对该函数使用（ A  ）

A．成员名限定 B． 指针   C．引用    D．VIRTUAL关键字

答案：A

204.下面（        ）的叙述不符合赋值兼容规则。

A.派生类的对象可以赋值给基类的对象

B.基类的对象可以赋值给派生类的对象

C.派生类的对象可以初始化基类的对象

D.派生类的对象的地址可以赋值给指向基类的指针

答案：B

205.C++有（      ）种联编。

A.1

B.2

C.3

D.4

答案：B

静态联编和动态联编

206.对于下列程序段，没有二义性的表达式是（         ）

class A{public:int f();};

class B{public:int g();int f();};

class C:public A,public B{ public : int g( ) ; h( ) ; } ;

C obj;

A.obj .f( )

B.obj .A : : g( )

C.obj .B : : f( )

D.obj .B : : h( )

答案：C

207.下面叙述错误的是（           ）

A.派生类可以使用private派生

B.对基类成员的访问必须是无二义性的

C.基类成员的访问能力在派生类中维持不变

D.赋值兼容规则也适用于多继承的组合

答案：C

208.派生类的对象与基类的对象的关系是（       ）

A.属于前者而不属于后者

B.属于前者，不一定属于后者

C.不属于前者则一定属于后者

D.属于前者则一定属于后者

答案：D

209.对于下面程序段，表达式正确的是（         ）

class Base {public:int b;};

class Base1:public base{ };

class Base2:public base{ };

class Derived:public base1,public base2{public:int fun ( );};

Derived d;

A. d. Base1::b

B. d. Base ::b

C. d.b

D. d. Base :: fun( )

答案：A

210.下列程序中横线处正确的语句应该是（        ）

＃i nclude<iostream>

using namespace std;

class Base

{

public;

void fun( ){cout< < “Base : : fun” < < endl;}

};

class Derived : public Base

{

public:

void fun( )

{

_________//显示调用基类的函数fun( )

cout < < “Derived : : fun” < < endl;

}

};

Afun( ).

B.Base.fun( )

C.Base : : fun( )

D.Base - >fun( )

答案：C

211.虚函数必须是类的（      ）

A.成员函数

B.友元函数

C.构造函数

D.析构函数

答案：A

212.不能说明为虚函数的是（        ）

A.析构函数

B.构造函数

C.类的成员函数

D.以上都不对

答案：B

213.不同的对象可以调用相同名称的函数，并可导致完全不同的行为的现象称为（        ）

A.多态性

B.抽象

C.继承

D.封装

答案：A

214. 若析构函数是虚函数，则delete对析构函数的调用采用（        ）

A.静态联编

B.动态联编

C.重载函数

D.多重函数

答案：B

215. 关于虚函数，下列表述正确的是（      ）

A.如果在重定义虚函数时使用virtual，则该重定义函数仍然是虚函数

B.虚函数不得声明为静态函数

C.虚函数不得声明为另一个类的友元函数

D.派生类必须重新定义基类的虚函数

答案：B

216.下列程序段中具有相同值的是（       ）

class Base {int b;};

class Base1:virtual public base{int b1;};

class Base2:virtual public base{int b2;};

class derived:publiic base 1,public base 2{int b3;};

derived d;

A.d.b与 d.base1::b

B. d.base1::b与 d.base1::b1

C. d.b与 d. b3

D. d.base:2:b与 d.base2::b2

答案：A

虚表的理解。

217.对于公有派生，它的“访问控制“是（        ）

A.private

B.public

C.protected

D.inaccessible

答案：B

218.关于纯虚函数，下列表述正确的是（    ）

A.纯虚函数是给出实现版本（即无函数体定义）的虚函数

B.纯虚函数的声明总是“=0”结束

C.派生类必须实现基类的纯虚函数

D.含有纯虚函数的类一定是派生类

答案：B

219.若派生类中没有对基类的虚函数进行重定义，则它继承基类中的（        ）

A.访问权限

B.保护成员

C.虚函数

D.成员函数

答案：C

220.基类和派生类可以分别叫做（     ）

A.“大类”和“小类”

B.“父类”和“子类”

C.“小类”和“大类”

D.“子类”和“父类”

答案：B

221.多态调用的指（       ）

A.以任何方式调用一个虚函数

B.以任何方式调用一个纯虚函数

C.借助于指向对象的基类指针或引用调用一个虚函数

D.借助于指向对象的基类指针或引用调用一个纯虚函数

答案：C

多态，父类指针指向子类对象

222.若派类的成员函数不能直接访问基类中继承来的某个成员，则该成员一定是基类中的（     ）

A.私有成员

B.公有成员

C.保护成员

D.保护成员或私有成员

答案：A

223.对基类和派生类的描述中错误的是（        ）

A.派生类是基类的具体化

B.基类继承了派生类的属性

C.派生类是基类定义的延续

D.派生类是基类的特殊化

答案：B

224.关于抽象类，下列表述正确的是（    ）

A.抽象类的成员函数中至少有一个没有实现的函数（即无函数体定义的函数）

B.派生类必须实现作为基类的抽象类中的纯虚函数

C.派生类不可能成为抽象类

D.抽象类不能用于定义对象

答案：D

225.类B是类A的公有派生类，类A和类B中都定义了虚函数func()，p是一个指向类A对象的指针，则p->A::func()将（      ）

A.调用类A中是函数func()

B.调用类B中是函数func()

C.根据P所指的对象类型而确定调用A中或类B中的函数func()

D.既调用类A中函数，也调用类B中的函数

答案：A

p->A::func()手动指定了调用函数

226.对于类定义

class A{

public:

virtual void funcl(){}

void func2(){}

};

class B:public A{

PUBLIC:

Void func1(){cout<<”class Bfunc1”<<endl;}

Cirtual void func2(){cout<<”class B func2”<<endl;}

};

下面正确的叙述是（       ）

A.A：：func2()和B：：func1()都是虚函数

B.A：：func2()和B：：func1()都不是虚函数

C.B：：func1()是虚函数，A：：func2()不是虚函数

D.B：：func1()不是虚函数，A：：func2()是虚函数

答案：C

227.对于多重继承，有（         ）

A.一个派生类只能有一个基类

B.一个基类只能产生一个派生类

C.一个基类必须产生多个派生类

D.一个派生类可有多个基类

答案：D

228.下列程序段中，错误的语句是（       ）

class A{

public:virtual void f()=0;        file://(1)

void g(){f();}               file://(2)

A(){f();}                   file://(3)

}

A.（1）

B.（2）

C.（3）

D.（1）和（2）

答案：C

在构造函数内部调用纯虚接口。

229.下面程序段中，说法正确的是（      ）

class location{

public :

int GetX();

};

class rectangle:private location {

public:

int GetW();

};

A.类rectangle私有派生类 location

B.类rectangle中的public成员在类 location中是私有的

C.类location中的public成员在类  rectangle中是不可访问的

D. viod f( ) {

Rectangle r;

Int X=r .GetX( );

}

其中int X = r .GetX( );是非法语句

答案：D

类rectangle私有派生类 location错误，是类location私有派生类rectangle

类rectangle中的public成员在类 location中是私有的错误，类location内部没有类rectangle中的成员。

类location中的public成员在类rectangle中是不可访问的错误，是不可以在类外部公开访问的。

230.在公有派生情况下，有关派生类对象和基类对象的关系的关系，不正确的叙述是（      ）

A.派生类的对象可以赋给基类对象

B.派生类的对象可以初始化基类的引用

C.派生类的对象可以直接访问基类的成员

D.派生类的对象的地址可以赋给指向基类的指针

答案：C

派生类的对象可以直接访问基类的成员是错误的，派生类只可以访问自身的，而不是基类的。他只是具有基类的某种性质。

231.可以用p.a的形式访问派生类对象p 的基类成员a其中a是（       ）

A.私有继承的公有成员

B.公有继承的私有成员

C.公有继承的保护成员

D.公有继承的公有成员

答案：D

子类可以访问的父类成员对象必须是公开继承并且在父类中是公开的。

232.建造新的派生类是（         ）的实质。

A.派生

B.抽象

C.继承

D.封装

答案：C

利用继承机制，新的类可以从已有的类中派生。那些用于派生的类称为这些特别派生出的类的“基类”。

233.动态联编所支持的多态性称为（        ）

A.虚函数

B.继承

C.编译时的多态性

D.运行时的多态性

答案：D

编译程序在编译阶段并不能确切知道将要调用的函数，只有在程序运行时才能确定将要调用的函数，为此要确切知道该调用的函数，要求联编工作要在程序运行时进行，这种在程序运行时进行联编工作被称为动态联编。

234．下列运算符中，（     ）运算符在C++中不能重载。

A）？：

B）+

C）-

D）〈=

答案：A

C++并不是所有的操作符都能被重载。除了. ，.* ，:: ，? : ，sizeof，typeid这几个运算符不能被重载，其他运算符都能被重载。

235．在C++中，打开一个文件就是将这个文件与一个（     ）建立关联；关闭一个文件就是取消这种关联。

A）流

B）类

C）结构

D）对象

答案：A

C++中，输入和输出全部都是输入流和输出流。

236．下列关于运算符重载的描述中， （    ）是正确的。

A）运算符重载可以改变操作数的个数

B） 运算符重载可以改变优先级

C）运算符重载可以改变结合性

D）运算符重载不可以改变语法结构

答案：D

运算符重载不可以改变语法结构。语法结构是语言本身决定的，用户无法进行改变。

237．若定义cin>>str;

当输入

Microsoft Visual Studio 6.0!

所得的结果是str=（    ）。

A、    Microsoft Visual Studio 6.0!

B、     Microsoft

C、    Microsoft Visual

D、    Microsoft Visual Studio 6.0

答案：B

以空格作为一次有效输入，Microsoft Visual Studio 6.0!默认为4次有效输入。

238．有元运算符obj1〉obj2被C++编译器解释为（    ）。

A）operator>（obj1,obj2）

B） >(obj1,obj2)

C）jobj2.operator>(obj1)

D）obj1.operator(obj2)

答案：A

友员解释为operator > (obj1, obj2)

成员解释为obj1.operator>(obj2)

239．进行文件操作时需要包含（    ）头文件。

A、    iostream

B、    fstream

C、    stdio

D、    stdlib

答案：B

fstream是文件操作的最高父类，他又包括两个子类：ifstream和ofstream。

240．当使用ifstream流类定义一个流对象并打开一个磁盘文件时，文件的隐含打开方式为（     ）。

A）ios::in

B） ios::out

C）ios::trunc

D）ios::binary

答案：A

fstream有两个子类：ifstream(input file stream)和ofstream(outpu file stream)，ifstream默认以输入方式打开文件，而ofstream默认以输出方式打开文件。

241．使用如setw()的操作符对数据进行格式输出时，应包含（      ）文件。

A）iostream

B）fstream

C）stdio

D）iomanip

答案：D

io代表输入输出，manip是manipulator（操纵器）的缩写。

iomanip的作用:

主要是对cin,cout之类的一些操纵运算子，比如setfill,setw,setbase,setprecision等等。它是I/O流控制头文件,就像C里面的格式化输出一样。