习题.docx

习题.docx

《习题.docx》由会员分享，可在线阅读，更多相关《习题.docx（58页珍藏版）》请在冰豆网上搜索。

习题

提示

思考题用于帮助同学复习。

所以做思考题时必须先进行思考，运用课堂上所学知识，求得答案。

必要时才上机操作进行验证。

这样才真有收获。

切勿先上机求取思考题结果而少动或不动脑子，收获将小得多。

第二章思考题

（一）判断下列各种描述是否正确，对者划√，错者划

（1）引用的运行机理和指针完全相同，而其使用却方便的多。

（2）引用的功能和指针相同，但却多一项，即从函数返回的引用可用作等式左值。

（3）引用是“别名其表，指针其实”。

也即，引用在使用时是一个别名，但实质上是一个指针。

（4）虽然用户程序无法读取引用的地址，但引用本身具有一定地址。

（二）填空：

（1）被定义于所有函数之外的变量称为（）变量，也称（）变量。

（2）被定义于某个函数（程序块）之内的变量称为（）变量，也称（）变量。

（3）静态变量分为（）静态变量和（）静态变量两种。

（4）所有函数的代码通常都被存放在内存的（）区。

全局变量和所有静态变量通常都被存放在内存的（）区。

所有函数中的局部变量、函数参数、所用通用寄存器的值、返主地址等通常在该函数被调用时，被存放在内存的（）区。

使用new所分配的空间被存放在内存的（）区。

（三）给出以下程序的运行结果：

（1）//cal_val2.cpp

//callbyvalue

#include

voidinc（intv）

{

v++;

}

voidmain（）

{

inti=10;

inc（i）;

cout<

}

（2）//cal_ptr2.cpp

//callbypointer

#include

voidinc（int*v）

{

（*v）++;

}

voidmain（）

{

inti=10;

inc（&i）;

cout<

}

（3）//cal_ref2.cpp

//callbyreference

#include

voidinc（int&v）

{

++v;

}

voidmain（）

{

inti=10;

inc（i）;

cout<

}

（四）给出以下程序的运行结果，并画出程序中执行第一、第二、第三和第五语句后变量及其引用的栈区内存存储内容：

#include

voidmain（）

{

intval;//

（1）

int&refv=val;//

（2）

val=15;//（3）

cout<<"变量与引用的值：

"<

refv=30;//（5）

cout<<"重新赋值后变量与引用的值：

"<

}

（五）给出以下程序的运行结果，并画出程序中执行第一、第二和第四语句后变量及其引用的双区内存存储内容：

//definingreferenceforheapareadatum

#include

voidmain（）

{

int*p=newint（10）;

int&ref=*p;

cout<

ref=50;

cout<<*p<

deletep;

}

（六）给出以下程序的运行结果：

//exer_ch2_6.cpp

#include

statics（3）;//orstaticints（3）;"int"maybeomitted!

intfun（void）;

voidmain（）

{

cout<<"externalstatics（global）="<

fun（）;

fun（）;

}

intfun（）

{

staticb（3）;//"int"maybeomitted!

b+=s;

cout<<"staticbinfun="<

returnb;

}

（七）试问以下各变量位于何区？

//exer_ch2_7.cpp

//trytoreadtheaddressesofdata,functionsandheap

#include

intdata=23;//globaldatum

voidmain（）

{

inti=15;//localdatum

int*ptr=newint（8）;//datuminheap

cout<<"codeaddress:

"<

cout<<"globaldatumaddress:

"<<&data<

cout<<"localdatumaddress:

"<<&i<

cout<<"pointeraddress:

"<<&ptr<

cout<<"heapaddress:

"<

cout<<"datuminheap:

"<<*ptr<

deleteptr;

}

/*Results:

codeaddress:

0x00401014

globaldatumaddress:

0x00428D64

localdatumaddress:

0x0012FF7C

pointeraddress:

0x0012FF78

heapaddress:

0x00431AE0

datuminheap:

8

*/

data位于_______、i位于_______、ptr位于_______、*ptr位于_______、main（）位于_______。

