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

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

1．下列选项中，不是算法的基本特征的是( )。

A．完整性
B．可行性
C．有穷性
D．拥有足够的情报
正确答案：A
解析：作为一个算法，一般应该具有下列4个特征：①可行性，即考虑到实际的条件能够达到一个满意的结果；②确定性，算法中的第一个步骤都必须是有明确定义的；③有穷性，一个算法必须在有限的时间内做完；④拥有足够的情报。

2．结构化分析方法是面向( )的自顶向下、逐步求精进行需求分析的方法。

A．对象
B．数据结构
C．数据流
D．目标
正确答案：C
解析：结构化分析方法是面向数据流进行需求分析的方法，采用自顶向下、逐步求精，建立系统的处理流程，以数据流图和数据字典为主要工具，建立系统的逻辑模型。

3．下列工具中为需求分析常用工具的是( )。

A．PAD
B．PFD
C．N-S
D．DFD
正确答案：D
解析：需求分析常用的工具有数据流图(DFD)、数据字典(DD)、判定树和判定表。

PAD(问题分析图)、PFD(程序流程图)、N-S(盒式图)都是详细设计的常用工具，不是需求分析的工具。

4．线性表进行二分法检索，其前提条件是( )。

A．线性表以顺序方式存储，并按关键码值排好序
B．线性表以顺序方式存储，并按关键码的检索频率排好序
C．线性表以链式方式存储，并按关键码值排好序
D．线性表以链式方式存储，并按关键码的检索频率排好序
正确答案：A
解析：对线性表进行二分法检索，要求线性表是按顺序方式存储，并按关键码值的大小排好序，而不是按关键码的检索频率排序。

5．下列选项中不属于结构化程序设计方法的是( )。

A．自顶向下
B．逐步求精
C．模块化
D．可复用
正确答案：D
解析：结构化程序设计的主要原则概括为自顶向下，逐步求精，限制使用GOTO语句。

6．下列关于结构化程序设计原则和方法的描述中，错误的是( )。

A．选用的结构只准许有一个入口和一个出口
B．复杂结构应该用嵌套的基本控制结构进行组合嵌套来实现
C．不允许使用GOTO语句
D．语言中所没有的控制结构，应该采用前后一致的方法来模拟
正确答案：C
解析：限制使用GOTO语句是结构化程序设计的原则和方法之一，但不是绝对不允许使用GOTO语句。

选项A)、B)、D)为结构化程序设计的原则。

7．软件需求分析阶段的工作，可以分为4个方面：需求获取、需求分析、编写需求规格说明书以及( )。

A．阶段性报告
B．需求评审
C．总结
D．都不正确
正确答案：B
解析：需求分析是软件定义时期的最后一个阶段。

可以概括为4个方面：①需求获取：②需求分析；③编写需求规格说明书；④需求评审。

8．下列关于软件测试的描述中正确的是( )。

A．软件测试的目的是证明程序是否正确
B．软件测试的目的是使程序运行结果正确
C．软件测试的目的是尽可能多地发现程序中的错误
D．软件测试的目的是使程序符合结构化原则
正确答案：C
解析：软件测试是为了尽可能多地发现程序中的错误，尤其是至今尚未发现的错误。

9．用链表表示线性表的优点是( )。

A．便于随机存取
B．花费的存储空间较顺序存储少
C．便于插入和删除操作
D．数据元素的物理顺序和逻辑顺序相同
正确答案：C
解析：在链表中因为除了存放数据元素之外，还要存放指针，所以链表花费的存储空间比顺序表还要多。

在插入和删除数据元素时，只需要移动相应的记录指针即可。

在链表中，数据的物理结构与逻辑结构不一定相同，因为是靠指针来实现对数据的指定，所以不能进行随机存取。

10．在数据库设计中，将E-R图转换为关系模式的过程属于( )。

A．需求分析阶段
B．逻辑设计阶段
C．概念设计阶段
D．物理设计阶段
正确答案：B
解析：数据库设计阶段主要包括需求分析、概念设计、逻辑设计和物理设计。

其中逻辑设计的主要工作是将E-R图转换为关系模式。

11．下列符号中可以用作C++标识符的是( )。

A．_radius
B．foo～bar
C．else
D．3room
正确答案：A
解析：此题考查的是标识符。

