【精品】C++面向对象程序设计题库(含答案)

【精品】C++面向对象程序设计题库（含答案）C++面向对象程序设计试题集
一、填空题(每空2分，共20分)
1. 设a、b、c都是int型变量，则a=(b=4)+(c=2)后，a值为_ _，b值为。

2. 在派生类的成员中有公有成员、、、四类成员。

3. 类Sample的构造函数将形参data赋值给数据成员data。

请将类定义补充完整。

class Sample{
public: Sample(int data=0);
Private: int data;
};
Sample::Sample(int data){
4. 面向对象程序设计的机制提供了重复利用程序资源的一种途径。

5. 继承发生在利用现有类派生新类时，其中现有类称为，或父类;派生的新类称为，或。

6. 若表达式(x+(y-z)*(m/n))+3中的变量均为double型，则表达式值的类型为。

7. 已知数组a 中的元素个数为n，下列语句的作用是将下标为i 的元素移动到下标为i,1 的单元，其中1?i,n。

例如，当n=4，a 中原有数据为1，2，3，4 时，则移动后a 中元素为2,3,4,4。

请将语句补充完整:
for(int i=0;i<n-1;i++) a[i]= 。

8. 类是对具有共同属性和行为的一类事物的抽象描述，共同属性被描述为类
中的，共同行为被描述为类中的。

9. 类Sample的构造函数将形参data赋值给数据成员data。

请将类定义补充
完整。

class Sample{
public:
Sample(int data=0);
Private:
int data; };
Sample::Sample(int data){
}
10. 实现运行时多态，要使用函数。

11. 设A为test类的对象且赋有初值,则语句test B(A); 表示。

12. 在MyClass 类的定义中，对赋值运算符=进行重载。

请将画线处缺失的部分补充完整。

MyClass::operator=(const MyClass rhs) {
if(this=&rhs) return *this;
value=rhs. value;
return *this; }
13. C++语言中的每条基本语句以 ________作为结束符，每条复合语句以
________ 作为结束符。

14. 若p指针指向字符串“ABCDEFGHIJKL”，则语句cout<<*(p+5);的输出结果是________。

15. 当一个函数或一个类希望能够直接访问另一个类中的非公用成员时，应该将该函数
声名为另一个类的________或________。

16. 设px是指向一个类动态对象的指针变量，则执行“delete px”语句时，将自动调用该类的_______函数。

17. C++中没有字符串类型，字符串是通过________来表示的，每一个字符串都有一个结尾字符________。

18. 使用const 语句定义一个标识符常量时，则必须对它同时进行________。

19. 类test的析构函数名是。

20. 建立对象时，为节省内存，系统只给_______分配内存。

21. 类中的数据和成员函数默认访问类型为。

当建立一个新对象时，程序自动调用_______________。

22.
23. 在C++中，函数的参数有两种传递方式，它们是值传递和________。

24. 若表达式(x+(y-z)*(m/n))+3中的变量均为double型，则表达式值的类型为。

25. 循环语句:for(int i=50; i>20; i-=2) cout<<i<<?,?;
运行时循环体的执行次数是
26. 任何类中允许有三种访问权限的数据，这三种访问权限分别是
public 、、 27. 类是用户定义的类型，具有类类型的变量称为。

当建立一个新对象时，程序自动调用。

28. 利用成员函数对二元运算符重载，其左操作数为，右操作数为。

29. C++将类继承分为和两种。

30. 派生类可以定义其_______________中不具备的数据和操作。

31. 有如下类定义:
class Sample{
public: Sample(); ~Sample();
private: static int date;};
将静态数据成员data初始化为0的语句是。

32. 在保护继承方式下，基类的公有和保护成员成为派生类中的成员。

33. 若表达式(x+(y-z)*(m/n))+3中的变量均为double型，则表达式值的类型为。

34. 类test的析构函数名是。

35. 在保护继承关系下，基类的公有成员和保护成员将成为派生类中的成员。

36. 类是对具有共同属性和行为的一类事物的抽象描述，共同属性被描述为类中的，共同行为被描述为类中的。

37. 在派生类的成员中有私有成员、、四类成员。

38. 在继承机制下，当对象消亡时，编译系统先执行的析构函数，然后才执行派生类中子对象类的析构函数，最后执行的析构函数。

39. 在C语言中，编程的单位是在C++语言中，编程的单位是。

40. 若表达式(x+(y-z)*(m/n))+3中的变量均为double型，则表达式值的类型为。

41. 面向对象程序设计的机制提供了重复利用程序资源的一种途径。

42. 非成员函数应声明为类的才能访问这个类的private成员。

43. 派生新类的过程一般包括、、三个步骤。

44. C++程序的头文件和源程序文件扩展名分别为和。

45. 循环语
句:for(int i=50; i>20; i-=2) cout<<i<<?,?;
运行时循环体的执行次数是
46. 类中构造函数有个，析构函数有个。

47. 有如下类定义:
class Sample{
public:
Sample();
~Sample();
private:
static int date;};
将静态数据成员data初始化为0的语句是。

48. 假定p所指对象的值为25，p+1所指对象的值为46，则执行“(*p)++;”语句后，p所指对象的值为。

49. 若在类的定义体中只给出了一个成员函数的原型，则在类外给出完整定义时，其函数名前必须加上类名和两个________分隔符。

50. 若需要把一个函数“void F( );”定义为一个类AB的友元函数，则应在类AB的定义中加入一条语句: 。

51. 若要把类外定义的成员函数规定为内联函数，则必须把________关键字放到函数原型或函数头的前面。

52. (为了避免在调用成员函数时修改对象中的任何数据成员，则应在定义该成员函数时，在函数头的后面加上________关键字。

53. 程序段i=5;j=0;j=++i+j;输出结果为j= 。

54. 类定义中，既包含数据成员，也包含________成员。

55. 假定AB为一个类，则执行“AB a[10];”语句时，系统自动调用该类的构造函数的次数为，其构造函数名是。

56. 假定一个类对象数组为A[N]，当离开它的作用域时，系统自动调用该类析构函数的次数为________。

57. 已知数组a 中的元素个数为n，下列语句的作用是将下标为i 的元素移动到下标为i,1 的单元，其中1?i,n。

例如，当n=4，a 中原有数据为1，2，3，4 时，则移动后a中元素为2,3,4,4。

请将语句补充完整:
for(int i=0;i<n-1;i++) a[i]= 。

58. 是指对已有的运算符赋予多重含义。

59. 带有的类称为抽象类，抽象类的特征是不能声明一个抽象类的，但可以声明一个抽象类的指针或引用。

60. 若表达式(x+(y-z)*(m/n))+3中的变量均为double型，则表达式值的类型为。

61. 设A为test类的对象且赋有初值，则语句test B(A); 表示。

62. 利用“对象名.成员变量”形式访问的对象成员仅限于被声明为的成员;若要访问其他成员变量，需要通过函数或函数。

63. 是指同样的消息被不同类型的对象接收时导致不同的行为。

64. 在继承机制下，当对象消亡时，编译系统先执行的析构函数，然后才执行派生类中子对象类的析构函数，最后执行的析构函数。

65. 类中构造函数有个，析构函数有个。

66. 循环语句:for(int i=50; i>20; i-=2) cout<<i<<’,’;
运行时循环体的执行次数是
67. 类是用户定义的类型，具有类类型的变量称为。

当建立一个新对象时，程序自动调用。

68. 有如下类定义:
class Sample{
public: Sample(); ~Sample(); private: static int date;};
将静态数据成员data初始化为0的语句是。

69. 继承发生在利用现有类派生新类时，其中现有类称为，或父类;新类称
为，或子类。

70. 利用“对象名.成员变量”形式访问的对象成员仅限于被声明为的成员;若要访问其他成员变量，需要通过函数或函数。

71. 是指同样的消息被不同类型的对象接收时导致不同的行为。

二、单项选择题(每小题2分，共20分)
类中定义的成员默认为( )访问属性。

A.public
B. private
C. protected
D. friend
如果一个函数无返回值，定义时它的函数类型应是()。

A(任意 B(int C(void D(无
下面的函数声明中，( )是“void BC(int a,int b);”的重载函数。

A(int BC(int x,int y); B(void BC(int a,char b); C(float BC(int a,int b,int c=0); D(int BC(int a,int b=0); 与C语言printf(“Hello word\n”) ;语句功能相同的C++语句是( )。

A.cout>>”Hello word\n” B.cin>>” Hello word\n”
C. cout<<” Hello word\n”
D.cin<<” Hello word\n”
假定要对类AB定义加号操作符重载成员函数，实现两个AB类对象的加法，并返回相加结果，则该成员函数的声明语句为( )。

A. AB operator+(AB & a , AB & b)
B. AB operator+(AB & a)
C. operator+(AB a)
D. AB & operator+( )
以下不正确的语句是( )。

A(if(x>y);
B(if(x=y)&&(x!=0) x+=y;
C(if(x!=y)cin>>x;else cin>>y;
D(if(x<y) {x++;y++;}
int x=-1;
do
{x=x*x;}
while(!x);
下列说法正确的是( )。

A(是死循环 B(循环执行两次
C(循环执行一次 D(有语法错误
下面函数( )的表示方法说明它使用对象的引用作为参数。

A. test(pt *p)
B.test(pt p)
C.test(pt &p)
D.test(const P)
下面叙述不正确的是( )。

A( 基类的保护成员在派生类中仍然是保护的
B( 基类的保护成员在公有派生类中仍然是保护的
C( 基类的保护成员在私有派生类中是私有的
D( 对基类成员的访问必须是无两义性
下列运算符中，( )运算符在C++中不能重载。

A. ,:
B. +
C. -
D.〈=
在C++中，打开一个文件就是将这个文件与一个( )建立关联;关闭一个文件就是取消这种关联。

A. 流
B. 类
C. 结构
D. 对象
对while、do…while循环结构，下面说法正确的是( )。

A(只是表达形式不同
B(do…while结构中的语句至少执行一次
C(while结构中的语句至少执行一次
D(条件成立时，它们有可能一次也不执行
关于函数的调用下面不正确的是( )。

A( 由于程序总是从主函数开始，所以函数的调用总是在主函数和其他函数之间进行 B( 函数的调用可以在任意函数之间进行，只要有需要
C( 一个函数可以自己调用自己
D( 函数返回时可以不必带返回值，这时函数在定义时其类型应用void表示
关于函数的声明和定义正确的是( )。

A( 函数的声明是必须的，只有这样才能保证编译系统对调用表达式和函数之间的参数
进行检测，以确保参数的传递正确
B( 函数的定义和声明可以合二为一，可以只有函数定义即可 C( 函数在声明时，其参数标识符可省略，但参数的类型、个数与顺序不能省略 D( 函数的存储类型为外部型，所以可以在其他函数中被调用，它在定义时象其他外部变量一样，可以在其他函数内定义
用于类中虚成员函数说明的关键字是( )。

A.public
B.virtual
C. protected
D. private 有如下程序段:
int i=5;
while (int i=0) { cout<<"*"; i--;} 运行时输出“*”的个数是 ( )
A. 0
B.1
C. 5
D. 无穷
运算符重载时不需要保持的性质是( )
A. 操作数个数
B.操作数类型
C. 优先级
D.结合性
有如下类定义和变量定义:
class A {
public:
A() { data=0;}
~A() {}
int GetData() const { return data;}
void SetData(int n) { data=n;} private:
int data;
};
const A a;
A b;
下列函数调用中错误的是( )
A. a.GetData();
B.a.SetData(10);
C.b.GetData();
D. b.SetData(10);
对类的构造函数和析构函数描述正确的是( )
A. 构造函数可以重载，析构函数不能重载;
B. 构造函数不能重载，析构函数可以重载;
C. 构造函数可以重载，析构函数也可以重载;
D. 构造函数不能重载，析构函数也不能重载;
下列有关类的说法不正确的是( )。

A( 对象是类的一个实例
B( 任何一个对象只能属于一个具体的类
C( 一个类只能有一个对象
D( 类与对象的关系和数据类型与变量的关系相似
( )的功能是对象进行初始化。

A(析构函数 B. 数据成员 C.构造函数 D.静态成员函数关于友元的描述中，( )是错误的。

A( 友元函数是成员函数，它被说明在类体内
B( 友元函数可直接访问类中的私有成员
C( 友元函数破坏封装性，使用时尽量少用
D( 友元类中的所有成员函数都是友元函数
为了使类中的某个成员不能被类的对象通过成员操作符访问，则不能把该成员的访问权限定义为( )。

A.public
B. protected
C.private
D. static
下面对静态数据成员的描述中，正确的是( )。

A.静态数据成员是类的所有对象共享的数据
B.类的每一个对象都有自己的静态数据成员
C.类的不同对象有不同的静态数据成员值
D.静态数据成员不能通过类的对象调用
下列表达方式正确的是( )。

A(class P{ B( class P{ public: public:
int x=15; int x;
void show(){cout<<x;} void show(){cout<<x;}
}; }
C( class P{ D. class P{
int f; public:
}; int a;
f=25; void Seta (int x) {a=x;}
以下叙述中不正确的是( ):
A.一个类的所有对象都有各自的数据成员，它们共享函数成员;
B. 在一个类中可以声明另一个类的对象作为它的数据成员;
C. 类与对象的关系和数据类型与变量的关系相似;
D. 一个对象可以属于多个类。

对于一个功能不太复杂，并且要求加快执行速度，选用( )合适 A(内置函数B(重载函数 C(递归调用 D(嵌套调用 Sample是一个类，执行下面语句后，调用Sample类的构造函数的次数是 ( )
Sample a[2], *p = new Sample; A.0 B. 1 C. 2 D.3
已知函数FA调用FB，若要把这两个函数定义在同一个文件中，则( ) A.FA必须定义在FB之前
B.FB必须定义在FA之前
C.若FA定义在FB之后，则FA的原型必须出现在FB的定义之前
D.若FB定义在FA之后，则FB的原型必须出现在FA的定义之前下列有关运算符函数的描述中，错误的是( ) A.运算符函数的名称总是以operator为前缀
B.运算符函数的参数可以是对象
C.运算符函数只能定义为类的成员函数
D.在表达式中使用重载的运算符相当于调用运算符重载函数
下面描述中，正确的是( )。

A(virtual可以用来声明虚函数
B(含有纯虚函数的类是不可以用来创建对象的，因为它是虚基类 C(既使基类的构造函数没有参数，派生类也必须建立构造函数 D(静态数据成员可以通过成员初始化列表来初始化
下列对基类和派生类关系的描述中，错误的是( )。

A.派生类是基类的具体化
B.派生类是基类的子集
C.派生类是基类定义的延续
D.基类是派生类的抽象
C++语言对C语言做了很多改进，C++语言相对于C语言的最根本的变化是( )。

A(增加了一些新的运算符 B.允许函数重载，并允许设置缺省参数 C(规定函数说明符必须用原型 D.引进了类和对象的概念下列表示引用的方法中，( )是正确的。

已知:int k=1000;
A(int &x=k; B(char &y; C(int &z=1000; D(float &t=&k; 下面对于友元函数描述正确的是( )。

A(友元函数的实现必须在类的内部定义 B(友元函数是类的成员函数 C(友元函数破坏了类的封装性和隐藏性 D(友元函数不能访问类的私有成员假定AB为一个类，则执行“AB a(4) , b[3] , * p[2] ;”语句时，自动调用该类构造函数的次数为( )。

A.3
B.4
C.6
D.9 以下不属于构造函数特征的是( )
A. 构造函数名与类名相同
B. 构造函数可以重载
C. 构造函数可以设置默认参数
D. 构造函数必须指定函数类型下列定义中，X是一个类, ( )是定义指向对象数组的指针p。

A(X *p[4] B(X (*p)[4] C(( X*) p[4] D(X *p[] 假定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) 以下正确的说法是( )。

A.实参和其对应的形参各占用独立的存储单元。

B.实参和其对应的形参共占用一个存储单元。

C.只有当实参和与其对应的形参同名时才共占用存储单元。

D.形参是虚拟的，不占用存储单元。

下列关于多态性的描述，错误的是( )。

A(C++语言的多态性分为编译时的多态性和运行时的多态性
B(编译时的多态性可通过函数重载实现
C(运行时的多态性可通过模板实现
D(实现运行时多态性的机制称为动态绑定
对C++编译器区分重载函数无任何意义的信息是( ) A.参数类型 B.参数个数
C.返回值类型
D..参数顺序
关于new运算符的下列描述中，( )是错误的。

A(它可以用来动态创建对象和对象数组
B(使用它创建对象或对象数组,可以使用运算符DELETE删除
C(使用它创建对象时要调用构造函数
D(使用它调用对象数组时不许指定初始值
如果一个类至少有一个纯虚函数，那么就称该类为( )。

A(抽象类 B(派生类 C(纯基类 D(以上都不对有如下程序:
#include <iostream>
using namespace std;
class A{
public:
virtual void f() {cout<<1;}
void g() {cout<<2;} };
class B: public A{
public: virtual void f() {cout<<3;}
void g() {cout<<4;} };
void show(A &a) {a.f(); a.g();} int main() {
B b; show(b); return 0; } 运行时的输出结果是( )
A.12
B.34
C.14
D.32
下列虚基类的声明中，正确的是( )
A. class virtual B:public A
B. virtual class B:public A
C. class B:public A virtual
D. class B: virtual public A 派生类的对象对它的基类成员中( )是可以访问的。

A.公有继承的公有成员
B.公有继承的私有成员
C.公有继承的保护成员
D.私有继承的公有成员
已知数组arr的定义如下:
int arr[5] = {1,2,3,4,5};
下列语句中输出结果不是2的是( )
A.cout << *arr+1 <<endl;
B.cout << *(arr+1)<<endl;
C.cout << arr[1] <<endl;
D.cout << *arr <<endl; 下列运算符中，( )运算符在C++中不能重载。

A(?: B([] C(new D(&&
有如下程序:
#include <iostream>
using namespace std;
class A{
public:
virtual void f() {cout<<1;}
void g() {cout<<2;}
};
class B: public A{
public: virtual void f() {cout<<3;}
void g() {cout<<4;} };
void show(A &a) {a.f(); a.g();} int main() {
B b;
show(b);
return 0; } 运行时的输出结果是( )
A(12 B(34 C(14 D(32
有如下程序段:
int i=4; int j=1;
int main() {
int i=8,j=i;
cout<<i<<j<<endl; }
运行时的输出结果是( )
A(44 B(41 C(88 D(81
下列情况中，不会调用拷贝构造函数的是( )。

A(用一个对象去初始化同一类的另一个新对象时 B(将类的一个对象赋予该类的另一个对象时 C(函数的形参是类的对象，调用函数进行形参和实参结合时 D(函数的返回值是类的对象，函数执行返回调用时下面对静态数据成员的描述中，正确的是( )。

A(静态数据成员是类的所有对象共享的数据
B(类的每一个对象都有自己的静态数据成员
C(类的不同对象有不同的静态数据成员值
D(静态数据成员不能通过类的对象调用
下面的函数调用
fun(a+b,3,max(n-1)*b) 则fun 的实参个数是( )。

A(3 B(4 C(5 D(6
已知函数fun的原型为
int fun(int ,int ,int) 下列重载函数原型中错误的是( )
A.char fun(int,int);
B.double fun(int,int,double);
C.int fun(int,char *);
D.float fun(int,int,int);
下面描述中，正确的是( )。

A(virtual可以用来声明虚函数
B(含有纯虚函数的类是不可以用来创建对象的，因为它是虚基类 C(即使基类的构造函数没有参数，派生类也必须建立构造函数 D(静态数据成员可以通过成员初始化列表来初始化有如下类定义:
class MyBase{
int k;
public:
MyBase(int n=0):k(n){}
int value()const{return k;}
};
class MyDerived: MyBase{
int j;
public:
MyDerived(int i): j(i){}
int getK()const {return k;}
int gutj()const{return j;}
};
编译时发现有一处语法错误，对这个错误最佳准确的描述是( )
A(在类MyDerived 的定义中，基类名MyBase 前缺少关键字public、protected 或private
B(函数getK 试图访问基类的私有成员变量k
C(类MyDerived 缺少一个无参的构造函数
D(类MyDerived 的构造的数没有对基数数据成员k 进行初始化
关于多继承二义性的描述，( )是错误的。

A(派生类的多个基类中存在同名成员时，派生类对这个成员访问可能出现二义性
B(派生类和它的基类中出现同名函数时，将可能出现二义性
C(一个派生类是从具有共同的间接基类的两个基类派生来的，派生类对该公共基类的访
问可能出现二义性
D(解决二义性最常用的方法是作用域运算符对成员进行限定
有如下的运算重载函数定义:
double operator+(int i, int k){return double(i+k);}
但定义有错误，对这个错误的最准确的描述是( )。

A(+只能作为成员函数重载，而这里的+是作为非成员函数重载的
B(两个int 型参数的和应该是int 型，而这里将+的返回类型声明为double C(没有将运算符重载函数声明为某个类的友元
D(C++已经提供了求两个int 型数据之和运算符+，不能再定义同样的运算符
关于友元的描述中，( )是错误的。

A(友元函数是成员函数，它被说明在类体内 B(友元函数可直接访问类中的私有成员 C(友元函数破坏封装性，使用时尽量少用 D(友元类中的所有成员函数都是友元函数 class Parents{
public: int publicData;
private: int privateData;};
class ChildA: public Parents{/*类体略*/};
class ChildB: private Parents{/*类体略*/};
ChildA a; ChildB b;
下面语句中正确的是:( )
A. cout<<a.publicData<<endl;
B. cout<<a.privateData<<endl;
C. cout<<b.publicData<<endl;
D. cout<<b.privateData<<endl;
对C++编译器区分重载函数无任何意义的信息是( )
A(参数类型 B(参数个数
C(返回值类型 D(常成员函数关键字const
下面的程序段的运行结果为( )
char str[] = "job", *p = str;
cout << *(p+2) << endl;
A)98 B)无输出结果 C)字符’b’的地址 D)字符’b’
已知表达式++a中的“++”是作为成员函数重载的运算符，则与++a等效的运
算符函数调用形式为( ) A(a.operator++(1) B(operator++(a) C(operator++(a,1) D(a.operator++() 下列运算符中，不能重载的是 ( )
A( && B( != C( .(成员访问运算符) D( ->
已知有数组定义
char a[3][4];
下列表达式中错误的是( )
A. a[2]=”WIN”
B. strcpy(a[2],”WIN”)
C. a[2][3]=?W?
D. a[0][1]=a[0][1]
有如下程序:
#include <iostream>
using namespace std;
class Toy{
public:
Toy(char* _n) { strcpy (name,_n); count++;}
~Toy(){ count--; }
char* GetName(){ return name; } static int getCount(){ return
count; }
private:
char name[10];
static int count; };
int Toy::count=0;
int main(){
Toy t1(“Snoopy”),t2(“Mickey”),t3(“Barbie”);
cout<<t1.getCount()<<endl; return 0; }
运行时的输出结果是( )
A.1
B.2
C.3
D.运行时出错
将运算符重载为类成员函数时，其参数表中没有参数，说明该运算是( ) A(不合法的运算符 B(一元运算符 C(无操作数的运算符 D(二元运算符有如下程序: #include <iostream>
using namespace std;
class Toy{
public:
Toy(char* _n) { strcpy (name,_n); count++;}
~Toy(){ count--; }
char* GetName(){ return name; } static int getCount(){ return count; }
private:
char name[10];
static int count; };
int Toy::count=0;
int main(){
Toy t1(“Snoopy”),t2(“Mickey”),t3(“Barbie”);
cout<<t1.getCount()<<endl; return 0; }
运行时的输出结果是( )
A(1 B(2 C(3 D(运行时出错有如下两个类定义
class AA{};
class BB{ AA v1,*v2; BB v3; int *v4; }; 其中有一个成员变量的定义是错误的，这个变量是( ) A(v1 B(v2 C(v3 D(v4
有如下类定义:
class XX{
int xdata;
public: XX(int n=0) : xdata (n) { } }; class YY : public XX{ int ydata; public: YY(int m=0, int n=0) : XX(m), ydata(n) { } };
YY类的对象包含的数据成员的个数是( )
A(1 B(2 C(3 D(4
字符串常量"MyName\n"在内存中需要占用( )字节
A(6 B(7 C( 8 D( 9
下列表达方式正确的是( )。

A(class P{ B( class P{
public: public:
int x=15; int x;
void show(){cout<<x;} void show(){cout<<x;}
}; }
C( class P{ D. class P{
int f; public:
}; int a;
f=25; void Seta (int x) {a=x;}
关于友元的描述中，( )是错误的。

A(友元函数是成员函数，它被说明在类体内 B(友元函数可直接访问类中的私有成员 C(友元函数破坏封装性，使用时尽量少用 D(友元类中的所有成员函数都是友元函数有如下程序段:
int i=4; int j=1;
int main() {
int i=8,j=i;
cout<<i<<j<<endl;}
运行时的输出结果是( )
A(44 B(41 C(88 D(81
已知表达式++a中的“++”是作为成员函数重载的运算符，则与++a等效的运算符函数调用形式为( )
A(a.operator++(1) B(operator++(a)
C(operator++(a,1) D(a.operator++()
#include<iostream>
using namespace std;
class Test{
public:
Test(){}
~Test(){cout<<'#';}
};
int main(){
Test temp[2], *pTemp[2];
return 0;
}
执行这个程序输出星号(#)的个数为( )。

A(1 B(2 C(3 D(4
关于多继承二义性的描述，( )是错误的。

A(派生类的多个基类中存在同名成员时，派生类对这个成员访问可能出现二义性
B(一个派生类是从具有共同的间接基类的两个基类派生来的，派生类对该公共基类的访问可能出现二义
性
C(解决二义性最常用的方法是作用域运算符对成员进行限定 D(派生类和它的基类中出现同名函数时，将可能出现二义性将运算符重载为类成员函数时，其参数表中没有参数，说明该运算是( )
A(不合法的运算符 B(一元运算符 C(无操作数的运算符 D(二元运算符有如下程序
#include <iostream>
using namespace std;
class A {
public:
A(int i):r1(i) {}
void print() {cout<<?E?<<r1<<?-…;}
void print() const {cout<<?C?<<r1*r1<<?-…;}
private:
int r1; };
int main(){
A al(2); const A a2(4); al.print();a2.print(); return 0;
}
运行时的输出结果是( )
A(运行时出错 B(E2-C16- C(C4-C16- D(E2-E4-
下列有关运算符函数的描述中，错误的是( ) A(运算符函数的名称总是以operator为前缀
B(运算符函数的参数可以是对象
C(运算符函数只能定义为类的成员函数
D(在表达式中使用重载的运算符相当于调用运算符重载函数下列关于this指针的说法正确的是( )
A. this指针存在于每个函数之中
B. 在类的非静态函数中this指针指向调用该函数的对象
C. this指针是指向虚函数表的指针
D. this指针是指向类的函数成员的指针
有如下程序段:
int i=5;
while (int i=0) { cout<<"*"; i--;}
运行时输出“*”的个数是 ( )
A. 0
B.1
C. 5
D. 无穷
下列有关内联函数的叙述中，正确的是( )。

A(内联函数在调用时发生控制转移
B(内联函数必须通过关键字inline 来定义
C(内联函数是通过编译器来实现的
D(内联函数体的最后一条语句必须是return 语句
一个类可包含析构函数的个数是( )
A(0个 B(1个 C(至少一个 D(0个或多个
关于虚函数的描述中，正确的是( )。

A(虚函数是一个static类型的成员函数
B(虚函数是一个非成员函数
C(基类中说明了虚函数后，派生类中将其对应的函数可不必说明为虚函数
D(派生类的虚函数与基类的虚函数具有不同的参数个数和类型下面对于友元函数描述正确的是( )
A(友元函数的实现必须在类的内部定义
B(友元函数是类的成员函数
C(友元函数破坏了类的封装性和隐藏性
D(友元函数不能访问类的私有成员
在公有派生情况下，有关派生类对象和基类对象的关系，下列叙述不正确的是( )
A(派生类的对象可以赋给基类的对象
B(派生类的对象可以初始化基类的引用
C(派生类的对象可以直接访问基类中的成员 D(派生类的对象的地址可以赋给指向基类的指针
下列关于虚基类的描述，错误的是( ) A(设置虚基类的目的是为了消除二义性B(虚基类的构造函数在非虚基类之后调用
C(只有最远派生类的构造函数调用虚基类的构造函数 D(若虚基类由非虚基类派生而来，则仍然先调用基类构造函数，再调用派生类的构造函数。