posts - 12,  comments - 21,  trackbacks - 0

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_是错误的。

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

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

 

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

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

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

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

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

 

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

A  inline   B  break   C  private D public

 

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

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

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

 

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

A   #   B     C   //    D  }

 

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

A   C++C语言的超集                        B   C++C语言进行了扩充

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

 

14、下列正确的选项是________A______

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

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

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

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

 

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

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

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

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

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

 

 

类和对象

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

Class CSample

{

       int a = 2;               (A)

       CSample();       (B)

       Public:

       CSample(int val); (C)

       ~CSample();          (D)

}

 

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

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

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

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

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

 

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

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

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

 

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

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

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

对象是模板,类是实例

类和对象间没有任何关系

 

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______不是类的成员函数

构造函数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 指针名前只用一对方括号,不管所删除数组的维数

 

继承和派生

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

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

//答案:B  

 

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

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

//答案:

 

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

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

//答案:①A②C③B  

 

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

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

//答案:① B②A③D   

 

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

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

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

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

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

//答案:D  

 

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

A  同类的继承关系无关

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

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

不用调用构造函数

//答案:B  

 

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

同类的继承关系无关

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

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

不用调用析构函数

//答案: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 不能说明其对象

//答案:

 

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

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

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

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

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

//答案:

 

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

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

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

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

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

//答案:

 

 

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

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

虚函数是一个非成员函数

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

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

//答案:C  

 


填空题:

C++概述

 

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

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

 

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

//答案:继承 

 

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

//答案:虚函数 

 

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

//答案://

 

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

//答案:publicprotectedprivate

 

 


类和对象

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 <iostream.h>

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 <iostream.h>

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 <iostream.h>

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 <iostream.h>  

class A {

    int a;

public:

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

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

};

class B:public A {

    int b;

public:

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

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

};

void main() {

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

}

//答案:

Destructor  B!  7

Destructor  A!  6

Destructor  B!  0

Destructor  A!  5


重载多态和虚函数

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

#include <iostream.h>

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 <iostream.h>

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 <iostream.h>

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 <iostream.h>

class base

{

public:

       virtual void f1()

       { cout<<"f1 fuc of base"<<endl;}

       virtual void f2()

       { cout<<"f2 fuc of base"<<endl;}

       virtual void f3()

       { cout<<"f3 fuc of base"<<endl;}

       void f4()

       { cout<<"f4 fuc of base"<<endl;}

};

 

class derive : public base

{

       void f1()

       { cout<<"f1 fuc of derive"<<endl;}

       void f2(int x)

       { cout<<"f2 fuc of derive"<<endl;}

       void f4()

       { cout<<"f4 fuc of derive"<<endl;}

};

 

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 <iostream.h>

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 <iostream.h>

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 <iostream.h>

 

class Base

{

public:

       virtual void show()

       {cout<<"Parent class.\n";}

};

 

class First: public Base

{

public:

       void show()

       {cout<<"First Derived class.\n";}

};

 

class Second :public Base

{

public:

       void show()

       {cout<<"Second Derived class.\n";}

};

 

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 <iostream.h>

 

class Base

{

public:

       void show()

       {cout<<"Parent class.\n";}

};

 

class First: public Base

{

public:

       void show()

       {cout<<"First Derived class.\n";}

};

 

class Second :public Base

{

public:

       void show()

       {cout<<"Second Derived class.\n";}

};

 

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 阅读(1600) 评论(0)  编辑 收藏 引用

只有注册用户登录后才能发表评论。
【推荐】超50万行VC++源码: 大型组态工控、电力仿真CAD与GIS源码库
网站导航: 博客园   IT新闻   BlogJava   知识库   博问   管理


<2011年5月>
24252627282930
1234567
891011121314
15161718192021
22232425262728
2930311234

常用链接

留言簿(3)

随笔档案(12)

文章档案(2)

最新随笔

搜索

  •  

积分与排名

  • 积分 - 23780
  • 排名 - 663

最新随笔

最新评论

阅读排行榜

评论排行榜