C考试重点.docx

C考试重点.docx

《C考试重点.docx》由会员分享，可在线阅读，更多相关《C考试重点.docx（23页珍藏版）》请在冰豆网上搜索。

C考试重点

C＋＋考试重点

一、选择题

1.关于函数重载：

A

A.两个或两个以上的函数取相同的函数名，但形参的个数或类型不同

B.两个以上的函数取相同的名字和具有相同的参数个数，但形参的类型可以不同

C两个以上的函数名字不同，但形参的个数或类型相同

.D.两个以上的函数取相同的函数名，并且函数的返回类型相同

2.关于引用：

A.每一个引用都是其所引用对象的别名,因此必须初始化V

B.形式上针对引用的操作实际上作用于它所引用的对象V

C.一旦定义了引用，一切针对其所引用对象的操作只能通过该引用间接进行X

D.不需要单独为引用分配存储空间V

3.关于封装，B

A.通过封装，对象的全部属性和操作结合在一起，形成一个整体

B.通过封装，一个对象的实现细节被尽可能地隐藏起来（不可见）

C.通过封装，每个对象都成为相对独立的实体

D.通过封装，对象的属性都是不可见的

4.判断

A派生类的对象可以赋给基类的对象V

B.派生类的对象可以初始化基类的引用V

C.派生类的对象可以直接访问基类中的成员X

D.派生类的对象的地址可以赋给指向基类的指针V

5.对于类定义

Class{

public:

virtualvoidfuny（）{}

voidfunx（）{}

}

classB:

publicm{

public:

voidfuny（）{cout<<〃classBfunc1〃<

virtualvoidfunx（）{cout<<〃classBfunc2〃<

};

判断下列说法是否正确C对

A.M:

:

funx（）和B:

:

funy（）都是虚函数

Ｂ、M:

:

funx（）和B:

:

funy（）都不是虚函数

Ｃ、B:

:

funy（）是虚函数，而M:

:

funx（）不是虚函数V

Ｄ、B:

:

funy（）不是虚函数，而M:

:

funx（）是虚函数

6对于char*kk[7];的描述，（）是正确的。

D

A.kk是一个指向数组的指针，所指向的数组是7个char型元素；

B.kk是一个指向某个数组中第7个元素的指针，该元素是char型变量；

C.kk[7]表示某个数组的第7个元素的值；

D.kk是一个具有7个元素的指针数组，每个元素是一个char型指针；

7.关于静态数据成员：

A.说明静态数据成员时前边要加修饰符static;V

B.静态数据成员要在类体外进行初始化；X

、C.引用静态数据成员时，要在静态数据成员名前加<类名>和作用域运算符；V

D.静态数据成员不是所有对象所共用的。

V

8.关于函数模板：

A.函数模板也是一个具体类型的函数X

B.函数模板的类型参数与函数的参数是同一个概念X

C.通过使用不同的类型参数，函数模板可以生成不同类型的函数V

D用函数模板定义的函数没有类型X

9.下列哪种调用方式是引用调用。

C

A.形参和实参都是变量B.形参是指针，实参是地址值

C.形参是引用，实参是变量D.形参是变量，实参是地址值

填空题：

1.为了提高程序的运行速度，可将不太复杂的功能用函数实现，此函数应选择（内联）函数。

2.面向对象方法的多态性是指（针对一消息，不同的对象可以以适合自身的方式加以响应）。

3.当一个成员函数被调用时，该成员函数的（this指针）指向调用它的对象。

4.在公有继承的情况下，基类数据成员在派生类中的访问权限是什么

保持不变，派生类会继承基类的成员函数和成员变量，在公有继承的情况下，派生类不改变基类成员的访问权限。

5．静态数据成员在类外进行初始化，且静态数据成员的一个拷贝被类的所有对象（共享）。

6．构造函数与析构函数除功能不同外，在定义形式上，它们的区别还包括构造函数名与类名相同，而析构函数名是在类名前加一个~、析构函数__没有___（有/没有）参数、析构函数___可以__（可以/不可以）定义为虚函数。

7.在类作用域中能够直接使用该类的（任何）成员名进行访问。

8．面向对象的程序设计有四大特征，它们是

1.抽象：

　　抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。

抽象并不打算了解全部问题，而只是选择其中的一部分，暂时不用部分细节。

比如，我们要设计一个学生成绩管理系统，考察学生这个对象时，我们只关心他的班级、学号、成绩等，而不用去关心他的身高、体重这些信息。

抽象包括两个方面，一是过程抽象，二是数据抽象。

过程抽象是指任何一个明确定义功能的操作都可被使用者看作单个的实体看待，尽管这个操作实际上可能由一系列更低级的操作来完成。

数据抽象定义了数据类型和施加于该类型对象上的操作，并限定了对象的值只能通过使用这些操作修改和观察。

2.继承：

　　继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。

对象的一个新类可以从现有的类中派生，这个过程称为类继承。

新类继承了原始类的特性，新类称为原始类的派生类（子类），而原始类称为新类的基类（父类）。

派生类可以从它的基类那里继承方法和实例变量，并且类可以修改或增加新的方法使之更适合特殊的需要。

这也体现了大自然中一般与特殊的关系。

继承性很好的解决了软件的可重用性问题。

比如说，所有的Windows应用程序都有一个窗口，它们可以看作都是从一个窗口类派生出来的。

但是有的应用程序用于文字处理，有的应用程序用于绘图，这是由于派生出了不同的子类，各个子类添加了不同的特性。

3.封装：

　　封装是面向对象的特征之一，是对象和类概念的主要特性。

封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面。

面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。

一旦定义了一个对象的特性，则有必要决定这些特性的可见性，即哪些特性对外部世界是可见的，哪些特性用于表示内部状态。

在这个阶段定义对象的接口。

通常，应禁止直接访问一个对象的实际表示，而应通过操作接口访问对象，这称为信息隐藏。

事实上，信息隐藏是用户对封装性的认识，封装则为信息隐藏提供支持。

封装保证了模块具有较好的独立性，使得程序维护修改较为容易。

对应用程序的修改仅限于类的内部，因而可以将应用程序修改带来的影响减少到最低限度。

4.多态性：

　　多态性是指允许不同类的对象对同一消息作出响应。

比如同样的加法，把两个时间加在一起和把两个整数加在一起肯定完全不同。

又比如，同样的选择编辑-粘贴操作，在字处理程序和绘图程序中有不同的效果。

多态性包括参数化多态性和包含多态性。

多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。

9．动态联编要满足哪两个条件

调用的函数是虚函数、用指针或引用调用虚函数

　10．在C++类中，有一种不能定义对象的类，这样的类只能被继承，称之为（抽象类），定义该类至少具有一个（纯虚函数）。

　11．在C++类中，const关键字可以修饰对象和成员函数，const对象不能（调用类中的非const成员函数），const成员函数不能（修改类的private数据成员）。

　12．举出C++中两种代码复用的方式：

（继承）、（复用）。

假定AA为一个类，a为该类公有的数据成员，px为指向该类对象的一个指针，则访问px所指对象中数据成员a的格式为（）。

；如果是，直接AA:

:

a，对象为，指针访问为x->a

14.假定AA为一个类，inta（）为该类的一个成员函数，若该成员函数在类定义体外定义，则函数头为（intAA:

:

a（））。

15.类的构造函数是在定义该类的一个（对象）时被自动调用执行的。

16.假定一个类AB只含有一个整型数据成员a，用户为该类定义的带参构造函数可以写为（AB（intaa=0）{a=aa;}）。

17.对于任一个类，用户所能定义的构造函数的个数至多为（任意个）。

18.对类对象成员的初始化是通过构造函数中给出的（初始化表或函数体）实现的。

19.被非静态成员函数访问的类的数据成员可以是（静态数据成员）

20.引入友元的主要目的是（提高程序的效率和灵活性）。

。

判断：

1．构造函数不是类的成员函数X

C++中,成员函数包括构造函数、析构函数、私有函数和公有函数四种

2．引用一旦初始化，就维系在一定目标上，任何对该引用的赋值都不能使引用维系在其他目标上。

V

3．函数重载的目的是提高运行效率。

X

使用方便，提高可读性

4．类的静态数据成员需要在定义每个类的对象时进行初始化X

5．函数的参数和返回值类型可以是简单数据类型，也可以是指针、引用、数组和类。

X

6．在基类中被说明为虚函数的类的成员函数必须在每个派生类中说明为虚函数，才能具有多态的特征。

X

7．在类定义时，并不给类分配存储实间，因此类定义中不允许对其数据成员直接进行初始化。

V

8．C++中使用了新的注释符（某类中的友元类的所有成员函数可以存取或修改该类中的私有成员。

（X　）

错误不能存取或修改该类的static成员和const成员

11.对象数组的元素可以是不同类的对象。

（X　）

12.Constint*p说明了p是指向整型的常量指针。

（V　）

。

阅读程序，写出运行结果

#include

classAA{public:

AA（inti,intj）

{A=i;B=j;cout<<"Constructor\n";}

AA（AA&obj）

{A=+10;B=+50;cout<<"Copy_Constructor\n";}

~AA（）{cout<<"Destructor\n";}

voidprint（）

{cout<<"A="<

private:

intA,B;

};

voidmain（）{

AAa1（5,8）;AAa5（a1）;（）;AA*pa=newAA（4,6）;

pa->print（）;deletepa;

结果：

Constructor

Copy_Constructor

A=15,B=58

Constructor

A=4,B=6

Destructor

#include

ClassT

{public:

T（intx）{a=x;b+=x;};

staticvoiddisplay（Tc）

{cout<<”a=”<<<<’\t’<<”b=”<<<

private:

inta;

staticintb;

};

intT:

:

b=4;

voidmain（）

{TA（8）,B（4）;

T:

:

display（A）;

T:

:

display（B）;

}

解答：

A=8B=16

A=4B=16

#include

ClassCC1

{public:

CC1（inti）{cout<<”调用CC1的构造函数：

”<

};

ClassCC5

{public:

CC5（intj）{cout<<”调用CC5的构造函数:

’<

};

ClassA:

publicCC5,publicCC1

{public:

A（inta,intb,intc,intd）:

CC1（c）,CC5（b）,b5（a）,b1（d）

{cout<<”调用A的构造函数:

”<

Private:

CC1b1;

CC5b5;

};

Voidmain（）

{Aobj（2,3,7,2）;}

结果：

调用CC5的构造函数:

3

调用CC1的构造函数：

7

调用CC1的构造函数：

2

调用CC5的构造函数:

2

调用A的构造函数:

14

阅读程序，回答问题：

10．分析下列程序中的访问权限，并回答下列问题

#inLlude

classM

{public:

voidf1（）{}

M（）{}

proteLted:

intj1;

private:

inti1;

};

classN:

proteLtedM

{puNliL:

voidf5（）{}

N（）{}

proteLted:

intj5;

privMte:

inti5;

};

classL:

proteLtedN

{public:

voidf3（）{}

L（）{}

proteLted:

intj3;

private:

inti3;

};

（1）派生类N中成员函数f5（）能否访问基类M中的成员f1（）,i1,j1;

答案：

1（）,i1可以访问j1不可以private是任何继承方式都不能访问的

（2）派生类N的对象N能否访问基类M中的成员f1（）,i1,j1;

答案：

f1（）可以访问，i1只能在内部直接访问不能被对象访问，j1不能

（3）派生类C中成员函数f3（）能否访问基类N中的成员f5（）,i5,j5;能否访问基类M中的成员f1（）,i1,j1;

答案：

f5（）,j5可以访问f1（）,i5可以访问j1不行

（4）派生类C的对象c能否访问基类N中的成员f5（）,i5,j5;能否访问基类M中的成员f1（）,i1,j1;

答案：

f5（）可以,j5不行,f1可以,i1j1不行

XX原题：

#include<>

classA

{public:

voidf1（）;

protected:

intj1;

private:

inti1;

};

classB:

publicA

{public:

voidf2（）;

protected:

intj2;

private:

inti2;

};

classC:

publicB

{public:

voidf3（）;

};

回答下列问题：

1．派生类B中成员函数f2（）能否访问基类A中的成员：

f1（）,i1和j1

2．派生类B的对象b1能否访问基类A中的成员：

f1（）,i1和j1

3．派生类C中成员函数f3（）能否访问直接基类B中的成员：

f2（）和j2能否访问间接基类A中的成员：

f1（）,i1和j1

4．派生类C的对象c1能否访问直接基类B中的成员：

f2（）和j2能否访问间接基类A中的成员：

f1（）,i1和j1

（）,i1可以访问j1不可以private是任何继承方式都不能访问的

（）可以访问，i1只能在内部直接访问不能被对象访问，j1不能

（）,j2可以访问f1（）,i1可以访问j1不行

（）可以j2不行f1可以,i1，j1不行

1设计一个立方体类Nox，它能计算并输出立方体的体积和表面积。

第一种代码：

#include

usingnamespacestd;

classBox

{

public:

Box（doublet）

{

a=t;

volume=;

area=;

}

doubleseta（doublei）

{

a=i;

returna;

}

doublegetvolume（）

{

volume=a*a*a;

returnvolume;

}

doublegetarea（）

{

area=6*a*a;

returnarea;

}

voiddisp（）

{

getvolume（）;

getarea（）;

cout<<"=>体积"<

}

private:

doublea,volume,area;

};

intmain（）

{

Boxobj1;

cout<<"obj1";

（）;

Boxobj2;

cout<<"obj2";

（）;

system（"PAUSE"）;

}

第二种代码：

#include

usingnamespacestd;

classBox{

private:

doublelength;

doublevolume;

doublearea;

public:

Box（doublel）{

length=l;

volume=;

area=;

}

doublegetVolume（）{returnlength*length*length;}

doublegetArea（）{returnlength*length*6;}

voidshow（）{volume=getVolume（）;area=getArea（）;cout<<"立方体的体积：

"<

"<

};

intmain（）{

intlength=0;

cout<<"请输入立方体的边长:

";

cin>>length;

Boxbox（length）;

（）;

getchar（）;

system（"PAUSE"）;

return0;

}

第三种代码：

#include<>

classNox

{

public:

Nox（doublet）

{

a=t;

volume=;

area=;

}

doubleseta（doublei）

{

a=i;

returna;

}

doublegetvolume（）

{

volume=a*a*a;

returnvolume;

}

doublegetarea（）

{

area=6*a*a;

returnarea;

}

voiddisp（）

{

getvolume（）;

getarea（）;

cout<<"=>体积"<

}

private:

doublea,volume,area;

};

voidmain（）

{

Noxobj1;

cout<<"obj1";

（）;

Noxobj2;

cout<<"obj2";

（）;

}

2．编程实现抽象类Employee，派生类Mnger和HourlyWorker，Employee有数据成员姓名nMme和工号ID，MMnger有数据成员sMl，代表经理的月工资，HourlyWorker有wMge和hours，分别代表钟点工的每小时的工资数和月工作时数，定义的所有类中必须包含构造函数、析构函数、修改和获取所有数据成员的成员函数,以及虚函数来计算职员的工资、输出职员的姓名nMme和工号ID。

#include

#include

usingnamespacestd;

classEmployee{

public:

Employee（）{};

virtualvoidgongzi（）{cout<<"no";}

voidxianshi（）{cout<<"no";}

stringname;stringid;

~Employee（）{};

};

classManger:

publicEmployee

{

public:

Manger（strings1,strings2）{name=s1;id=s2;}

voidgongzi（）{

cout<

"<

cout<

}

voidxianshi（）{

cout<<"经理的姓名为：

"<

cout<<"经理的ID为：

"<

}

voidset（）{cout<<"请修改经理的月工资为：

";cin>>sal;cout<

~Manger（）{};private:

intsal;

};

classHourlyWorker:

publicEmployee

{

public:

HourlyWorker（strings1,strings2）{name=s1;id=s2;}

voidgongzi（）{cout<

"<

voidxianshi（）{

cout<<"钟点工的姓名为：

"<

cout<<"钟点工的ID为：

"<

}voidset（）{

cout<<"请输入钟点工每小时的工资数：

";

cin>>wage;cout<

cout<<"请输入钟点工月工作时数：

";

cin>>hours;cout<

}

~HourlyWorker（）{};private:

intwage;inthours;

};voidfun（Employee*p）{

p->gongzi（）;

}voidmain（）{

（）;（）;

fun（&zhangye）;

（）;

（）;

fun（&zjy）;

}

在用class定义一个类时，数据成员和成员函数的默认访问权限是；私有

（3）含有纯虚函数的类称作；抽象类

（4）已知intDNL（intn）{returnn+n;}和longDNL（longn）{returnn+n;}

是一个函数模板的两个实例，则该函数模板的定义为：

TemplateTDBL（Tn）{returnn+n;}

在下面程序的横线处填上适当的语句，使该程序执行结果为121.

#include

classMyClass

{　puNlic:

　　MyClass（inta）{x=M;}

　　MyClass（intx）{=x;};intGetNum（）{returnx;};

//取x值

　　private

　　intx;

};

intmMan（）

{　MyClassmy（121）;

　　cout<<（）<

　　return0;

}

下面程序的打印结果是

#include

intf（int）;

intmain（）