c++期末考试判断题+填空题

1

判断题

1、对空指针不能用delete运算符。（错误）

2、对重载的函数，要求函数类型相同但参数不同。（错误）

3、任何一个对象只能属于一个具体的类。（正确）

4、用new运算符来创建对象时不会调用构造函数。（错误）

5、对重载的函数，要求参数不同或函数类型不同。（错误）

6、在公有继承中，基类中的公有成员和私有成员在派生类中都是可见的。（错误）

7、析构函数可以是虚函数。（正确）

8、无论什么方式的继承，基类的私有成员都不能被派生类访问。（正确）

9、要达到动态联编的效果，基类和派生类的对应函数不仅名字相同，而且返回类型、参数个数和类型也必须相同。（正确）

10、如果派生类没有实现虚函数，那么它将使用他的基类的虚函数。（正确）

11、构造函数可以是虚函数。（错误）

12、指向对象数组的指针不一定必须指向数组的首指针。（正确）

13、对象数组的元素可以是不同类的对象。（错误）

14、对象数组可以赋初值又可以赋值。（错误）

15、一个类的构造函数可以不包含对其子对象的初始化。（错误）

16、在C++中，既允许单继承，又允许多继承。（正确）

17、派生类从基类派生出来，它不能生成新的派生类。（错误）

18、派生类的继承方式只有2种：公有继承和私有继承。（错误）

19、在公有继承中，基类的成员在派生类中都可以直接使用。（错误）

20、在单继承中，派生类中对基类成员的访问也会出现二义性。（错误）

21、解决多继承下二义性问题的方法之一是使用作用域运算符。（正确）

22、作用域运算符(::)只能用来限定成员函数所属的类。（错误）

注：还限制成员变量所属的类。

23、析构函数是一种函数体为空的成员函数。（错误）

24、构造函数和析构函数都不能重载。（错误）

注：构造函数可以重载，析构函数不可以重载（因为析构函数无参数，不可能进行参数区分）。

25、说明或定义对象时，类名前面不需要加class关键字。（正确）

26、对象成员的表示与结构变量成员表示相同，使用运算符．或->。（正确）

27.所谓私有成员是指只有类中所提供的成员函数才能直接使用它们，任何类以外的函数对它们的访问都是非法的。（错误）注：私有成员还可以被友元访问。

28、某类中的友元类的所有成员函数可以存取或修改该类中的私有成员。（正确）

29、可以在类的构造函数中对静态数据成员进行初始化。（错误）

注：静态数据成员属于类而不管是否存在该类的对象，只有创建对象才会调用构造函数，所以静态成员不应该在构造函数中初始。

30、如果一个成员函数只存取一个类的静态数据成员，则可将该成员函数说明为静态成员函数。（正确）注：一般情况，静态成员函数不能访问类的非静态成员；非静态成员函数可访问类任何成员。

31、使用关键字class定义的类中缺省的访问权限是私有(private)的。（正确）

32、已知：m是类A的对象，n是类A的公有数据成员，p是指向类A中n成员的指针。下述两种表示是等价的：m.n和m.*p （正确）

第 1 页 共 17 页

2

33、指向对象的指针与对象都可以作函数参数，但是使用前者比后者好些。（正确）

34、对象引用作函数参数比用对象指针更方便些。（正确）注：不需要间接访问

35、对象数组的元素可以是不同类的对象。（错误）

36、对象数组既可以赋初值又可以赋值。（正确）

37、指向对象数组的指针不一定必须指向数组的首元素。（正确）注：指针可以移动。

38、一维对象指针数组的每个元素应该是某个类的对象的地址值。（正确）

39、const char* p说明了p是指向字符串的常量指针。（错误）注：p是指向字符串常量的指针-正确。

40、一个类的构造函数中可以不包含对其子对象的初始化。（正确）

注：形式上可以，但本质会调用缺省构造函数对子对象进行初始化。本题有二义性。

41、转换函数不是成员函数，它是用来进行强制类型转换的。（错误）

42、指向对象的指针和指向类的成员的指针在表示形式上是不相同的。（正确）

43、C++语言中，既允许单继承，又允许多继承。（正确）

44、派生类是从基类派生出来，它不能再生成新的派生类。（错误）

45、派生类的继承方式有两种：公有继承和私有继承。（错误）//还有保护继承

45、在公有继承中，基类中的公有成员和私有成员在派生类中都是可见的。（错误）

注：基类中的公有成员和保护成员在派生类中都是可见的，基类私有成员在派生类中不可见。

47、在公有继承中，基类中只有公有成员对派生类对象是可见的。（正确）

48、在私有继承中，基类中只有公有成员对派生类是可见的。//保护成员也可见（错误）

49、在私有继承中，基类中所有成员对派生类的对象都是不可见的。（正确）

注：基类成员public,protected成员都变成派生类private成员了。

50、在保护继承中，对于垂直访问同于公有继承，而对于水平访问同于私有继承。（正确）

51、派生类是它的基类的组合。（错误）//不仅是组合，更重要的是扩充和完善

52、构造函数可以被继承。（错误）

53、析构函数不能被继承。（正确）注：构造函数、析构函数都不能继承。

54、子类型是不可逆的。（正确）

55、只要是类M继承了类N，就可以说类M是类N的子类型。（错误）//公有继承

56、如果A类型是B类型的子类型，则A类型必然适应于B类型。（正确）

57、多继承情况下，派生类的构造函数的执行顺序取决于定义派生类时所指定的各基类的顺序。（正确）

58、单继承情况下，派生类中对基类成员的访问也会出现二义性。（错误）

59、解决多继承情况下出现的二义性的方法之一是使用成员名限定法。（正确）注：严格讲“作用域限定”。

60、虚基类是用来解决多继承中公共基类在派生类中只产生一个基类子对象的问题。（错误）注：“多个”

61、函数的参数个数和类型都相同，只是返回值不同，这不是重载函数。（正确）

62、重载函数可以带有缺省值参数，但是要注意二义性。（正确）

