国家二级(C++)笔试模拟试卷73(题后含答案及解析)

国家二级（C++）笔试模拟试卷73(题后含答案及解析) 题型有：1. 选择题 2. 填空题
选择题（每小题2分，共70分）下列各题A、B、C、D四个选项中，只有一个选项是正确的，请将正确选项涂写在答题卡相应位置上。

1．在一个长度为n的线性表中删除一个元素，最坏情况下需要移动的数据元素数目为( )。

A．1
B．n-1
C．n+1
D．n／2
正确答案：B
解析：在一般情况下，要删除第i个元素时，首先是从第i+1个元素开始，直到第n个元素之间共n-i个元素依次向前移动一个位置，删除结束后，线性表的长度减1。

最坏情况指的是删除线性表的第一个元素，则需要移动表中第1个元素以外所有的元素，答案为B。

2．下列叙述中，正确的是( )。

A．入栈运算只需将新元素插到栈顶指针指向的位置
B．出栈运算只需将栈顶元素赋给一个指定变量
C．出栈运算与读栈顶元素是相同的操作
D．读栈顶元素不删除栈顶元素
正确答案：D
解析：入栈运算需先将栈顶指针加1，然后将新元素插到栈顶指针指向的位置，选项A是错误的。

出栈运算需将栈顶元素赋给一个指定变量，然后将栈顶指针减1，选项B是错误的。

出栈运算与读栈顶元素不同之处在于读栈顶元素不删除栈顶元素。

答案是选项D。

3．在一个单链表HL中，若要向表头插入一个由指针p指向的节点，则需要执行语句序列( )。

A．HL=p；p-＞next=HL；
B．p-＞next=HL；HL=p；
C．p-＞next=HL；p=HL；
D．p-＞next=HL-＞next；HL-＞next=p
正确答案：B
解析：HL为链表的头指针。

HL指示链表中第一个节点的存储位置，在表头插入一个由指针p指向的节点后，头指针指向p，p的指针域指向原链表中第
一个节点
4．已知二叉树的前序序列为ABDCEFG，中序序列为DBCAFEG，则其后序序列为( )。

A．DCBAFGE
B．DCBFGEA
C．DCBFEGA
D．DCBGFEA
正确答案：B
解析：本题先可用排除法，由二叉树的前序序列为ABDCEFG可知：二叉树的根节点为A，因此选项A错误。

通过分析可知，B、E是A的左右子节点，D、C是B的左右子节点，F、G是E的左右子节点。

5．一组记录的排序码为(46，79，56，38，40，84)，则利用快速排序的方法，以第一个记录为基准得到的一次划分结果为( )。

A．38，40，46，56，79，84
B．40，38，46，79，56，84
C．40，38，46，56，79，84
D．40，38，46，84，56，79
正确答案：B
解析：快速排序的思想是：从线性表中选取一元素，如本题中的46，将线性表后面小于46的元素移到前边，而前面大于46的元素移到后边。

本题中46是第一个元素，因此只需将线性表后面小于46的元素移到前边。

6．下列关于严格控制goto语句使用的理解中，错误的是( )。

A．用一个非结构化的程序设计语言实现一个结构化的构造
B．若不使用goto语句会使功能模糊
C．在某种可以改善而不是损害程序可读性的情况下
D．goto语句可以完全不用
正确答案：D
解析：goto语句会造成程序的混乱，但在某些地方goto语句还是需要的，若不使用goto语句会使功能模糊。

7．下面不属于软件设计原则的是( )。

A．抽象
B．模块化
C．自底向上
D．信息隐蔽
正确答案：C
解析：在软件开发过程中，必须遵循软件工程的基本原则。

这些原则使用于
所有软件项目。

这些基本原则包括：抽象、信息隐蔽、模块化、局部化、确定性、一致性、完备性、可验证性。

选项C是错误的，它是一种软件开发的方法，而不属于软件工程的基本原则。

