C/C++测试题

面向对象

选择题：

C++概述

1、以下C++新增的关键字为D。

A break

B continue

C stuct

D inline

2、面向对象程序设计将数据与__A___放在一起，作为相互依存、不可分割的整体来处理。

A对数据的操作B信息C数据隐藏D数据抽象

3、面向对象程序设计优于传统的结构化程序设计，其优越性主要表现在，它有希望解决软件工程的两个主要问题：软件复杂性和__A____。

A 软件生产率的提高  B 精化已有的代码C共享代码D编写可重用代码

4、面向对象系统的____B__是一种信息隐藏技术，目的在于将对象的使用者与设计者分开，使用者不必知道对象行为实现的细节，只需用设计者提供的协议命令对象去做即可。

A多态性B封装性C继承性D复用性

5、___A___不是面向对象系统所包含的要素

A重载B对象C类D继承

6、关于C++与C语言的关系的描述中，____D__是错误的。

A  C语言是C++的一个子集B  C++与C语言是兼容的

C  C++对C语言进行了一些改进D  C++与C语言都是面向对象的

7、下面关于对象概念的表述中，___A___是错误的。

A 对象就是C语言中的结构变量

B 对象代表着正在创建的系统中的一个实体

C 对象是一个状态和操作(或方法)的封装体

D 对象之间的信息传递是通过信息进行的

8、下面关于类概念的表述中，_____D_是错误的。

A 类是抽象数据类型的实现B类是具有共同行为的若干对象的统一描述体

C 类是创建对象的样板D类就是C语言中的结构类型

9、下列关于C++类的描述中错误的是___C___。

A 类与类之间可以通过一些手段进行通信和联络

B 类用于描述事物的属性和对事物的操作

C 类与类之间必须是平等关系，而不能组成层次关系

D 类与类之间可以通过封装而具有明确的独立性

10、下列关键字中,____B__既在C语言中使用，又在C++语言中使用

A  inline   B  breakC  private D public

11、C++对C语言做了很多改进。下列描述中___D___使得C语言发生了质变，即从面向过程变成了面向对象

A增加了一些新的运算符B允许函数重载，并允许设置默认参数

C规定函数说明必须用原型D引进了类和对象的概念

12、下列C++标点符号中表示行注释开始的是___C___。

A #   B；C   //    D  }

13、下列关于C++与C语言关系的描述中错误的是__C____。

AC++是C语言的超集B   C++对C语言进行了扩充

CC++|与C语言都是面向对象的程序设计语言D   C++包含C语言的全部语法

14、下列正确的选项是________A______。

A 继承是创建一个具有另一个类的属性和行为的新类的能力

B  C语言支持面向对象的程序设计

C 空白符是一种可以被编译的符号

D 标识符不宜太长，一般设定为16个字符

15、下列关于多态说法错误的是__B_______。

A 不同的对象调用相同名称的函数，并可导致完全不同的行为的现象称为多态性

B C++语言中多态性通过使用封装技术来支持

C 多态是面向对象程序设计的一个重要机制

D 多态是人类思维方式的一种模拟

类和对象

16、以下类的说明，请指出错误的地方_____A___。

Class CSample

{

int a = 2;               (A)

CSample();       (B)

Public:

CSample(int val); (C)

~CSample();          (D)

}

17、有关类的说法不正确的是____D____。

A 类是一种用户自定义的数据类型

B 只有类中的成员函数才能存取类中的私有数据

C 在类中，如果不做特别说明，所有的数据类型均为私有类型

D 在类中，如果不做特别说明，所有的成员函数均为公有类型

18、有关类和对象的说法下列不正确的有____C____。

A 对象是类的一个实例B任何一个对象只能属于一个具体的类

C 一个类只能有一个对象D类与对象的关系和数据类型和变量的关系

19、关于类和对象，以下叙述正确的是__B____

A 一个类的成员函数可以任意调用

B 通常，只有通过具体的对象，才能访问类的成员函数

C 对象是模板，类是实例

D 类和对象间没有任何关系

20、有关构造函数的说法不正确的是____D____。

A 构造函数名字和类的名字一样B构造函数在说明类变量时自动执行

C 构造函数无任何函数类型D构造函数有且只有一个

21、有关析构函数的说法不正确的是___C_____。

A 析构函数有且只有一个