63、多数运算符可以重载，个别运算符不能重载，运算符重载是通过函数定义实现的。（正确）

64、对每个可重载的运算符来讲，它既可以重载为友元函数，又可以重载为成员函数，还可以重载为非成员函数。（错误）//“可以重载为非成员函数”不确切。

65、对单目运算符重载为友元函数时，说明一个形参；重载为成员函数时，不能显式说明形参。（错误）

第 2 页 共 17 页

3

注：前面描述对的。此题不全面，应该是“重载为成员函数时，除了后置++、--，不能显式说明形参。本题一般理解也可以按上面描述，此题考试不扣分。

66、重载运算符保持原运算符的优先级和结合性不变。（正确）

67、虚函数是用virtual关键字说明的成员函数。（正确）

68、构造函数说明为纯虚函数是没有意义的。（正确）

69、抽象类是指一些没有说明对象的类。（错误）//抽象类是指一些“不能”说明对象的类。

70、动态联编是在运行时选定调用的成员函数的。（正确）

1. 重载流操作符<<和>> 时，如果第一个参数的类型为ostream 和istream，那么这个重载函 数既可以用于标准输入输出流，也可以用于文件流上。

对，ostream 和istream是标准输入输出流、文件流、字符串流的基类

2. 在同一个类中，可以定义重载的成员函数 void f(int);和virtual void f(int); 。

错，这属于重复定义

3. 抽象类不会产生实例，所以不需要有构造函数。

错，被派生时需要它的构造函数

4. 类A有一个非静态的成员函数f，其函数原型是：void A::f( ) const，则该函数被调用时， 一定是通过类A或类A的某后裔类的一个用const修饰符说明的常量对象调用的。

错，常函数可以由变量对象或常量对象调用

5. 异常必须在其产生的当前函数中捕获，而不能在外层函数中捕获该异常。

错，可以在外层捕获，并且这是最常见的用法

6. 只要程序中没有A a1 = a2; 和A a1(a2); 形式的代码，类A的拷贝构造函数就不会被调

用。

错，参数传递或函数返回时也调用拷贝构造函数

7. 在protected继承方式下，派生类对象的指针不能直接转换成指向基类对象的指针。

对，否则基类中的公有成员由不可见变为可见，权限被放大

8. 若静态成员函数中调用了一个函数f，那么f 一定不是虚函数。 对，静态成员函数不能是虚函数，因为虚函数入口需要在保存在对象中的虚函数 表中，而静态成员函数不属于对象。

9. 若要实例化一个含有引用型数据成员的类，那么只能使用构造函数初始化列表来初始化该

数据成员。

对，没有别的办法

10. 构造函数的函数体中，不能使用return语句；但在实现该类的自动类型转化函数时，必须 有return 语句。

对

1、C++中标识符内的大小写字母是没有区别的。 （F）

2、C++是一种以编译方式实现的高级语言。 （T）

3、在公有继承中，基类中的公有成员和私有成员在派生类中都是可见的。 （ F）

4、在私有继承中，基类中所有成员对派生类都是不可见的。 （ F）

5、返回值类型、参数个数和类型都相同的函数也可以重载。 （F）

第 3 页 共 17 页

4

6、使用关键字class定义的类中缺省的访问权限是私有（private）的。 （T）

7、类的私有成员只能被类中的成员函数访问，任何类以外的函数对它们的访问都是非法的。（F） ）

8、C++中使用了新的注释符（//），C语言中注释符（/*…*/）不能在C++中使用。 （ F）

9、While循环语句的循环体至少执行一次。 （ F）

10、引用就是某个变量的别名，对引用的操作，实质上就是对被引用的变量的操作。 （T ）

11、类封装了数据和操作。 （ T ）

12、在类的定义中，必须包含private、public、protected三种存取方式对应的部分。

（ F ）

13、类中的数据成员不能为指针类型。 （ F ）

14、析构函数可以有形参。 （T ）

15、派生类至少有一个基类。 （T ）

16、在公有和保护继承方式下，派生类的对象可以对基类的保护成员进行访问。

（ T ）

17、全局函数和静态成员函数也能声明为虚函数。 （F ）

18、在一个类的对象空间里不包含静态成员的空间。 （ T ）

19、友元本身就是类的成员。 （ T ）

20、运算符重载后，原运算符的优先级和结合特性会改变。 （ F ）

21、一个类只能有一个对象。 （ F）

22、在类中不能对所定义的数据成员进行初始化。 （ T ）

23、类的公有成员函数是类与外界的接口。 （ T ）

24、构造函数没有函数类型。 （ T ）

25、在派生类的构造函数的初始化表中不能对包含基类的子对象初始化。

（ T ）

26、在公有和保护继承方式下，派生类的成员可以对基类的保护成员进行访问。

（ F ）

27、只有类的成员函数才能声明为虚函数。 （ T ）

28、在一个类的对象空间里已经包含了静态成员的空间。 （F ）

29、C++不允许将构造函数、析构函数和虚函数声明为友元函数。（ T ）

30、运算符重载后，原运算符的优先级和结合特性不会改变。 （ T ）

31. C++中使用了新的注释符（//），C语言中注释符（/*…*/）不能在C++中使用。 （ F）

32. 数组赋初值时，初始值表中的数据项的数目可以大于或等于数组元素的个数。 （ F）

33. 隐含的类型转换都是保值映射，显式的类型转换都是非保值映射。 （ F）

34. 宏定义命令是以分号结束的。 （ F）

35. While循环语句的循环体至少执行一次。 （ F）

36. 返回值类型、参数个数和类型都相同的函数也可以重载。 （ F）

37. 函数形参的作用域是该函数的函数体。 （ T）

38. 静态类标识符在它的作用域之外是不存在的。 （ F）

39. 对象成员的表示与结构变量成员表示相同，使用运算符.或->。 （T ）

40. 某类中的友元类的所有成员函数可以存取或修改该类中的私有成员。 （T ）

41. 对象数组的元素可以是不同类的对象。 （ T）

42. const char *p说明了p是指向字符串的常量指针。 （F ）