第三章思考题

（一）选择填空：

（1）关于类定义格式的描述中，（）是错的：

i.A.一般类的定义格式可分为类的说明（也称类的接口）部分和成员函数定义（也称类的实现）部分共两部分，有时这两部分也可合并为一个统一的类的定义。

B.类中一般包含有数据成员和成员函数两部分。

C.类对象的内存存储内容中，所有数据（包括静态数据成员和非静态数据成员）都存于内存数据区内。

D.类对象的成员函数的代码部分都存于内存代码区内。

（2）关于类成员的描述中，（）是错的：

A.类中可以说明或定义一个或多个成员函数。

B.类中的成员函数只能定义在类体外。

C.在类体外使用数据成员时，须使用类名及作用域运算符（:

:

）来指明（限定）该数据成员（例如base:

:

a）。

（3）在类的静态成员的描述中，（）是错的：

A.静态成员分为静态数据成员和静态成员函数。

B.静态数据成员声明后必须在类体外进行初始化。

C.静态数据成员初始化不使用其构造函数。

D.D.静态成员函数可以不使用类名和作用域运算符而直接访问该类的一个对象的非静态成员。

（4）在友元的描述中，（）是错的：

A.一个类的友元函数是该类的成员函数。

B.友元函数可直接访问类中的私有成员。

C.友元函数损害封装性，应限用。

D.友元类中的所有成员函数都是友元函数。

（5）在有关类和对象的描述中，（）是错的：

A.对象是类的一个实例。

B.任何一个对象只能属于一个类。

C.类和对象的关系与数据类型和变量的关系相似。

D.一个类只能有一个对象。

（6）下列关于对象数组的描述中，（）是错误的。

A.对象数组只能赋初值而不能再赋值。

B.对象数组的下标（序号）从0开始。

C.对象数组的每个元素都是相同类的对象。

D.对象数组的数组名是一个常量指针。

（7）下列关于子对象的描述中，（）是错误的。

A.子对象是另一个类（复合类）的一个数据成员。

B.子对象不可以是本复合类的对象而应是其它类的对象。

C.对子对象的初始化必须通过构造函数中的初始化列表。

D.一个类中只能含有一个子对象作其成员。

（8）在new运算符的下列描述中，（）是错误的。

A.它可以为创建对象或对象数组而动态地在堆区申请分配空间。

B.用它创建对象数组时必须指定初始值。

C.当构造函数使用它在堆区内创建对象或对象数组时，在程序结束前应使用运算符delete来释放所分配的堆区空间。

（9）在delete运算符的下列描述中，（）是错误的。

A.用它可以释放用new运算符创建的为对象或对象数组分配的堆区空间。

B.用它释放一个对象的堆空间时，它作用于一个new所返回的指针。

C.用它释放一个对象数组的堆空间时，它作用的指针名前须加下标运算符[]。

D.用它释放一个对象的堆空间时，它同时删除new运算符所使用的指针。

（二）判断下列各种描述是否正确，对者划√，错者划

（1）建立一个类的对象时，系统将其非静态数据成员存储于该对象的栈区存储空间内。

而该类的静态数据成员和成员函数代码则分别存储于数据区和代码区内。

（2）如果一个成员函数只访问一个类的静态数据成员，则可将该成员函数定义为静态成员函数。

（3）可在类的构造函数的初始化列表中对该类的静态数据成员进行初始化。

（三）给出以下程序的运行结果：

//exer_3_3.cpp

#include