B 析构函数无任何函数类型

C 析构函数和构造函数一样可以有形参

D 析构函数的作用是在对象被撤销时收回先前分配的内存空间

22、在类的定义体外定义成员函数时，需要在函数名前加上__B______。

A 类标记B类域标记C类对象D域运算符

23、在类的定义形式中，数据成员、成员函数和___A____组成了类定义体。

A 成员的访问控制消息 B公有消息C私有消息D保护消息

24、____C____的功能使对对象进行初始化。

A 析构函数B数据成员C构造函数D静态成员函数

25、若Q是类，a是它的一个对象，p1是类对象a的一个指针，那么类对象a可以通过①___B____来访问类的成员，类对象a的指针p1可以通过②_____D__来访问类的成员。

A：：B     .      C；D ->

26、下列的各类函数中，___C______不是类的成员函数

A 构造函数B 析构函数 C 友元函数 D 拷贝初始化构造函数

27、通常拷贝初始化构造函数的参数是______C____。

A 某个对象名B某个对象的成员名C某个对象的引用名D某个对象的指针名

28、类模板的使用实际上是将类模板实例化成一个具体的____A___。

A 类B对象C函数D模板类

29、模板是实现类属机制的一种工具，其功能非常强大，它既允许用户构造类属函数，既① ____B___；也允许用户构造类属类，即② ______D__。

A函数模板B模板函数C类模板D模板类

30、关于对象的this指针，以下叙述正确的是__B____

A 必须显式地在类定义中声明this数据成员，才能使用this指针

B 一旦生成一个对象，该对象的this指针就指向该对象本身

C 一个类的所有对象的this指针的值都是相同的

D 不能通过对象的this指针访问对象的数据成员和成员函数

31、关于new运算符的下列描述中，D是错误的。

A 它可以用来动态创建对象和对象数组

B 使用它创建的对象或对象数组，可以使用运算符delete删除

C 使用它创建对象时要调用构造函数

D 使用它创建对象数组时必须指定初始值

32、关于delete运算符的下列描述中，C是错误的。

A 它必须用于new返回的指针

B 它也适用于空指针

C 对一个指针可以使用多次该运算符

D 指针名前只用一对方括号，不管所删除数组的维数

继承和派生

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

A 复用B继承C单继承D多继承

//答案：B

34、继承具有_______,即当基类本身也是某一个类的派生类时，底层的派生类也会自动继承间接基类的成员。

A 规律性B传递性C重复性D多样性

//答案：B

35、派生可以分为①________和②_________。由②________得到的派生类，其基类的所有公有成员都只能成为它的私有成员，这些私有成员只能被派生类的成员函数访问，而③________无权访问；①________的意义是基类中所有公有成员在派生类中也都是公有的。

A 公有派生B派生类的使用者C私有派生D派生类的构造函数

//答案：①A②C③B

36、基类的①________不能为派生类的成员访问，基类的②_______在派生类中的性质和继承的性质一样，而基类的③_______在私有继承时在派生类中成为私有成员函数，在公有和保护继承时在派生类中仍为保护成员函数

A 公有成员B私有成员C私有成员函数D公有成员函数

//答案：① B②A③D

37、子类的数据成员和成员函数除了有从父类继承而来的外，还有：

A 子类不能拥有自己的数据成员和成员函数

B 子类可以新添自己的数据成员，但成员函数只能从父类继承

C 子类可以新添自己的成员函数，但数据成员只能从父类继承

D 子类可以拥有自己独特的数据成员和成员函数

//答案：D

38、在构造一个类的对象时，如果该类是从另一个类继承的，则构造函数的调用顺序是

A  同类的继承关系无关

B 先调用父类的构造函数，然后调用本类的构造函数

C 先调用本类的构造函数，然后调用父类的构造函数

D 不用调用构造函数

//答案：B

39、在析构一个类的对象时，如果该类是从另一个类继承的，则析构函数的调用顺序是

A 同类的继承关系无关

B 先调用父类的析构函数，然后调用本类的析构函数

C 先调用本类的析构函数，然后调用父类的析构函数

D 不用调用析构函数

//答案：C

重载、多态和虚函数

40、下列运算符中，________运算符在C++中不能重载。

A ?:B +           C –              D <=

//答案：A

41、下列运算符中，________运算符在C++中不能重载。

A &&B [ ]                     C：：D new

//答案：C

42、如果一个类至少有一个纯虚函数，那么就称该类为________。

A 抽象类B虚基类C派生类D以上都不是

//答案：A

43、下列描述中，________是抽象类的特性。

A 可以说明虚函数

B 可以进行构造函数重载

C 可以定义友元函数

D 不能说明其对象

//答案：D

44、关于动态联编的下列描述中，________是错误的。

A 动态联编是以虚函数为基础的

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

C 动态联编调用函数操作是指向对象的指针或对象引用

D 动态联编是在编译时确定操作函数的

//答案：D

45、关于虚拟成员函数，以下叙述正确的是________

A 析构函数同构造函数一样，不能是虚拟的

B 在一个类中被定义为虚拟的成员函数，其所有的派生类中相同的成员函数都是虚拟的

C 带有虚拟函数的类不能直接生成对象，只有其子类才能生成对象

D 虚拟成员函数同普通成员函数不同，不能调用父类的虚拟成员函数

//答案：B

46、关于虚函数的描述中，是正确的

A 虚函数是一个static类型的成员函数

B 虚函数是一个非成员函数

C 基类中说明了虚函数后，派生类中与其对应的函数可不必说明为虚函数

D 派生类的虚函数与基类的虚函数具有不同的参数个数和类型

//答案：C

填空题：

C++概述

47、写出除class ，private， protected，public之外的任意五个C++新增的关键字、、、、。

参考//答案：catch, ,const,delete,friend,new,operator, template,this,throw,try,virtual

48、_____________是指一种事物保留了另一种事物的全部特征，并且有自身的独有特征。

//答案：继承

49、C++语言中使用函数重载、模板、__________等概念来支持多态性。

//答案：虚函数

50、在C++中有两种类型的注释，一种是C语言中使用的注释符(/*···*/)，另一种是______。

//答案：//

51、在C++类中可以包含_______、_____和______三种具有不同访问控制权的成员。

//答案：public、protected、private

类和对象

52、类中的数据和成员函数默认类型为_________。

//答案：私有

53、任何类中允许有三种权限的数据成员、、。

//答案：public   private   protected

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

//答案：static

55、以下程序运行的结果_________。

#include “iostream.h”

class CSample

{

private:

int i;

public:

CSample();

CSample(int val);

void Display();

~CSample();

};

CSample::CSample()

{

cout << “Constructor1” << endl;

i=0;

}

CSample:: CSample(int val)

{

cout << “Constructor2” << endl;

i=val;

}

void CSample::Display()

{

cout << ”i=” << i << endl;

}

CSample::~CSample()

{

cout << “Destructor” << endl;

}

void main()

{

CSample a, b(10);

a.Display();

b.Display();

}

//答案：

Constructor1

Constructor2

i=0

i=10

Destructor

Destructor

56、以下程序执行的结果是_____________________。

#include

class B

{

int x,y;

public:

B() {x = y = 0; cout << “Constructor1” << endl;}

B(int i) {x = i; y = 0; cout << “Constructor2” << endl;}

B(int i ,int j) {x = i; y = j; cout << “Constructor3” << endl;}

~B() {cout << “Destructor” << endl;}

void print() {cout << “x=” << x << “,y=” << y << endl;}

};

void main()

{

B *ptr;

ptr = new B[3];

ptr[0] = B();

ptr[1] = B(5);

ptr[2] = B(2,3);

for (int i=0;i<3;i++)

ptr[i].print();

delete[] ptr;

}

//答案：

Constructor1

Constructor1

Constructor1

Constructor1

Destructor

Constructor2

Destructor

Constructor3

Destructor

x=0,y=0

x=5,y=0

x=2,y=3

Destructor

Destructor

Destructor

57、以下程序执行的结果是_____________________。

class B{

int x,y;

public:

B() {x = y = 0; cout << "Constructor1" << endl;}

B(int i) {x = i; y = 0; cout << "Constructor2" << endl;}

B(int i ,int j) {x = i; y = j; cout << "Constructor3" << endl;}

~B() {cout << "Destructor" << endl;}

void print() {cout << "x=" << x << ",y=" << y << endl;}

};

void main(){

B *ptr;

ptr = new B[2];       ptr[0] = B();

ptr[1] = B(5);               delete[] ptr;

}

//答案：Constructor1

Constructor1

Constructor1

Destructor

Constructor2

Destructor

Destructor

Destructor

58、以下程序执行结果是_____________。

#include

class A

{

public:

A(int i=0) {m = i; cout << "Constructor" << m << endl; }

void set(int i) {m = i;}

void print() const {cout << m << endl;}

~A() {cout << "Destructor" << m << endl;}

private:

int m;

};

void fun(const A &c)

{

c.print();

}

void main()

{

fun(5);

}

//答案：

Constructor5

5

Destructor5

继承和派生

59、以下程序执行结果是________________。

#include

class A

{

public:

A(int i, int j) {a = i; b = j;}

void move (int x, int y) {a += x; b += y;}

void show() { cout << “(“ << a << “,” << b << “)” << endl;}

private:

int a, b;

};

class B:private A

{

public:

B(int i, int j, int k, int l):A(i, j)

{

x =k; y = l;

}

void show()

{ cout << x << “,” << y << endl;}

void fun() {move (3,5);}

void f1() { A::show();}

private:

int x, y;

};

void main()

{

A   e(1,2);

e.show();

B   d(3,4,5,6);

d.fun();

d.show();

d.f1();

}

//答案：(1,2)

5,6

(6,9)

void main()

{

A   e(1,2);

e.show();

B   d(3,4,5,6);

d.fun();

d.A::show();

d.B::show();

d.f1();

}

//答案：(1,2)

(6,9)

5,6

(6,9)

60、以下程序执行结果是________________

# include