43、引用就是某个变量的别名，对引用的操作，实质上就是对被引用的变量的操作。（ F）

44、无论是私有继承还是保护继承中，基类中所有成员对派生类对象都是不可见的。（T ）

45、当break语句用在双重循环的内循环中时，它只能退出内循环到外循环中去，而不能直出整个双重循环。 （ T）

第 4 页 共 17 页

5

46、 For循环是只有可以确定的循环次数时才可使用，否则不能用for循环。 （F ）

47、返回值类型、参数个数和参数类型都相同的函数也可以重载。 （ F）

48、通常的拷贝初始化函数的参数是某个对象的成员名或对象的引用名。 （T ）

49、友元函数是类的成员函数，所以可以存取或修改该类中的私有成员。 （ F）

50、已知：类A中一个成员函数说明如下：void Set(A&a)；其中A &a的含意是将a的地给变量Set。

（F ）

51、在语句const char *ptr中， ptr是指向字符串的常量指针。 （ F）

52、多继承情况下，派生类的构造函数的执行顺序取决于定义派生类时所指定的各基类的顺序，而与派生类构造函数中所定义的成员初始化列表的各项顺序无关。 （ T）

53、在说明语句 int a(15),&b=a,*p=&a;中，b的值的*P的是不相等的。（ F ）

54、已知：int a(5),b(10); 表达式++a+b++有二义性。（ F ）

55、在不同类型操作数组成的表达式中，其表达式的类型一定是最高类型double型。（F ）

56、break语句也可以用于if体内，它可退出if语句。（ F ）

57、在一个被调用函数中，一个return语句可返回多个值给调用函数。（ F ）

58、在传值调用中，要求实参和形参的类型完全一致并且个数相等。（ F ）

59、for循环中，循环变量的作用域是该循环的循环体内。（ F ）

60、所谓私有成员是指只有类中所提供的成员函数才能直接访问它们，任何类以外的函数对它们的访问都是非法的。（ F ）

61、const char *p说明了p是指向字符串的常量指针。（ F ）

62、私有继承中，基类中所有成员对派生类的对象都是不可见的。（ F ）

第 5 页 共 17 页

6

填空

1、定义类的动态对象数组时，系统只能够自动调用该类的 无参 构造函数对其进行初始化。

2、在 C++ 程序设计中，建立继承关系倒挂的树应使用单一 ( 或单 )继承。

3、表达式 cout<

4、基类的公有成员在派生类中的访问权限由 访问控制 决定。

5、C++ 支持的两种多态性分别是编译时的 ( 或静态，或操作重载 ) 多态性和运行时的 ( 或动态，或虚函数 ) 多态性。

6、C++ 中语句 const char * const p= ″ hello ″；所定义的指针 p 和它所指的内容都不能被 改变 ( 或重新赋值 )。

7、假定 AB 为一个类，则语句 AB(AB&x) ；为该类复制初始化 ( 或拷贝 )构造函数的原型说明。

8、将关键字 const 写在成员函数的 函数头 ( 或参数表 )和函数体之间时，所修饰的是 this

指针。

9、在 C++ 中，访问一个对象的成员所用的运算符是成员选择运算符 ( 或“ . ” )，访问一个指针所指向的对象的成员所用的运算符是成员访问运算符 ( 或“ -> ” )。

10、派生类从一个或多个以前定义的该类的 基 类继承数据和函数。

11、在一个类中可以对一个操作符进行函数重载。

12、在C++中有二种参数传递方式：传值与传引用。

13、模板对处理数据的类型的要求不同可以分为两种类型：函数模板与类模板。

14、静态联编是在程序_ 编译 时进行的，而动态联编是在程序_ 运行 时进行的。

15、在函数体之前加___const__关键字可以防止函数改变数据成员的值。

16、一个const对象只能访问__ const _成员函数。

17、派生类的主要用途是可以定义其基类中成员函数。

18、当建立____对象时__，程序自动调用该类的构造函数。

19、使用指向对象的指针来标识类的成员，则使用的运算符是_->__。

20、拷贝初始化构造函数使用 一个已知对象 来初始化创建中的对象。

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

22、设px是指向一个类动态对象的指针变量，则执行”delete px;”语句时，将自动调

用该类的析构函数。

23、若需要把一个函数”void F();”定义为一个类AB的友元函数，则应在类AB的定义

中加入一条语句：friend void F();

24、若要在程序文件中进行标准输入输出操作，则必须在开始的#include命令中使用

iostream.h 头文件。

25、在C++中，用数组、指针、和引用作为函数参数，能够将参数值带回。

26、在C++中，虽然友元提供了类之间数据进行访问的一种方式，但它破坏了面向对象程序设计的封装特性。

27、在C++中，构造派生类对象时，总是先从基类的初始化开始的。

28、拷贝构造函数是在用一个对象初始化另一个对象时被调用，系统缺省的拷贝构造函数的工作方法是各个成员的复制。

29、类是用户定义的类型，具有类类型的变量称作 对象。

30、在C++中，类定义一般用class关键字，不过用struct关键字也可以定义类，它们定义类的区别在于用class定义时成员默认为private, 用struct定义时成员默认为public。

31、静态的成员函数没有隐含的this指针，所以，它们只能访问静态的数据成员。

32、在面向对象的程序设计中，通过类实现数据隐藏；通过继承实现代码的复用。

第 6 页 共 17 页

7

33、在下面的程序段中，语句"const int* c=&a;"和语句"int* const d=&b;"的含义分别是定义一个指向禁止修改的实体的指针、定义一个指针常量（不可修改的指针）。

const int a=78;

int b=28;

const int* c=&a;

int* const d=&b;

34、用new申请有10个数组元素的指针str，假定数组元素是字符型数据，该C++语句为 char

*str=new char[10]。

35、在C++中构造一个对象时，其数据成员在构造函数中初始化。对于内嵌的子对象、基类成员 、静态数据成员需要在构造函数的成员初始化列表中初始化。

36、在类的定义中，保护数据成员具有双重作用：对于其派生类而言，类似于public 成员 ；而对于其外部的程序而言，类似于private 成员。

37、C++中，对象保存在内存中，栈内存是自动分配和释放的，而堆内存需要用户自己申请和释放。

38、在C++函数中，可用return语句带回一个值。如果有多个返回值，可用指针、引用带回。

39、拷贝构造函数使用对象引用作为参数初始化创建中的对象。

40、用new申请某一个类的动态对象数组时，在该类中必须能够匹配到缺省的构造函数，否则应用程序会产生一个编译错误。

41、 静态数据成员在类外进行初始化，且静态数据成员的一个拷贝被类的所有对象使用。

42、面向对象的程序设计有四大特征，它们是抽象、封装、继承 、多态性。

43、在C++中，定义重载函数时，应至少使重载函数的参数个数或参数类型不同。

43、动态联编要满足两个条件，它们是使用基类指针、虚函数。

44、在C++类中，有一种不能定义对象的类，这样的类只能被继承，称之为抽象类，定义该类至少具有一个纯虚函数。

45、在C++类中，const关键字可以修饰对象和成员函数，const对象不能被修改，只有const成员函数才能操作const对象。

46、举出C++中两种用户自定义的数据类型：结构体 、类。

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

48、对虚函数使用基类类型的指针或引用调用，系统使用动态联编；而使用对象调用时，系统使用静态联编。

49、允许访问一个类的所有对象的私有成员、公有成员和保护成员的函数是该类的成员函数和友员函数。

50、执行完C++程序中的三条语句：

int a,b,*c=&a;

int * &p = c;

p = &b;

后c指向 b 。

51、在类定义中，类说明以关键字class开始，其后跟类名，它必须是一个有效的C++标识符。类说明的内容用花括号括起来，称为类的定义。

52、实现类对象初始化任务的是该类的构造函数。

53、初始化类模板时，相对于它的每个参数要提供类型参数。

54、从一个抽象类派生的类必须提供纯虚函数的实现代码，或者在该派生类中将它再说明为纯虚函数。

55、. 将关键字 const 写在函数头之后，函数体之前，说明该函数是一个 const 成员函数。此时 const 不是指定函数的返回值，而是修饰 this 指针。

第 7 页 共 17 页

8

56、一个抽象类的派生类可以实例化的必要条件是实现了所有的纯虚函数 。

57、在 C++ 中，虚函数帮助实现了类的 多态 性，而虚基类解决了二义性。

58、通过 C++ 语言中类的 继承，可以扩充和完善已有类以适应新的需求。

59、为了在对象生存期结束时释放其指针成员所指向的动态存储空间，通常需要为该类定义

析造函数。

60、在已经定义了整型指针 ip 后，为了得到一个包括 10 个整数的数组并由 ip 所指向，应使用语句 ip=new int [10];。

1． 在C++中，函数的参数有两种传递方式，它们是值传递和 地址或指针或引用传递。

2． 当一个成员函数被调用时，该成员函数的 this指针 指向调用它的对象。

3．在基类和派生类中，派生类可以定义其基类中不具备的数据和操作。对两个有相同名字的数据成员进行访问时，如果没有 作用域分隔符限定时 ，对此数据成员的访问将出现歧义。

4． 拷贝构造函数使用 引用 作为参数初始化创建中的对象。

5． 在公有继承的情况下，基类数据成员在派生类中的访问权限 保持不变 。

6． 描述命题"A小于B或小于C"的表达式为 A

7． 用new申请某一个类的动态对象数组时，在该类中必须能够匹配到 没有形参的或缺省参数 构造函数，否则应用程序会产生一个编译错误。

8．静态数据成员在类外进行初始化，且静态数据成员的一个拷贝被类的所有对象 共享 。

9．为了避免可能出现的歧义，C++对if…else语句配对规则规定为：else总是与 与最近的if 配对。

10． 设"int a=3,b=4,c=5;"，表达式"（a+b）>c&&b==c"的值是 0 。

（以下每小题2分，共20分）

11． 面向对象的程序设计有四大特征，它们是抽象、封装、 继承 、 多态 。

12． 在Visual C++中，定义重载函数时，应至少使重载函数的参数个数或参数类型 不同 ；在基类和派生类中，成员函数的覆盖是指 派生类成员函数与在基类被覆盖的成员函数名、参数个数、参数类型和返回值类型均相同 。

13．构造函数与析构函数除功能不同外，在定义形式上，它们的区别还包括构造函数名与类名相同，而析构函数名是在类名前加一个~、 析构函数没有参数 、析构函数可以定义为虚函数 。

14． 动态联编要满足两个条件，它们是 被调用的成员函数是虚函数 、用指针或引用调用虚函数 。

15．在C++类中，有一种不能定义对象的类，这样的类只能被继承，称之为 抽象类 ，定义该类至少具有一个 纯虚函数 。

16． 在C++类中，const关键字可以修饰对象和成员函数，const对象不能 被修改 ，const成员函数不能 修改类数据成员 。

17． 举出C++中两种用户自定义的数据类型： 类 、 枚举 。

18． C++中没有字符串类型，字符串是通过 字符数组 来表示的，每一个字符串都有一个结尾字符 0 。

19． C++中没有输入输出语句，输入输出是通过 输入输出库 实现的，写出一条打印整型变量n的输出语句：cout<

20． 举出C++中两种代码复用的方式： 继承 、复用 。

1. C++语言的头文件与源程序文件扩展名分别是（.h ）和（ .cpp ）。

第 8 页 共 17 页

9

2. 在C++程序中使用基本输入与输出流时需要包含的头文件名是（ iostr eam ）。

3. 在C++语言中，惟一的一个三目运算运算符是（ ?: ）。

4. C++中当一个函数无返回值时，则函数的类型是（void ）。

5. 一个类中可以有（多）个构造函数，只能有（ 一 ）个析构函数。

6.一般情况下,按照面向对象的要求,把类中的数据成员(属性)定义为（ 私有 ）权限,

