c++课后习题解答610.docx

c++课后习题解答610.docx

《c++课后习题解答610.docx》由会员分享，可在线阅读，更多相关《c++课后习题解答610.docx（82页珍藏版）》请在冰点文库上搜索。

c++课后习题解答610

第6章;类和对象

（一）　

练习题6

6.1判断题

×1．使用class定义的类，其默认的访问权限是公有的，使用struct定义的类，其默认的访问权限是私有的。

×2．类中的成员函数都是公有的，数据成员都是私有的。

×3．定义在类体内的成员函数是内联函数，定义在类体外的成员函数不能是内联函数。

√4．类定义后，它的成员个数及名称就不会再被改变了。

×5．定义或说明对象时，系统会自动调用构造函数为创建的对象初始化。

如果类中没有定义任何构造函数时，就无法给定义的对象初始化。

√6．定义一个对象时，系统只为该对象的数据成员开辟内存空间，而成员函数是同类对象共享的。

√7．对象成员的表示方法与结构变量成员的表示方法相同。

√8．创建对象时系统自动调用相应的构造函数为对象初始化，没有相应的构造函数时，系统会自动生成。

√9．构造函数是一个其名与类名相同的特殊的成员函数。

×10．析构函数是一个函数体为空的成员函数。

√11．构造函数和析构函数都是系统自动调用的成员函数。

×12．构造函数和析构函数都可以重载。

√13．成员函数与一般函数一样可以重载、内联和设置参数的默认值。

×14．静态成员是指静态对象的成员。

×15．静态数据成员必须在构造函数的成员初始化列表中进行初始化。

√16．静态成员都可以使用类名加作用域运算符的方法来引用。

×17．静态成员函数中引用静态数据成员和非静态数据成员的方式是相同的。

√18．常成员指的是类体内使用const关键字说明的常数据成员和常成员函数。

×19．常数据成员在常成员函数中的值是不允许改变的，而在非常成员函数中是允许改变的。

√20．常对象需要引用常成员函数，而不能引用非常成员函数。

×21．常对象的数据成员都是常数据成员。

√22．友元函数是说明在类体内的非成员函数，它可以访问类中的所有成员。

×23．可以把一个一般函数说明为某类的友元函数，也可以将某类的成员函数说明为另类的友元函数。

√24．友元类中的所有成员函数都是友元函数。

√25．类型转换函数是一种特殊的成员函数，定义时不加类型说明，无函数参数。

√26．单参数的构造函数具有类型转换的作用。

6.2单选题

1．下列关于类的定义格式的描述中，错误的是（C）。

A．类中成员有3种访问权限

B．类的定义可分说明部分和实现部分

C．类中成员函数都是公有的，数据成员都是私有的

D．定义类的关键字通常用class，也可用struct

2．下列关键字中，不属于定义类时使用的关键字是（D）。

A．classB．struct

C．publicD．default

3．下列关于成员函数的描述中，错误的是（A）。

A．成员函数的定义必须在类体外

B．成员函数可以是公有的，也可以是私有的

C．成员函数在类体外定义时，前加inline可为内联函数

D．成员函数可以设置参数的默认值

4．下列关于对象的描述中，错误的是（D）。

A．定义对象时系统会自动进行初始化

B．对象成员的表示与C语言中结构变量的成员表示相同

C．属于同一个类的对象占有内存字节数相同

D．一个类所能创建对象的个数是有限制的

5．下列关于构造函数的描述中，错误的是（C）。

A．构造函数可以重载

B．构造函数名同类名

C．带参数的构造函数具有类型转换作用

D．构造函数是系统自动调用的

6．下列关于析构函数的描述中，错误的是（A）。

A．析构函数的函数体都为空

B．析构函数是用来释放对象的

C．析构函数是系统自动调用的

D．析构函数是不能重载的

7．下列关于静态成员的描述中，错误的是（C）。

A．静态成员都是使用static来说明的

B．静态成员是属于类的，不是属于某个对象的

C．静态成员只可以用类名加作用域运算符来引用，不可用对象引用

D．静态数据成员的初始化是在类体外进行的

8．下列关于常成员的描述中，错误的是（C）。

A．常成员是用关键字const说明的

B．常成员有常数据成员和常成员函数两种

C．常数据成员的初始化是在类体内定义它时进行的

D．常数据成员的值是不可以改变的