标识符是由数字、字母以及下划线构成，其第一个字符必须是字母或下划线，中间不能有空格；标识符的长度是任意的，但由于编译系统的限制一般不超过31个字符：标识符中的大小写字母是不同的；定义标识符时不能采用系统的保留字。

符合这些要求的只有选项A)。

12．下列关于C++流的说明中，正确的是( )。

A．与键盘、屏幕、打印机和通信端口的交互都可以通过流类来实现
B．从流中获取数据的操作称为插入操作，向流中添加数据的操作称为提
取操作
C．cin是一个预定义的输出流类
D．输出流有一个名为open的成员函数，其作用是生成一个新的流对象
正确答案：A
解析：选项B)中，从流中获取数据的操作称为提取操作，向流中添加数据的操作称为插入操作；选项C)中，cin是一个预定义的输入流对象；选项D)中，open的成员函数只能打开文件：故只有选项A)的叙述是正确的。

13．若执行语句：cout＜＜setfill(‘*’)＜＜setw(10)＜＜123＜＜”OK”＜＜endl 后将输出( )。

A．******* 1230K
B．123********OK
C．*******123********OK
D．123*******OK********
正确答案：A
解析：cout.fill( )用于设置或返回输出的填充字符，默认是空格，fill( )函数的设置一直有效，直到下一个fill( )函数改变该值为止。

setw (int n)作用是设置输入输出的宽度，此设置只对一次输入或输出有效，在完成一次数据的输入或输出后，宽度设置自动恢复为0。

需要注意的是，默认为输出数据在指定宽度内右对齐。

14．类模板的使用实际上是将类模板实例化成一个具体的( )。

A．类
B．对象
C．函数
D．模板类
正确答案：A
解析：类模板就是把类中的数据分离出来，作为一个类的描述。

C++编译器根据类模板和特定的数据类型来产生一个类，类模板就是一个抽象的类。

15．有如下函数模板定义：template＜class T＞T func(T x,T y){return x*x+y*y;} 在下列对func的调用中，错误的是( )。

A．func(3,5);
B．func(3.0,5.5);
C．func(3,5.5);
D．func＜int＞(3,5.5);
正确答案：C
解析：选项C)中两个实参的实际类型不同而未进行转换，会出现错误。

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

A．AB operator+(AB &a,AB &)
B．AB operator+(AB&)
C．opetacor+(AB a)
D．AB &operator+( )
正确答案：B
解析：因为题目的要求是对类AB定义加号操作符重载成员函数，所以首先应该对范围加以限定，参数是对类对象的引用。

17．下列运算符中全都可以被友元函数重载的是( )。

A．=，+，-，\
B．[]，+，( )，new
C．-＞，+，*，＞＞
D．＜＜，＞＞，+，*
正确答案：D
解析：运算符重载为成员函数的形式为：函数类型operator运算符(形参表){函数体;}；运算符重载为友元函数的形式为：friend函数类型operator运算符(形参表){函数体;)。

一般来讲，单目运算符最好重载为成员函数，双目运算符最好重载为友元函数。

=、[]、( )、-＞以及所有的类型转换运算符只能作为成员函数重载。

18．关于纯虚函数，下列表述中正确的是( )。

A．纯函数是没有给出实现版本(即无函数体定义)的虚函数
B．纯虚函数的声明总是以“=0”结束
C．派生类必须实现基类的纯虚函数
D．含有纯虚函数的类不可能是派生类
正确答案：B
解析：纯虚函数是在声明虚函数时被“初始化”为。

的虚函数。

纯虚函数没有函数体，所以选项A)、C)不正确。

纯虚函数的作用是在基类中为其派生类保留一个函数名字。

所以选项D)错误。

19．有如下程序：#include＜iostream＞using namespace std; class TestClass { public: virtual void fun1( ) { cout＜＜”fun1TestClass”; } virtual void fun2( ) { cout＜＜”fun2TestClass”; } }; class TestClass1:public TestClass { void fun( ) { cout＜＜”fun1TestClass1”; } void fun2(int x) { cout＜＜”fun2TestClass1”; } }; int main( ) { TestClass obj1,*p; TestClass1 obj2; p=&obj2; p-＞fun1( ); p-＞fun2( ); return 0; } 该程序执行后的输出结果是( )。