8．规范化理论中消除其中多余的数据相关性是靠分解( )。

A．关系运算
B．内模式
C．外模式
D．视图
正确答案：A
解析：本题考核数据库规范化理论。

数据库规范化的基本思想是逐步消除数据依赖中不合适的部分，根本思想是通过分解关系运算来消除多余的数据相关性。

9．常用的关系运算是关系代数和( )。

A．集合代数
B．逻辑演算
C．关系演算
D．字段
正确答案：C
解析：本题考核关系代数运算。

关系运算包括关系代数和关系演算。

10．源程序中应包含一些内部文档，以帮助阅读和理解源程序，源程序的内部文档通常包括选择合适的标识符、注解和( )。

A．程序的视觉组织
B．尽量不用或少用GOTO语句
C．检查输入数据的有效性
D．设计良好的输出报表
正确答案：A
解析：源程序文档化主要包括3个方面的内容：标识符的命名、程序中添加注释以及程序的视觉组织。

11．下列关于类概念的描述中，错误的是( )。

A．类是抽象数据类型的实现
B．类是具有共同行为的若干对象的统一描述体
C．类是创建对象的模板
D．类就是C语言中的结构类型
正确答案：D
解析：类是创建对象的模板，它包含着所创建对象的状态描述和方法的定义。

类的完整描述包含了外部接口和内部算法以及数据结构的形式。

12．字符串常量”hello”的字符个数是( )。

A．3
B．4
C．5
D．6
正确答案：D
解析：本题考核的是字符串常量这个知识点。

字符串常量实际上是一个数组，组成数据的字符除显式给出的外，还包括字符结尾处标识字符串结束的符号’\0’。

所以字符串的字符个数等于字符个数加1，C++语言编译器会自动在字符串的末尾加上‘\0’，作为字符串结束标识。

故本题答案选项是：D。

13．“or(int x=0，y=0；!x&&y＜=5；y++)”语句执行循环的次数是( )。

A．0
B．5
C．6
D．无数次
正确答案：C
解析：此题是典型的考题。

题中x=0，则!x永远为真，对于条件表达式“!x&&y ＜=5”只考虑“y＜=5”，由于每次循环y都增加1，而且y从0开始到5。

所以可知，总共循环了6次。

14．有如下程序段，请指出”p所代表的是( )。

int **p，*s，k=20；S = &k；p = &s；
A．s
B．&k
C．*p
D．k
正确答案：D
解析：在程序中，指针变量p是int类型的指针类型。

从程序中可看出：①赋值语句“s=&k；”，使s指向k，即s的值为k在内存中地址，*s代表k的值；
②赋值语句“p=&s；”，使p指向s，*p代表s中的值，即k在内存中的地址：③因为*p代表s中的值，即k在内存中的地址，所以“p代表的是k的值20。

15．在函数声明中，下面哪项是不必要的( )。

A．函数参数的类型和参数名
B．函数名
C．函数的类型
D．函数体
正确答案：D
解析：本题考核函数的原型声明格式。

解析此题时，要注意函数定义和函数声明的区别。

①C++中每一个函数的定义都是由4个部分组成的，即函数类型、函数名、函数参数表和函数体。

②函数的声明是为了消除函数定义的位置影响。

不管函数是在何处定义的，只要在调用前进行函数的声明，就可保证函数调用的合法性。

③函数原型的说明格式为：＜类型＞＜函数名＞(＜形参表＞)；
16．若有以下函数调用语句：f(m+n，x+y，f(m+n，z，(x，y)))；在此函数调用语句中实参的个数是( )。

A．6
B．5
C．4
D．3
正确答案：D
解析：本题考察对函数参数表的掌握程度。

调用函数时，在函数名后面跟参数，参数用逗号隔开。

调用时，实参与形参的个数相等，类型一致，且按顺序一一对应传递数据，同时实参是实际调用函数时所给定的有确定值的常量、变量或表达式。