9．下列关于友元函数的描述中，错误的是（B）。

A．友元函数不是成员函数

B．友元函数只可访问类的私有成员

C．友元函数的调用方法同一般函数

D．友元函数可以是另一类中的成员函数

10．下列关于类型转换函数的描述中，错误的是（C）。

A．类型转换函数是一种成员函数

B．类型转换函数定义时不指出类型，也没有参数

C．类型转换函数的功能是将其函数名所指定的类型转换为该类类型

D．类型转换函数在一个类中可定义多个

6.3填空题

1．类体内成员有3个访问权限，说明它们的关键字分别是公有、私有和保护。

2．使用class定义的表中，成员的默认访问权限是私有的；由struct定义的类中，成员的默认的访问权限是公有的。

3．如果一个类中没有定义任何构造函数时，系统会自动提供一个默认构造函数；同样，类中没有定义析构函数时，系统会自动提供一个默认析构函数。

4．静态成员是属于类的，它除了可以通过对象名来引用外，还可以使用

类名限定来引用。

5．友元函数是被说明在类体内的非成员函数。

友元函数可访问该类中的成员。

6．完成下列类的定义。

classA

{

public:

A（）{a=0;}

intintGeta（A&m）;

private:

inta;

};

intGeta（A&m）

{returnm.a;}

6.4分析下列程序的输出结果

1．

#include

classA