A．fun1TestClass1 fun2TestClass
B．fun1TestClass1 fun2TestClass1
C．fun1TestClass fun2TestClass
D．fun1TestClass fun2TestClass1
正确答案：A
解析：TestClass为基类，Testclass1是TestClass的派生类。

基类中的fun1和fun2被定义为虚函数，C++规定，当一个成员函数被声明为虚函数后，其派生类中的同名函数都自动成为虚函数，所以派生类中的fun1和tim2也是虚函数。

本题从main主函数入手，首先定义了TestClass类型的对象obj1和指针p，然后又定义了TestClass1的对象obi2。

指针指向对象obi2，然后调用其成员函数fun1( )，即输出“fun1TcstClass1”。

多态性是在程序运行过程中才动态地确定操作指针指向的对象，“p-＞fun2( );”语句中没有任何参数，并不是调用派生类中的fun2(int x)，而是调用其基类中的fun2( )，所以输出“fun2TestClass”。

20．有如下程序：#include＜iostream＞using namespace std; class A{ public: virtual void func1( ){cout＜＜”A1”;} void func2( ){cout＜＜”A2”;} }; class B:public A{ public: void func1( ){cout＜＜”B1”;} void func2( ){cout＜＜”B2”;} }; int main( ) { A *p=new B; p-＞func1( ); p-＞func2( ); return 0; } 执行该程序，屏幕上将显示输出( )。

A．B1B2
B．A1A2
C．B1A2
D．A1B2
正确答案：C
解析：程序中B为A的派生类，由主函数入手，主函数中定义了类A的指针p指向类B。

根据基类中的“virtual void func1( )”知道A中的func1为虚函数，执行“p-＞func1( )；”语句，通过指针变量调用此虚函数，此时调用的就是指针变量指向的同名函数，即派生类的func1函数，输出B1。

而fun2不是虚函数，所以执行“p-＞func2( );”输出为A2。

21．有如下类声明：class TestClass int i; private:int j; protected:int k; public:int m,n; 其中，私有成员的数量为( )。

A．0
B．1
C．2
D．3
正确答案：C
解析：首先声明为pfivate的“private:int j;”中j为私有成员。

然后在类中没有指定，系统默认为私有。

即“int i;”中的i也是私有成员。

所以本题中的私有成员数量为2。

22．有如下程序：#include＜iostream＞using namespace std;
class TestClass { private; char c; public; TestClass (char n):c(n){} ～TestClass ( ) { cout＜＜c; } }; class TestClass1:public TestClass { Private: char c; public: TestClass1(char n):TestClass (n+1),c(n){} ～TestClass1( ) { cout＜＜c; } }; int main( ) { TestClass1 obj(‘x’); return 0; } 执行上面的程序输出( )。

A．xy
B．yx
C．x
D．y
正确答案：A
解析：题目中程序TestClass为基类，TestClass1为派生类。

在主函数中定义TestClass1对象obj(‘x’)，“TestClass1(char n):TestClass (n+1),c(n){}”，所以先输出x，然后调用基类构造函数，’x’+1=‘y’，所以输出y，即答案为xy。

23．阅读下面程序：#include＜iostream.h＞void main( ) { int i,j,row=0,column=0,min; static int a[3][3]={100,28,72,-30,2,-100}; min=a[0][0]; for(i=0;i＜3;i++) for(j=0;j＜3;j++) if(a[i][jl＜min) { min=a[i][j]; row=i; column=j; } cout＜＜min＜＜”,”＜＜row ＜＜”,”＜＜column＜＜endl; } 该程序的执行结果为( )。

A．-100,2,3
B．-100,1,2
C．100,1,1
D．100,0,0
正确答案：B
解析：该程序是找到数组a中的最小值，然后输出其数值及行、列。

首先将min的值赋值为a中的第一行第一列的数值。

然后在for两层循环中利用if语句进行大小比较，求出数组最小值，即-100。

它的位置为第二行；第三列。

标识由0开始计数，所以是1，2。

24．重载输入流运算符＞＞必须使用的原型为( )。

A．istream& operator＞＞(istream&,＜类名＞&);
B．istream& operator＞＞(istream,＜类名＞);
C．istream operator＞＞(istream,＜类名＞&);
D．＜类名＞operator＞＞(istream&,＜类名＞&);
正确答案：A
解析：C++流的输入运算符“＞＞”和输出运算符“＜＜”只能作为非成员函数重载。