根据以上知识点，可以得到此函数调用语句中实参的个数是3。

故本题答案是：D。

17．下列关于类和对象描述中，错误的是( )。

A．对象(Object)是现实世界中的客观事物，对象具有确定的属性
B．类是具有相同属性和行为的一组对象的集合
C．对象是类的抽象，类是对象的实例
D．类是对象的抽象，对象是类的实例
正确答案：C
解析：C++中，类是用户自定义的一种数据类型，对象是类的实例，类定义了属于该类的所有对象的共同特性。

一个类作为一种数据类型，它可以定义多个对象。

18．下面关于继承机制的描述中，不正确的是( )。

A．派生类不仅可以继承基类的成员，也可以添加自己的成员
B．设置protected成员是为派生类访问基类成员之用
C．采用不同的继承方式，将限制派生类对基类成员的访问
D．采用私有继承，派生类只能得到基类的公有成员
正确答案：D
解析：本题主要考察C++中继承机制的特点。

C++中允许利用已有的数据类型来定义新的数据类型，这种机制称为继承机制，并称已存在的用来派生新类的类称为基类，由已存在的类派生出的新类称为派生类。

派生类有3种继承方式可以采用，即public、private和protected方式。

派生类除了继承基类中的数据
成员和成员函数外，还可以添加具有自身特点的成员，这是继承机制的真正用意所在。

因此选项A的叙述正确。

采用不同的继承方式，将限制派生类对基类成员的访问权限，因此选项C的叙述正确。

对于类本身，protected成员和private 成员对外的访问权限是相同的，即外界函数都无法直接访问这两类成员。

对于类作为基类被继承产生派生类时，protected成员又和public成员性质相同，即在所有继承方式下都可以被派生类所继承，在public继承时可以被派生类对象访问，在protected和private继承方式下无法被派生类的子类访问。

这也正是C++设置protected访问权限成员的真正用途，即为派生类继承基类隐蔽成员之用途。

因此选项B的叙述正确。

19．实现运行时的多态性要使用( )。

A．重载函数
B．析构函数
C．构造函数
D．虚函数
正确答案：D
解析：本题考核虚函数的应用。

动态联编一直要到程序运行时才能确定调用哪个函数。

虚函数是实现动态联编的必要条件之一。

没有虚函数一定不能实现动态联编，但有虚函数存在时，必须同时满足下列条件，才能实现动态联编：类之间满足子类型关系；调用虚函数操作的是指向对象的指针或对象引用，或者是由成员函数调用虚函数。

20．下列对模板的声明中，正确的是( )。

A．temvlate＜T＞
B．template＜classT1,T2＞
C．temvlate＜classT1，classT2＞
D．template＜classT1；classT2＞
正确答案：C
解析：本题考核模板的定义。

模板定义的＜类型参数表＞中包含一个或多个由逗号分隔的类型参数项，每一项由关键词class后跟一个用户命名的标识符，此标识符为类型参数，它不是一种数据类型，但可以同一般数据类型一样使用。

在使用类模板时，必须将其实例化，即用实际的数据类型代替它。

21．若有以下程序段：#include ＜iostream＞using namespace std; int main ( ) { int a[]={1,4,5}; int *p=&a[0],x=6, y,z; for (y=0; y＜3; y++) z= ( (* (p+y) ＜x) ? *(p+y) :x); cout＜＜z＜＜end1; return 0; } 程序运行后的输出结果是( )。

A．1
B．4
C．5
D．2
正确答案：C
解析：本题考核指针的运算。

程序首先定义了一整型数组a，并赋初值1，4，5。

即a[0]，a[1]和a[2]的值分别为1，4和5。

程序还定义了一个整型指针p，并将其初始化且指向数组元素a[0]。

在for循环语句中，赋值语句“z=((*(p+y)＜x)?*(p+y)：x);”可等价为“z=(a[y]＜x)?a[y]：x”。