而把成员函数(方法)定义为（公有 ）权限.

7.在定义类的对象时,C++程序将自动调用该对象的（ 构造 ）函数初始化对象自身.在撤销类的对象时,C++程序将自动调用该对象的（ 折构 ） 函数.

8.类继承中,缺省的继承方式是（ 私有继承 ）.

9．在C++语言中，用转义字符序列（ 'n' ）或操纵符（ endl ）表示输出一个换行符。

10．表达式a=a＋l表示成增量表达式为（ ++a ）。

11．当不需要函数返回任何值时，则应把该函数类型定义为（ void ）。

12．用于输出表达式值的标准输出流对象是（ cout）。，用于从键盘上为变量输人值的标准输人流对象是（cin ）。

13、变量分为全局和局部两种，（全局变量默认初始化为0 ）。变量没有赋初值时，其值是不确定的。

14、假定类AB中有一个公用属性的静态数据成员bb，在类外不通过对象名访问该成员bb的写法为（ AB：:bb ）。

15、类的成员分为＿数据成员＿和＿成员函数＿。

16、一个＿类＿和＿对象＿的关系，正如基本数据类型与该类型的变量一样，如int x;。

17、对一个类中的数据成员的初始化可以通过构造函数中的＿赋值＿实现，也可以通过构造函数中的＿初始化列表＿实现。

18、类有两种用法：一种是＿定义对象＿，即生成类的对象；另一种是通过＿派生＿，派生出新的类。

19、C++语言提供的＿多态＿机制允许一个派生类继承多个基类，即使这些基类是相互无关的。

20、声明虚函数的方法是在基类中的成员函数原型前加上关键字＿virtual＿。

21、如果一个类中有一个或多个纯虚函数，则这个类称为＿虚基类＿。

22、静态数据成员在定义或说明时，前面要加上关键字＿static＿。

23、如果成员函数不需要访问类的＿非静态＿成员，则可以把它声明为静态成员函数。

24、友元可以是＿全局函数＿，也可以是＿其他类的成员函数＿。

25、若需要把一个函数“void fun();”定义为一个类A的友元函数，则应在类A的定义中加入一条语句：＿friend void fun（）；＿。

26、运算符函数中的关键字是＿operator＿，它和＿运算符＿一起组成该运算符函数的函数名。

27、类中运算符重载一般采用两种形式：＿成员函数＿和＿友元函数＿。

28、面向对象程序设计的3大机制为：＿封装性＿、＿继承性＿和＿多态性＿。2、类的访问权限有＿public＿、＿private＿和＿protected＿三种。

29、构造函数是＿对象＿被创建时自动执行，对象消失时自动执行的成员函数称为＿析构函数＿。

30、如果类A继承了类B，则类A称为＿基类＿，类B称为＿派生类＿。

31、如果一个特定的类型S当且仅当它提供了类型T的行为时，则称类型S是类型T的＿＿子类型＿。

32、在类定义中，将＿=0＿置于虚函数的函数原型的末尾可以声明该函数为纯虚函数。

33、类的静态成员分为＿静态数据成员＿和＿静态成员函数＿。

34、友元函数的声明可以放在类的＿私有＿部分，也可以放在类的＿共有＿部分，它们是没有区别的。

35、如果说类B是类A的友元类，则类B的所有成员函数都是类A的＿成员函数＿。

36、设a和b是两个整型变量，我们用a+b的形式求这两个变量的和；设c和d为浮点型变量，我们用c+d的形式求这两个变量的和。显然运算符“+”具有不同的用途，这是＿运算符重载＿的例子。

37、对于双目运算符，若重载为类的成员函数，有1＿个参数；若重载为友元函数，则有＿2个参数。

38、 当建立__一个新的对象___，程序自动调用该类的构造函数。

第 9 页 共 17 页

10

39、 在C++中有二种参数传递方式：__传值___ 和___引用__ 。

40、 模板对处理数据的类型的要求不同可以分为两种类型：__函数模板__ 和 __ 类模板__。

41、 异常是通过_检查（try）__ 、_抛出（throw）__和__捕捉（catch）__ 来实现的。

42、 虚函数实现了C++的__多态__ 机制，类实现了C++的___封装__ 机制。

43、 面向对象程序设计的___继承___机制提供了重复利用程序资源的一种途径。

44、C++语言程序设计的三种基本结构是：_顺序结构_ 、 _选择结构_ 、 __循环结构__ 。

45、为了避免嵌套的条件语句if-else的二义性，C++语言规定else与__if __配对使用。

46、定义函数时，在函数的类型前加上修饰词 ___ inline ___，指明将该函数定义为内联函数。

47、有说明语句：*p；则*p++运算首先访问 ___*p___，然后使__p____ 的值加1。

48、执行int *p=new int 操作，可以得到一个动态分配整型对象的__指针____。

49、有说明语句：int *p；则(*p)++运算首先访问 ___*p___，然后使 __*p____的值加1。

50． C++目标程序经___编译链接___后生成扩展名为exe的可执行程序文件。

51． 16位计算机中整型占___2_______个字节存储空间。

52． 要在屏幕上显示"Hello，world!"应执行语句cout<<_______ "Hello，world!"; _____。

53． 表达式8&3的结果是___0_______。

54． 作为语句的函数调用是通过____函数的副作用____来体现的。

55． 执行if (x>=0||x<=0) cout<<"abcd"；else cout<<"wxyz"；屏幕上显示的是____abcd____。

56． 设一维整型数组data已进行了初始化，则其元素个数可由操作符sizeof通过表达式____ sizeof(data)

/ sizeof(int) ___计算出来。

57． 若一全局变量只允许本程序文件中的函数使用，则定义它时应加上修饰符__ static ______。

58． 设有int w[3][4]；，pw是与数组名w等价的数组指针，则pw应初始化为____ int*[4] pw = w; _____。

59.要使引用pr代表变量char * p；，则pr应初始化为________ char*& pr = p; ________。

60．在C++中封装性、继承性和_____多态性

61．假设int a=1，b＝2;则表达式a+++--b的值为 __2____。

