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) 编辑 收藏 引用
2048
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
