在线考试系统c++题库填空题

更新时间：2024-04-05 20:04:01 阅读量：综合文库文档下载

说明：文章内容仅供预览，部分内容可能不全。下载后的文档，内容与下面显示的完全一致。下载之前请确认下面内容是否您想要的，是否完整无缺。

在线考试推荐度：
相关推荐

二、填空题

1、设有定义语句：int a=12;，则表达式a*=2+3的运算结果是______。

答案： 60

根据运算的优先级和结合性，可以将表达式的计算顺序规则总结为以下3条：（1）优先计算带有括号的子表达式。（2）在没有括号的部分，依照运算优先级，由高到低进行计算。（3）具有相同优先级的运算符，按照结合性规定，依次进行计算。本题中*=的结合性是右结合，所以表达式a*=2+3相当于a=a*(2+3)，所以a=60。知识点：C++部分/数据类型、表达式和基本运算/掌握C++运算符的种类、运算优先级和结合性

2、从实现的角度划分，C++所支持的两种多态性分别是______时的多态性和运行时的多态性。答案：编译

在C++语言中，多态性可分为两类：编译时的多态性和运行时的多态性。编译时的多态性是通过函数重载和模板体现的。运行时的多态性是通过虚函数体现的。知识点：C++部分/了解多态性概念/虚函数机制的要点_

3、将一个函数声明为一个类的友元函数必须使用关键字______。答案： friend

友元函数不是当前类的成员函数，而是独立于当前类的外部函数（包括普通函数和其他类的成员函数），但它可以访问该类的所有对象的成员，包括私有成员、保护成员和公有成员。友元函数要在类定义时声明，声明时要在其函数名前加上关键字friend。该声明可以放在公有部分，也可以放在私有部分。友元函数的定义既可以在类内部进行，也可以在类外部进行。

知识点：C++部分/熟练掌握类与对象的相关知识/友元函数和友元类_ 4、请按下面注释的提示，将类B的构造函数定义补充完整。 class A {

int a; public:

A(int aa=0){a=aa;} };

class B:public A{ int b; A c; public:

// 用aa初始化基类A，用aa+1初始化类对象成员c B(int aa):______ { b=aa+2; } };

答案： A(aa),c(aa+1)#c(aa+1),A(aa)

本题主要考查了类对基类及成员类的初始化。在类的构造函数中，要对类的基

类及成员类进行初始化，可在构造函数后面加上初始化列表，函数与初始化列表间用冒号隔开，列表间各项用逗号隔开。要对基类进行初始化，可用形如：类名（初始化参数）的方式，要对内部对象初始化，可用形如：对象名（初始化参数）的方式。

知识点：C++部分/熟练掌握类与对象的相关知识/构造函数与析构函数 5、下列程序的输出结果是______。

#include using namespace std; int main() {

int i=5;

int &r=i;r=7; cout<

} 答案： 7

本题主要考查了引用的概念，引用实质上是为变量取一个别名，因为系统不会为引用变量所代表的数据对象再次分配空间。本题中引用变量r与它所代表的数据对象i共用一个存储空间，所以所有对r的操作就是对i的操作，故本题在执行r=7后，i的值也就是7。

知识点：C++部分/C++的基本语句/掌握C++的基本语句 6、下列程序的输出结果是______。

#include using namespace std; class Test{ public:

Test(){cnt++;} ~Test(){cnt--;}

static int Count(){return cnt;} private:

static int cnt; };

int Test::cnt=0; int main() {

cout<

Test*pT3=new Test; Test*pT4=new Test;

cout<

delete pT3;

cout<

}

答案：0 4 2

本题主要考查了类的静态成员的概念。在C++中可以用static关键字为类指定静态成员。静态成员为类的所有实例所共享。对于类中的静态函数，可以通过类名::函数名的方法来调用，并且该函数只能访问类中的静态数据。对于静态int型数据，在编译时将会被初始化为0，故在main函数中第一句将会输出\；在Test t1,t2；语句中将创建类的两个实例，一共调用了两次构造函数，故类的静态数据cnt将会执行两次自加运算，变为2，main中接下来的两条语句通过new方法也创建了该类的两个实例，此时cnt变为4，故第二次执行输出时将输出\\；接下来执行了两条delete语句，将销毁pT4,pT3所对应的实例，这将执行两次析构函数，故cnt的值将变为2，最后的一条输出语句将输出\（后面有回车）。

知识点：C++部分/熟练掌握类与对象的相关知识/对象和对象指针的定义与使用 7、下面是用来计算n的阶乘的递归函数，请将该函数的定义补充完整。（注：阶乘的定义是n!=n*(n-1)*…*2*1） unsigned fact(unsigned n) {

if(n<=1) return 1; return ______; }

答案：n*fact(n-1)#fact(n-1)*n

注意到阶乘的定义，当n<=1时，n!=1；当n>1时，n!=n*(n-1)!，符合递归的定义，因此，本题答案为n*fact(n-1)。

知识点：C++部分/掌握函数的有关使用/递归函数 8、下列程序的输出结果是______。

#include using namespace std; template