重载输入流运算符“＞＞”须使用以下原型：istream & operator＞＞(istream&,＜类名＞&);。

25．关于在调用模板函数时模板实参的使用，下列表述中正确的是( )。

A．对于虚拟类型参数所对应的模板实参，如果能从模板函数的实参中获得相同的信息，则都可以省略
B．对于虚拟类型参数所对应的模板实参，如果它们是参数表中的最后的若干个参数，则都可以省略
C．对于虚拟类型参数所对应的模板实参，若能够省略则必须省略
D．对于常规参数所对应的模板实参，任何情况下都不能省略
正确答案：D
解析：以下情况模板实参不能省略：从模板函数实参表获得的信息有矛盾；需要获得特定类型的返回值，而不管返回值类型如何；虚拟类型的参数没有出现在模板形参表中；函数模板含有常规形参。

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

A．fail
B．eof
C．bad
D．good
正确答案：A
解析：可以用文件流对象的成员函数来判别文件流当前的状态：fail，刚进行的操作失败是返回true，否则返回false；eof，进行输入操作时，若文件到达文件尾返回true，否则返回false；bad，如果进行了非法操作返回true，否则返回false；good，刚进行的操作成功时返回true，否则返回false。

27．已知n是一个int型变量，下列语句中错误的是( )。

A．long*p=new long[n]；
B．long p[n]；
C．long*p=new long(n)；
D．long p[10]；
正确答案：B
解析：此题考查的是数组、指针及关键字new。

说明一维数组的一般形式是：数组类型数组名[数组长度]；其中数组长度必须是整型常量或常量表达式。

选项B)中，n是一个变量，不能做数组的长度，故选项B)错误；其他选项均正确。

28．有如下程序：#include ＜iostream.h＞using namespace std; class Base { protected: int i; public: int j; }; class Derived:public Base { int m; public: int n; }; int main( ) { Derived d; d.i=0; //[1] d.j=0; //[2] d.m=0; //[3] d.n=0; //[4] return 0; } 其中主函数中有两个赋值语句有错，这两个错误的赋值语句是( )。

A．[1]和[2]
B．[1]和[3]
C．[2]和[3]
D．[2]和[4]
正确答案：B
解析：此题考查的是类和派生类的访问权限。

类Derived公有继承类Base，所以d对基类Base成员的访问权限不变。

因数据成员i为保护，故不能通过对象访问；派生类Derived中m变量为私有，同样不能通过对象访问，所以[1]、[3]错误。

29．有如下语句序列：int k=0：do{k+=5;cout＜＜’＄’;} while(k ＜19); while(k--＞0)cout＜＜’*’; 执行上面的语句序列输出字符“＄”和“*”的个数分别是( )。

A．4和20
B．5和20
C．4和21
D．5和21
正确答案：A
解析：此题首先执行语句do{k+=5;cout＜＜’＄’;} while(k＜19);，循环执行4次，输出4个“＄”，k的值变为20；然后执行语句while(k--＞0)cout＜＜’*’;，因为其中的k是后缀自减，所以会输出20个“*”。

30．下列关于虚函数的描述中，正确的是( )。

A．虚函数是一个static类型的成员函数
B．虚函数是一个非成员函数
C．基类中采用virtual说明一个虚函数后，派生类中定义相同原型的函数时可不必加virtual说明
D．派生类中的虚函数与基类中相同原型的虚函数具有不同的参数个数或类型
正确答案：C
解析：虚函数是允许在派生类中重新定义与基类同名的函数，并且可以通过基类指针或引用来访问基类和派生类中的同名函数。

在基类用virtual声明成员函数为虚函数，在派生类中重新定义此函数，要求函数名、函数类型、函数参数个数和类型全部与基类的虚函数相同。

31．有如下程序：#include ＜iostream.h＞using namespace std; class Base { public: Base( ){cout＜＜”BB”; f( ); void f( ){cout ＜＜”Bf”;} }; class Derived: public Base { public: Derived( ){cout＜＜”DD”;} void f( ){cout＜＜”Df”;} }; int main( ){Dcrivcd d; return 0;} 执行上面的程序将输出( )。

A．BBBfDD
B．BBDfDDDf
C．DD
D．DDBBBf
正确答案：A
解析：此题考查的是类的继承和派生。