因为表达式中的“*(p+y)=p[y]=a[y]”。

for语句每循环一次，就给变量z重新赋值一次，z的值其实就是数组和x相比较，将数组a中的最大值赋给z。

当y=2后，退出循环，输出结果是5。

22．以下4个程序中，不能实现两个实参值进行交换的是( )。

A．void swap (float *p, float *q) { float *t ,a; t = &a; t = p; *p = *q; *q = *t; } void main ( ) { float x = 8.0;y = 9.0; swap (&x, &y); cout＜＜x＜＜”, “＜＜y＜＜
B．void swap (float *p, float *q) { float a; a = *p; *p = *q; *q = a; } void main( ) { float x = 8.0;y = 9.0; swap (&x, &y); cout＜＜x＜＜”, “＜＜y＜＜end1;
C．void swap (float *p, float *q) { float x; x = *p; *p = *q; *q = x; } void main( ) { float a,b.; *a = 8.0;*b = 9.0; swap (a, b) ;
D．void swap (float &p, float &q) { float a; a = p; p = q; q = a; } void main( ) { float a = 8.0,b = 9.0; swap (a,b); cout＜＜x＜＜”, “＜＜y＜＜
正确答案：C
解析：本题考核指针和引用作为函数形参。

做此类题时，应学会整体比较，要不然花费的时间不亚于一个大的编程题。

①首先，这4个程序都是调用swap 函数，而且目的都一致，交换传入的两个实参值。

②分析被调函数swap( )。

在选项A、B和C中都是指针作为形参，只有在选项D中，函数swap( )是以引用作为形参。

由指针和引用作为函数形参的特点可知，只要调用了函数，就能达到交换两个实参变量的值，所以这几个被调函数没有问题。

③再看主函数。

在选项C中，没有定义指针类型变量，而是直接给指针变量赋值：“floata，b；*a=8.0；*b=9.0；”，这显然是非法的。

想直接开辟存储空间，交换两个常量值，是不可能的。

所以只有选项C是错误的。

23．有以下程序：#include ＜iostream＞#include ＜string＞using namespace std; int main ( ) { char s[]=“\n123\\”; cout＜＜strlen (s) ＜＜”, “＜＜sizeof (s) ＜＜end1; return 0; } A．赋初值的字符串有错
B．6,7
C．5,6
D．6,6
正确答案：C
解析：本题考核字符串的长度和字符型数组所占的字节数。

本题在定义字符数组时没有定义数组长度，但赋给数组初值，初值的个数即为数组的长度。

故数
组长度为6(包括’\0’)。

字符串的长度为有效字符的个数，为5。

所以程序最后输出5,6。

24．若有如下程序：#include ＜iostream＞using namespace std; int s=0; class sample { static int n; public: sample (int i) { n=i; } static void add( ) { s+=n; } }; int sample: :s=0; int main ( ) { sample a(2),b(5); sample:: add ( ); cout＜＜s＜＜end1; return 0; } 程序运行后的输出结果是( )。

A．2
B．5
C．7
D．3
正确答案：B
解析：本题考核静态数据成员和静态成员函数的应用。

程序中定义一个类sample，它包括一个静态数据成员n和一个静态成员函数add( )，并在类的构造函数中给类私有静态数据成员n赋值。

在主函数中，定义对象a(2)时，通过构造函数使静态数据成员n的值变为2，在定义对象b(5)时，通过构造函数使静态数据成员n=5(覆盖了前面的n=2)，再执行“sample：：add( )”使全局变量s=5。

25．有以下程序：#include ＜iostream＞using namespace std; class B { private: int a,b; public: B( ){} B(int i,int j); void printb( ); }; class A { B C; public: A( ){} A(int i,int j); void printa( ); }; A::A(int i,int j) :c(i,j) {} void A::printa( ) { c.printb ( ); } B::B(int i, int j) { a=i; b=j; } void B: :printb( ) { cout＜＜a＜＜”, “＜＜b＜＜end1; } int main ( ) { A m(7,8); m.printa( ); return 0；} 该程序运行后的输出结果是( )。

A．5,6
B．7,8
C．8,9
D．9,10
正确答案：B
解析：本题考核类的定义和应用。

程序首先定义了两个类A和B。

在类A 中，其私有数据成员c为类B的对象。

类A的成员函数printa( )中，调用私有成员对象c的成员函数printb( )输出类B私有数据成员a和b的值。

26．为了使程序的输出的正确结果为：Now is 2004．7.10 10：10：10．那么应在下列程序划线处填入的正确语句是( )。

那么应在下列程序划线处填入的正确语句是( )。

#include ＜iostream＞using namespace std; class TIME; class DATE { public: DATE(int
y=2004,int m=1,int d=1) { year=y; month=m; day=d; } friend void DateTime(DATE &d, TIME &t); private: int year, month, day; }; class TIME { public: TIME(iht h=0, int m=0,int s=0) { hour=h; minute=m; second=s; } friend void DateTime(DATE &d,TIME &t); private: int hour,minute, second; }; ______________________ //函数DateTime 的首部{ cout＜＜”Now is”＜＜d.year＜＜’.’＜＜d.month＜＜’.’＜＜d.day＜＜‘‘＜＜t.hour＜＜”:”＜＜t.minute＜＜’:’＜＜t.second＜＜’.’＜＜end1; } int main ( ) { DATE d(2004,7,10); TIME t(10, 10, 10); DateTime(d,t); return 0; }
A．void DateTime(DATE &d,TIME &t)
B．void TIME::DateTime(DATE &d,TIME &t) const
C．friend void DateTime(DATE &d,TIME &t)
D．void DATE::DateTime(DATE &d,TIME &t)
正确答案：A
解析：本题程序中，分别在类DATE和TIME中将普通函数DateTime声明为友元函数，但该友元函数的定义是在类体外进行的。

友元函数是一个普通函数，它虽然可以访问类对象的私有成员，但它毕竟不是类中的成员函数，因此在类体外定义友元函数时，不需要像成员函数一样在函数名前加上“类名：：”。

函数首部的其他定义照抄类中友元函数的声明。

所以函数DateTime的首部为void DateTime(DATE&d；TIME &t)，即选项A。

27．若有以下程序：#include ＜iostream＞using namespace std; class A { private: int x; protected: int y; public: int z; void setx(int i) { x=i; } int getx ( ) { return x; }; class B : protected A { public: void setvalue(int a, int b, int c) { setx (a); y=b; z=c; } void display( ) { cout＜＜getx ( ) ＜＜”, “＜＜y＜＜”, “＜＜z＜＜”, “＜＜end1; } }; int main ( ) { B obj; obj.setvalue(5, 6, 7); obj.display ( ); return 0; } 程序运行后的输出结果是( )。

A．产生语法错误
B．7,6,5
C．5,6,7
D．7,5,6
正确答案：C
解析：本题考核保护继承中对类成员的访问权限。

①在保护继承中，基类公有成员和保护成员都以保护成员身份出现在派生类中，而基类私有成员不可访问。

②基类的公有成员和保护成员被继承以后作为派生类的保护成员，这样，派生类的其他成员可以直接访问它们。

③由保护派．生的类声明的对象，不能访问任何基类的成员。

在本题中，基类A中的数据成员y和函数setx，经过保护继承以后，在派生类B中成为保护成员，派生类B的对象不能访问它们。

而派生类B中的函数setvalue和display都是公有成员，可以通过对象对它们进
行访问。

所以程序中对各成员的访问是正确的。

本程序的功能是对类中各数据成员进行赋值，然后查看赋值是否正确。

28．若有以下程序：#include ＜iostream＞using namespace std; class A { protected: int a; public: A( ) { a=10; } }; class A1 : public A { public: A1( ) { a=a+1; } }; class A2 : public A { public: A2 ( ) {a=a+2; } }; class B : public A1,public A2 { public: B( ){} void print( ) { cout＜＜a＜＜end1; } }; int main ( ) { B obj; obj.print( ); return 0; } 程序运行后的输出结果是( )。

A．产生语法错误
B．11
C．12
D．10
正确答案：A
解析：本题考核派生类的定义和使用。

本程序有语法错误，这是由于类B 中的print函数中的语句“cout＜＜a＜＜end1；”要输出成员a的值，从而产生了二义性。

分析如下：程序中定义了类A，类A1和类A2都是在类A的基础上以公有继承方式产生的派生类，而类B是在类A1和类A2的基础上经过多重继承方式产生的派生类，所以在类B中成员a有两个拷贝，系统无法区分是从A1继承过来的a，还从A2类继承过来的a。

修改方法有以下两种：①在被访问的成员加上作用域分辨符“::”。

将类B中的print( )函数体中语句改为：cout＜＜A1：：a＜＜end1；或cout＜＜A2：：a＜＜end1；但两者的输出结果不同，前者输出11，而后者输出12。

②采用虚基类的方法。

就是在定义A1和A2时，在派生方式前加上关键词“virtual”。

29．有以下程序：#include ＜iostream＞using namespace std; class Base { public: Base( ){} virtual void who( ) { cout＜＜”Base Class”＜＜end1; } ～Base( ){} }; class Derivel : public Base { public: void who( ) {cout ＜＜”Derivel Class”＜＜end1; } }; class Derive2 : public Base { public: void who ( ){ cout＜＜”Derive2 Class”＜＜end1;} }; int main ( ) { Base *p; Derivel obj1; Derive2 obj2; p=&obj1; p=&obj2; p-＞who ( ); return 0; } 执行程序后的输出结果是( )。

A．Base Class
B．Derivel Class
C．Derive2 Class
D．程序编译时出错
正确答案：C
解析：本题考核虚函数的应用。

本题中，先定义了一个基类Base，它含有一个虚成员函数who( )，随后定义的类Derivel和Derive2都是基类Base的公
有派生类。

在主函数中定义了一个指向Base类的指针，它也被允许指向其派生类。

在执行过程中，不断改变它所指向的对象，p-＞who就能调用不同的函数实现。

这是因为使用了虚函数，因而进行动态联编。

程序最后把指针p指向派生类Derive2的对象，由于函数who( )在基类Base中是虚函数，所以系统调用Derive2中的who( )函数，最后输出Derive2Class。

30．在进行了任何C++流的操作后，都可以用C++流的有关成员函数检测流的状态，其中用于是否进行了非法操作的函数名是( )。

A．fail
B．eof
C．bad
D．good
正确答案：C
解析：C++中可以用文件流对象的下列成员函数来判别文件流的当前状态。

①函数is open 判定流对象是否与一个打开的文件相联系，若是，返回true，否则返回false。

②函数good 刚进行的操作成功时返回true，否则返回false。

③函数fail 与good( )相反，刚进行的操作失败时返回true，否则返回false。

④函数bad 如果进行了非法操作返回true，否则返回false。

⑤函数eof 进行输入操作时，若到达文件尾返回true，否则返回false。

其中，eof函数只能用于输入流操作。

填空题（每空2分，共30分）请将每一个空的正确答案写在答题卡上。

注意：以命令关键字填空的必须拼写完整。

31．已知序列{17,18,60,40,7,32,73,65,85}，采用冒泡排序法对该序列作降序排序时，第4趟的结果是【】。

正确答案：60，40，73，65，85，32，18，17，7
解析：冒泡排序法的算法基本思想是：通过无序区中相邻记录关键词间的比较和位置交换，使关键词最小的记录如气泡一般逐渐往上“漂浮”直至“水面”。

整个算法是从最下面的记录开始，对每两个相邻的关键词进行比较，且使关键词较小的记录换至关键词较大的记录之前，使得经过一趟冒泡排序后，关键词最小的记录达到最上端。

接着，再在剩下的记录中找关键词最小的记录，并把它换在第2个位置上。

依此类推，一直到所有记录都有序为止。

根据这种思想，每趟的排序结果如下：初始：17，18，60，40，7，32，73，65，85 第一趟18，60，40，17，32，73，65，85，7 第二趟60，40，18，32，73，65，85，17，7 第三趟60，40，32，．73，65，85，18，17，7 第四趟60，40，73，65，85，32，18，17，7 第五趟60，73，65，85，40，32，18，17，7 第六趟73，65，85，60，40，32，18，17，7 第七趟73，85，65，60，40，32，18，17，7 第八趟85，73，65，60，40，32，18，17，7
32．【】是按照程序语句行的自然顺序，依次执行语句。

正确答案：顺序执行
解析：结构化程序设计语言仅仅使用顺序、选择和循环3种基本结构。

其中，顺序结构是最基本、最常用的结构，它采用顺序执行的结构，即按照程序语句行的自然顺序，依次执行语句。

33．调试方法中的【】最适合小规模程序的排错。

正确答案：回溯法
解析：这种调试方法是从出现错误征兆处开始，人工沿控制流程往回追踪，直至发现出错的根源。

这是在小程序中常用的一种有效的调试方法。

程序变大后，可能的回溯路线显著增加，以致人工进行完全回溯可望而不可及。

例如，程序中发现错误处是某个打印语句。

通过输出值可推断程序在这一点上变量的值，再从这一点出发。

回溯程序的执行过程，反复考虑：“如果程序在这一点上的状态(变量的值)是这样，那么程序在上一点的状态一定是这样……”，直到找到错误的位置。

34．若a=12,b=14,c=0，则表达式“((y=(a>B) ?a：B) >C) ?y：c”的值为【】。

正确答案：14
解析：条件运算符是一种在两个表达式中选择一个的操作，它是C++中惟一的三元运算符。

在本题中，先计算“(a>B) ?a：b”，因为ac的逻辑值为真，所以表达式的值为y的值，即14。

35．函数sstrcmp( )的功能是对两个字符串进行比较。

当s所指字符串和t所指字符串相等时，返回值为0：当s所指字符串大于t所指字符串时，返回值大于0；当s所指字符串大于t所指字符串时，返回值大于0(功能等同于strcmp( ))。

请填空。

int Sstrcmp(char *S，char *t) { while(*s&&*t&&*S==*t) {s++；t++; } return 【】; }
正确答案：*s-*t或s[0]-t[0]
解析：函数sstrcmp( )有两个字符型指针变量，用来指向两个字符串。

比较两个字符串的大小方法是：从第1个字符开始依次向后比较，若对应的字符相等，则接着比较下一个字符，一直到两个字符串中的对应字符不相等，或有一个为“\0”，此时对应字符的ASCII码大的字符串就大。

故循环条件是*s和*t不为’＼0’，且*s和*t相同。

空白处应填入返回值，即“*s-*t”或其等价形式。

36．若有以下程序：#include ＜iostream＞using namespace std; int f(int x, int y) { return (y-x)*x; } int main( ) { int a=3,b=4,c=5,d;d=f(f(a,b) ,f(a,c) ); cout＜＜d＜＜＜end1; return 0; } 执行后的输出结果是【】。

正确答案：9
解析：本题考核函数的嵌套调用。

在主函数中执行语句“d=f(f(a,b) ,f(a,c))；”调用了3次f( )函数：调用f(a,b) 得到的值为3，调用f(a,c) 得到的值为6，调用f(3,6)得到的值为9。

37．如果一个数组中的每个元素都是同一类的对象，则该数组被称为【】。

正确答案：对象数组
解析：对象数组是指数组元素为对象的数组，该数组中的每一个元素都是同一个类的对象。

38．表达式c3=c1.operator+(c2)或c3=operator+(c1,c2)还可以表示为【】
正确答案：c3=c1+c2
解析：这是运算符重载应用的两种形式。

39．下面程序的打印结果是【】。

#include ＜iostream＞using namespace std; class Base { public: Base(int x) {a=x; } void show( ) {cout＜＜a; } private: int a; }; class Derived : public Base { public: Derived(int i) :Base(i+1) ,b(i) { } void show( ) {cout＜＜b; } private: int b; }; int main ( ) { Base b(5) , *pb; Derived d(1); pb=&d; pb-＞show( ); return 0; }
正确答案：2
解析：基类Base派生出派生类Derived，在主函数中，定义了基类对象b，基类指针pb，以及派生类对象d，并让基类指针pb指向派生类对象乙在C++中，当派生类的对象赋值给基类对象时，只能使用派生类对象中从基类继承的成员。

所以最后执行语句“pb-＞show( )；”是调用基类的成员函数show( )，输出a的值2。

40．有如下程序：#include ＜iostream＞using namespace std; class AA { public: virtual void f( ) {cout ＜＜“AA”; } }; class BB : public AA { public: BB( ) {cout＜＜”BB”; } }; class CC : public BB { public: virtual void f( ) {BB::f( );cout ＜＜“CC”; } }; int main( ) { AA aa,*p; BB bb; CC cc; p=&cc; p-＞f( ); return O; } 运行后的输出结果【】
正确答案：BBBBAACC
解析：本题中，函数f( )在基类AA中派生类CC中都声明为虚函数，所以采用动态联编。

主函数首先定义类AA的对象aa和指针对象p，然后定义了类BB的对象bb，此时调用了类BB的构造函数输出BB。

再定义类CC的对象cc，
由于类CC是类BB的派生类，所以此时又调用类BB的构造函数输出BB。

最后执行语句“p=&cc；p-＞f( )；”，输出AA和CC。

41．若有以下程序：#include ＜iostream＞using namespace std; int main( ) { char str[10]; cin＞＞str; cout＜＜str＜＜end1; return 0; } 当输入为：This is a program! 那么执行程序后的输出结果是【】。

正确答案：This
解析：本题考核C++的标准输入/输出。

提取符可以从输入流中读取一个字符序列，即一个字符串。

在处理这种字符序列时，字符串被认为是一个以空白字符结束的字符序列。

因此，本题得到的输入仅仅是第一个空白符之前的字符序列This。

所以程序最后的输出是This。

42．函数YangHui的功能是把杨辉三角形的数据赋给二位数组的下半三角，形式如下：其构成规律是：①第0列元素和主对角线元素均为1。

②其余元素为其左上方和正上方元素值之和。

③数据的个数每行递增1。

请将程序补充完整。

#define N 6 void YangHui(int x[N][N]) { int i，j；x[0] [0] =1；for(i = 1；i＜N；i++) { x[i][0] =【】= 1；for(j=1；j＜i；j++) x[i][j]=【】；} }
正确答案：x[i][0] x[i-1][j-1]+x[i-1][j]
解析：本题考核数组的应用，属于综合型考题。

在函数YangHui中，通过嵌套的for语句实现杨辉三角各个位置元素的赋值。

①由于杨辉三角中，第0列元素和主对角线元素均为1。

所以可知，x[i][0]=1，x[i][i] =1。

②杨辉三角中，其余元素为其左上方和正上方元素值之和。

若元素为x[i][j],那么其左上方的元素为x[-1][j-1)，正上方的元素为x[i-1][j]。

所以x[i][j]的值为x[i-1][j-1]+x[i-1][j]。