{

public:

A（）

{

a1=a2=0;

cout<<"Defaultconstructorcalled.\n";

}

A（inti,intj）;

~A（）

{cout<<"Destructorcalled.\n";}

voidPrint（）

{cout<<"a1="<

private:

inta1,a2;

};

A:

:

A（inti,intj）

{

a1=i;

a2=j;

cout<<"Constructorcalled.\n";

}

voidmain（）

{

Aa,b（5,8）;

a.Print（）;

b.Print（）;

}

答：

Defaultconstructorcalled.

Constructorcalled.

a1=0,a2=0

a1=5,a2=8

Destructorcalled.

Destructorcalled.

2．

#include

classB

{

public:

B（）

{cout<<++b<

~B（）

{cout<

staticintGetb（）

{returnb;}

private:

staticintb;

};

intB:

:

b=10;

voidmain（）

{

Bb1,b2,b3;

cout<

:

Getb（）<

}

答：

11

12

13

13

13

12

11

3．

#include

classDate

{

public:

Date（inty,intm,intd）

{

year=y;

month=m;

day=d;

}

friendvoidPrint（Date&）;

private:

intyear,month,day;

};

voidPrint（Date&d）

{

cout<

}

voidmain（）

{

Dated1（2005,10,1）,d2（2005,12,9）;

Print（d1）;

Print（d2）;

}

答：

2005/10/1

2005/12/9

4．

#include

classC

{

public:

C（inti,intj）

{c1=i;c2=j;}

voidSum（Ca,Cb）

{

c1=a.c1+b.c1;

c2=a.c2+b.c2;

}

voidPrint（）

{cout<<"c1="<

private:

intc1,c2;

};

voidmain（）

{

Ca（6,9）;

Cb（a）;

Cc（b）;

c.Sum（a,b）;

c.Print（）;

}

答：

c1=12,c2=18

5．

#include

classS

{

public:

S（）

{PC=0;}

S（S&s）

{

PC=s.PC;

for（inti=0;i

elems[i]=s.elems[i];

}

voidEmpty（）

{PC=0;}

intIsEmpty（）

{returnPC==0;}

intIsMemberOf（intn）;

intAdd（intn）;

voidPrint（）;

private:

intelems[100],PC;

};

intS:

:

IsMemberOf（intn）

{

for（inti=0;i

if（elems[i]==n）

return1;

return0;

}

intS:

:

Add（intn）

{

if（IsMemberOf（n））

return1;

elseif（PC==100）

return0;

else

{

elems[PC++]=n;

return1;

}

}

voidS:

:

Print（）

{

cout<<'{';

for（inti=0;i

cout<

if（PC>0）

cout<

cout<<'}'<

}

voidmain（）

{

Sa;

cout<

a.Print（）;

Sb;

for（inti=1;i<=5;i++）

b.Add（i）;

b.Print（）;

cout<

cout<

for（i=6;i<=10;i++）

b.Add（i）;

Sc（b）;

c.Print（）;

}

答：

1

{}

{1,2,3,4,5}

1

0

{1,2,3,4,5,6,7,8,9,10}

6.5编程题

1．按下列要求编程：

（1）定义一个描述矩形的类Rectangle，包括的数据成员有宽（width）和长（length）；

（2）计算矩形周长；

（3）计算矩形面积；

（4）改变矩形大小。

通过实例验证其正确性。

答：

编程如下：

#include

classRectangle

{

public:

Rectangle（inta,intb）

{width=a;length=b;}

intArea（）

{returnwidth*length;}

intPeriment（）

{return2*（width+length）;}

voidChangesize（inta,intb）

{width=a;length=b;}

voidPrint（）;

private:

intwidth,length;

};

voidRectangle:

:

Print（）

{

cout<<"AREA="<

cout<<"PERIMENT="<

}

voidmain（）

{

Rectangler（5,8）;

r.Print（）;

r.Changesize（3,9）;

r.Print（）;

}

2．编程实现一个简单的计算器。

要求从键盘上输入两个浮点数，计算出它们的加、减、乘、除运算的结果。

答：

编程如下：

#include

classASMD

{

public:

ASMD（doublea,doubleb）

{x=a;y=b;}

voidAddition（）

{cout<

voidSubtration（）

{cout<

voidMultiply（）

{cout<

voidDivison（）

{cout<

voidPrint（）;

private:

doublex,y;

};

voidASMD:

:

Print（）

{

Addition（）;

Subtration（）;

Multiply（）;

Divison（）;

}

voidmain（）

{

ASMDa（40,8）;

a.Print（）;

}

3．编一个关于求多个某门功课总分和平均分的程序。

具体要求如下：

（1）每个学生信息包括姓名和某门功课成绩。

（2）假设5个学生。

（3）使用静态成员计算5个学生的总成绩和平均分。

答：

编程如下：

#include

#include

classStudent

{

public:

Student（chars[],intgr）

{strcpy（name,s）;grade=gr;totalize+=gr;}

staticvoidPrint（）;

private:

charname[10];

intgrade;

staticinttotalize;

};

intStudent:

:

totalize=0;

voidStudent:

:

Print（）

{

cout<<"总成绩为"<

}

voidmain（）

{

Students1（"ma",85）,s2（"Wang",96）,s3（"Li",82）,s4（"lu",78）,s5（"zhang",80）;

Student:

:

Print（）;

}

6.6简单回答下列问题

1．一个类中是否必须有用户定义的构造函数？

如果用户没有定义构造函数，又如何对创建的对象初始化？

答：

一个类用户可以不定义构造函数，这时系统自动提供一个默认的构造函数，并可用该构造函数对创建的对象初始化。

2．拷贝构造函数具有几个参数？

它有类型转换的作用吗？

答：

拷贝构造函数具有一个参数，即为该类对象的引用。

拷贝构造函数没有类型转换作用。

3．静态成员属于类的，是否每个对象都可以引用该静态成员？

答：

可以。

4．常对象可以引用非常成员函数吗？

非常对象可以引用常成员函数吗？

答：

不可以。

可以。

5．友元函数能否访问类中的保护成员？

友元函数访问类中私有成员与成员函数访问私有成员的形式相同吗？

答：

能。

相同。

第7章　类和对象

（二）　

练习题7

7.1判断题

×1．定义对象指针时也要调用构造函数。

√2．对象指针可用同类对象的地址值给它赋值。

×3．对象指针成员表示与对象引用相同。

√4．常类型指针有两种，一种是指针的地址值是常量，另一种是指针所指向的变量或对象是常量。

×5．指向对象的常指针的地址值是可以改变的。

×6．指向常对象的指针所指向的对象是可以改变的。

√7．this指针是系统生成的指向当前被某个成员函数操作对象的指针。

×8．对象引用可以用一个同类对象的地址值对它赋值。

×9．定义对象引用时，可以对其引用进行初始化，也可以不进行初始化。

×10．对象数组的元素可以是不同类的对象。

×11．对象指针数组可以使用不同类的对象的地址值进行初始化。

×12．给对象数组元素赋值时都要创建临时对象。

√13．指向一维对象数组的指针是一个二级指针。

×14．自身类对象可作该类的子对象。

√15．子对象的初始化要在构造函数的成员初始化列表中进行。

√16．使用new运算符创建的对象称为堆对象。

√17．任何对象都可以使用delete运算符来释放。

×18．使用new运算符创建的对象数组其元素都具有默认值。

√19．类的作用域范围指的是类体内。

×20．对象的存储类只有外部的和静态的。

7.2单选题

1．f1（）函数是类A的公有成员函数，p是指向类的成员函数f1（）的指针，下列表示中正确的是（C）。

A．p=f1（）B．p=f1

C．p=A:

:

f1D．p=A:

:

f1（）

2．p是指向类A数据成员a的指针，a是类A的一个对象。

在给a成员赋值为5的下列表达式中，正确的是（C）。

A．a.p=5B．a->p=5

C．a.*p=5D．*a.p=5

3．VoidSet（A&a）;是类A中一个成员函数的说明，其中A&a的含义是（A）。

A．类A的对象引用a作该函数的参数

B．类A的对象a的地址值作函数的参数

C．表达式变量A与变量a按位与作函数参数

D．指向类A对象指针a作函数参数

4．已知：

constAa；其中A是一个类名，指向常对象指针的表示为（D）。

A．const*Apa;B．constA*pa;

C．A*constpa;D．const*paA;

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

A．子对象不可以是自身类的对象B．子对象是另一个类的对象

C．子对象的初始化要包含在构造函数中D．一个类中只能有一个子对象

6．执行下列说明语句，其调用构造函数的次数为（A）。

Aa[5]，*p[2]；其中，A是一个类名

A．5B．6

C．7D．10

7．下列关于运算符new的描述中，错误的是（D）。

A．它可以创建对象或变量

B．它可以创建对象数组或一般类型数组

C．用它创建对象或对象数组时要调用相应的构造函数

D．用它创建的对象可以不用delete运算符释放

8．下列关于运算符delete的描述中，错误的是（B）。

A．使用该运算符可以释放用new运算符创建的对象或对象数组

B．使用该运算符可以释放所有对象

C．使用delete运算符时会自动调用析构函数

D．用它释放对象数组时，它作用的指针名前要加下标运算符[]

9．定义不同存储类对象时，必须要加的存储类说明符是（C）。

A．autoB．extern

C．statieD．register

10．下列关于this的描述中，错误的是（D）。

A．this是一个由系统自动生成的指针

B．this指针是指向对象的

C．this指针在用对象引用成员函数时系统创建的

D．this指针只能隐含使用，不能显式使用

7.3填空题

已知：

classA{public:

A（inti）{a=i;}

voidprint（）{cont<

private:

inta;

};

要求：

1．定义一个指向对象的常指针p，应该是A*constp;。

2．定义一个指向常对象指针p，应该是Aconst*p;。

3．定义类A的含有5个元素的一维对象数组a，应该是Aa[5];。

4．定义一个对象指针数组pa，它有5个元素，每个元素是类A对象指针，应该是A*pa[5];。

5．使用new创建一个堆对象，一个实参值为5，应该是A*p;p=newA（5）;。

6．使用new创建一个对象数组，该数组用指针pa指向，并使数组的3个元素都是类A的对象a1的值。

应该是Aa1,*pa;pa=newA[3];pa[0]=pa[1]=pa[2]=a1;。

7．在某个函数体内定义一个静态类的对象sa，应该是staticAsa;。

8．定义一个类A的对象a1，并给它赋值，其实参值为8，应该是Aa1（8）;。

7.4分析下列程序的输出结果

1．

#include

classA

{

public:

A（inti）

{a=i;}

A（）

{

a=0;

cout<<"Defaultconstructorcalled."<

}

~A（）

{cout<<"Destructorcalled."<

voidPrint（）

{cout<

private:

inta;

};

voidmain（）

{

Aa[4],*p;

intn=1;

p=a;

for（inti=0;i<4;i++）

a[i]=A（++n）;

for（i=0;i<4;i++）

（p+i）->Print（）;

}

答：

Defaultconstructorcalled.0

Defaultconstructorcalled.0

Defaultconstructorcalled.0

Defaultconstructorcalled.0

Destructorcalled.2

Destructorcalled.3

Destructorcalled.4

Destructorcalled.5

2

3

4

5

Destructorcalled.5

Destructorcalled.4

Destructorcalled.3

Destructorcalled.2

2．

#include

classB

{

public: