总结基础知识习题

C++复习基础习题课第1页，共57页。1、每个类（）构造函数

A.只能有一个

B.只可有公有的

C.可以有多个

D.只可有缺省的答案为C第2页，共57页。2、已知类A中的一个成员函数的说明如下：voidSet(A&a);则该函数的参数“A&a”的含义是()

A.指向A的指针为a

B.将变量a的地址赋给类AC.类A对象引用a用作函数的形参

D.变量A与a按位与后作函数参数答案为C第3页，共57页。3、下列特性中，C与C++共有的是()

A.继承

B.封装

C.多态性

D.函数定义不能嵌套答案为D第4页，共57页。4、假定AB为一个类，则执行ABx；语句时将自动调用该类的()

A.有参构造函数B.无参构造函数

C.拷贝构造函数

D.赋值构造函数答案为B第5页，共57页。5、如果类A被说明成类B的友元，则()

A.类A的成员即类B的成员

B.类B的成员即类A的成员

C.类A的成员函数不得访问类B的成员

D.类B不一定是类A的友元

答案为D第6页，共57页。6、下列不是类的成员函数的是()

A.构造函数

B.析构函数

C.友元函数D.拷贝构造函数答案为C第7页，共57页。7、拷贝（复制）构造函数的作用是（）

A.进行数据类型的转换

B.用对象调用成员函数

C.用对象初始化对象

D.用一般类型的数据初始化对象答案为C第8页，共57页。8.若要把函数voidf()定义为类aClass的友元函数,则应该在类aClass的定义中加入的语句是()

A.voidf();

B.staticvoidf();

C.friendf();

D.friendvoidf();

答案为D第9页，共57页。9.下列关于析构函数的描述中,错误的是()

A.类中有且仅有一个析构函数

B.析构函数可以有形参

C.析构函数没有函数类型

D.析构函数在对象消失时被自动执行答案为B第10页，共57页。10.下面对静态数据成员的描述中,正确的是()

A.静态数据成员可以在类体内进行初始化

B.静态数据成员不可以被类的对象调用

C.静态数据成员不能受private控制符的作用

D.静态数据成员可以直接用类名调用答案为D第11页，共57页。11.下面关于友元函数的描述中,正确的是()

A.友元函数的实现必须在类的内部定义

B.友元函数是类的成员函数

C.友元函数破坏了类的封装性和隐藏性

D.友元函数不能访问类的私有成员答案为C第12页，共57页。12.下列关于new运算符的描述中,错误的是()

A.使用运算符new创建对象组时必须定义初始值

B.使用运算符new创建对象时,会调用类的构造函数

C.运算符new可以用来动态创建对象和对象数组

D.使用new运算符创建的对象可以运用运算符delete删除答案为A第13页，共57页。13.下列对类的构造函数和析构函数的描述中,正确的是()

A.构造函数可以重载,析构函数不能

B.构造函数不能重载,析构函数可以

C.构造函数可以重载,析构函数也可以重载

D.构造函数不能重载,析构函数也不能重载答案为A第14页，共57页。14.在C++中,数据封装要解决的问题是()

A.数据的规范化

B.便于数据转换

C.避免数据丢失

D.防止不同模块之间数据的非法访问答案为D第15页，共57页。15.假定MyClass为一个类,那么下列的函数说明中,()为该类的析构函数.

A.void~MyClass();

B.~MyClass(intn);

C.MyClass();

D.~MyClass();

答案为D第16页，共57页。16.为了使类中的成员不能被类的对象通过成员操作符访问,则不能把该成员的访问权限定义为

（）A.public

B.protected

C.private

D.static答案为A第17页，共57页。17.下列对与拷贝初始化构造函数的描述中,正确的()

A.在C++语言中,如果不自定义类的拷贝初始化构造函数,则每个类都有默认的拷贝初始化构造函数

B.必须为每个类定义拷贝初始化构造函数

C.如果要使用拷贝初始化构造函数,则必须在类中定义

D.当定义了类的构造函数时,如果要使用拷贝初始化构造函数,则必须定义拷贝初始化构造函数答案为A第18页，共57页。18.对于下面定义的类MyClass,在函数f()中将对象成员n的值修改为50的语句(划线处)应该是()

classMyClass

{

public:

MyClass(intx)

{

n=x;

}

voidSetValue(intn1)

{

n=n1;

}

private:

intn;

};

intf()

{

MyClass*ptr=newMyClass(45);

__________;

}

A.MyClass(50)

B.SetValue(50)

C.ptr->SetValue(50)

D.ptr->n=50答案为C第19页，共57页。19.类MyClass的定义如下:

classMyClass

{

public:

MyClass()

{

value=0;

}

setVariable(inti)

{

value=i;

}

private:

intvalue;

};

则以下各项对如下语句序列的描述中,正确的是().

MyClass*p,my;p=&my;

A.语句”p=&my;”是把对象my赋值给指针变量p

B.语句”MyClass*p,my;”会调用两次类MyClass的构造函数

C.对语句”*p.SetVariable(5)”的调用是正确的

D.语句”p->SetVariable(5)”与语句”my.SetVariable(5)”等价答案为D第20页，共57页。20.下面类的定义,有()错误.classMyClass{inti=0;public:voidMyClass();~MyClass(intValue);};

A.1

B.2

C.3

D.4

答案为C第21页，共57页。21.定义析构函数时，应该注意()

A.其名与类名完全相同

B.返回类型是void类型

C.无形参，也不可重载

D.函数体中必须有delete语句

答案为C第22页，共57页。22.构造函数不具备的特征的是()

A.构造函数的函数名与类名相同

B.构造函数可以重载

C.构造函数可以设置默认参数

D.构造函数必须指定返回类型

答案为D第23页，共57页。23.类的析构函数是在什么时间被自动调用的（）

A.类创建时

B.创建对象时

C.删除对象时

D.不自动调用答案为C第24页，共57页。24.对于任何一个类，析构函数最多有()个

A.0

B.1

C.2

D.325.通常，拷贝构造函数的参数是()

A.某个对象名

B.某个对象的成员名

C.某个对象的引用名

D.某个对象的指针名

答案为B答案为C第25页，共57页。26.面向对象程序设计中的数据隐藏指的是()

A.输入数据必须输入保密口令

B.数据经过加密处理

C.对象内部数据结构上建有防火墙

D.对象内部数据结构的不可访问性

答案为D第26页，共57页。27.下列关于类的访问权限的描述中,错误的是().

A.说明为公有的成员可以被程序中的任何代码访问

B.说明为私有的成员只能被类的成员和说明为友元类的成员函数访问

C.说明为保护的成员,除了能被本身的成员函数和说明为友元类的成员函数访问外,该类的派生类的成员也可以访问

D.类的所有成员都可以被程序中的任何代码访问

答案为D第27页，共57页。28.一个类的友元函数或友元类可以访问该类的()

A.私有成员

B.保护成员

C.公有成员

D.所有成员

答案为D第28页，共57页。29.下列关于成员函数特征的描述中,错误的是()

A.成员函数一定是内联函数

B.成员函数可以重载

C.成员函数可以设置参数的默认值

D.成员函数可以是静态的

答案为A第29页，共57页。30.下面对类中静态数据成员的描述中,正确的是()

A.静态数据成员是类的所有对象共享的数据

B.类的每个对象都有自己的静态数据成员

C.类的不同对象有不同的静态数据成员

D.静态数据成员不能通过类的对象调用答案为A第30页，共57页。31.下列虚基类的声明中，正确的是（）。

A.classvirtualB:publicA

B.virtualclassB:publicA

C.classB:publicAvirtual

D.classB:virtualpublicA

答案为D第31页，共57页。32.C++类体系中，不能被派生类继承的有（）。

A.构造函数

B.虚函数

C.静态成员函数

D.赋值操作函数

33.下列说法错误的是（）。

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

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

C.私有继承的基类中的public成员在派生类中变成private的

D.保护继承的基类中的public成员在派生类中变成protected的答案为A答案为B第32页，共57页。34.下列对基类和派生类关系的描述中，错误的是（）。