62．下面的程序实现输出x，y，z三个数中的最大值，请填入正确的内容。

#include

void main（）

{ int x=5,y=8,z=9, u, v;

if__（x〉u）__ u=x;

else u=y;

if_（u〉v）__ v=u;

else v=z；

cout<<”v=”<

}

63．C++语言的参数传递机制包括传值和传地址两种，如果调用函数时，需要改变实参或者返回多个值，应该采取 __传地址___ 方式。

64．在C++语言中，访问一个对象的成员所用的运算符是 ___ ., ____，访问一个指针所指向的对象的成员所用的运算符是 ___ -> ___。

65．C++语言支持的两种多态性分别是编译时的多态性和 __运行时___的多态性。

66．设有如下程序结构：

class Box

{ … };

void main()

{Box A,B,C; }

该程序运行时调用___3__次构造函数；调用 ___3__次析构函数。

第 10 页 共 17 页

11

67．目前，有两种重要的程序设计方法，分别是：___面向过程__和___面向对象___。

68． C++语言提供的基本控制结构可以分为3种类型：顺序结构、__分支__ 和循环结构。

69．函数的调用主要分为传值调用和__引用调用____调用。前者的特点是_不能改变传入变量的值 _。

70．函数重载时要求同名函数的_参数个数__或_参数类型__不同，否则无法确定是哪个函数。

71．静态数据成员是类的所有对象中的____共享__成员，而非静态数据成员是属于___一个具体___对象的。

72．设A为test类的对象且赋有初值,则语句test B(A); 表示__将对象A复制给对象B ___。

73.面向对象程序设计方法中的每个对象都具有_属性__和___方法__两方面的特征。

74.“类”指的是____对象的类型，代表了某一批对象的共性和特征_____。

75.构造数据类型，包括数组、_指针_、_结构体和共用体_、__枚举_和类等。

76.C++中数据类型标识符Signed Char，其字节数为__1___，范围是__-128到127___。

77.在函数体内部定义的变量称为__局部变量_。在所有函数体外部定义的变量称为__全局变量__。

78.有一数学表达式为2/3(f-32)，要写成对应的C++的表达式时，正确地写法应写__2.0/3.0*（f-32）_。

79.类的静态成员是_的所有对象中共享_的成员，不是_某个对象___的成员，静态成员在___类的声明中__进行引用性说明，在_其文件作用域的其他地方_进行定义性说明。

80.使用传统的结构化程序设计方法设计程序的步骤是__自顶向下___、__逐步细化_、__模块化设计_。

81.“封装”指的是_将有关的数据和操作代码封装在一个对象中，形成一个基本单位，各个对象之间相互独立，互不干扰，且将对象中某些部分对外隐藏

_。

82.可以让新类继承已定义的类的_数据成员_和_成员函数_，这个新类称为__继承_，原来的类称为___基类__。新类可以从一个类中派生，这叫__单继承__，也可以从多个类中派生，称为__多重继承_。

83.指针类型变量用于存储__另一变量的地址__，在内存中它占有____一个__存储单元。

84.类有三种继承方式，分别是：__公有继承_、__保护继承__、___私有继承_。

1. C++的流库预定义了4个流，它们是cin、cout、clog和___。

答案：(P193)cerr

［解析］cin、cout、clog和cerr分别用于标准输入、输出、标准错误流（缓冲）和标准错误流

（非缓冲）。

2. 每个对象都是所属类的一个___。

答案：实例

［解析］类是对象的抽象，对象是类的一个实例。

3. 在已经定义了整型指针ip后，为了得到一个包括10个整数的数组并由ip所指向，应使用语

句___。

答案：int *ip=new int［10］;

［解析］new用来动态开辟空间。常用来产生动态数组及对象构造函数。

4. 函数模板中紧随template之后尖括号内的类型参数都要冠以保留字___。

答案：class

［解析］类模板的使用。template ,也可以引入多参数的如：template

T1，class T2,...，class Tn>

5. 定义类的动态对象数组时，系统只能够自动调用该类的___构造函数对其进行初始化。

答案：无参

［解析］使用new创建对象数组，调用无参构造函数。

6. 表达式cout<

答案：‘＼n’

［解析］endl与字符常量‘＼n’等价。

7. 在C++中，访问一个指针所指向的对象的成员所用的指向运算符是___。

答案：->

第 11 页 共 17 页

12

［解析］指针使用成员有两种方法：“->”指向运算符和“.”成员访问运算符。

8. 假如一个类的名称为MyClass，使用这个类的一个对象初始化该类的另一个对象时，可以调

用___构造函数来完成此功能。

答案：复制或拷贝

复制或拷贝构造函数就是用对象初始化新的对象。

9. 对赋值运算符进行重载时，应声明为___函数。

答案：(P183)类成员

［解析］运算符重载的方法有友元或者成员函数两种途径，但是赋值运算符只能使用成员函数的

方法来实现。

10. 如果要把A类成员函数f（）且返回值为void声明为类B的友元函数，则应在类B的定义中加

入的语句___。

答案：(P109)friend void A::f()；

［解析］成员函数作为另一个类的友元函数，格式为：friend 返回类型 类名::函数(形参)。

11. 下列程序段的输出结果是___。

for(i=0,j=10,k=0;i<=j;i++,j-=3,k=i+j);cout<

答案：4

［解析］for循环结构,三个表达式的作用，初始化、循环判断条件和循环变量变化。循环执行了

三次，k的作用是计算i、j的和。

12. String 类的___方法返回查找到的字符串在主串的位置。

答案：(P40)find

［解析］string类对象方法的find，查不到字符串，则返回-1。

13. int n=0;

while（n=1）n++;

while循环执行次数是___。

答案：无限次

［解析］＝是赋值运算符，不是关系运算符，且不等0，所以死循环。

14. 控制格式输入输出的操作中，函数___是用来设置填充字符。要求给出函数名和参数类型

答案：setfill(char)

［解析］格式控制方法的使用，如setw，setfill等等。

15. C++语言支持的两种多态性分别是编译时的多态性和___的多态性。

答案：运行时

［解析］多态性包括静态的（编译时）多态性和动态的（运行时）多态性。

16. 设函数sum是由函数模板实现的，并且sum(3,6)和sum(4.6,8)都是正确的函数调用，则函

数模板具有___个类型参数。

答案：2

17. 执行下列代码

string str("HelloC++");

cout<<(5，3);

程序的输出结果是___。

答案：C++

［解析］substr取子字符串，第1个参数表示要截取子串在字符串中的位置，第2个表示取多少个

字符。

18. 在面向对象的程序设计中，将一组对象的共同特性抽象出来形成___。

答案：类

［解析］类是相似特征的对象的抽象，对象是类的一个实例。

19. 定义类动态对象数组时，元素只能靠自动调用该类的___来进行初始化。

答案：无参构造函数

［解析］使用new 创建动态对象数组，不能有参数，所以只能调用无参的构造函数，初始化对象

20. 已知有20个元素int类型向量V1，若用V1初始化为V2向量，语句是___。

答案：ector V2(V1);

［解析］采用向量初始化另一个向量的形式：vector name1(name);

第 12 页 共 17 页

13

1. 假设int a=1,b=2;则表达式(++a/b)*b--的值为___。

答案：2

［解析］前缀＋＋或――表示先使变量值变化，再使用，这和后缀恰恰相反。但是编译

cout<<(++a/b)*b--时，先++a/b值为1，后1*b--，先取b＝2，结果为2，再让b＝1。

2. 抽象类中至少要有一个___函数。

答案：纯虚

［解析］至少有一个纯虚函数的类就称为抽象类，即不能实例化。

3. 一个抽象类的派生类可以实例化的必要条件是实现了所有的___。

答案：纯虚函数的定义

［解析］抽象类只因有纯虚函数，所以不能被实例化，所以派生类要实例化必须对纯虚函数进行

定义。

4. 下面程序的输出结果为___。

#include

void main()

{int num=2,i=6;

do

{i--;

num++;

}while(--i);

cout<

}

答案：5

［解析］do－while循环，前缀先使i减少1后判断是否为零，不为零时再次执行循环，为零退出

循环。循环值执行3次就退出，所以结果为5。

5. 静态成员函数、友元函数、构造函数和析构函数中，不属于成员函数的是___。

答案：友元函数

［解析］友元函数不是类成员，但可以访问类成员。类的封装性保证了数据的安全，但引入友元

，虽然访问类是方便了，但确实破坏类访问的安全性。

6. 在用C＋＋进行程序设计时，最好用___代替malloc。

答案：new

［解析］new与delete是C++语言特有的运算符，用于动态分配和释放内存。new用于为各种数据

类型分配内存，并把分配到的内存首地址赋给相应的指针。new的功能类似于malloc（）函数。

使用new的格式为：

<指针变量>new<数据类型>;

其中，<数据类型>可以是基本数据类型，也可以是由基本类型派生出来的类型；<指针变量>取得

分配到的内存首地址。new有3种使用形式。

（1）给单个对象申请分配内存

第 13 页 共 17 页

14

int *ip;ip=new int;//ip指向1个未初始化的int型对象

（2）给单个对象申请分配内存的同时初始化该对象

int *ip;ip=new int(68);//ip指向1个表示为68的int型对象

（3）同时给多个对象申请分配内存

int *ip;ip=new int［5］;//ip指向5个未初始化的int型对象的首地址

for(int i=0;i<5;i++)ip［i］=5*i+1;//给ip指向的5个对象赋值

用new申请分配内存时，不一定能申请成功。若申请失败，则返回NULL，即空指针。因此，在程

序中可以通过判断new的返回值是否为0来获知系统中是否有足够的空间供用户使用。

7. 由const修饰的对象称为___。

答案：常对象

［解析］使用const关键字说明的成员函数称为常成员函数，使用const关键字说明的对象称为常

对象。

常成员函数的说明格式如下：<返回类型说明符><成员函数名>(<参数表>)const;

常成员函数不更新对象的数据成员，也不能调用该类中没有用const修饰的成员函数。常对象

只能调用它的常成员函数，而不能调用其他成员函数。const关键字可以用于参与重载函数的区

分。

8. 在C++程序设计中，建立继承关系倒挂的树应使用___继承。

答案：单

［解析］一个基类可以派生多个子类，一个子类可以再派生出多个子类，这样就形成了一个倒立

的树。

9. 基类的公有成员在派生类中的访问权限由___决定。

答案：访问控制方式或继承方式

10. 不同对象可以调用相同名称的函数，但执行完全不同行为的现象称为___。

答案：多态性

［解析］多态性的概念。虚函数是实现多态的基础，运行过程中的多态需要同时满足3个条件

：(1)类之间应满足子类型关系。(2)必须要有声明的虚函数。(3)调用虚函数操作的是指向对象

的指针或者对象引用；或者是由成员函数调用虚函数（如果是在构造函数或析构函数中调用虚函

数，则采用静态联编）。

11. this指针始终指向调用成员函数的___。

答案：对象

this指针是隐藏的指针，它指向调用函数的对象。

12. 预处理命令以___符号开头。

答案：operater

［解析］文件包含、预处理和编译都是以＃开头。

13. 类模板用来表达具有___的模板类对象集。

答案：相同处理方法

［解析］模板特点是不同的数据具有相同的处理方法的抽象。

14. C++程序的源文件扩展名为___。

答案：cpp

第 14 页 共 17 页

15

［解析］源程序*.cpp,目标文件为*.obj,可执行程序*.exe。

15. 在#include命令中所包含的头文件，可以是系统定义的头文件，也可以是___的头文件。

答案：自定义

［解析］＃include装入文件有两种方式<>和“”，一是系统的，一是自定义文件。

16. vector类中向向量尾部插入一个对象的方法是___。

答案：push_back

17. C++语言中如果调用函数时，需要改变实参或者返回多个值，应该采取___方式。

答案：传地址或引用