派生类执行构造函数的一般次序为：首先调用基类构造函数；然后调用成员对象的构造函数；最后是派生类构造函数中的内容。

题目中定义派生类对象d时，先调用基类Base的构造函数，输出BBBf，然后调用派生类Derived的构造函数，输出DD。

32．有如下程序：#include ＜iostream.h＞using namespace std; class Stack { public: Stack(unsigned n=10):size(n){rep_=new int [size]; top=0;} Stack(Stack&s): size (s.size) { rep_=new int[size]; for (int i=0;i＜size;i++) rep_[i]=s.rep_[i]; top=s.top; } ～Stack( ){delete[]rep_;} void push(int a){rep_[top]=a; top++;} int pop( ){--top; return rep_[top];} bool isEmpty( ) const {return top ==0;} private: int*rep_; unsigned size, top; }; int main( ) { Stack s1; for(int i=1;i＜5;i++) sl.push(i); Stack s2(s1); for (int i=1;i＜3;i++) cout＜＜s2.pop( )＜＜’,’; s2.push(6); s1.push(7); while(!s2.isEmpty( )) cout＜＜s2.pop( )＜＜’,’; return 0; } 执行上面程序将输出( )。

A．4,3,2,1,
B．4,3,6,7,2,1,
C．4,3,6,2,1,
D．1,2,3,4,
正确答案：C
解析：此题综合考查了类与对象、循环语句、指针等知识点。

在主函数main 中，先定义了类Stack的对象s1，通过循环将1、2、3、4压入堆栈内；然后定义对象s2，并用对象s1来初始化，所以s2的大小也是10。

第二个循环将4、3弹出并输出，然后将6压入s2的堆栈，然后将s2中剩下的值全部弹出，即6、2、1。

33．已知枚举类型定义语句为：enum Token{NAME,NUMBER,PLUS=5,MINUS,PRINT=10}; 则下列叙述中错误的是( )。

A．枚举常量NAME的值为1
B．枚举常量NUMBER的值为1
C．枚举常量MINUS的值为6
D．枚举常量PRINT的值为10
正确答案：A
解析：此题考查的是C++语言的数据类型。

第一个枚举常量的值为0；允许程序显示的定义中指定部分或全部枚举常量的值，枚举常量默认时，在前一枚举常量值的基础上以此增1。

34．要定义一个具有5个元素的一维数组vect，并使其各元素的初值依次是30，50，-88，0和0，则下列定义语句中错误的是( )。

A．int vect[5]={30,50,-88};
B．int vect[]={30,50,-88,0,0};
C．int vect[5]={30,50,-88};
D．int vect[5]={30,50,-88,0,0};
正确答案：A
解析：此题考查的是一维数组定义时的初始化。

当数组声明时没有给出数组的大小但是有初始化列表时，数组的大小就由列表中元素的个数来确定。

所以选项A)中数组只定义3个元素，不符合题目。

35．有如下程序：#include ＜iostream＞using namespace std; class Test { public: Test( ) {n+=2; } ～Test( ) {n-=3; } static int getNum( ) {return n; } private: static int n; }; int Test::n=1; int main( ) { Test* p=new Test; delete p; cout＜＜”n=“＜＜Test::getNum( )＜＜endl; return 0; } 执行该程序的输出结果是( )。

A．n=0
B．n=1
C．n=2
D．n=3
正确答案：A
解析：此题考查的是静态数据成员和静态成员函数。

静态数据成员是类中所有对象共享的成员，而不是某个对象的成员。

题目中的静态数据成员n的运算具有叠加性，执行“n+=2”和“n-=3”后n的值为0。

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

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

36．在长度为n的线性表中查找一个表中不存在的元素，需要的比较次数为【】。

正确答案：n
解析：在长度为n的线性表中查找一个表中不存在的元素，需要的比较次数为n。

37．在面向对象的程序设计中，用来请求对象执行某一处理或回答某些信息的要求称为【】。

正确答案：消息
解析：消息是一个实例与另一个实例之间传递的信息，它请求对象执行某一处理或回答某一要求的信息，它统一了数据流和控制流。

38．源程序文档化要求程序应加注释。

注释一般分为序言性注释和【】。

正确答案：功能性注释
解析：注释一般分为序言性注释和功能性注释。

序言性注释通常位于每个程序的开头部分，它给出程序的整体说明；功能性注释的位置一般嵌在源程序体之中，主要描述其后的语句或程序做什么。