A.派生类是基类的具体化

B.派生类是基类的子集

C.派生类是基类定义的延续

D.派生类是基类的组合

答案为B第33页，共57页。35.C++中的类有两种用法：一种是类的实例化，即生成类对象，并参与系统的运行；另一种是通过（）派生了新的类。

A.复用

B.继承

C.封装

D.引用

答案为B第34页，共57页。36.C++类体系中，能被派生类继承的是（）。

A.构造函数

B.虚函数

C.析构函数

D.友元函数

答案为B第35页，共57页。37.在重载一个运算符函数时，其参数表中没有任何参数，这说明该运算符是（）。

A.一元非成员运算符

B.一元成员运算符

C.二元非成员运算符

D.二元成员运算符

答案为B第36页，共57页。38.关于多继承二义性的描述，（）是错误的。

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

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

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

D.派生类和它的基类中出现同名函数时，将可能出现二义性答案为D第37页，共57页。39.下列对派生类的描述中，（）是错误的。

A.一个派生类可以作为另一个派生类的基类

B.派生类至少有一个基类

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

D.派生类中继承的基类成员的访问权限到派生类保持不变

答案为D第38页，共57页。40.若类A和类B的定义如下：

classA

{

inti,j;

public:

intgeti(){returni;}

};

classB:publicA

{

intk;

public:

voidmake(){k=i*j;}

};

则上述中，（）是非法的表达式。

A.k=i*j

B.intk;

C.returni;

D.voidmake();

答案为A第39页，共57页。41.关于公有继承，下列说法错误的是（）。

A.基类的公有成员和保护成员被继承后作为派生类的公有成员和保护成员。

B.派生类的其他成员可以直接访问基类的公有成员和保护成员。

C.派生类的对象可以访问基类的私有成员。

D.派生类成员和对象都无法访问基类的私有成员。

答案为C第40页，共57页。42.下列说法中错误的是（）。

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

B.公有继承时基类中的private成员在派生类中仍是private的；

C.私有继承时基类中的public成员在派生类中是private的；

D.保护继承时基类中的public成员在派生类中是protected的；

答案为B第41页，共57页。43.在公有继承中，基类中的公有成员作为派生类的（）。

A.公有成员

B.私有成员

C.保护成员

D.私有成员函数

答案为A第42页，共57页。44.基类中的（）不允许外界访问，但允许派生类的成员访问，这样既有一定的隐藏能力，又提供了开放的接口。

A.公有成员

B.私有成员

C.保护成员

D.私有成员函数

答案为C第43页，共57页。45.设置虚继承的声明中，正确的是（）。

A.简化程序

B.消除二义性

C.提高运行效率

D.减少目标代码

答案为B第44页，共57页。46.下面叙述错误的是（）。

A.基类的protected成员在派生类中仍然是protected

B.基类的protected成员在public派生类中仍然是protected的

C.基类的protected成员在private派生类中是private的

D.基类的protected成员不能被派生类的对象访问

答案为A第45页，共57页。47.派生类的对象对它的基类成员中（）是可以访问的。A.公有继承的公有成员

B.公有继承的私有成员

C.公有继承的保护成员

D.私有继承的公有成员

答案为A第46页，共57页。48.下列对派生类的描述中，错误的是（）。

A.一个派生类可以作为另一个派生类的基类

B.派生类至少有一个基类

C.派生类的缺省继承方式是private

D.派生类只含有基类的公有成员和保护成员

答案为D第47页，共57页。49.继承具有（），即当基类本身也是某一个类派生类时，底层的派生类也会自动继承间接基类的成员。

A.规律性

B.传递性

C.重复性

D.多样性

答案为B第48页，共57页。50、看程序写结果

#include<iostream.h>

classBase

{inti;

public:

Base(intn){cout<<"Constuctingbaseclass"<<endl;i=n;}

~Base(){cout<<"Destructingbaseclass"<<endl;}

voidshowi(){cout<<i<<",";}

intGeti(){returni;}

};

第49页，共57页。classDerived:publicBase

{intj;

Baseaa;

public:

Derived(intn,intm,intp):Base(m),aa(p){

cout<<"Constructingderivedclass"<<endl;

j=n;

}

~Derived(){cout<<"Destructingderivedclass"<<endl;}

voidshow(){Base::showi();

cout<<j<<","<<aa.Geti()<<endl;}

};

voidmain()

{Derivedobj(8,13,24);

obj.show();

}

Constuctingbaseclass

Constuctingbaseclass

Constructingderivedclass

13,8,24

Destructingderivedclass

Destructingbaseclass

Destructingbaseclass

第50页，共57页。51、指出并改正下面程序中的错误。

#include<iostream.h>

classA

{public:

intx;

A(inta=0){x=a;}

voiddisplay(){cout<<"A.x="<<x<<endl;}

};

classB

{public:

intx;

B(inta=0){x=a;}

voiddisplay(){cout<<"B.x="<<x<<endl;}

};

classC:publicA,publicB

{inty;

public:

C(inta,intb,intc):A(a),B(b)

{y=c;}

intgety(){returny;}

};

voidmain()

{Cmyc(1,2,3);

myc.x=10;

myc.display();

}

myc.A::x=10;myc.A::display();或myc.B::x=10;myc.B::display()；第51页，共57页。52、写出程序运行结果:

#include<iostream>

usingnamespacestd;

classbase

{

public:

voidwho(){cout<<"baseclass"<<endl;}

};

classderive1:publicbase

{

public:

voidwho(){cout<<"derive1class"<<endl;}

};

classderive2:publicbase

{

public:

voidwho(){cout<<"derive2class"<<endl;}

};

voidmain()

{

baseobj1;

obj1.who();

derive1obj2;

obj2.base::who();

derive2obj3;

obj3.base::who();

}

baseclass

baseclass

baseclass

第52页，共57页。53.阅读下列程序，写出程序运行结果。

#include<iostream>

usingnamespacestd;

classPerson

{

public:

Person(){cout<<"ConstructorofPerson"<<endl;}

~Person(){cout<<"DestructorofPerson"<<endl;}

};

classStudent:publicPerson

{

public:

Student(){cout<<"ConstructorofStudent"<<endl;}

~Student(){cout<<"DestructorofStudent"<<endl;}

};

classTeacher:publicPerson

{

public:

Teacher(){cout<<"ConstructorofTeacher"<<endl;}

~Teacher(){cout<<"DestructorofTeacher"<<endl;}

};

intmain()

{

Students;

Teachert;

return0;

}

ConstructorofPerson

ConstructorofStudent

ConstructorofPerson

ConstructorofTeacher

DestructorofTeacher

DestructorofPerson

DestructorofStudent

DestructorofPerson第53页，共57页。54.写出下列程序运行结果:

#include<iostream>

usingnamespacestd;

classB0

{

public:

voiddisplay(){cout<<"B0::display()"<<endl;}

};

classB1:publicB0

{

public:

voiddisplay(){cout<<"B1::display()"<<endl;}

};

classD1:publicB1

{

public:

voiddisplay(){cout<<"D1::display()"<<endl;}

};

intmain()

{

B0b0;

B1b1;

D1d1;

B0*p;

p=&b0;

p->display();

p=&b1;

p->display();

p=&d1;

p->display();

}B0::display()

B0::display()

B0::display()

第54页，共57页。55、写出程序运行结果:

#include<iostream>

usingnamespacestd;

classBase

{

intx;

public:

Base(intxx=0):x(xx){cout<<"ConstructorofBase"<<endl;}

~Base(){cout<<"DestructorofBase"<<endl;}

voidPrint(){cout<<x<<',';}

intGetX(){returnx;}

};

classDerived:publicBase

{

inty;

Basez;

public:

Derived(intxx=0,intyy=0):Base(xx),y(yy),z(xx+yy)

{cout<<"ConstructorofDerived"<<endl;}

~Derived(){cout<<"DestructorofDerived"<<endl;}

voidPrint()

{

Base::Print();

cout<<y<<','<<z.GetX()<<endl;

}

};

intmain()

{

Derivedobj1(2);

obj1.Pri