［解析］传地址即指针，在函数中通过指针修改它指向的变量的值时，实参也就变化了。使用引

用，直接修改变量的别名即引用的值，该变量也就随着变化。

18. 语句序列

ifstream infile;

(“”);

的功能可用一个语句实现，这个语句是___。

答案：ifstream infile(“”);

［解析］void ifstream::open(const char *fname,int mode=ios::in,int

access=filebuf::openprot);

ifstream::ifstream(const char *fname,int mode=ios::in,int

access=filebuf::openprot);

其中，第一个参数是用来传递文件名的；第二个参数mode的值决定文件将如何被打开；第三个参

数access的值决定文件的访问方式，一般取缺省值filebuf::openprot，表示是普通文件。

mode的取值如下：(1)ios::in：打开一个文件进行读操作，而且该文件必须已经存在

；(2)ios::nocreate：不建立新的文件。当文件不存在时，导致open()失败

；(3)ios::noreplace：不修改原来已经存在的文件。若文件已经存在，导致open()失败

；(4)ios::binary：文件以二进制方式打开，缺省时为文本文件。

19. 如果要把类B的成员函数void fun()说明为类A的友元函数，则应在类Ａ中加入语句___。

答案：(P111)friend void B::fun();

［解析］声明成员函数作为另外一个类的友元函数时，使用类作用域运算符：：。

20. 在编译指令中，宏定义使用___指令。

答案：#define

［解析］静态成员是所有对象共享的特征，也就是类的特征。

1. 单目运算符作为类成员函数重载时，形参个数为___个。

答案：0

［解析］单目运算符使用成员函数重载可以不用形参，双目运算符使用一个参数。

2. 抽象类中至少要有一个___函数。

答案：纯虚

［解析］至少有一个纯虚函数的类就称为抽象类，即不能实例化。

3. 设类A有成员函数void f(void)；若要定义一个指向类成员函数的指针变量pf来指向f，该

第 15 页 共 17 页

16

指针变量的声明语句是：___。

答案：void (A::*pf)(void)=&A::f;

［解析］void(A::*pf)(void)=&A::f;指向成员函数的指针，它相当于两条语句

：void(A::*pf)(void);和pf=&A::f;。

4. 执行下列程序

double a=3.1415926,b=3.14;

cout<

程序的输出结果是___。

答案：3.1416，3.14

［解析］题目设置精度即有效数字都是5，a四舍五入是3.1416，b是3.14。

5. vector类中用于删除向量中的所有对象的方法是___。

答案：clear()

［解析］向量的使用。返回向量中对象的方法有：front()back（）operator［］，在向量中删

除对象的方法pop_back erase clear。

6. 重载的运算符保持其原有的___、优先级和结合性不变。

答案：操作数

［解析］运算符重载时要遵循以下规则：

(1)除了类属关系运算符“.”、成员指针运算符“.*”、作用域运算符“::”、sizeof运算符

和三目运算符“?:”以外，C++中的所有运算符都可以重载。

(2)重载运算符限制在C++语言中已有的运算符范围内的允许重载的运算符之中，不能创建新的

运算符。

(3)重载之后的运算符不能改变运算符的优先级和结合性，也不能改变运算符操作数的个数及

语法结构。

7. 编译时的多态性通过___函数实现。

答案：重载

［解析］编译多态性，实现的方法主要通过函数的重载或运算符的重载。

8. 基类的公有成员在派生类中的访问权限由___决定。

答案：访问控制方式或继承方式

9. 假设类X的对象x是类Y的成员对象，则“Y Obj”语句执行时，先调用类___的构造函数。

答案：X

［解析］派生类中的构造函数的执行顺序，先基类后派生类。

10. 下列程序段的输出结果是___。

(ios::showpos);

cout<<509.3<

答案：(P193)+509.3

［解析］输入、输出格式ios::showpos用于输出数据的符号位。

11. 下列程序段的输出结果是___。

for(i=0,j=10,k=0;i<=j;i++,j-=3,k=i+j);cout<

答案：4

［解析］for循环结构,三个表达式的作用，初始化、循环判断条件和循环变量变化。循环执行了

第 16 页 共 17 页

17

三次，k的作用是计算i、j的和。

12. C＋＋中ostream的直接基类___。

答案：ios

［解析］istream和ostream的直接基类是ios。

13. int n=0;

while（n=1）n++;

while循环执行次数是___。

答案：无限次

［解析］＝是赋值运算符，不是关系运算符，且不等0，所以死循环。

14. C++中有两种继承：单继承和___。

答案：多继承

［解析］单继承和多继承，多继承即有多个基类。

15. 在C++中，利用向量类模板定义一个具有10个int的向量A，其元素均被置为1，实现此操作

的语句是___。

答案：vectorA(10,1)

［解析］定义向量列表vectorA(10,1)，使用两个参数，10表示长度，1表示数值。

16. vector类中向向量尾部插入一个对象的方法是___。

答案：push_back

17. C++语言中如果调用函数时，需要改变实参或者返回多个值，应该采取___方式。

答案：传地址或引用

［解析］传地址即指针，在函数中通过指针修改它指向的变量的值时，实参也就变化了。使用引

用，直接修改变量的别名即引用的值，该变量也就随着变化。

18. 若函数的定义处于调用它的函数之前，则在程序开始可以省去该函数的___语句。

答案：声明

［解析］函数使用有两部分：声明和定义。定义在前，可以无声明；但函数定义在后，调用在前

的话，需要先声明函数的原型。

19. 在C++中有两种参数传递方式：传值和___。

答案：传引用

［解析］（1）传值调用又分为数据传值调用和地址传值调用。（2）引用调用是将实参变量值传

递给形参，而形参是实参变量的引用名。引用是给一个已有变量起的别名，对引用的操作就是对

该引用变量的操作。

20. 将指向对象的引用作为函数的形参，形参是对象的引用，实参是 ___。

答案：对象名

［解析］实参与形参类型要一致，形参是对象的引用，实参应该是对象名。

第 17 页 共 17 页