2012面向对象程序设计试题集

2012 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

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<

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<

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

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<

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

{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<<\

运行时输出“*”的个数是 （ ） 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<

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 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 <

#include 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<

运行时的输出结果是（ ）

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<

C．返回值类型 D．常成员函数关键字const 下面的程序段的运行结果为（ ） char 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 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<

运行时的输出结果是( )

A.1 B.2 C.3 D.运行时出错

将运算符重载为类成员函数时，其参数表中没有参数，说明该运算是( )

A．不合法的运算符 B．一元运算符 C．无操作数的运算符 D．二元运算符 有如下程序：

#include 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<

运行时的输出结果是( )

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

字符串常量\在内存中需要占用（ ）字节 A．6 B．7 C． 8 D． 9 下列表达方式正确的是（ ）。

A．class P{ B． class P{ public： public： int x=15； int x；

void show(){cout<

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<

运行时的输出结果是（ ）

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 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 using namespace std; class A { public:

A(int i):r1(i) {}

void print() {cout<

void print() const {cout<

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<<\

运行时输出“*”的个数是 （ ）

) 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．若虚基类由非虚基类派生而来，则仍然先调用基类构造函数，再调用派生类的构造函数 下面描述中，表达错误的是（ ）

A．公有继承时基类中的public成员在派生类中仍是public的 B．公有继承是基类中的private成员在派生类中仍是private的 C．公有继承时基类中的protected成员在派生类中仍是protected的 D．私有继承时基类中的public成员在派生类中是private的 10. 关于new运算符的下列描述中，错误的是（ ）。 A．它可以用来动态创建对象和对象数组

B．使用它创建的对象和对象数组可以使用运算符delete删除 C．使用它创建对象时要调用构造函数

D．使用它创建对象数组时必须指定初始值 if 语句的语法格式可描述为 格式1：if（<条件>）<语句> 或

格式2：if（<条件>）<语句1>else<语句2>

关于上面的语法格式，下列表述中错误的是( )

A．<条件>部分可以是一个if 语句，例如if(if(a =0)?)? B．<语句>部分可以是一个if 语句，例如if(?)if(?)?

C．如果在<条件>前加上逻辑非运算符！并交换<语句1>和<语句2>的位置，语句功能不变

D．<语句>部分可以是一个循环语句，例如if(?)while（?）?

有如下类定义和变量定义：下列情况中，不会调用拷贝构造函数的是( )。 A．用一个对象去初始化同一类的另一个新对象时 B．将类的一个对象赋予该类的另一个对象时

C．函数的形参是类的对象，调用函数进行形参和实参结合时 D．函数的返回值是类的对象，函数执行返回调用时 有如下类定义：

class XX{ int xx; public:

XX():xx(0) {cout<

XX( int n):xx(n) { cout<

YY():yy(0) {cout<

YY(int n): XX(n+1), yy(n) {cout<

A．YY y1(0,0); B．YY y2(1); C．YY y3(0); D．YY y4; 下面对静态数据成员的描述中，正确的是（ ）。

A.静态数据成员可以在类体内进行初始化B.不能用参数初始化表对静态数据成员初始化 C.静态数据成员只能用类名调用 D.静态数据成员在定义对象时被分配空间 对C++编译器区分重载函数无任何意义的信息是( )

A．参数类型 B．参数个数 C．返回值类型 D．常成员函数关键字const 下面（ ）项是对构造函数和析构函数的正确定义。 A．void X::X(), void X::~X() B．X::X(参数), X::~X() C．X::X(参数), X::~X(参数)

D．void X::X(参数), void X::~X(参数) 有如下程序段： int i=4; int j=1;

int main() { int i=8,j=i; cout<

C++中的类有两种用法：一种是类的实例化，即生成类对象，并参与系统的运行；另一种是通过（）派生了新的类。

A.复用 B.继承 C.封装 D.引用 下列对继承的描述中，错误的是（ ）。

A. 析构函数不能被继承 B. 派生类也是基类的组合

C. 派生类的成员除了它自己的成员外，还包含了它的基类的成员

D. 派生类中继承的基类成员的访问权限到派生类保持不变 派生类的对象对它的基类成员中（ ）是可以访问的。

A.公有继承的公有成员 B.公有继承的私有成员 C.公有继承的保护成员 D.私有继承的公有成员 下列说法错误的是（ ）。

A. 公有继承的基类中的public成员在派生类中仍是public的

B. 公有继承的基类中的private成员在派生类中仍是private的 C. 私有继承的基类中的public成员在派生类中变成private的 D. 保护继承的基类中的public成员在派生类中变成protected的

C++类体系中，不能被派生类继承的有（ ）。

A.构造函数 B.虚函数 C.静态成员函数 D.赋值操作函数 拷贝构造函数具有的下列特点中，（ ）是错误的。

A. 如果一个类中没有定义拷贝构造函数时，系统将自动生成一个默认的 B. 拷贝构造函数只有一个参数，并且是该类对象的引用 C. 拷贝构造函数是一种成员函数 D. 拷贝构造函数的名字不能用类名

下列关于虚基类的描述中，错误的是 ( ) A．使用虚基类可以消除由多继承产生的二义性

B．构造派生类对象时，虚基类的构造函数只被调用一次 C．声明“class B : virtual public A”说明类B为虚基类 D．建立派生类对象时，首先调用虚基类的构造函数 有如下程序

#include using namespace std; class A { public:

A(int i):r1(i) {}

void print() {cout<

void print() const {cout<

int main(){

A al(2); const A a2(4); al.print();a2.print(); Return 0; }

运行时的输出结果是( )

A．运行时出错 B．E2-C16- C．C4-C1. D．E2-E4- 下列对派生类的描述中，（ ）是错误的。 A． 一个派生类可以作为另一个派生类的基类 B． 派生类至少有一个基类

C． 派生类的成员除了它自己的成员外，还包含了它的基类成员 D． 派生类中继承的基类成员的访问权限到派生类保持不变 派生类的对象对它的哪一类基类成员是可以访问的？（ ）

A．公有继承的基类的公有成员 B. 公有继承的基类的保护成员 C. 公有继承的基类的私有成员 D. 保护继承的基类的公有成员 关于多继承二义性的描述，（ ）是错误的。

A． 派生类的多个基类中存在同名成员时，派生类对这个成员访问可能出现二义性

B． 一个派生类是从具有共同的间接基类的两个基类派生来的，派生类对该公共基类的访问可能出现二义性

C． 解决二义性最常用的方法是作用域运算符对成员进行限定

D． 派生类和它的基类中出现同名函数时，将可能出现二义性 C++类体系中，能被派生类继承的是（ ）。

A．构造函数 B．虚函数 C．析构函数 D．友元函数 设有基类定义： class Cbase

{ private: int a; protected: int b; public: int c; };

派生类采用何种继承方式可以使成员变量b成为自己的私有成员( ) A. 私有继承 B.保护继承

C. 公有继承 D.私有、保护、公有均可 关于虚函数的描述中，（ ）是正确的。

A. 虚函数是一个静态成员函数 B. 虚函数是一个非成员函数

C. 虚函数既可以在函数说明时定义，也可以在函数实现时定义 D. 派生类的虚函数与基类中对应的虚函数具有相同的参数个数和类型 下列关于动态联编的描述中，错误的是（）。 A．动态联编是以虚函数为基础

B．动态联编是运行时确定所调用的函数代码的

C．动态联编调用函数操作是指向对象的指针或对象引用 D．动态联编是在编译时确定操作函数的 下面4个选项中，（ ）是用来声明虚函数的。

A．virtual B．public C．using D．false 关于纯虚函数和抽象类的描述中，错误的是（ ）。 A．纯虚函数是一种特殊的虚函数，它没有具体的实现 B．抽象类是指具体纯虚函数的类

C．一个基类中说明有纯虚函数，该基类派生类一定不再是抽象类 D．抽象类只能作为基类来使用，其纯虚函数的实现由派生类给出 编译时的多态性可以通过使用( )获得。

A．虚函数和指针 B．重载函数和析构函数 C．虚函数和对象

三、填写程序运行结果（每小题4分，共20分）以下程序的输出结果为 #include using namespace std; void main() { int k=5; while(--k)

cout<<”k=”<< k<

下面程序的运行结果为： #include

D．虚函数和引用

using namespace std; void main（）

{ int i,j,m=0,n=0; for（i=0;i<2;i++） for（j=0;j<2;j++） if（j>=i） m=1;n++; cout<

执行这个程序段输出字符*的个数是 #include using namespace std; int f(int a) {int b=0;

static int c=3; b++;c++;

return(a+b+c); }

void main( ) {int a=2,I;

for(I=0;I<3;I++) cout<

下面程序的运行结果为： #include using namespace std; class Obj{ static int i;

public: Obj(){i++;} ~Obj(){i--;} static int getVal(){return i;} }; int Obj::i=0;

void f (){Obj ob2;cout<

Obj*ob3=new Obj;cout<getVal(); delete ob3;cout<

下面程序运行结束后，k的值为_____。 #include void main（） { int i,j,k; for（i=0,j=10;i<=j;i++,j--） k=i+j; count<

下面程序的运行结果为： #include using namespace std;

class C1{ public:

~C1(){ cout<<1; } }; class C2: public C1{ public:

~C2(){ cout<<2; } };

int main(){ C2 cb2; C1 *cb1; return 0; }

下面程序的运行结果为： #include using namespace std; class A{ public:

virtual void funcl(){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->funcl(); p->func2(); return 0; 以下程序的输出结果为 #include using namespace std; int add(int x,int y=8); void main() { int a=4;

cout<

cout<

int add(int x,int y); { return x+y; }

程序的输出结果为 。 #include

using namespace std; void main()

{ int i=0,x=0,y=0; do{ ++i;

if(i%2!=0) {x=x+i;i++;} y=y+i++; }while(i<=7);

cout<<“x=”<

以下程序的输出结果为 。 int x1=30, x2=40; void main()

{ int x3=10, x4=20; int sub(int x, int y);

} sub(x3, x4); sub(x2, x1);

cout<

sub(int x, int y) { x1=x; x=y; y=x1; }

以下程序的输出结果为 #include using namespace std; class Csample {private: int i;

static int k; public:

Csample( ); void Display( ); };

int Csample::k=0;

Csample::Csample( ) { i=0; k++; }

void Csample::Display( ) { cout<<\void main( )

{ Csample a,b;

a.Display( ); b.Display( ); }

以下程序的输出结果为 。 #include using namespace std; class Point{ int x,y; public:

Point(int x1=0,int y1=8){x=x1;y=y1;}

~Point(){cout<<\ }; void main() {Point a;

Point b(10,10); }

以下程序的输出结果为 。 #include

using namespace std; class A{ public:

virtual void funcl(){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->funcl(); p->func2(); return 0; } 以下程序的输出结果为 #include #include using namespace std; class XCD{ char *a; int b; public:

XCD(char *aa, int bb) {

a=new char[strlen(aa)+1]; strcpy(a,aa); b=bb; }

char* Geta() {return a;}

int Getb() { return b;} }; int main(){

char *p1=”abcd”, *p2=”weirong”; int d1=6,d2=8;

XCD x(p1,d1), y(p2,d2);

cout<

下面程序运行结果为： #include”iostream.h” f(int a) {int b=0;

static int c=3; b++;c++;

return(a+b+c); }

void main( ) {int a=2,I;

for(I=0;I<3;I++) cout<

以下程序的输出结果为 #include using namespace std; class A{ public:

A() { cout<<\

virtual ~A() { cout<<\ virtual void f() { cout<<\

void g() { f(); } };

class B : public A{ public:

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

class C : public B{ public:

C() { cout<<\~C() { cout<<\void f() { cout<<\};

void main() { A *a=new C; a->g(); delete a; }

下面程序运行结果为： #include

void main()

{ int i=0,x=0,y=0; do{ ++i;

if(i%2!=0) {x=x+i;i++;} y=y+i++; }while(i<=7);

cout<<“x=”<

程序运行结果为：

计算斐波那契数列第n项的函数定义如下： int fib(int n){

if (n == 0) return 1; else if (n == 1) return 2;

else return fib(n-1)+fib(n-2); }

若执行函数调用表达式fib(2)，函数fib被调用的次数是 下面程序运行结果为： #include using namespace std; class A { public:

A(int i):r1(i) {}

void print() {cout<

void print() const {cout<

};

int main(){

A al(2); const A a2(4); al.print();a2.print(); return 0; }

下面程序运行结果为： #include using namespace std; class GrandChild{ public:

GrandChild(){ strcpy (name, \ const char * getName()const { return name; } virtual char * getAddress()const=0; private:

char name[20]; };

class GrandSon : public GrandChild{ public:

GrandSon(char *name) {}

char * getAddress() const { return \};

int main(){

GrandChild *gs=new GrandSon(\

cout<getName()<<\住在\delete gs; return 0; }

以下程序的输出结果是 。 #include main()

{ int y=9;

for( ;y>0;y--) if(y%3==0) cout<<--y; }

以下程序的输出结果是 。 #include main()

{ int a[5]={9,6,8,3,-1},i; sort(a);

for(i=0;i<=4;i++) cout<

for(j=0;j<4;j++) { p=j;

for(i=j;i<=4;i++) if (a[i]

}

以下程序的输出结果是 。 #include class Point{ int x,y; public:

Point(int x1=0,int y1=8){x=x1;y=y1;} ~Point(){cout<<\ }; void main() {Point a;

Point b(10,10); }

下面程序的运行结果是 。 #include class Base { int i; public:

Base(int n){cout <<\ ~Base(){cout <<\ void showi(){cout << i<< \ int Geti(){return i;} }; class Derived:public Base { int j; Base aa; public:

Derived(int n,int m,int p):Base(m),aa(p){ cout << \ j=n; }

~Derived(){cout <<\ void show(){Base::showi(); cout << j<<\ }; void main()

{ Derived obj(8,13,24); obj.show(); }

下面程序的运行结果是 。 #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; }

以下程序的输出结果是 #include using namespace std; main()

{ int i,j,sum;

for(i=3;i>=1;i--) { sum=0;

for(j=1;j<=i;j++) sum+=i*j; }

cout<

以下程序的输出结果是 #include \#define N 6 main()

{char c[N];int i;

for(i=0;i

当运行程序时输入三行，每行都是在第一列上开始： abcdef 如果不能使用多态机制，那么通过基类的指针虽然可以指向派生类对象，但是只能访问从基数继承的成员，下列程序没有使用多态机制，其输出结果是 。 #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; } 以下程序的输出结果是 #include class Csample {private: int i;

static int k;

public:

Csample( );

void Display( ); }; int Csample::k=0;

Csample::Csample( ) { i=0; k++; }

void Csample::Display( ) { cout<<\void main( )

{ Csample a,b; a.Display( ); b.Display( ); }

以下程序的输出结果是 #include class A

{ public: A(char *s) { cout<

{ public: B(char *s1, char *s2):A(s1)

{ cout<

C(char*s1,char *s2):A(s1)

{ cout<

public:

D(char *s1, char *s2,char *s3, char *s4):B(s1,s2),C(s1,s3),A(s1) { cout<

{ D *p=new D(\ delete p; }

下面程序的运行结果为： #include void main() { int i,k=0;

for(i=0; ;i++) {k++;

if(k%3= =0) break; } cout<

下面程序的运行结果为： #include class Point{ int x,y; public:

Point(int x1=0,int y1=8){x=x1;y=y1;} ~Point(){cout<<\void main() {Point a;

}; Point b(10,10); }

下面程序的运行结果为： #include using namespace std; class Sp { int x; public:

void setx(int i) {x=i;}

int putx() {return x;} }; void main()

{ Sp a[3],*p;

for (int i=0;i<=2;i++) a[i].setx(i); p=a; for (;i>0;i--)

cout<putx()<<\ cout<

下面程序的运行结果为： #include using namespace std; class MyClass{ public:

MyClass(){cout<

MyClass p1,*p2; p2=new MyClass(?X?); delete p2; return 0; }

下面程序的运行结果为： #include #include using namespace std; class XCD{ char *a; int b; public:

XCD(char *aa, int bb) {

a=new char[strlen(aa)+1]; strcpy(a,aa); b=bb; }

char* Geta() {return a;} int Getb() { return b;} };

int main(){

char *p1=”abcd”, *p2=”weirong”; int d1=6,d2=8;

XCD x(p1,d1), y(p2,d2);

cout<

以下程序的输出结果为 。 char ch1='b',ch2; ch2=ch1+'A'-'a';

cout<

以下程序的输出结果为 。 #include \void main()

{int n[2]={0},i,j; for(i=0;i<2;i++)

for(j=0;j<2;j++) n[j]=n[i]+1; for(i=0;i<2;i++) cout<

以下程序的输出结果为 。 #include void main() { int i,k=0; for(i=0; ;i++) {k++;

if(k%3= =0) break; }

cout<

下面程序的运行结果是________。 #include \ class test {

private: int num; float fl; public: test( );

int getint( ){return num;} float getfloat( ){return fl;} ~test( ); };

test::test( ) {

cout << \ num=0;fl=0.0;

}

test::~test( ) {

cout << \}

void main( ) {

test array[2];

cout << array[1].getint( )<< \ }

下面程序的运行结果是________。 #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; }

下列程序运行结果为：

#include

void main（） { int i,j,m=0,n=0; for（i=0;i<2;i++） for（j=0;j<2;j++） if（j>=i） m=1;n++; cout<

}

写出下列程序运行结果：

#include

void main（）

{ int a,b; for（a=1,b=1;a<=100;a++） { if（b>=10）break; if（b%3= =1） { b+=3;continue;} } cout<

}

下面程序段的运行结果为：

for(y=1;y<10;) y=((x=3*y,x+1),x-1); cout<<“x=”<

A．x=27,y=27 B．x=12,y=13 C．x=15,y=14 D．x=y=27 下面程序段的运行结果是为：

i=1;a=0;s=1; do {a=a+s*i;s=-s;i++; } while(I<=10); cout<<“a=”<

下面程序段的运行结果为： #include void main() {int i,t,sum=0;

for(t=i=1;i<=10; ) {sum+=t;++i; if(i%3= =0) t=-i; else t=i;}

cout<<“sum=”<

下面程序的输出结果为: #include”iostream.h” f(int a) {int b=0;

static int c=3; b++;c++;

return(a+b+c); }

void main( ) {int a=2,I;

for(I=0;I<3;I++) cout<

下面程序的输出结果为: #include class Point{ int x,y; public:

Point(){x=1;y=1;}

~Point(){cout<<\

};

void main() {Point a;}

下面程序的输出结果为: #include #include int count=0; class Point { int x,y;

public: Point() { x=1;y=1; count++; }

~Point() {count--;} friend void display(); }；

void display() { cout <<\void main() { Point a;

display(); { Point b[5]; display(); }

display(); }

下面程序的运行结果为: #include class base { public:

void show() {cout<<\};

class derived: public base { public:

void show() {cout<<\};

void main() {base demo1; derived demo2; demo1.show(); demo2.show();

demo2.base::show(); }

下面程序的运行结果为: #include class A{

public:

A() { cout<<\

virtual ~A() { cout<<\ virtual void f() { cout<<\void g() { f(); } };

class B : public A{ public:

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

class C : public B{ public:

C() { cout<<\~C() { cout<<\void f() { cout<<\};

void main() { A *a=new C; a->g(); delete a; }

四、程序设计题（每小题10分，共40分）

1. 编写一个程序根据输入的三角形的三条边判断是否能组成三角形，如果可以则输出它的面积和三角形

类型（等边、等腰、直角三角形）。

2. 定义一个学生类，其中有3个数据成员：学号、姓名、年龄，构造函数，display函数。同时编写main

函数使用这个类，实现对学生数据的赋值和输出。

3. 从键盘输入若干个学生成绩，统计并输出最高成绩和最低成绩，当输入负数时结束输入。 4. 编写一个程序，从键盘输入半径和高，输出圆柱体的底面积和体积。 5. 编写一个程序，输入年、月，打印出该年份该月的天数。

6. 编写函数将化氏温度转换为摄氏温度，公式为C=（F-32）*5/9；并在主函数中调用。 7. 声明一个Tree（树）类，有成员ages(树龄),成员函数grow(int years)用以对ages 加上years，showage( )

用以显示tree对象的ages值。在主函数中定义Tree类对象，并调用成员函数（学生自行指定实参数据）。

8. 定义一个复数类，用友元函数实现对双目运算符“+”的运算符重载，使其适用于复数运算。 9. 有一个函数如下： x (x<5)

y= x+6 (5<=x<15) x-6 (x>=15)

输入x的值，计算出相应的y值。

10. 使用函数重载的方法定义两个重名函数，分别求出整型数的两数之和和浮点数的两数之和，并在主函

数中调用。

11. 定义一个抽象类shape用以计算面积，从中派生出计算长方形、梯形、圆形面积的派生类。程序中通

过基类指针来调用派生类中的虚函数，计算不同形状的面积。

12. 定义计数器类Counter。要求具有以下成员：计数器值；可进行增值和减值记数；可提供记数值。 13. 输入一个自然数，输出其各因子的连乘形式，如输入12，则输出12=1*2*2*3。

14. 使用函数重载的方法定义两个重名函数，分别求出整型数的两数之和和浮点数的两数之和，并在主函

数中调用。

15. 定义一个基类：点类，包括x坐标和y坐标，从它派生一个圆类，增加数据成员r（半径），圆类成员

函数包括构造函数、求面积的函数和输出显示圆心坐标及圆半径的函数。 16. N个整数从小到大排列，输入一个新数插入其中，使N+1个整数仍然有序。

17. 使用函数重载的方法定义两个重名函数，分别求出整型数的两数之和和浮点数的两数之和，并在主函

数中调用。

18. 编写一个矩形rectangle类，有数据成员长len和宽wid，构造函数retange(int,int).和友元函数int

area(rectangle T)和int fun(rectangle T) 分别计算给定长方形的周长和面积。

19. 定义一个复数类，用友元函数实现对双目运算符+和*的运算符重载，使其适用于复数运算。 20. 输入10 个同学的成绩，统计80分以上和不及格的人数，并输出平均值。

21. 声明一个类String1，其数据成员为char head[100]，构造函数String（char *Head）实现head的初始化，

成员函数void Reverse（）实现head内字符串的逆序存放，成员函数void Print()实现head内字符串的输出。

22. 编写程序形成如下矩阵。

?1?2?A=?3??4??51111?1111??2111?

?3211?4321??23. 定义盒子Box类，要求具有以下成员：可设置盒子形状；可计算盒子体积；可计算盒子的表面积。

24. 声明一个哺乳动物Mammal类，再由此派生出狗Dog类，二者都定义Speak( )成员函数，基类中定义

为虚函数。声明一个Dog类的对象，调用Speak()函数，观察运行结果。

25. 定义一个基类有姓名、性别、年龄，再由基类派生出教师类和学生类，教师类增加工号、职称和工资，

学生类增加学号、班级、专业和入学成绩。 26. 声明计数器Counter类，对其重载运算符“+”。

27. 实现一个名为SimpleCircle的简单圆类，其数据成员int *itsRadius为一个指向其半径值的指针，

设计对数据成员的各种操作，给出这个类的完整实现并测试这个类。

28. 有一个Time类，包含数据成员minute(分)和sec(秒)，模拟秒表，每次走一秒，满60秒进一分钟，

此时秒又从0开始算。要求输出分和秒的值。（提示：重载单目运算符++）

29. 有一个学生类student,包括学生姓名、成绩，设计一个友元函数，输出成绩对应的等级：大于等于

90：优；80~90：良；70~79：中；60~69：及格；小于60：不及格。

30. 定义一个基类有姓名、性别、年龄，再由基类派生出教师类和学生类，教师类增加工号、职称和工资，

学生类增加学号、班级、专业和入学成绩。

31. 编写一个函数来检验输入的一个字符是大写字母还是小写字母或不是26个英文字母。

32. 有两个长方体，其长、宽、高分别为： (1)12,20,25；(2)10,14,20。求它们的体积。编一个基于对

象的程序，在类中用带参数的构造函数。

33. 定义一个哺乳动物Mammal类，再由此派生出狗Dog类，二者都定义 Speak()成员函数，基类中定义

为虚函数，定义一个Dog类的对象，调用Speak函数，观察运行结果。

34. 设计一个三角形类Triangle，包含三角形三条边长的私有数据成员，另有一个重载运算符“+”，以实

现求两个三角形对象的面积之和。

五、简答题(每小题5分，共20分)

1构造函数和析构函数有什么作用？

2．什么叫做作用域？有哪几种类型的作用域？

3．比较类的三种继承方式public公有继承、protected保护继承、private私有继承之间的差别。 4．什么叫做多态性? C++中的多态可以分为哪几类？

5. 解释public和private的作用，公有类型成员与私有类型成员有些什么区别？ 6．什么叫做友元函数？什么叫做友元类？ 7．什么是对象？什么是面向对象方法？

8．什么叫做抽象类？抽象类有何作用？抽象类的派生类是否一定要给出纯虚函数的实现 9. 派生类构造函数执行的次序是怎样的? 10. 什么叫做虚基类?它有何作用?

答案

四：编程题：

1、编写一个程序根据输入的三角形的三条边判断是否能组成三角形，如果可以则输出它的面积和三角形类型（等边、等腰、直角三角形）。

#include #include

using namespace std; int main() { double a,b,c; double v,p; cout<<\请输入三角形三条边:\ cin>>a>>b>>c; if(a+b>c&&a+c>b&&b+c>a) { p=(a+b+c)/2; v=sqrt(p*(p-a)*(p-b)*(p-c)); cout<<\该三角形面积是\ if(a==b&&a==c) cout<<\该三角形是等边三角形！\ else if(a==b&&a!=c||a==c&&a!=b||b==c&&b!=a) cout<<\该三角形是等腰三角形！\ if((a*a+b*b==c*c)||(a*a+c*c==b*b)||(c*c+b*b==a*a)) cout<<\该三角形是直角三角形！\ } else cout<<\这三条边组不成三角形！\ return 0; }

2、定义一个学生类，其中有3 个数据成员：学号、姓名、年龄，以及若干成员函数。同时编写main 函数使用这个类，实

现对学生数据的赋值和输出。 #include #include

using namespace std; class student { int num; string name; int age; public: student(){num=0;name='\\0';age=0;} student(int,string,int); void show(); };

student::student(int a,string b,int c):num(a),name(b),age(c){} void student::show() { cout<<\ cout<<\ cout<<\}

int main() {

student s1(200803986,\梅寒芳\s1.show();

return 0; }

3、从键盘输入若干个学生成绩，统计并输出最高成绩和最低成绩，当输入负数时结束输入。

#include using namespace std; int main() { double a[100]; double max=0,min=100,t; int i; for(i=0;i<100;i++) { cin>>a[i]; if(a[i]<0) break; else { if(a[i]>max) max=a[i]; if(a[i]

4、 编写一个程序，从键盘输入半径和高，输出圆柱体的底面积和体积。 #include

using namespace std; int main() {

double a,h,s,v; cout<<\半径为：\ cin>>a; cout<<\高为：\

本文来源：https://www.bwwdw.com/article/4bu6.html