T fun(T a,T b) { return(a<=b)?a:b; } int main() {

cout<

答案： 3,3.14

本题主要考查了模板的定义及使用。在C++中为了能够实现代码的重用，提供了模板机制。在本题中，定义了一个模板函数，其参数a，b及返回结果均为T类型。分

析fun函数的可知，其功能是返回a，b中数值较小的数。在main函数中第一次调用fun时，实际上是调用了int fun(int a,int b)这个函数，故返回3，第二次调用时，实质上是调用了函数float fun(float a,float b)，返回值为一个浮点型数据3.14。知识点：C++部分/掌握函数的有关使用/函数重载

9、与成员访问表达式p->name等价的表达式是______。答案： (*p).name

p->name实际上是批指针p所指结构的成员name，因此我们可以用*p来指定p所指的内容，其成员可用\操作符实现，故为(*p).name，注意到\的优先级要高于\，故对*p要加上括号。

知识点：C++部分/数据类型、表达式和基本运算/熟练掌握C++表达式类型及求值规则

10、下列程序的输出结果是______。

#include using namespace std; class base{ public:

int n;

base(int x) { n=x;}

virtual void set(int m) { n=m;cout<

};

class deriveA:public base{

public:

deriveA(int x):base(x){ }

void set(int m){ n+=m;cout<

class deriveB:public base{

public:

deriveB(int x):base(x){ }

void set(int m) { n+=m;cout<

int main() {

deriveA d1(1); deriveB d2(3); base *pbase; pbase=&d1; pbase->set(1); pbase=&d2; pbase->set(2); return 0; }

答案 2 5

本题主要考查了C++中的虚拟函数及多态机制。在C++中可以用虚拟函数来实现运行时多态。本题中首先创建了两个对象d1、d2，其对应的类分别是deriveA与deriveB。在创建d1，d2时，构造函数分别为它们设置了属性n的值为1，3。pbase为一个指向基类的指针，在将d1，d2的地址赋值给pbase后，调用pbase的指针成员将自动根据其所属的子类调用相应的成员函数，故本题输出应为\。

知识点：C++部分/熟练掌握类与对象的相关知识/对象和对象指针的定义与使用 11、在C++面向对象程序设计框架中，______是程序的基本组成单元。答案：类

面向对象程序设计语言一般是以类为程序的组成单元，这是其与面向过程语言的主要区别。

知识点：C++部分/C++语言概述/掌握C++程序的基本框架 12、对于枚举类型的定义语句enum Color{Blue,Green=3,Black,White=6,Red};其中枚举常量Red的值为______。答案： 1：7

本题考查了枚举型的定义。

一个enum类型实际上是int类型的一个子集，其每一个枚举值代表一个整数。当n个枚举型未被赋值时，他们自左至右依次为0，1，.....，n-1，如果第i个枚举值为m，则其未赋值的后面枚举值分别是m+1，m+2...。所以本题答案是7。

知识点：C++部分/数据类型、表达式和基本运算/掌握C++数据类型及其定义方法 13、执行下面语句段后输出结果是______。 int k=1,n=10,m=1; while(k<=n) {

m*=2; n--; k++; }

cout<

本题考查的是循环结构。

解题思路是：这是一个由while控制的循环，循环变量k的初始值为1，循环条件为k<=n，在循环体中k的值每次增加1，n的值每次减少1，这样循环共进行5次，所以最后m的值为32。

知识点：C++部分/C++的基本语句/用while语句实现循环结构 14、执行下列语句后，输出的结果为______。 void show() {

static int a=3; a++;

cout<

}

int main() {

for(int i=0;i<2;i++) show(); }

答案： 4 5

本题考查了静态变量的用法。

当函数执行完毕，返回调用点时，该变量并不撤消，其值将继续保留，若下次进入该函数，其值仍然存在。故本题输出4 5。

知识点：C++部分/掌握函数的有关使用/变量的作用域、生存周期和存储类别 15、执行下列程序后输出的结果为______。 #include using namespace std; int x[]={5,4,3,2,1}; int main() {

int i,*p,m=0;

for(p=x,i=1;p+i<=x+4;i++) for(i=0;i<4;i++) m+=p[i];

cout<

答案： 14

本题考查的是循环语句和数组、指针的结合。

解题思路是：数组名实际上是一个指针常量存放数组的第一个元素的地址。本题是一个二重循环，但实际上第一重循环只执行了一次。故本题答案是14。

知识点：C++部分/数组、指针与引用 /指针与指针变量的概念，指针与地址运算符，指针与数组

16、函数m(x,n) 计算并返回具有n个元素数组x中的最小元素的下标。请填空。 int m(int *x,int n) {

int i=0,j;

for(j=0;j

答案：i=j;

本题考查的是基本算法。

解题思路是：只是一个求小值下标的程序，先假设第一元素是最小的，然后分别与后面元素比较，如果其中一个更小，则把其下标赋给i。所以答案是i=j。

知识点：C++部分/掌握函数的有关使用/函数的类型和返回值

17、非成员函数必须声明为类的______才能访问这个类的private成员。答案： 1：友元函数

本题考查的是友元函数。

友元提供了不同类或对象的成员函数之间、类的成员函数与一般函数之间进行数据共享的机制。对于一个类可以利用friend将一般函数、其它类成员函数或者其它类声明为友元。友元的声明可以放在类的任何一个区域。但是友元的实现不可以在类内部。

知识点：C++部分/熟练掌握类与对象的相关知识/友元函数和友元类_ 18、含有纯虚函数的类称为______。答案： 1：抽象类

本题考查的是抽象类的概念。

拥有纯虚函数的类成为抽象类。抽象类不能用来定义对象。如果一个抽象类的派生类没有重定义来自基类的某个纯虚函数，则该函数在派生类中仍是纯虚函数，该类仍为抽象类。

知识点：C++部分/掌握类的继承与派生知识/虚基类

19、已知int DBL(int n){return n+n;}和long DBL(Long n){return n+n;} 是一个函数模板的两个实例，则该函数模板的定义是______。答案： 1：[YY]templateT DBL(T n){return n+n;} 本题考查的是函数模板的用法。

声明一个函数模板的格式如下：template<模板形参表声明><函数声明>，模板函数的调用是可以省略实参模板的。但是实参模板的省略是有条件的。如果从模板函数实际参数列表获得的信息有矛盾，则不能省略实际参数模板。知识点：C++部分/模板/简单了解类模板的定义和使用方式 20、表达式cout<<'\\n'还可以表示为：______。答案： 1：[YY]cout<

本题考查的是输入输出流的概念。

cout<<'\\n'表示输出一个换行符，与cout<

z=!(x!=y)||(y==z);

已知x=false,z=true，则y=______。

答案： false

本题考查的是逻辑变量的运算以及他们之间的优先级关系。

C++语言提供了三种逻辑运算符，它们是：!（逻辑非）、&&（逻辑与）、||（逻辑或）。其中!为单目运算符，&&和||为双目运算符。它们之间优先级从高到低依次为：!，&&，||。

知识点：C++部分/数据类型、表达式和基本运算/掌握C++数据类型及其定义方法 22、执行下列语句后，输出结果为______。 int x=0,y=2,z=3; switch(x) {

case 0:switch(y) {

case 1:cout<<'*';break; case 2:cout<<'%';break; }

case 1:switch(z) {

case 1:cout<<'$';break; case 2:cout<<'*';break; default:cout<<'#'; } }

答案： %\\#

本题考查的switch语句的使用。

解题思路为：首先判断x的值，题中x的值为0然后判断y的值，y的值为2，所以先输出\，而case 0后面没有break语句，所以再判断z的值，这样又输出\。知识点：C++部分/C++的基本语句/用switch语句实现多分支选择结构 23、执行下列程序后，写出程序的输出结果______。 #include using namespace std; int main() {

int a=3; int &b=a; b++;

cout<

答案： 4

本题考查的是引用的使用。

引用实际上是为一个为变量起个别名，其后对其的任何操作都相当于对原变量

的操作。所以最后输出4。

知识点：C++部分/数组、指针与引用 /引用的基本概念，引用的定义与使用 24、下面程序的功能是将形参x的值转换为二进制数，所得二进制数的每一位数放在一维数组y中返回，二进制的最低位放在放在下标为0的元素中。请填空。 void f(int x,int y[]) {

int a=0,b; do {

b=x%______; y[a++]=b; x/=2;

}while(x); }

答案： 2

本题考查的是二进制转换的基本算法。解题思路为：把十进制转换为二进制每次把十进制数对2求余，然后将其整除2。所以答案为2。

知识点：C++部分/数组、指针与引用 /指针与指针变量的概念，指针与地址运算符，指针与数组 25、若要把类FriendClass定义为类MyClass的友元类，则应该在类MyClass的定义中加入语句______。

答案： 1：[YY]friend class FriendClass 本题考查的是友元类的声明。

要把一个类声明为另外一个类的友元类，只要在另外一个类中添加如下语句：friend class 类名；所以本题答案为：\。知识点：C++部分/熟练掌握类与对象的相关知识/友元函数和友元类_ 26、类继承中，缺省的继承方式是______。答案：私有继承

本题考查的是继承的基本概念。

类的继承方式有公有、保护、私有三种。默认的继承方式为私有继承。知识点：C++部分/掌握类的继承与派生知识/继承基类的数据成员与成员函数 27、经常和一个运算符连用，构成一个运算符函数名的C++关键字为______。答案： 1：[YY]operator

本题考查的是操作符重载的一些概念。运算符重载一般是和operator结合使用的。知识点：C++部分/了解多态性概念/了解运算符重载 28、C++中的多态性分为编译时的多态性和运行时的多态性，其中运行时的多态性时通过______实现的。答案：虚函数

本题考查的是多态性的基本概念。

多态性分为编译时多态性和运行时多态。编译时多态性是通过函数重载实现的，运行时多态性是通过虚函数实现的。

知识点：C++部分/了解多态性概念/虚函数机制的要点_ 29、C++中预定义标准输入流对象是______。答案： 1：[YY]cin

本题考查的C++的预定义流对象。

C++中有4个标准的流对象。cin，cout，cerr，clog。故本题填\。知识点：C++部分/输入输出流/掌握C++流的概念

30、在面向结构程序设计语言中，______是程序组成的基本单位。答案：函数

本题考查的是面向对象和面向结构两种程序实际方法的区别。

在面向对象程序设计语言中，类是程序组成的基本单位。面向结构程序设计语言以函数作为程序组成的基本单位。

知识点：C++部分/C++语言概述/了解C++语言的基本符号 31、C++中，一个float类型的变量占______个字节。答案： 4

本题考查的是基本变量类型的基本概念。

一个int类型变量占4个字节，一个float类型变量占4个字节，一个double类型的变量占8个字节。

知识点：C++部分/数据类型、表达式和基本运算/掌握C++数据类型及其定义方法 32、下列语句段的输出结果是______。 int k=1,n=10,m=1; while(k<=n) {

m*=2; n--; }

cout<

答案： 1024

本题考查基本的循环语句。

while循环是当型循环，本题的条件是k<=n；k的初始值为1，而每次循环都会执行n--，循环执行10次，故最后输出1024。

知识点：C++部分/C++的基本语句/用while语句实现循环结构 33、执行下列语句段后程序的输出结果是______。 int a[]={1,2,3,4,5}; int *pa=a;

cout<<*(++pa)<

答案： 2

本题考查数组和指针的基本概念。

数组名实际上是数组第一个元素的地址。对于本题pa=a，将a[0]的地址赋予pa，cout<<*(++pa)<

34、定义字符指针char *s=\，已知sizeof(s)=4，则strlen(s)=______。答案： 5

本题考查的是字符串函数。

函数strlen（字符指针），求的是字符指针所指向当前字符串的实际长度，不包括'\\0'。

知识点：C++部分/数组、指针与引用 /熟练掌握常用字符串函数 35、执行下列程序段以后程序的输出是______。 void add(int &a) { a++; }

int main() {

int b=3; add(b);

cout<

答案： 4

本题考查的是函数的调用和参数传递。c++的参数传递包括传值与传地址两种。前者是默认的参数传递方式。如果调用函数时，须要改变实参或者返回多个值，就应该采用传地址方式。传递指针属于显式的传地址方式，传递引用属于隐式的传地址方式。本题采用的是传递引用，所以实参被改变。

知识点：C++部分/数组、指针与引用 /引用的基本概念，引用的定义与使用 36、在c++中，每个类都有一个隐含的指针叫______指针。答案： this

本题考查的是this指针的基本概念。

c++提供了一个特殊的对象指针－－－this指针，它是成员函数所属对象的指针，指向当前类对象的地址。

知识点：C++部分/熟练掌握类与对象的相关知识/this指针的使用

37、在一个类成员函数声明的前面加上______修饰，即把该函数声明为虚函数。答案：virtual

本题考查虚函数的声明。

在C++中，运行时的多态性通过虚函数来实现的，在成员函数的声明前面加上virtual，即把该函数声明为虚函数。虚函数可以是另一个类的友元函数，但是不得是静态成员函数。

知识点：C++部分/了解多态性概念/虚函数机制的要点_ 38、重载的关系运算符和逻辑运算符返回值类型是______。

答案： bool

本题考查的是运算符重载的一些概念。 C++把重载的运算符看做特殊的函数，称为运算符函数。对于关系运算符和逻辑运算符的重载返回值类型应该是bool型的。

知识点：C++部分/了解多态性概念/了解运算符重载

39、模板形参分为两种类型：虚拟类型参数和______参数。答案：常规

本题考查模板参数的一些概念。

模板形参分为虚拟类型参数和常规类型参数。虚拟类型参数必须用typename或者class定义，对应的实参应该是double、int等具体的类型修饰符。常规参数用具体的类型修饰符号（如int、double）定义，对于的实参必须是常量表达式。知识点：C++部分/模板/简单了解类模板的定义和使用方式 40、表达式8&3的结果是______。答案： 0

相当于二进制1000和0011进行与运算，答案为0000（即十进制的0）。

知识点：C++部分/数据类型、表达式和基本运算/掌握C++运算符的种类、运算优先级和结合性 41、已知'A'～'Z'的ASCII码为65～90，当执行\ch＝14*5+2；cout<

ASCII码为72的字符为'H'。在系统容许的情况下，赋值符\总是试着将右边的表达式向左边变量的类型转换。

知识点：C++部分/输入输出流/掌握C++流的概念

42、若需要把一个函数\；\定义为一个类AB的友元函数，则应在类AB的定义中加入一条语句：______。答案： friend void F( );

友元函数定义时在函数前面加上关键字friend。

知识点：C++部分/熟练掌握类与对象的相关知识/友元函数和友元类_

43、使用const语句定义一个标识符常量时，则必须对它同时进行______。答案：初始化

定义常量必需对其进行初始化。

知识点：C++部分/数据类型、表达式和基本运算/了解C++的常量定义 44、将两个字符串连接起来组成一个字符串时，用______函数。答案： strcat

函数strcat的作用是将两个字符串连接起来组成一个字符串。知识点：C++部分/数组、指针与引用 /熟练掌握常用字符串函数

45、假定P所指对象的值为25，p+1所指对象的值为46，则执行\；\语句后，P所指对象的值为______。答案： 26

本题考查的是指针使用。

(*p)++首先是将p所指向的内存单元的数值取出，然后加1。故本题答案为26。

知识点：C++部分/数组、指针与引用 /指针与指针变量的概念，指针与地址运算符，指针与数组

46、基类中被说明为______的成员只能被其派生类的成员函数访问，不能被外界函数访问。

答案：protected

基类中被说明为protected的成员只能被其派生类的成员函数访问，不能被其它的函数访问。

知识点：C++部分/熟练掌握类与对象的相关知识/类的定义方式、数据成员、成员函数及访问权限

47、字符串\在内存中存放时，占用______个字节的空间。答案： 12

字符串中有一个字符串的结束符'\\0'，需要占一个字节的空间。知识点：C++部分/数组、指针与引用 /了解字符串与字符数组 48、用new动态申请的内存空间，必须用______来释放。答案： delete

用new动态申请的内存空间，必须用delete来释放。new和delete是相对应的。知识点：C++部分/数组、指针与引用 /动态存储分配

49、设px是指向一个类动态对象的指针变量，则执行\；\语句时，将自动调用该类的______函数。答案：析构

析构函数是用于取消对象成员函数，当一个对象作用域结束时，系统自动调用析构函数。

知识点：C++部分/熟练掌握类与对象的相关知识/构造函数与析构函数

50、说明指向______类型的指针，说明以后，这个指针就可指向各种不同类型的数据对象。答案： void

空类型void用于显示说明一个函数不返回任何值。还可以说明指向void类型的指针，说明以后，这个指针就可指向各种不同类型的数据对象。

知识点：C++部分/数据类型、表达式和基本运算/掌握C++数据类型及其定义方法 51、在下面函数的横线处填上适当的内容，使该函数能够利用递归方法求解字符串str的长度（不得使用系统提供的字符串处理函数）。 int GetLen(char*str) {

if( )return ; else return 1+GetLen(str+1); }

答案： 2：0

本题主要考查了递归算法。

要计算字符串str的长度，其基本思想是，如果当前指针指向NULL，则字符串长度为零，否则字符串长度为从下一个字符开始到字符串结束的字符串的长度+1。故第一空为str==NULL，第二空为 0。

知识点：C++部分/数组、指针与引用 /了解字符串与字符数组 52、下列程序的输出结果是。 #include #include using namespace std;

void fun(const char *s,char &c){c=s[strlen(s)/2];} int main() {

char str[]=\ char ch=str[1]; fun(str,ch); cout<

由于在函数fun中，参数c采用了按地址传递方式。在函数fun中的任何改变都将得到返回。当执行函数fun(str,ch)时，strlen(s)=6，c=s[3]，即c='C'，故ch亦为C。所以本题输出为C。

知识点：C++部分/数组、指针与引用 /熟练掌握常用字符串函数

53、在下面程序的横线处填上适当的内容，使程序执行后的输出结果为1/2005。 #include class Date {

public:

Date(int m=1,int y=0):month(m),year(y){} void Print(){cout<

int month,year; };

operator +(const Date& d1,const Date&d2) {

int year,month;

year=d1.year+d2.year; month=d1.month+d2.month; year+=(month-1)/12; month=(month-1)+1; return Date(month,year); }

void main() {

Date d1(3,2004),d2,d3(10); d2=d3+d1; d2.Print(); }

答案： friend Date Date

本题主要考查了运算符的重载及友元运算符的使用。

对于运算符重载有两种实现方式，由\Date&d2);\知，此处必定采用了友元函数的方式。由\知该运算的返回结果为一Date型的变量，故第一空应填friend Date.在友元函数实现时，前面不需要添加friend关键字，故第二空应为Date。

知识点：C++部分/了解多态性概念/了解运算符重载

54、在下面程序的横线处填上适当的内容，使程序执行后的输出结果为ABCD #include using namespace std; class A {

public:

A(){cout<<'A';} };

class B: {

public:

B(){cout<<'B';} };

class C: {

public:C(){cout<<'C';} };

class D:public B,public C {

public:D(){cout<<'D';} };

void main(){D obj;}

答案： 1：[YY]virtual A#virtual public A#virtual private A#virtual protected A

2：virtual A#virtual public A#virtual private A#virtual protected A

本题主要考查了虚基类的使用。

由于每执行一次A的构造函数，都将输出一个字符A，而输出结果中只有一个A，且第一个输出为A，D继承自B，可知必有B继承自A。由题面知C必继承自某个类，这

里C只能是继承自A，要保证输出中只有一个A，A必须为虚基类，故本题两空均为virtual A。

知识点：C++部分/掌握类的继承与派生知识/虚基类

55、Staff类含有int型数据成员ID，两个Staff对象相等是指它们的ID相同。下面的函数重载了运算符==，它用来判断两个Staff对象是否相等，相等时返回true，否则返回false。请将横线处缺失部分补充完整。 bool Staff::Staff==(const Staff&s) {

return ( ); }

答案： 1：[YY]ID==s.ID#s.ID=ID 本题主要考查了==运算符的重载。由题面的意思知，如果两个Staff类对象中的数据成员ID的值相等，则表示这两个对象相等。因此该空应填ID==s.ID或其等效形式。知识点：C++部分/了解多态性概念/了解运算符重载

56、以下函数模板max的功能是：返回数组a中最大元素的值。请将横线处缺失部分补充完整。

template T max(T a[],int n) {

T m=a[0];

for(int i=1;im) ; return m; }

答案： 1：[YY]m=a[i]#m=*(a+i)#m=*(i+a)

本题主要考查了在一个数组中求取最大数的算法。

在程序中，首先将a[0]标识为最大数，然后循环比较各个数，如果该数大于当前的最大值，则将最大值置为该数。故本空应填m=a[i]。知识点：C++部分/模板/简单了解函数模板的定义和使用方式 57.下面程序的执行结果是 #include #include using namespace std; void main() {

cout<

答案： 1：[YY]xxxxxHello

本题主要考查了如何用格式控制数据的输入输出。在主函数main中，由于执行了cout<

出，如果不足10个字符，将以\填充，故本题输出应为xxxxxHello。知识点：C++部分/输入输出流/能够使用格式控制数据的输入输出

58、下列函数的功能是判断字符串str是否对称，对称则返回true，否则返回false。请在横线处填写上适当的内容，实现该函数。 bool fun(char *str) {

int i=0,j=0;

while(str[j])______;

for(j--;i

答案： 1：j++#++j#j=j+1#j=1+j 2：>=

本题主要考查了字符串回文算法。 while循环用来统计字符串的长度，故第一空应为j++，循环判断str[j]是否为0，从而统计出字符串的长度。for循环实现字符串第i个字符与倒数第i个字符的比较，如果两者相等，则继续比较，否则结束循环。当结束循环时，如果i>=j，则说明一圈已比较结束，该字符串回文，否则说明字符串不回文，故第二空应为>=。知识点：C++部分/输入输出流/能够使用格式控制数据的输入输出 59、执行下列语句序列 int x=10,&r=x;

cout<

本题主要考查了引用类型。

在本题中，首先定义了一个变量x，并初始化为10，然后为x添加一个别名r。第二条语句将依次输出x的值，'-'，及r的值，而r是x的别名，故也输出x的值，故本题答案为10-10。

知识点：C++部分/输入输出流/能够使用格式控制数据的输入输出 60、下列程序的输出结果为 Object id=0 Object id=1

请将程序补充完整。 #include using namespace std; class Point {

public:

Point(int xx=0,int yy=0){X=xx;Y=yy;countP++;} ~Point(){countP--;} int GetX(){return X;}

int GetY(){return Y;} static void GetC() {

cout<<\ }

private: int X,Y;

static int countP; };

______ //静态数据成员的初始化 int main() {

Point::GetC(); Point A(4,5); A.GetC(); return 0; }

答案： 1：int Point::countP=0;

本题主要考查了静态成员的初始化。

在本题中，由于第一个输出为Object id=0，而执行该输出的语句为Point::GetC()，在该语句前没有对Point进行过实例化（即没有执行过构造函数），根据静态函数的内容可知，该函数仅将静态成员变量countP的值输出，故该静态成员变量应该初始化为0。在对静态成员变量进行初始化时，其格式是：类型名类名::成员变量名=初始值;

故本题的答案为:int Point::countP=0;。注意，前面不能加static。

知识点：C++部分/输入输出流/能够使用格式控制数据的输入输出

61、非成员函数应声明为类的______函数才能访问这个类的private成员。答案： 1：友元#friend

本题主要考查了友元函数的概念。

在C++中，一个类的private成员不能被该类的外部代码（包括非成员函数）所访问，除非将该函数或类声明为当前类的友元函数或友元类。故本题答案为\友元\或\。

知识点：C++部分/输入输出流/能够使用格式控制数据的输入输出 62、派生类中的成员不能直接访问基类中的______成员。答案： 1：私有

本题主要考查了类中成员变量的访问权限。

在类中，声明为public型的成员变量将能被所有对象访问，声明为protected的成员只能被其子类访问，而private型的成员只能被该类内部的成员访问。故派生类不能直接访问基类的private(私有)成员，除非声明为友元类。知识点：C++部分/输入输出流/能够使用格式控制数据的输入输出

63、下列程序的输出结果为2，请将程序补充完整。 #include using namespace std; class Base {

public:

______ void fun(){cout<<1;} };

class Derived:public Base {

public:

void fun(){cout<<2;} };

int main() {

Base *p=new Derived; p->fun(); delete p; return 0; }

答案： 1：virtual

本题主要考查了C++中的虚拟函数。在C++中，如果声明一个类的成员函数为虚拟函数，则一个对象在调用该函数时将根据该对象实际类型调用相应的成员函数，而不是根据其指针所代表的类类型进行调用。在本题中，指针p所指的变量实际上是一个Derived类型的对象，在执行p->fun();时，将调用类Derived的成员函数fun，而不是调用Base的fun函数。知识点：C++部分/输入输出流/能够使用格式控制数据的输入输出

64、请将下列类定义补充完整。

class Base{public:void fun(){cout<<\class Derived:public Base {

public:

void fun() {

______ //显式调用基类的fun函数 cout<<\ } };

答案： 1：Base::fun();

本题主要考查了子类对基类中函数的调用。

要在子类中显式的调用基类中的函数，只要在函数名前加上基类的限定运算符就可以了，即本题的答案为Base::fun();。

知识点：C++部分/输入输出流/能够使用格式控制数据的输入输出

65、多数运算符既能作为类的成员函数重载，也能作为类的非成员函数重载，但[]运算符只能作为类的______函数重载。答案： 1：成员

本题主要考查了C++中运算符的重载。

在C++中，可以对操作符进行重载，但对于有些运算符不能进行重载，

如::,?:,->*等，有些运算符可以重载，但不能改变其原有语义，如->，有些运算符只能作为成员函数重载，如[]。

知识点：C++部分/输入输出流/能够使用格式控制数据的输入输出

66、下面是一个栈类的模板，其中push函数将元素i压入栈顶，pop函数弹出栈顶元素。栈初始为空，top值为0，栈顶元素在stack[top-1]中，在下面横线处填上适当语句，完成栈类模板的定义。 template class Tstack {

enum{size=1000}; T stack[size]; int top; public:

Tstack():top(0){} void push(const T&i) {

if(top

stack[top++]=i; }

T pop() {

if(top==0)exit(1); return ______; } }; 答案： 1：stack[--top]#stack[top-=1]#stack[top=top-1]#stack[top=-1+top] 本题主要考查了堆栈的操作。

由于在本算法中，栈顶元素为stack[top-1]，故要弹出栈顶元素，必须要先将top的值减1，然后取出stack[top]中的元素，能够一次性完成该操作的表达式为stack[--top]或stack[top-=1]或其它类似表示。

知识点：C++部分/输入输出流/能够使用格式控制数据的输入输出 67、有一种只在循环语句或switch 语句中使用的流程控制语句，表示该语句的关键字是______。

答案： 1：break

本题主要考查了break语句。

break语句只能用于循环语句（表示跳出循环）或switch语句（表示跳出当前分支）。

知识点：C++部分/C++的基本语句/用switch语句实现多分支选择结构 68、程序中有如下语句

for(int i = 0;i<5;i++)cout<<*(p+i)<<\

能够依次输出int型一维数组DATA的前5个元素。由此可知，变量p 的定义及初始化语句是______。

答案： 1：int *p=DATA;

本题主要考查了指针与指针变量的概念，指针与地址运算符，指针与数组。首先，p是一个指向整型数据的指针，其次，要能够循环打印出DATA中的元素，必须将p指向数组DATA的首地址，而数组变量本身就表示数组元素的首地址，故本题应填int *p= DATA。

知识点：C++部分/数组、指针与引用 /指针与指针变量的概念，指针与地址运算符，指针与数组

69、若下面程序运行时输出结果为 l,A,10.1 2,B,3.5

请将程序补充完整。 #include using namespace std; int main() {

void test(int,char,double【8】); test(1,'A',10.1); test(2,'B'); return 0; }

void test(int a,char b,double c) {

cout<

答案： 1：c=3.5

本题主要考查了函数的调用。

由于存在两个test函数的调用，一个有2个参数，一个有3个参数，而test函数并没有重载，故test函数的参数中必有一个缺省参数。根据第二个输出中有\知，该缺省参数为3.5，故本题应填\。

知识点：C++部分/掌握函数的有关使用/函数的定义方法和调用方法 70、有如下类声明：

class MyClass {

int i; private : int j; protected :int k; public : int m,n; };

其中，私有成员的数量为______。答案： 1：2

本题主要考查了类的定义方式。

在用class关键字定义类时，如果未指定数据的访问类型，默认情况下为\，故本题一共有i，j两个私有数据成员。

知识点：C++部分/熟练掌握类与对象的相关知识/类的定义方式、数据成员、成员函数及访问权限 71.如下程序：

#include using namespace std; class Con {

char ID; public:

Con():ID('A'){cout<<1;}

Con(char ID):ID(ID){cout<<2;}

Con(Con& c):ID(c.getID()){cout<<3;} char getID()const{return ID;} };

void show(Con c){cout<

Con c1; show(c1); Con c2('B'); show(c2); return 0; }

执行上面程序的输出是______。答案： 1：13A23B

本题主要考查了构造函数。

首先主程序中代码\执行一次构造函数（由于在创建对象时没有参数，故调用第一个构造函数），输出\，然后调用show方法时，由于参数是按值传递，故要调用拷贝构造函数输出3，最后在show函数中输出成员变量ID，此时ID的值为A，

输出'A'；执行\时，调用第二个构造函数，输出2，然后调用拷贝构造函数输出3，最后调用show方法输出ID的值'B'，故本题输出为\。知识点：C++部分/熟练掌握类与对象的相关知识/构造函数与析构函数 72、有如下程序： #include using namespace std; class ONE {

public :

virtual void f(){cout<<\};

class TWO : public ONE {

public:

TWO(){cout<<\};

class THREE : public TWO {

public :

virtual void f(){TWO::f();cout<<\};

int main() {

ONE aa,*p; TWO bb; THREE cc; p=&cc; p->f(); return 0; }

执行上面程序的输出是______。答案： 1：2213

本题主要考查了构造函数. TWO bb将定义一个TWO型对象bb，这时需调用TWO的构造函数，在该构造函数中，将输出\；Three cc将定义一个THREE型对象cc，这时需调用THREE的构造函数，而该函数为缺省构造函数，其将调用父类TWO的构造函数，在该构造函数中，将输出\；由于p采用指针方式调用成员函数f，而f在基类中被声明为虚拟函数，故函数f的执行与指针p所指向对象的实际类型相一致，p指向一个THREE型对象cc，故执行p->f()时，将执行THREE的f函数，在该函数中，首先直接调用了父类TWO的函数f，而在TWO中直接继承了ONE类的f函数，故先要执行ONE的f函数，输出1，然后再输出3。知识点：C++部分/熟练掌握类与对象的相关知识/构造函数与析构函数

73、有如下程序： #include using namespace std; class PARENT {

public:

PARENT(){cout<<\};

class SON:public PARENT {

public:

SON(){cout<< \};

int main( ) {

SON son; PARENT *p; p=&son; return 0; }

执行上面程序的输出是______。答案： 1：PARENTSON

本题主要考查了继承基类的数据。

创建SON型对象将导致SON的构造函数被执行，而执行SON构造函数时，首先要执行其父类的构造函数，故应先输出\，然后输出\；p是一个指向PARENT型的指针，对其赋值不会引起构造函数的执行，故本题输出为\。知识点：C++部分/掌握类的继承与派生知识/继承基类的数据成员与成员函数

74、若以非成员函数形式，为类Bounce重载\运算符，其操作结果为-bool型数据，则该运算符重载函数的原型是______。

答案： 1：bool operator!(const BOUNCE);#friend bool operator!(const BOUNCE);

本题主要考查了函数重载。

由于是采用非成员函数的方式（友元函数方式）重载了\运算符，故必须有一个参数；由于是对BOUNCE类进行\运算符重载，故参数类型为BOUNCE，而对于\运算，逻辑上应该不会改变BOUNCE对象的内容，故最好应用\限定参数，当然，不作const限定也应该是正确的，而friend关键字不是函数原型的一部分，故可以省略。

知识点：C++部分/掌握函数的有关使用/函数重载

75、下面是复数类complex的定义，其中重载的运算符\的功能是返回一个新的复数对象，其实部等于两个操作对象实部之和，其虚部等于两个操作对象虚部之和；请补充完整：

class complex {

double real ; //实部 double imag ; //虚部 public :

complex(double r ,double i):real(r),imag(i){} complex operator+(complex a ) {

return complex( ______ ); } };

答案： 1：real+a.real,imag+a.imag

本题主要考查了形式参数与实在参数，参数值的传递。根据复数+的运算规则，实数部分为各加数实数部分之和，虚数部分为各加数虚数部分之和。在类complex中，构造函数的第1、2个参数分别表示复数类型的实部与虚部，内部数据成员real与imag分别用来存入复数类型的实部、虚部，故只要将两个complex的\之和\和\之和\分别作为结果complex对象构造函数的两个参数就行了，所以应填real+a.real,imag+a.imag或等效形式。

知识点：C++部分/掌握函数的有关使用/形式参数与实在参数，参数值的传递 76、已知一个函数模板定义为

template T1 FUN(T2 n){return n*5.0;}

若要求以int型数据7 为函数实参调用该模板函数，并返回一个double 型数据，则该调用应表示为______。

答案： 1：FUN(7) 评析：

本题主要考查了模板函数。

由于FUN是一个模板函数，根据模板函数的定义知，函数返回T1类型，参数是T2类型，故在实例化该模板函数时，两个模板实参分别为double,int，函数本身的参数为7，所以调用形式应为FUN(7)。等级：1 难度：1

知识点：C++部分/模板/简单了解函数模板的定义和使用方式 77、若有定义语句：int *a,b;，则变量b的数据类型是______。答案： 1：整型#int 评析：

本题考查的是变量的定义。

int *a,b;把a定义为一个int类型的指针；把b定义为一个整型变量。等级：1 难度：1

知识点：C++部分/数据类型、表达式和基本运算/掌握变量的定义与使用方法 78、已知数组a中的元素个数为n，下列语句的作用是将下标为i的元素移动到下标为

i-1的单元，其中1<=i

本题考查循环的基本应用。

解题思路为：循环条件是i

if(n<=1) return 1; //递归结束情况 else return n*f(n-2); //递归}

则函数调用语句f(5)的返回值是______。答案： 1：15

本题主要考查了递归算法。

函数每次将f(n)的值转换成相应的关系式n*f(n-2)，直到f(1)时为止。所以f(5)=5*f(5-2)=5*3*f(1)=5*3*1=15。

知识点：C++部分/掌握函数的有关使用/递归函数

80、创建对象数组时，对数组的每一个元素都将调用一次构造函数，如果没有显式给出数组元素的初值，则调用缺省构造函数。下列程序涉及到对象数组的创建和单个对象的创建，其输出结果是______。 #include using namespace std; class Foo{ public:

Foo(int x){cout<<'A';} Foo(){} };

int main() {

Foo f[3],g(3); return 0; }

答案： 1：[YY]A

本题考查的是类的对象数组和成员对象。

从程序可以看出f[3]是类Foo的一个对象数组，因为f[3]没有显式的给定初值，所以系统自动调用缺省构造函数Foo()；在定义类Foo的对象g(3)时，执行相应的构造函数Foo(int x)，输出字母A。

知识点：C++部分/熟练掌握类与对象的相关知识/对象数组与成员对象 81、己知下列程序的输出结果是42，请将画线处缺失的部分补充完整。

#include using namespace std; class Foo{ int value; public:

Foo():value(0){}

void setValue(int value)

{______=value;} //给Foo的数据成员value赋值 void print(){cout<

int main() {

Foo f;

f.setValue(42); f.print(); return 0; }

答案： 1：this->value#Foo::value#(*this).value

本题考查的是this指针。

this指针，它是成员函数的所属对象的指针，它指向类对象的地址。本题要输出42，也就是要把f.setValue(42);中的42赋值给Foo的数据成员value，因此横线处缺少的是给Foo的数据成员value赋值的语句，所以答案为this->value或Foo::value。

知识点：C++部分/熟练掌握类与对象的相关知识/this指针的使用

82、如果不使用多态机制，那么通过基类的指针虽然可以指向派生类对象，但是只能访问从基类继承的成员。下列程序没有使用多态机制，其输出结果是______。 #include using namespace std; class Base{ public:

void print(){cout<<'B';}}; class Derived:public Base{ public:

void print(){cout<<'D';}}; int main() {

Derived*pd=new Derived(); Base*pb=pd; pb->print(); pd->print(); delete pd;

return 0; }

答案： 1：[YY]BD

本题考查的是派生类。

派生类Derived由基类Base公有继承而来，是基类的子类型。调用pb->print();后，执行基类的函数void print()，因为尽管pb的函数print()可以对类Base的公有派生类Derived的对象pd进行操作，但是只能使用从基类Base中继承的成员；调用pd->print();后，执行派生类的函数void print()。知识点：C++部分/C++语言概述/了解C++语言的基本符号

83、在声明派生类时，如果不显式地给出继承方式，缺省的类继承方式是私有继承private。已知有如下类定义： classe Base{ protected:

void fun(){} };

class Derived:Base{};

则Base类中的成员函数fun()，在Derived类中的访问权限是______。（注意：要求填写private、protected或public中的一项）。答案： 1：[YY]private 本题考查的是派生类。

派生类的继承方式如果不显式的给出，缺省的继承方式是私有继承private。派生类从基类私有继承时，基类的公有成员和保护成员在派生类中都改变为私有成员。知识点：C++部分/掌握类的继承与派生知识/派生类的定义和访问权限

84、在MyClass类的定义中，对赋值运算符=进行重载。请将画线处缺失的部分补充完整。

______ MyClass::operator=(const MyClass& rhs) {

if(this==&rhs) return *this; value=rhs.value; return *this; }

答案： 1：[YY]MyClass&

本题考查的是运算符的重载。一个类如果要重载运算符=，通常也就需要定义自己特有的拷贝构造函数。可以在类体中增加：(const & operator MyClass& rhs);然后在MyClass的类体外给出它的完整定义：

MyClass & MyClass::operator=(const MyClass& rhs) {......}

因此在MyClass类的定义中缺少MyClass&语句。知识点：C++部分/掌握函数的有关使用/函数重载

85、插入排序算法的主要思想是：每次从未排序序列中取出的一个数据，插入到已

排序序列中的正确位置。InsertSort类的成员函数sort()实现了插入排序算法。请将画线处缺失的部分补充完整。 class InsertSort{ public:

InsertSort(int*a0,int n0):a(a0),n(n0){} //参数a0是某数组首地址，n是数组元素个数 void sort()

{//此函数假设已排序序列初始化状态只包含a[0]，未排序序列初始为a[1] …a[n-1]

for(int i=1;i

for(______;j>0;--j){ if(t>=a[j-1])break; a[j]=a[j-1];} a[j]=t;}} protected:

int*a,n; //指针a用于存放数组首地址，n用于存放数组元素个数 };

答案： 1：j=i

本题考查的是插入排序。

在Sort函数中，实现函数的插入排序算法，若队列中已有i个数，则向其中插入第i+1个数时，依次与从下标为i-1到下标为0的数比较，如果后面的数小于前面的数，则交换这两个数，否则说明该数已排好序，直接跳出内层循环，故此空应填j=i。知识点：C++部分/C++语言概述/了解C++语言的基本符号 86、下列程序的输出结果是______。 #include using namespace std; class A{ int a; public:

A():a(9){}

virtual void print() const{cout<

class B:public A{ char b; public:

B(){b='S';}

void print() const{cout<

void show(A&x){x.print();}

int main() { A d1,*p; B d2; p=&d2;

d1.print(); d2.print(); p->print(); show(d1); show(d2); return 0; }

答案： 1：[NN]9SS9S

本题主要考查了缺省构造函数。

在d1、d2定义时分别调用它们的构造函数。调用d1.print();后，执行类A的virtual void print()函数；调用d2.print();后，执行派生类B的构造函数void print()；调用p->print();后，执行执行派生类B的构造函数void print()；调用show(d1);后，调用函数show(A&x)，再调用类A的virtual void print()函数；调用show(d2);后，调用函数show(A&x)，再调用派生类B的构造函数void print()。知识点：C++部分/C++语言概述/了解C++语言的基本符号 87、C++中只有两个逻辑常量：true和______。答案： 1：false

本题考查的是逻辑变量。

在C++中引进了两个逻辑变量，true与false。

知识点：C++部分/数据类型、表达式和基本运算/掌握变量的定义与使用方法 88、若要访问指针变量p所指向的数据，应使用表达式______。答案： 1：*p

本题考查的是指针的应用。

要访问一个指针所指向的数据，应该用*运算符。

知识点：C++部分/数组、指针与引用 /指针与指针变量的概念，指针与地址运算符，指针与数组

89、已知一个函数的原型是： int fn(double x);

若要以5.27为实参调用该函数，应使用表达式______。答案： 1：fn(5.27)

函数的调用形式为：<函数名> (<实参表>)

当调用一个函数时，其实参的个数、类型及排列次序必须与函数定义时的形参一致，也就是说实参与形参应该一对一地匹配。

知识点：C++部分/掌握函数的有关使用/函数的定义方法和调用方法 90、有如下定义： class MA{ int value;

public:

MA(int n=0):value(n){} };

MA *ta,tb;

其中MA类的对象名标识符是______。答案： 1：tb

ta是一个指向MA对象的指针，它不是对象名标识，tb是一个MA对象的标识。知识点：C++部分/数组、指针与引用 /指针与指针变量的概念，指针与地址运算符，指针与数组

91、如下类定义中包含了构造函数和拷贝构造函数的原型声明，请在横线处填写正确的内容，使拷贝构造函数的声明完整。 class myClass{ private: int data; public:

myClass(int value); //构造函数

myClass(const ______anotherObject); //拷贝构造函数 }

答案： 1：myClass &

拷贝函数的参数必须为其所对应类的引用类型。要实现拷贝，首先要保证前后类型一致，其次，不能为非引用类型，否则将递归调用拷贝构造函数。知识点：C++部分/熟练掌握类与对象的相关知识/构造函数与析构函数

92.用来派生新类的类称为______，而派生出的新类称为它的子类或派生类。答案： 1：基类#父类

当类A继承自或派生于类B时，类B称为类A的基类或父类，类A称为类B的子类或派生类。

知识点：C++部分/掌握类的继承与派生知识/继承基类的数据成员与成员函数 93、有如下程序： #include using namespace std; class CA{ public:

CA(){cout<< 'A';} };

class CB:private CA{ public:

CB(){cout<< 'B';} };

int main(){ CA a; CB b;

return 0; }

这个程序的输出结果是______。答案： 1：AAB \a;\语句将导致CA的构造函数被执行，输出\，\b;\语句将导致CB的构造函数执行，由于CB私有继承CA，故在执行CB的构造函数前，先执行CA的构造函数，输出\，然后执行CB的构造函数，输出\。

知识点：C++部分/熟练掌握类与对象的相关知识/构造函数与析构函数

94、若将一个二元运算符重载为类的成员函数，其形参个数应该是______个。答案： 1：一#1

函数可以以成员函数与友元函数这两种不同的方式来重载。对于二元运算符来说，当采用成员函数方式重载时，其实参的第一个参数为该对象本身，即a.operator x(b) 等价于a x b，当采用友元函数重载时，必须要具有两个参数operator x(a,b)等价于axb。（其中x表示运算符）。

知识点：C++部分/了解多态性概念/了解运算符重载 95、有如下程序： #include using namespace std; class DA{ int k; public:

DA(int x=1):k(x){} ~DA(){cout<

int main(){

DA d[]={DA(3),DA(3),DA(3)}; DA *p=new DA[2]; delete []p; return 0; }

这个程序的输出结果是______。答案： 1：11333

定义DA型数组d时，将导致DA的构造函数被执行三次，每次执行时，其传入参数为3，定义DA指针p时，将执行两次默认构函数，其参数为1，执行\时，将执行DA的构造函数，输出p[0].k,p[1].k（两者均为1），在程序运行结束后，将释放局部变量，从而导致数组d中的三个元素被析构，输出d[0],d[1],d[2]中的a值（均为3）。

知识点：C++部分/熟练掌握类与对象的相关知识/构造函数与析构函数 96、C++语言中的多态性分为编译时的多态性和______时的多态性。答案： 1：运行

C++的多态表现在编译时多态与运行时多态两个方面，所谓编译时多态是指源代

码在编译时必须能够确定要执行的代码，如函数的重载，模板等，在编译时必须要知道函数的参数类型，模板的实参等，以使编译器生成唯一的内部标识，对于运行时多态，在程序运行时，根据程序当前的数据环境选择执行不同的代码，如虚拟函数。

知识点：C++部分/C++语言概述/了解C++语言的词汇

97、若有定义语句：int a=3,b=2,c=1;，则表达式a

本题考查的是运算符的优先级。

首先a=3,b=2，判断a

知识点：C++部分/数据类型、表达式和基本运算/熟练掌握C++表达式类型及求值规则

98、执行下列语句后，变量sum的值是______。 int sum = 0;

for (int i=1;i<=3;i++) for (int j=1;j<=i;j++) sum++; 答案： 1：6

本题考查的是for语句。本题sum的执行过程是：

当i=1时，内循环中的j的值为1，sum自加一次，此时sum=1；当i=2时，内循环中的j的值为1和2，sum自加两次，此时sum=3；当i=3时，内循环中的j的值为1、2、3，sum自加三次，此时sum=6；所以sum的值为6。

知识点：C++部分/C++的基本语句/用for语句实现循环结构 99、已知有函数f 的定义如下： int f(){

static int s = 0; s+=2; return s; }

则在某程序中第2次执行函数调用语句f();时，函数f的返回值是______。答案： 1：4

本题考查的是static的用法。

static在程序运行的过程中只初始化一次。第一次运行时，s=2 第二次运行时，s=2+2=4 所以答案为4。

知识点：C++部分/数据类型、表达式和基本运算/熟练掌握C++表达式类型及求值规则

100、已知如下程序的输出结果是23，请将画线缺失的部分补充完整。 #include

using namespace std; class MyClass{ public:

void Print() const { cout<<23;} };

int main() {

MyClass*p =new MyClass(); ______.Print(); return 0; }

答案： 1：(*p)

本题考查的是指针。

MyClass*p =new MyClass();是创建一个类MyClass的指针对象。要执行创建的对象，那么(*p).Print();即为执行此对象的方法。

知识点：C++部分/数组、指针与引用 /指针与指针变量的概念，指针与地址运算符，指针与数组 101、有如下程序： #include using namespace std; class A { public:

A(){cout<<\ ~A(){cout<<\};

class B { A a; public:

B(){ cout<< \ ~B(){cout<<\};

int main(){ B b;

return 0; }

程序的输出结果是______。答案： 1：ABBA

本题考查的是类的构造。 main(){B b;

创建类B一个对象b，这时转到类B里去执行类B的构造方法B()，因为在类B里有个全局的类A的对象a，所以在执行构造方法B()之前会先创建类A的对象a，就去执行类A的构造方法A()，输出字符A，再返回到类B执行它的构造方法B()输出字符B，现

在所有的构造方法执行完了，就执行析构方法了，因为析构方法与构造方法的执行顺序相反，所以先执行~B()方法输出字符B，再执行~A()输出字符A。所以输出结果ABBA。

知识点：C++部分/熟练掌握类与对象的相关知识/构造函数与析构函数 102、请在如下程序中的空格处填写正确的语句： # include using namespace std; class Base{ public:

void fun() {cout<<\};

class Derived : public Base{ public:

void fun(){

______; // 调用基类的函数fun() cout<<\ } };

答案： 1：Base::fun() 本题考查的是基类。

本题程序要求运行后输出结果\。通过调用基类函数fun()，即运行Base::fun();输出结果\。

知识点：C++部分/掌握类的继承与派生知识/继承基类的数据成员与成员函数 103、已知类sample 是一个抽象类，其成员函数 display 是无形参、无返回类型的纯虚函数，请完成其声明： class sample{ public:

sample(){}; ______ };

答案： 1：virtual void display()=0; 考查是纯虚函数。

这是一个纯虚函数定义。它的定义格式是：virtual函数返回类型函数名(参数列表)=0，根据题目的意思，返回类型为空，则用void表示函数名为display参数列表为空，则用()表示结合起来，就是virtual void display()=0;（其中0表示无函数体）。

知识点：C++部分/了解多态性概念/纯虚函数与抽象基类、虚函数 104、有如下复数类的声明，请补充完整。 class complex{

double real; //实部 double imag;//虚部

public :

complex(double x,double y){ real=x; imag=y; }

complex operator +(complex c) {//重载加法运算符\ return complex(______); } };

答案： 1：real+c.real,imag+c.imag

using namespace std; class A{ public:

______{cout<<\ };

class B: public A { public:

~B(){cout<<\ };

int main (){ B *p=new B; delete p; return 0; }

答案： 1：~A()

本题考查的是一个带有指针的类的构造方法。 B *p=new B;这个是创建一个类B的指针对象。在创建时因为类B是公共继承类A，所以会先执行类A的构造方法再执行类B的构造方法。因为这两个类没有重载构造方法，用默认的构造方法，默认的构造方法只创建对象不作任何处理，所以没有任何输出。 delete p;是删除这个指针对象，删除对象就是调用析构方法，因为析构方法的执行与构造相反，所以会先调用类B的析构方法~B()输出bb，再调用它的基类A的析

构方法~A()输出aa，所以输出bbaa。

构造方法是以类名为方法名再带参数，比如类A，那么它的构造方法为A()或A(int i)...

析构方法是以~ 加类名为方法名再带参数。比如~A() 或~A(int i)...

知识点：C++部分/数组、指针与引用 /指针与指针变量的概念，指针与地址运算符，指针与数组

106、请将下列栈类Stack补充完整。 class Stack{ private :

int pList[100]; //int 数组，用于存放栈的元素 int top; //栈顶元素（数组下标） public:

Stack():top(0){}

void Push (const int &item);// 新元素item 压入栈 int Pop (void); // 新栈顶元素弹出栈 };

void Stack::Push(const int &item){

if(top==99) // 如果栈满，程序终止} exit(1);

top++; // 栈顶指针增 1 ______; }

int Stack::Pop(){

if (top < 0) // 如果栈空，程序终止 exit(1);

return pList[top--]; }

答案： 1：pList[top]=item 本题考查堆栈的操作。

由于在本算法中，要弹出栈顶元素，要先将新元素item压入栈，然后取出stack[top]中的元素。

如果栈满，if(top==99)，程序终止，栈顶指针增1。如果栈空，程序终止。

按照堆栈先进后的原则，向堆栈压入的数据总是在最上面的，top为最大记数，所以pList堆栈的第top数组位置将被赋值成压入数据。所以答案为pList[top]=item。

知识点：C++部分/掌握函数的有关使用/内联函数 107、在面向对象的程序设计中，将数据和处理数据的操作封装成一个整体就定义了一种事物的类型，称作\类\。类是一种抽象的概念，属于该类的一个实例叫做\。

答案： 1：对象

知识点：C++部分/熟练掌握类与对象的相关知识/对象和对象指针的定义与使用 108、指针数组是由______构成的数组。答案： 1：指针

知识点：C++部分/数组、指针与引用 /指针与指针变量的概念，指针与地址运算符，指针与数组

109、如果使用数组名作为函数参数，形实结合时，传递的是______。答案： 1：数组首地址#数组的首地址#数组第一个元素的地址

知识点：C++部分/数组、指针与引用 /掌握数组的定义、初始化和访问 110、在类的对象被创建的时候，______函数会被自动调用。答案： 1：构造

知识点：C++部分/熟练掌握类与对象的相关知识/构造函数与析构函数 111、在类中，______成员为类的所有对象所共享。答案： 1：静态成员#static成员知识点：C++部分/熟练掌握类与对象的相关知识/静态数据成员与静态成员函数的定义与使用方式

112、有如下程序： #include using namespace std; class Base{ public: int m,n; };

class Derived1: ______ Base{}; class Derived2:public Derived1{ public:

void SetMN(int M,int N){m=M;n=N;} int GetSumNM(){return(m+n);} };

int main(){

Derived2 objD; objD.SetMN(3,4);

cout<<\ return 0; }

编译时只有\有语法错误，程序的其他地方没有语法错误。请判断下划线处使用的关键字是什么。答案： 1：protected

知识点：C++部分/熟练掌握类与对象的相关知识/类的定义方式、数据成员、成员函数及访问权限

113、有如下程序： #include

using namespace std; class Base{ int b; public:

Base(int i){b=i;}

void disp(){cout<<\};

class Base1:virtual public Base{ public:

Base1(int i):Base(i){} };

class Base2:virtual public Base{ public:

Base2(int i):Base(i){} };

class Derived:public Base2,public Base1{ int d; public:

Derived(int i,int j):Base1(j),Base2(j), {d=i;}

void disp(){cout<<\};

int main(){

Derived objD(1,2);objD.disp(); objD.Base::disp(); objD.Base1::disp(); objD.Base2::disp(); return 0; }

请将程序补充完整，使程序在运行时输出： Derived:d=1 Base:b=2 Base:b=2 Base:b=2 答案： 1：[YY]Base(j)

知识点：C++部分/掌握类的继承与派生知识/继承基类的数据成员与成员函数 114、如下程序声明了一个电话号码类PhoneNumber，重载了流插入运算符<<，以便于电话号码的输出。请将程序补充完整。 #include #include #include using namespace std; class PhoneNumber{ public:

void setNumber(string number){this->number=number;} //重载流插入操作符

friend (ostream &output,const PhoneNumber &num) {output<

string number; };

int main(){

PhoneNumber phone;

phone.setNumber(\

cout<<\ return 0; }

答案： 1：ostream& operator<<#ostream&operator<< 知识点：C++部分/输入输出流/掌握C++流的概念

115、如下程序声明了一个二维图形类TwoDShape，从其派生出矩形类Rec。 #include #include using namespace std;

class TwoDShape{ //二维图形类. char name[20]; public:

TwoDShape(char *n=\ strcpy(name,n); }

char *getName(){return name;} =0; };