class A {

int a;

public:

A(int aa=0) { a=aa; }

~A() { cout <

};

class B:public A {

int b;

public:

B(int aa=0,int bb=0):A(aa) { b=bb; }

~B() { cout <

};

void main() {

B x(5),y(6,7);  // 后定义的变量将先被释放

}

//答案：

Destructor  B!  7

Destructor  A!  6

Destructor  B!  0

Destructor  A!  5

重载多态和虚函数

61、以下程序执行结果是________________。

#include

class base

{

public:

base()

{

cout << “构造base子对象” << endl;

f();

}

virtual void f()

{

cout << “调用base::f()” << endl;

}

};

class derived : public base

{

public:

derived()

{

cout << “构造derived对象” << endl;

f();

}

void f()

{

cout << “调用derived :: f()” << endl;

}

};

void main()

{

derived d;

}

//答案：

构造base子对象

调用base::f()

构造derived对象

调用derived :: f()

62、以下程序执行结果是________________。

#include

class base

{

public:

base() {

cout << “Constructor base subobject” << endl;

f(); }

virtual void f(){

cout << “Call base::f()” << endl;   }

};

class derived : public base

{

public:

derived() {

cout << “Constructor derived object” << endl;

f(); }

void f(){

cout << “Call derived :: f()” << endl;   }

};

void main(){

derived d;

}

//答案：

Constructor base subobject

Call base::f()

Constructor derived object

Call derived :: f()

63、以下程序执行结果是________________。

#include

class Sample

{

private:

int x;

public:

Sample() {x = 0;}

void disp()

{

cout << “x=” << x << endl;

}

void operator ++() {x += 10;}

};

void main()

{

Sample obj;

obj.disp();

obj ++;

cout << “执行obj++之后” << endl;

obj.disp();

}

//答案：

x=0

执行obj++之后

x=10

64、以下程序执行结果

#include

class base

{

public:

virtual void f1()

{ cout<

virtual void f2()

{ cout<

virtual void f3()

{ cout<

void f4()

{ cout<

};

class derive : public base

{

void f1()

{ cout<

void f2(int x)

{ cout<

void f4()

{ cout<

};

void main()

{

base obj1, *p;

derive obj2;

p = &obj1;

p->f1();

p->f2();

p->f3();

p = &obj2;

p->f1();

p->f2();

p->f4();

}

//答案：

f1 fuc of base

f2 fuc of base

f3 fuc of base

f1 fuc of derive

f2 fuc of base

f4 fuc of base

解析题：

*65、指出程序中的错误，并予以改正(全部重写)

#include “iostream.h”

class point

{int x1;

public:

int x2;

public:

point(int x, int y);

//......

};

void main()

{point data(5,5);

cout << data.x1 << endl;

cout << data.x2 << endl;

}

//答案：构造函数定义不正确，在main()中对数据成员x1访问不正确

改正：

#include “iostream.h”

class point

{int x1;

public:

int x2;

public:

point(int x)

{

x1=x;

}

void disp()

{

cout << x1 << endl;

}

};

void main()

{

point data(5);

data.disp();

cout << data.x2 << endl;

}

或

#include “iostream.h”

class point

{

int x1;

public:

int x2;

public:

point(int x)

{

x1=x;

}

int disp()

{

return x1;

}

};

void main()

{

point data(5);

cout << data.disp() << endl;

cout << data.x2 << endl;

}

66、分析以下程序的执行的顺序以及输出结果

#include "iostream.h"

class Sample

{

public:

Sample()

{

cout << "构造函数" << endl;

}

};

void fn(int i)

{

static Sample c;

cout << "i=" << i << endl;

}

void main()

{

fn(10);

fn(20);

}

//答案：

程序中fn(int i)函数中的static Sample c;语句定义的是一个静态对象，仅在函数第一次进入时创建该对象，以后在进入时，c对象便始终存在，fn(int i)函数不再为其创建，所以程序执行结果如下：

构造函数

i=10

i=20

67、给出程序执行结果

#include

class MyDataType

{

protected:

int m_nData;

public:

MyDataType( ){

m_nData = -1;

cout << "Constructor MyDataType" << endl;              }

MyDataType & operator = (int n) {

m_nData = n;

return *this;           }

MyDataType & operator = (MyDataType & obj)      {

m_nData = obj.m_nData;

return *this;           }

MyDataType & operator + (MyDataType & obj2)       {

static      MyDataType tempData;

tempData = m_nData + obj2.m_nData;

return tempData;           }

operator int()        {      return m_nData;     }//定义一个从MyDataType类型到int类型的转换

};

void main()

{

MyDataType Obj1,Obj2;

Obj1 = 10;

Obj2 = Obj1;

MyDataType Obj3 = Obj1 + Obj2;

int nValue = (int)Obj3;

cout << "nValue = " << nValue << endl;

}

//答案：

Constructor MyDataType

Constructor MyDataType

Constructor MyDataType

nValue = 20

68、指出程序中的错误，改正并简述原因

#include

class Base

{

public:

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

int GetX() {return x;}

private:

int x;

};

class Derived : public Base

{

public:

void SetY(int i) {y = i;}

int GetY() {return y;}

private:

int y;

};

void main()

{

Base *p;

Base b_ob;

Derived d_ob;

p = &b_ob;

p->SetX(11);

cout << "base object x:" << p->GetX() << endl;

p = &d_ob;

p->SetX(55);

cout << "base object x:" << p->GetX() << endl;

p->SetY(99);

cout << "derived object y:" << p->GetY() << endl;

}

//答案：p->SetY(99)是错误的，改为d_ob.SetY(99)

基类指针虽然可以指向派生类的对象，但是只可以访问派生类中从该基类继承下来的的那些成员(如GetX())。基类指针指向的对象只认识基类，而不知道关于派生类的成员信息。

69、分析程序给出运行结果

#include

class Base

{

public:

virtual void show()

{cout<

};

class First: public Base

{

public:

void show()

{cout<

};

class Second :public Base

{

public:

void show()

{cout<

};

void main()

{

Base b1, *ptr;

First f1;

Second s1;

ptr = &b1;

ptr->show();

ptr = &f1;

ptr->show();

ptr = &s1;

ptr->show();

}

//答案：

Parent class.

First Derived class.

Second Derived class.

70、分析程序给出运行结果，说明原因

#include

class Base

{

public:

void show()

{cout<

};

class First: public Base

{

public:

void show()

{cout<

};

class Second :public Base

{

public:

void show()

{cout<

};

void main()

{

Base b1, *ptr;

First f1;

Second s1;

ptr = &b1;

ptr->show();

ptr = &f1;

ptr->show();

ptr = &s1;

ptr->show();

}

//答案：

Parent class.

Parent class.

Parent class.

由于基类中show函数没声明成虚函数，这时的函数调用是在编译时静态联编的。

posted on 2011-05-31 22:05 DoubleW 阅读(1712) 评论(0)  编辑 收藏 引用