classC{

staticintc;

public:

C（）{cout<<++c<

staticintGetc（）

{returnc;}

~C（）{cout<

};

intC:

:

c;

voidmain（）

{

Cc1,c2,c3;//创建类的时候所有的构造函数会执行一遍在类消失的时候析构函数会执行一遍先创建的后执行后创建的先执行

cout<

:

Getc（）<

}

Result/*

1

2

3

3*/

（四）给出以下程序的运行结果：

//exer_ch3_4.cpp

#include

classM

{

intm1,m2;

public:

M（inti,intj）{m1=i;m2=j;}

voidSum（Ma,Mb）{

m1=a.m1+b.m1;

m2=a.m2+b.m2;

}

voidprint（）

{cout<<"m1="<

};

voidmain（）

{

Ma（30,70）;

Mb（a）;//相当于b=a

b.Sum（a,b）;

b.print（）;

}

Result/*

m1=60,m2=140

*/

（五）给出以下程序的运行结果：

//exer_ch3_5.cpp

#include

classAA{

public:

inta;

AA（intx）{a=x;}

~AA（）{cout<<"Des-"<

};

voidinc_by_value（AAobj）//形参是classAA的对象obj

{

obj.a++;

}

voidinc_by_refer（AA&obj）//形参是classAA的对象obj的引用，实即指针

{

obj.a++;

}

voidmain（）

{

AAobj（50）;

inc_by_value（obj）;

cout<<"inc_by_value:

a="<

inc_by_refer（obj）;

cout<<"inc_by_reference:

a="<

}

Result/*

Des-51//在第一次调用的函数时新创建了一个AA类调用结束时新的类的a变成51然后消亡调用析构函数

inc_by_value:

a=50//第一次调用结束后原来了AA类的obj不影响

inc_by_reference:

a=51//给出原来的obj的地址时才把它指向了原来obj的储存区才能真的改变原来obj的值

*/

（六）给出以下程序的运行结果：

//exer_ch3_6.cpp

#include

classfigure

{

doubled;

public:

figure（doublem）

{d=m;cout<<"CONS-sub:

"<

~figure（）{cout<<"Des-sub:

"<

};

classpoint

{

intx;

figuresub_obj;//sub_obj为子对象

public:

point（inta,doubled）:

x（a）,

sub_obj（d）//将子对象初始化

{cout<<"CONS:

"<

~point（）{cout<<"Des:

"<

};

voidmain（）

{

pointobjp1（123,98.76）;

}

（七）判断下列描述是否正确，对者划√，错者划x。

（1）对象和指向对象的指针都可以用作函数参数。

（2）对象数组的元素必须是同一个类的对象。

（3）一维对象指针数组的每个元素应该是同一个类的不同对象的地址值。

（4）运算符new可以在堆区内创建变量或对象，也可以创建变量数组或对象数组。

（5）子对象的初始化可在复合类的构造函数的函数体内进行。

（八）给出以下程序的运行结果，并画出对象obj的栈区存储内容。

#include

classB

{

intb1,b2;

public:

B（inti,intj）;

voidprintB（）;

};//这是典型的类的接口

B:

:

B（inti,intj）

{

b1=i;

b2=j;

}

voidB:

:

printB（）

{

cout<<"b1="<

}

classA

{

inta;

Bsub_obj;

public:

A（inti,intj,intk）;

voidprintA（）;

};

A:

:

A（inti,intj,intk）:

sub_obj（i,j）,a（k）{}

voidA:

:

printA（）

{

sub_obj.printB（）;

cout<<"a="<

}

voidmain（）

{

Aobj（12,65,100）;

obj.printA（）;

}

Result/*

Bi=12,b2=65

A=100

*/

（九）给出以下程序的运行结果，并画出主程序第一句和第二句后对象obj的双区存储内容。

#include

classM

{

intx;

staticints;

public:

M（inta）{x=a;}

voidadd（intb）{s+=b;}

voidshow（）{cout<<"objectdatum:

"<

staticvoidshow_s（）{cout<<"staticdatum:

"<

};

intM:

:

s=3;

voidmain（）

{

Mobj（6）;

obj.add（7）;

obj.show（）;

M:

:

show_s（）;

}

Result/*

objectdatum:

6

staticdatum:

10

*/

（十）给出以下程序的运行结果：

//Toshowdifferentstatusofauto,staticandexternaldata

//staticandexternaldataareinitializedonlyonce

//andexistallthetime

#include

voidstatic_f（void）;

voidauto_f（void）;

voidexternal_f（void）;

intg=9;

voidmain（）

{

auto_f（）;

auto_f（）;

static_f（）;

static_f（）;

external_f（）;

external_f（）;

}

//functiontoreadandincrementanautodatum

voidauto_f（void）

{

inti=3;

i+=3;

cout<

}

//functiontoreadandincrementastaticdatum

voidstatic_f（void）

{

statici=6;//i.e.staticinti=6;

i+=3;

cout<

}

//functiontoreadandincrementanexternaldatum

voidexternal_f（void）

{

g+=3;

cout<

}

Result略

（十一）填空：

（1）一般程序有四个内存分区，它们是：

（）、（）、（）和（）。

（2）（）用于存放主函数和各子函数（包括各类中的成员函数）代码。

（3）（）用于存放全局变量和和静态变量。

（4）（）用于存放局部变量，函数参数，寄存器值等。

（5）（）用于为由new所创建的对象或其数组动态地分配存储空间。

第四章思考题

（一）选择填空：

（1）下列对派生类的描述中，（）是错误的。

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

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

C.基类中成员被派生类继承后其映射的访问权限并无变化。

D.派生类对象的栈区内存存储内容中除了本类部分的所有非静态数据成员外，还首先包含了它的基类部分的所有非静态数据成员。

（2）主函数main可以访问派生类的对象中哪一类映射的基类成员？

（）

A.公有继承的基类部分的公有成员。

B.公有继承的基类部分的保护成员。

C.公有继承的基类部分的私有成员。

D.保护继承的基类部分的公有成员。

（3）多继承派生类建立对象时，（）被最先调用。

A.派生类自己的构造函数。

B.祖先虚基类的构造函数。

C.祖先非虚的基类的构造函数。

D.派生类中子对象的构造函数。

（4）下列关键字中，（）不是类定义中使用的关键字：

A.classB.publicC.switchD.private

（二）判断下列描述的正确性，对者划√，错者划

（1）C++语言中，允许单继承，也允许多继承。

（2）派生类不能再派生出新的派生类。

（3）在公有继承中，派生类对象的成员函数可以访问基类部分中的私有成员。

（4）在公有继承中，派生类对象的成员函数不可以访问基类部分中的保护成员。

（5）在私有继承中，派生类对象的成员函数不可以访问基类部分中的公有成员。

（6）在保护继承中，派生类对象的成员函数可以访问基类部分中的保护成员。

（6）（7）用class定义的类中，缺省的访问权限是公有的。

（三）写出以下程序运行结果，画出以下题中的DAG和访问控制表

//exer_ch4_3.cpp

#include

classA

{

inta,b;

public:

A（inti,intj）

{a=i;b=j;}

voidMove（intx,inty）

{a+=x;b+=y;}

voidShow（）

{cout<<"（"<

};

classB:

publicA

{

intx,y;

public:

B（inti,intj,intk,intl）:

A（i,j）

{x=k;y=l;}

};

voidmain（）

{

Aa（1,2）;

Bb（3,4,5,6）;

b.Move（7,8）;

b.Show（）;

}

（四）画出以下程序的访问控制表，并根据该表找出程序中错误语句，将它删去后显示运行结果。

#include

classA

{

protected:

voidf（inta）{cout<

voidg（）{cout<<"g（）"<

};

classB:

A//[private]

{

public:

voidh（）{cout<<"h（）"<

};voidmain（）{Bobjb;objb.f（5）;objb.g（）;objb.h（）;}

（五）以下程序中，有些类只定义了构造函数，另有些类只定义了析构函数，请写出其运行结果：

//exer_ch4_5.cpp

#include

classB

{

public:

B（）{cout<<"CONS_B"<

};

classV:

publicB

{

public:

~V（）{cout<<"DES_V"<

};

classX:

virtualpublicV

{

public:

X（）{cout<<"CONS_X"<

~X（）{cout<<"DES_X"<

};

classY:

virtualpublicV

{

public:

Y（）{cout<<"CONS_Y"<

};

classW:

publicY,publicX

{

public:

~W（）{cout<<"DES_W"<

};

classZ:

publicW

{

public:

~Z（