39．数据模型分为格式化模型与非格式化模型，层次模型与网状模型属于【】。

正确答案：格式化模型
解析：层次模型与网状模型属于格式化模型。

40．在关系运算中，【】运算是在给定关系的某些域上进行的运算。

正确答案：投影
解析：在关系运算中，投影运算是在给定关系的某些域上进行的运算。

41．设有定义语句：double x=2.5, y=4.7；int a=7；那么表达式x+a%3*(int)(x+ y)%2/4的值为【】。

正确答案：2.5
解析：本题考核运算符的使用(包括类型、优先级、结合性)。

强制类型转换符( )将表达式x+y的值转换为int型，那么表达式“a%3*(int) (x+y)%2/4”结果将为整型，计算：7%3*7%2/4的结果为0，而x为double型，所以最后的结果为2.5
42．函数swap(arr,n)可完成对arr数组从第1个元素到第n个元素两两交换。

在运行调用函数中的语句后，a[0]和a[1]的值分别为【】。

a[0]=1；a[1]=2；swap(a，2)；
正确答案：2，1
解析：本题考核函数参数的传递。

数组名作为函数参数传递的是数组的首地址，即实参数组名把实参数组的首地址传给了形参数组名，形参数组名就指向了相应的实参数组，就是说形参数组和实参数其实就是同一个数组，对形参数组元素的修改也同样影响到对应的实参数组元素。

43．下列程序的输出结果是【】#include＜iostream＞using namespace std；int main( ) { int num=500；int &ref=num；ref +=100；cout＜＜num＜＜end1；return 0；}
正确答案：600
解析：考核引用的使用。

题中整型变量ref定义为num的引用，所以对ref 的作用等同于对num的作用，所以ref加上100后，num的值也就变成了600。

44．类模板的使用实际上是将类模板实例化成一个具体的【】。

正确答案：类
解析：本题考核类模板的使用，使用类模板时是将其定义实例化为一个真正的类。

45．在下面横线上填上适当的语句，完成程序。

#include＜iostream＞using namespace std；class Base { int x；public: Base(int i){x=i;} ～Base( ){} }; class Derived : public Base { public:【】/完成类Derive构造函数的定义}; int main ( ) { Derived Obj; return 0; }
正确答案：Derived (int i)：Base(i){}
解析：本题考核派生类中构造函数的的定义。

程序中，类Derived是基类Base的公有派生。

在类Derived的构造函数应该包括调用基类构造函数使基类的数据成员得以初始化。

46．已知：double A(double A) {return++a；}和int A(in A) {return++a；}是一个函数模板的两个实例，则该函数模板定义为【】
正确答案：template＜typename T＞TA(TA) {return a++,)
解析：本题考核函数模板的定义。

通过两个实例知道该例中只有一种数据类型，所以在定义模板时只需定义一个模板参数T。

47．有以下程序：#include＜iostream.h＞class A { int x; public: A(int a) {x=a; }friend class B; } class B{ public: void print(A a){a. x--;cout＜＜a.x＜＜end1; } }; void main( ) { A a(10); B b; b.print(a) ; }程序执行后的输出结果是【】。

正确答案：9
解析：本题考核友元类的应用。

在程序中，类B是类A的友元类，因此，在类B的所有成员函数中均可访问类A的任何成员。

在main( )中，先定义类A的一个对象a(10)和类B的一个对象b。

然后通过对象b调用其成员函数print 输出对象a的私有成员x的值减1即9。

48．下面程序的输出结果是【】。

#include ＜iostream＞using namespace std; class base { protected: int a; public: base( ){cout＜＜”0”:} }; class basel: virtual public base { public:
base1( ){ cout＜＜”1”;} }; class base2 : virtual public base { public: base2( ){cout＜＜”2”;} }; class derived : public base1,public base2 { public: derived ( ) {cout＜＜”3”; } } int main ( ) { derived obj; cout＜＜end1; return 0; }
正确答案：0123
解析：本题考核含有虚基类的继承中构造函数的调用顺序，应该先调用基类的构造函数，接着是按照派生类继承列表的顺序依次调用虚基类的构造函数，最有调用派生类自己的构造函数．题中先调用base的构造函数，然后调用base1、base2的构造函数，最后调用derived的构造函数。