C++语言程序设计课后答案(郑莉第版)-FreeNAS中文网

admin 管理员组

文章数量: 887020

2024年2月29日发(作者：toolba)

第一章概述

1-1 简述计算机程序设计语言的发展历程。

解：

迄今为止计算机程序设计语言的发展经历了机器语言、汇编语言、高级语言等阶段，C++语言是一种面向对象的编程语言，也属于高级语言。

1-2 面向对象的编程语言有哪些特点

解：

面向对象的编程语言与以往各种编程语言有根本的不同，它设计的出发点就是为了能更直接的描述客观世界中存在的事物以及它们之间的关系。面向对象的编程语言将客观事物看作具有属性和行为的对象，通过抽象找出同一类对象的共同属性（静态特征）和行为（动态特征），形成类。通过类的继承与多态可以很方便地实现代码重用，大大缩短了软件开发周期，并使得软件风格统一。因此，面向对象的编程语言使程序能够比较直接地反问题域的本来面目，软件开发人员能够利用人类认识事物所采用的一般思维方法来进行软件开发。C++语言是目前应用最广的面向对象的编程语言。

1-3 什么是结构化程序设计方法这种方法有哪些优点和缺点

解：

结构化程序设计的思路是：自顶向下、逐步求精；其程序结构是按功能划分为若干个基本模块；各模块之间的关系尽可能简单，在功能上相对独立；每一模块内部均是由顺序、选择和循环三种基本结构组成；其模块化实现的具体方法是使用子程序。结构化程序设计由于采用了模块分解与功能抽象，自顶向下、分而治之的方法，从而有效地将一个较复杂的程序系统设计任务分解成许多易于控制和处理的子任务，便于开发和维护。

虽然结构化程序设计方法具有很多的优点，但它仍是一种面向过程的程序设计方法，它把数据和处理数据的过程分离为相互独立的实体。当数据结构改变时，所有相关的处理过程都要进行相应的修改，每一种相对于老问题的新方法都要带来额外的开销，程序的可重用性差。

由于图形用户界面的应用，程序运行由顺序运行演变为事件驱动，使得软件使用起来越来越方便，但开发起来却越来越困难，对这种软件的功能很难用过程来描述和实现，使用面向过程的方法来开发和维护都将非常困难。

1-4 什么是对象什么是面向对象方法这种方法有哪些特点

解：

从一般意义上讲，对象是现实世界中一个实际存在的事物，它可以是有形的，也可以是无形的。对象是构成世界的一个独立单位，它具有自己的静态特征和动态特征。面向对象方法中的对象，是系统中用来描述客观事物的一个实体，它是用来构成系统的一个基本单位，由一组属性和一组行为构成。

面向对象的方法将数据及对数据的操作方法放在一起，作为一个相互依存、不可分离的整体--对象。对同类型对象抽象出其共性，形成类。类中的大多数数据，只能用本类的方法进行处理。类通过一个简单的外部接口，与外界发生关系，对象与对象之间通过消息进行通讯。这样，程序模块间的关系更为简单，程序模块的独立性、数据的安全性就有了良好的保障。通过实现继承与多态性，还可以大大提高程序的可重用性，使得软件的开发和维护都更为方便。

面向对象方法所强调的基本原则，就是直接面对客观存在的事物来进行软件开发，将人们在日常生活中习惯的思维方式和表达方式应用在软件开发中，使软件开发从过分专业化的方法、规则和技巧中回到客观世界，回到人们通常的思维。

1-5 什么叫做封装

解：

封装是面向对象方法的一个重要原则，就是把对象的属性和服务结合成一个独立的系统单位，并尽可能隐蔽对象的内部细节。

1-6 面向对象的软件工程包括哪些主要内容

解：

面向对象的软件工程是面向对象方法在软件工程领域的全面应用，它包括面向对象的分析（OOA）、面向对象的设计（OOD）、面向对象的编程（OOP）、面向对象的测试（OOT）和面向对象的软件维护（OOSM）等主要内容。

1-7 简述计算机内部的信息可分为几类

解：

计算机内部的信息可以分成控制信息和数据信息二大类；控制信息可分为指令和控制字两类；数据信息可分为数值信息和非数值信息两类。

1-8 什么叫二进制使用二进制有何优点和缺点

解：

二进制是基数为2，每位的权是以2 为底的幂的进制，遵循逢二进一原则，基本符号为0和1。采用二进制码表示信息，有如下几个优点：1.易于物理实现；2.二进制数运算简单；3.机器可靠性高；4.通用性强。其缺点是它表示数的容量较小，表示同一个数，二进制较其他进制需要更多的位数。

1-9 请将以下十进制数值转换为二进制和十六进制补码：

（1）2 （2）9 （3）93

（4）-32 （5）65535 （6）-1

解：

（1）（2）10 = （10）2 = （2）16

（2）（9）10 = （1001）2 = （9）16

（3）（93）10 = （1011101）2 = （5D）16

（4）（-32）10 = （）2 = （E0）16

（5）（65535）10 = （）2 = （FFFF）16

（6）（-1）10 = （）2 = （FFFF）16

1-10 请将以下数值转换为十进制：

（1）（1010）2 （2）（）2 （3）（01011111 ）2

（4）（7F）16 （5）（2D3E）16 （6）（F10E）16

解：

(1)（1010）2 = （10）10

(2)（）2 = （143）10

(3)（01011111 ）2 = （24515）10

(4)（7F）16 = （127）10

(5)（2D3E）16 = （11582）10

：

(6)（F10E）16 = （61710）10

1-11 简要比较原码、反码、补码等几种编码方法。

解：

原码：将符号位数字化为 0 或 1，数的绝对值与符号一起编码，即所谓"符号──绝对值表示"的编码。

正数的反码和补码与原码表示相同。

负数的反码与原码有如下关系：

符号位相同(仍用1表示)，其余各位取反(0变1，1变0)。

补码由该数反码的最末位加1求得。

…

第二章 C++简单程序设计

2-1 C++语言有那些主要特点和优点

解：

C++语言的主要特点表现在两个方面，一是全面兼容C，二是支持面向对象的方法。C++是一个更好的C，它保持了C的简洁、高效、接近汇编语言、具有良好的可读性和可移植性等特点，对C的类型系统进行了改革和扩充，因此C++比C更安全，C++的编译系统能检查出更多的类型错误。 C++语言最重要的特点是支持面向对象。

2-2 下列标识符哪些是合法的

Program， -page， _lock， test2， 3in1， @mail， A_B_C_D

解：

Program， _lock， test2， A_B_C_D是合法的标识符，其它的不是。

2-3 例中每条语句的作用是什么

#include <>

void main(void)

{

cout<<"Hello!n";

cout<<"Welcome to c++!n";

}

解：

！

#include <> 201 / 4

2. 201 % 4

3. 201 /

解：

1． 50

2． 1

3．

2-10 执行完下列语句后，a、b、c三个变量的值为多少

a = 30;

b = a++;

c = ++a;

解：

a：32 ； b：30 ； c：32；

2-11 在一个for循环中，可以初始化多个变量吗如何实现

解：

在for循环设置条件的第一个";"前，用，分隔不同的赋值表达式。

]

例如：

for (x = 0， y = 10; x < 100; x++， y++)

2-12 执行完下列语句后，n的值为多少

int n;

for (n = 0; n < 100; n++)

解：

n的值为100

2-13 写一条for语句，计数条件为n从100到200，步长为2；然后用while和do…while语句完成同样的循环。

…

解：

for循环：

for (int n = 100; n <= 200; n += 2);

while循环：

int x = 100;

while (n <= 200)

n += 2;

do…while循环：

。

int n = 100;

{

n += 2;

} while(n <= 200);

2-14 if ( x = 3 ) 和 if (x = = 3) 这两条语句的差别是什么

解：

语句if(x = 3)把3赋给x，赋值表达式的值为true，作为if语句的条件；语句if(x == 3)首先判断x的值是否为3，若相等条件表达式的值为ture，否则为false。

…

2-15 什么叫做作用域什么叫做局部变量什么叫做全局变量，如何使用全局变量

解：

作用域是一个标识符在程序正文中有效的区域。局部变量，一般来讲就是具有块作用域的变量；全局变量，就是具有文件作用域的变量。

2-16 已知x、y两个变量，写一条简单的if语句，把较小的的值赋给原本值较大的变量。

解：

if (x > y)

x = y;

else n";

cout << "The size of a short int is:t" << sizeof(short) << " bytes.n";

cout << "The size of a long int is:t" << sizeof(long) << " bytes.n";

cout << "The size of a char is:tt" << sizeof(char) << " bytes.n";

cout << "The size of a float is:tt" << sizeof(float) << " bytes.n";

cout << "The size of a double is:t" << sizeof(double) << " bytes.n";

return 0;

}

程序运行输出：

—

The size of an int is: 4 bytes.

The size of a short int is: 2 bytes.

The size of a long int is: 4 bytes.

The size of a char is: 1 bytes.

The size of a float is: 4 bytes.

The size of a double is: 8 bytes.

2-20 打印ASCII码为32~127的字符。

解：

：

#include <>

int main()

{

for (int i = 32; i<128; i++)

cout << (char) i;

return 0;

}

程序运行输出：

￥

!"#$%G'()*+，./09:;<>@ABCDEFGHIJKLMNOP_QRSTUVWXYZ[]^'abcdefghijklmnopqrstuvwxyz<|>~s

2-21 运行下面的程序，观察其输出，与你的设想是否相同

#include <>

int main()

{

unsigned int x;

unsigned int y = 100;

unsigned int z = 50;

x= y - z;

cout << "Difference is: " << x;

x = z - y;

cout << "nNow difference is: " << x <

return 0;

}

解：

程序运行输出：

[

Difference is: 50

Now difference is: 46

注意，第二行的输出并非 -50，注意x、y、z的数据类型。

2-22 运行下面的程序，观察其输出，体会i++与++i的差别。

#include <>

int main()

{

int myAge = 39; n";

cout << "You are: " << yourAge << " years oldn";

myAge++; .n";

cout << "I am: " << myAge << " years old.n";

cout << "You are: " << yourAge << " years oldn";

cout << "Another year passesn";

cout << "I am: " << myAge++ << " years old.n";

cout << "You are: " << ++yourAge << " years oldn";

cout << "Let's print it again.n";

]

cout << "I am: " << myAge << " years old.n";

cout << "You are: " << yourAge << " years oldn";

return 0;

}

解：

程序运行输出：

I am 39 years old

You are 39 years old

One year passes

I am 40 years old

You are 40 years old

Another year passes

I am 40 years old

You are 41 years old

Let's print it again

I am 41 years old

，

You are 41 years old

2-23 什么叫常量什么叫变量

解：

所谓常量是指在程序运行的整个过程中其值始终不可改变的量，除了用文字表示常量外，也可以为常量命名，这就是符号常量；在程序的执行过程中其值可以变化的量称为变量，变量是需要用名字来标识的。

2-24 变量有哪几种存储类型

解：

变量有以下几种存储类型：

auto存储类型：采用堆栈方式分配内存空间，属于一时性存储，其存储空间可以被若干变量多次覆盖使用；

；

register存储类型：存放在通用寄存器中；

extern存储类型：在所有函数和程序段中都可引用；

static存储类型：在内存中是以固定地址存放的，在整个程序运行期间都有效。

2-25 写出下列表达式的值：

1. 2 < 3 && 6 < 9

2. ! ( 4<7 )

3. ! ( 3 > 5) || (6 < 2 )

解：

、

1. true

2. false

3. true

2-26 若a = 1，b = 2，c = 3，下列各式的结果是什么

1. a | b - c

2. a ^ b & -c

3. a & b | c

4. a | b & c

解：

1． -1

2． 1

3． 3

4． 3

2-27 若a = 1，下列各式的结果是什么

1. ! a | a

2. ~ a | a

￥

3. a ^ a

4. a >> 2

解：

1． 1

2． -1

3． 0

4． 0

2-28 编写一个完整的程序，实现功能：向用户提问"现在正在下雨吗"，提示用户输入Y或N。若输入为Y，显示"现在正在下雨。"；若输入为N，显示"现在没有下雨。"；否则继续提问"现在正在下雨吗"

解：

源程序：

#include <>

void main()

{

char flag;

while(1)

{

cout << "现在正在下雨吗(Yes or No):";

cin >> flag;

if ( toupper(flag) == 'Y')

{

cout << "现在正在下雨。";

break;

}

…

if ( toupper(flag) == 'N')

{

cout << "现在没有下雨。";

break;

}

程序运行输出：

现在正在下雨吗(Yes or No):x

现在正在下雨吗(Yes or No):l

现在正在下雨吗(Yes or No):q

现在正在下雨吗(Yes or No):n

现在没有下雨。

或：

现在正在下雨吗(Yes or No):y

现在正在下雨。

（

2-29 编写一个完整的程序，运行时向用户提问"你考试考了多少分（0~100）"，接收输入后判断其等级，显示出来。规则如下：

解：

#include <>

void main()

{

int i,score;

cout << "你考试考了多少分(0~100):";

cin >> score;

if (score>100 || score<0)

cout << "分数值必须在0到100之间!";

else

{

i = score/10;

switch (i)

{

case 10:

case 9:

cout << "你的成绩为优！";

break;

case 8:

cout << "你的成绩为良！";

break;

case 7:

case 6:

cout << "你的成绩为中！";

break;

default:

cout << "你的成绩为差！";

}

程序运行输出：

;

你考试考了多少分(0~100)：85

你的成绩为良！

2-30 （1）实现一个简单的菜单程序，运行时显示"Menu: A(dd) D(elete) S(ort) Q(uit)，

Select one:"提示用户输入，A表示增加，D表示删除，S表示排序，Q表示退出，输入为A、D、S时分别提示"数据已经增加、删除、排序。"输入为Q时程序结束。要求使用if … else语句进行判断，用break、continue控制程序流程。

解：

#include <>

void main()

{

《

char choice,c;

while(1)

{

cout << "Menu: A(dd) D(elete) S(ort) Q(uit)， Select one:";

cin >> c;

choice = toupper(c);

if (choice == 'A')

{

;

cout << "数据已经增加. " << endl;

continue;

}

else if (choice == 'D')

{

cout << "数据已经删除. " << endl;

continue;

}

—

else if (choice == 'S')

{

cout << "数据已经排序. " << endl;

continue;

}

else if (choice == 'Q')

break;

}

程序运行输出：

Menu: A(dd) D(elete) S(ort) Q(uit)， Select one:a

数据已经增加.

Menu: A(dd) D(elete) S(ort) Q(uit)， Select one:d

数据已经删除.

Menu: A(dd) D(elete) S(ort) Q(uit)， Select one:s

数据已经排序.

。

Menu: A(dd) D(elete) S(ort) Q(uit)， Select one:q

（2）实现一个简单的菜单程序，运行时显示"Menu: A(dd) D(elete) S(ort) Q(uit)， Select

one:"提示用户输入，A表示增加，D表示删除，S表示排序，Q表示退出，输入为A、D、S时分别提示"数据已经增加、删除、排序。"输入为Q时程序结束。要求使用Switch语句。

解：

源程序：

#include <>

void main()

{

char choice;

while(1)

{

cout << "Menu: A(dd) D(elete) S(ort) Q(uit)， Select one:";

cin >> choice;

switch(toupper(choice))

{

case 'A':

cout << "数据已经增加. " << endl;

break;

case 'D':

cout << "数据已经删除. " << endl;

break;

case 'S':

cout << "数据已经排序. " << endl;

break;

！

case 'Q':

exit(0);

break;

default:

;

}

。

程序运行输出：

Menu: A(dd) D(elete) S(ort) Q(uit)， Select one:a

数据已经增加.

Menu: A(dd) D(elete) S(ort) Q(uit)， Select one:d

数据已经删除.

Menu: A(dd) D(elete) S(ort) Q(uit)， Select one:s

数据已经排序.

Menu: A(dd) D(elete) S(ort) Q(uit)， Select one:q

：

2-31 用穷举法找出1~100间的质数，显示出来。分别使用while，do-while，for循环语句实现。

解：

源程序：

使用while循环语句：

#include <>

void main()

{

int i,j,k,flag;

i = 2;

while(i <= 100)

{

flag = 1;

k = sqrt(i);

j = 2;

while (j <= k)

{

if(i%j == 0)

{

flag = 0;

break;

}

j++;

}

if (flag)

cout << i << "是质数." << endl;

i++;

}

使用do…while循环语句：

#include <>

）

void main()

{

int i,j,k,flag;

i = 2;

do{

flag = 1;

k = sqrt(i);

j = 2;

do{

if(i%j == 0)

{

flag = 0;

break;

}

j++;

}while (j <= k);

！

if (flag)

cout << i << "是质数." << endl;

i++;

}while(i <= 100);

}

使用for循环语句：

#include <>

void main()

{

int i,j,k,flag;

for(i = 2; i <= 100; i++)

{

flag = 1;

k = sqrt(i);

for (j = 2; j <= k; j++)

{

if(i%j == 0)

{

flag = 0;

break;

}

if (flag)

。

cout << i << "是质数." << endl;

}

程序运行输出：

2是质数.

3是质数.

5是质数.

7是质数.

11是质数.

13是质数.

17是质数.

19是质数.

23是质数.

29是质数.

31是质数.

37是质数.

、

41是质数.

43是质数.

47是质数.

53是质数.

59是质数.

61是质数.

67是质数.

71是质数.

73是质数.

79是质数.

83是质数.

89是质数.

97是质数.

2-32 比较Break语句与Continue语句的不同用法。

解：

Break使程序从循环体和switch语句内跳出，继续执行逻辑上的下一条语句，不能用在别处；

…

continue 语句结束本次循环，接着开始判断决定是否继续执行下一次循环；

2-33 定义一个表示时间的结构体，可以精确表示年、月、日、小时、分、秒；提示用户输入年、月、日、小时、分、秒的值，然后完整地显示出来。

解：

源程序见"实验指导"部分实验二

2-34 在程序中定义一个整型变量，赋以1~100的值，要求用户猜这个数，比较两个数的大小，把结果提示给用户，直到猜对为止。分别使用while、do…while语句实现循环。

解：

n Number one: ";

cin >> one;

cout << "Number two: ";

cin >> two;

answer = Divider(one, two);

if (answer > -1)

cout << "Answer: " << answer;

else

cout << "Error, can't divide by zero!";

return 0;

}

程序运行输出：

Enter two numbers.

Number one:8

Number two:2

Answer: 4

3-8 编写函数把华氏温度转换为摄氏温度，公式为：C = (F - 32) * 5/9; 在主程序中提示用户输入一个华氏温度，转化后输出相应的摄氏温度。

;

解：

源程序见"实验指导"部分实验三

3-9 编写函数判断一个数是否是质数，在主程序中实现输入、输出。

解：

#include <>

int prime(int i); << endl;

else

cout << i << "不是质数." << endl;

}

int prime(int i)

{

int j,k,flag;

flag = 1;

k = sqrt(i);

for (j = 2; j <= k; j++)

{

if(i%j == 0)

{

flag = 0;

break;

}

if (flag)

，

return 1;

else

return 0;

}

程序运行输出：

请输入一个整数：1151

1151是质数.

3-10 编写函数求两个整数的最大公约数和最小公倍数。

解：

源程序：

#include <>

int fn1(int i,int j); n";

(7);

(20);

cout << "Now Jack is " ;

cout << () << " years old and";

cout << () << " pounds weight.";

return 0;

}

程序运行输出：

Jack is a Dog who is 2 years old and 10 pounds weight.

Now Jack is 7 years old 20 pounds weight.

4-9 设计并测试一个名为Rectangle的矩形类，其属性为矩形的左下角与右上角两个点的坐标，能计算矩形的面积。

]

解：

源程序：

#include <>

class Rectangle

{

public:

Rectangle (int top, int left, int bottom, int right);

~Rectangle () {}

int GetTop() const { return itsTop; }

int GetLeft() const { return itsLeft; }

int GetBottom() const { return itsBottom; }

int GetRight() const { return itsRight; }

void SetTop(int top) { itsTop = top; }

void SetLeft (int left) { itsLeft = left; }

void SetBottom (int bottom) { itsBottom = bottom; }

void SetRight (int right) { itsRight = right; }

int GetArea() const;

private:

int itsTop;

int itsLeft;

int itsBottom;

int itsRight;

};

Rectangle::Rectangle(int top, int left, int bottom, int right)

{

itsTop = top;

itsLeft = left;

itsBottom = bottom;

itsRight = right;

}

int Rectangle::GetArea() const

{

)

int Width = itsRight-itsLeft;

int Height = itsTop - itsBottom;

return (Width * Height);

}

int main()

{

Rectangle MyRectangle (100, 20, 50, 80 );

int Area = ();

、

cout << "Area: " << Area << "n";

return 0;

}

程序运行输出：

Area: 3000

Upper Left X Coordinate: 20

4-10 设计一个用于人事管理的People（人员）类。考虑到通用性，这里只抽象出所有类型人员都具有的属性：number（编号）、sex（性别）、birthday（出生日期）、id（身份证号）等等。其中"出生日期"定义为一个"日期"类内嵌子对象。用成员函数实现对人员信息的录入和显示。要求包括：构造函数和析构函数、拷贝构造函数、内联成员函数、带缺省形参值的成员函数、聚集。

解：

…

本题用作实验四的选做题，因此不给出答案。

4-11 定义一个矩形类，有长、宽两个属性，有成员函数计算矩形的面积

解：

#include <>

class Rectangle

{

public:

Rectangle(float len, float width)

{

Length = len;

Width = width;

}

~Rectangle(){};

float GetArea() { return Length * Width; }

float GetLength() { return Length; }

float GetWidth() { return Width; }

private:

float Length;

float Width;

};

void main()

{

float length, width;

cout << "请输入矩形的长度：";

cin >> length;

cout << "请输入矩形的宽度：";

cin >> width;

Rectangle r(length, width);

cout << "长为" << length << "宽为" << width << "的矩形的面积为："

<< () << endl;

}

程序运行输出：

￥

请输入矩形的长度：5

请输入矩形的宽度：4

长为5宽为4的矩形的面积为：20

4-12 定义一个"数据类型" datatype类，能处理包含字符型、整型、浮点型三种类型的数据，给出其构造函数。

解：

#include <>

class datatype{

enum{

）

character,

integer,

floating_point

} vartype;

union

{

char c;

int i;

;

float f;

};

public:

datatype(char ch) {

vartype = character;

c = ch;

}

datatype(int ii) {

vartype = integer;

i = ii;

}

datatype(float ff) {

vartype = floating_point;

f = ff;

}

void print();

；

};

void datatype::print() {

switch (vartype) {

case character:

cout << "字符型: " << c << endl;

break;

case integer:

cout << "整型: " << i << endl;

break;

case floating_point:

cout << "浮点型: " << f << endl;

break;

}

void main() {

datatype A('c'), B(12), C;

》

();

}

程序运行输出：

字符型: c

整型: 12

浮点型:

4-13 定义一个Circle类，有数据成员半径Radius，成员函数GetArea()，计算圆的面积，构造一个Circle的对象进行测试。

解：

#include <>

class Circle

{

public:

Circle(float radius){ Radius = radius;}

~Circle(){}

）

float GetArea() { return * Radius * Radius; }

private:

float Radius;

};

void main()

{

float radius;

cout << "请输入圆的半径：";

：

cin >> radius;

Circle p(radius);

cout << "半径为" << radius << "的圆的面积为：" << ()

<< endl;

}

程序运行输出：

请输入圆的半径：5

半径为5的圆的面积为：

《

4-14 定义一个tree类，有成员ages，成员函数grow(int years)对ages加上years,age()显示tree对象的ages的值。

解：

#include <>

class Tree {

int ages;

public:

Tree(int n=0);

~Tree();

！

void grow(int years);

void age();

};

Tree::Tree(int n) {

ages = n;

}

Tree::~Tree() {

age();

】

}

void Tree::grow(int years) {

ages += years;

}

void Tree::age() {

cout << "这棵树的年龄为" << ages << endl;

}

void main()

{

Tree t(12);

();

(4);

}

程序运行输出：

这棵树的年龄为12

这棵树的年龄为16

》

第五章 C++程序的基本结构

5-1 什么叫做作用域有哪几种类型的作用域

解：

作用域讨论的是标识符的有效范围，作用域是一个标识符在程序正文中有效的区域。C++的作用域分为函数原形作用域、块作用域(局部作用域)、类作用域和文件作用域.

5-2 什么叫做可见性可见性的一般规则是什么

解：

可见性是标识符是否可以引用的问题；

可见性的一般规则是：标识符要声明在前，引用在后，在同一作用域中，不能声明同名的标识符。对于在不同的作用域声明的标识符，遵循的原则是：若有两个或多个具有包含关系的作用域，外层声明的标识符如果在内层没有声明同名标识符时仍可见，如果内层声明了同名标识符则外层标识符不可见。

5-3 下面的程序的运行结果是什么，实际运行一下，看看与你的设想有何不同。

#include <>

void myFunction();

int x = 5， y = 7;

int main()

{

cout << "x from main: " << x << "n";

cout << "y from main: " << y << "nn";

)

myFunction();

cout << "Back from myFunction!nn";

cout << "x from main: " << x << "n";

cout << "y from main: " << y << "n";

return 0;

}

void myFunction()

{

、

int y = 10;

cout << "x from myFunction: " << x << "n";

cout << "y from myFunction: " << y << "nn";

}

解：

程序运行输出：

x from main: 5

y from main: 7

x from myFunction: 5

y from myFunction: 10

Back from myFunction!

x from main: 5

y from main: 7

5-4 假设有两个无关系的类Engine和Fuel，使用时，怎样允许Fuel成员访问Engine中的私有和保护的成员

解：

源程序：

class fuel;

class engine

{

friend class fuel;

private;

int powerlevel;

public;

engine(){ powerLevel = 0;}

void engine_fn(fuel &f);

};

class fuel

{

friend class engine;

private;

int fuelLevel;

public:

fuel(){ fuelLevel = 0;}

void fuel_fn( engine &e);

};

5-5 什么叫做静态数据成员它有何特点

解：

类的静态数据成员是类的数据成员的一种特例，采用static关键字来声明。对于类的普通数据成员，每一个类的对象都拥有一个拷贝，就是说每个对象的同名数据成员可以分别存储不同的数值，这也是保证对象拥有自身区别于其它对象的特征的需要，但是静态数据成员，每个类只要一个拷贝，由所有该类的对象共同维护和使用，这个共同维护、使用也就实现了同一类的不同对象之间的数据共享。

5-6 什么叫做静态函数成员它有何特点

解：

使用static关键字声明的函数成员是静态的，静态函数成员属于整个类，同一个类的所有对象共同维护，为这些对象所共享。静态函数成员具有以下两个方面的好处，一是由于静态成员函数只能直接访问同一个类的静态数据成员，可以保证不会对该类的其余数据成员造成负面影响；二是同一个类只维护一个静态函数成员的拷贝，节约了系统的开销，提高程序的运行效率。

5-7 定义一个Cat类，拥有静态数据成员HowManyCats，记录Cat的个体数目；静态成员函数GetHowMany（），存取HowManyCats。设计程序测试这个类，体会静态数据成员和静态成员函数的用法。

解：

源程序：

#include <>

class Cat

：

{

public:

Cat(int age):itsAge(age){HowManyCats++; }

virtual ~Cat() { HowManyCats--; }

virtual int GetAge() { return itsAge; }

virtual void SetAge(int age) { itsAge = age; }

static int GetHowMany() { return HowManyCats; }

private:

、

int itsAge;

static int HowManyCats;

};

int Cat::HowManyCats = 0;

void TelepathicFunction();

int main()

{

const int MaxCats = 5;

Cat *CatHouse[MaxCats]; int i;

for (i = 0; i

{

CatHouse[i] = new Cat(i);

TelepathicFunction();

}

for ( i = 0; i

{

[

delete CatHouse[i];

TelepathicFunction();

}

return 0;

}

void TelepathicFunction()

{

cout << "There are " << Cat::GetHowMany() << " cats alive!n";

）

}

程序运行输出：

There are 1 cats alive!

There are 2 cats alive!

There are 3 cats alive!

There are 4 cats alive!

There are 5 cats alive!

There are 4 cats alive!

There are 3 cats alive!

There are 2 cats alive!

There are 1 cats alive!

There are 0 cats alive!

5-8 什么叫做友元函数什么叫做友元类

解：

友元函数是使用friend关键字声明的函数，它可以访问相应类的保护成员和私有成员。友元类是使用friend关键字声明的类，它的所有成员函数都是相应类的友元函数。

5-9 如果类A是类B的友元，类B是类C的友元，类D是类A的派生类，那么类B是类A的友元吗类C是类A的友元吗类D是类B的友元吗

解：

类B不是类A的友元，友元关系不具有交换性；

类C不是类A的友元，友元关系不具有传递性；

类D不是类B的友元，友元关系不能被继承。

5-10 静态成员变量可以为私有的吗声明一个私有的静态整型成员变量。

解：

可以，例如：

private:

static int a;

5-11 在一个文件中定义一个全局变量n，主函数main()，在另一个文件中定义函数fn1()，在main()中对n赋值，再调用fn1()，在fn1()中也对n赋值，显示n最后的值。

解：

#include <>

#include ""

int n;

void main()

：

{

n = 20;

fn1();

cout << "n的值为" <

}

.n"; }

private:

myColor itsColor;

};

Mammal::Mammal():

itsAge(1)，

itsWeight(5)

{

cout << "";

}

Mammal::~Mammal()

{

cout << "";

}

Dog::Dog(): itsColor (WHITE)

{

cout << "";

}

Dog::~Dog()

{

cout << "";

}

int main()

{

Dog Jack;

();

cout << " Jack is " << () << " years oldn";

return 0;

}

程序运行输出：

Mammal sound!

，

Fido is 1 years old

7-7 定义一个基类，构造其派生类，在构造函数中输出提示信息，观察构造函数的执行情况。

解：

#include <>

class BaseClass

{

public:

BaseClass();

};

BaseClass::BaseClass()

{

cout << "构造基类对象!" << endl;

}

—

class DerivedClass : public BaseClass

{

public:

DerivedClass();

};

DerivedClass::DerivedClass()

{

cout << "构造派生类对象!" << endl;

、

}

void main()

{

DerivedClass d;

}

程序运行输出：

构造基类对象!

构造派生类对象!

；

7-8 定义一个Document类，有name成员变量，从Document派生出Book类，增加PageCount变量。

解：

#include <>

class Document

{

public:

Document(){};

Document( char *name );

char *Name; void PrintNameOf(); };

Document::Document( char *name )

{

Name = new char[ strlen( name ) + 1 ];

strcpy( Name, name );

};

void Document::PrintNameOf()

{

cout << Name << endl;

}

class Book : public Document

{

public:

Book( char *name, long pagecount );

void PrintNameOf();

private:

long PageCount;

};

Book::Book( char *name, long pagecount ):Document(name)

{

PageCount = pagecount;

}

void Book::PrintNameOf()

{

cout << "Name of book: ";

Document::PrintNameOf();

}

void main()

{

Document a("Document1");

Book b("Book1",100);

();

}

程序运行输出：

Name of book: Book1

7-9 定义基类Base，有两个共有成员函数fn1()、fn2()，私有派生出Derived类，如果想在Derived类的对象中使用基类函数fn1()，应怎么办

解：

class Base

{

public:

int fn1() const { return 1; }

int fn2() const { return 2; }

};

class Derived : private Base

{

public:

int fn1() { return Base::fn1();};

int fn2() { return Base::fn2();};

};

void main()

{

Derived a;

();

}

7-10 定义object类，有weight属性及相应的操作函数，由此派生出box类，增加Height和width属性及相应的操作函数，声明一个box对象，观察构造函数与析构函数的调用顺序。

解：

#include <>

class object

{

private:

int Weight;

public:

object()

：

{

cout << "构造object对象" << endl;

Weight = 0;

}

int GetWeight(){ return Weight;}

void SetWeight(int n){ Weight = n;}

~object() { cout << "析构object对象" << endl;}

};

！

class box : public object

{

private:

int Height,Width;

public:

box()

{

cout << "构造box对象" << endl;

Height = Width = 0;

}

int GetHeight(){ return Height;}

void SetHeight(int n){ Height = n;}

int GetWidth(){ return Width;}

void SetWidth(int n){ Width = n;}

~box() { cout << "析构box对象" << endl;}

};

￥

void main()

{

box a;

}

程序运行输出：

构造object对象

构造box对象

析构box对象

】

析构object对象

7-11 定义一个基类BaseClass，从它派生出类DerivedClass，BaseClass有成员函数fn1()、fn2()，DerivedClass也有成员函数fn1()、fn2()，在主程序中定义一个DerivedClass的对象，分别用DerivedClass的对象以及BaseClass和DerivedClass的指针来调用fn1()、fn2()，观察运行结果。

解：

#include <>

class BaseClass

{

public:

》

void fn1();

void fn2();

};

void BaseClass::fn1()

{

cout << "调用基类的函数fn1()" << endl;

}

void BaseClass::fn2()

；

{

cout << "调用基类的函数fn2()" << endl;

}

class DerivedClass : public BaseClass

{

public:

void fn1();

void fn2();

…

};

void DerivedClass::fn1()

{

cout << "调用派生类的函数fn1()" << endl;

}

void DerivedClass::fn2()

{

cout << "调用派生类的函数fn2()" << endl;

（

}

void main()

{

DerivedClass aDerivedClass;

DerivedClass *pDerivedClass = &aDerivedClass;

BaseClass *pBaseClass = &aDerivedClass;

();

pBaseClass->fn1();

pBaseClass->fn2();

pDerivedClass->fn1();

pDerivedClass->fn2();

}

程序运行输出：

调用派生类的函数fn1()

调用派生类的函数fn2()

调用基类的函数fn1()

调用基类的函数fn2()

调用派生类的函数fn1()

调用派生类的函数fn2()

7-12 为例9-1的吹泡泡程序加一版权（About）对话框。

然后修改例9-1的程序，加入以下内容：

程序：

1．在程序首部加上文件包含命令

#include “”

2．在框架窗口类之前加入从CDialog类派生的对话框类：

etValue(name,point,height,

color,escapement);

m_nCount++;

Invalidate();

}

howSignal(&dc);

}

etValue(name, point, height, color,

escapement);

m_nCount++;

Invalidate();

}

howSignal(&dc);

}

etValue(name, point, m_colorSignal,

escapement, &m_fontSignal);

m_nCount++;

Invalidate();

}

！

}

howSignal(&dc);

}

eft,

pDoc->GetBubble(i).top,

pDoc->GetBubble(i).right,

pDoc->GetBubble(i).bottom);

，

-= nHeight;

pDC->TextOut, , str);

}

-x;

dy = m_pointList[i].y-y;

m_pointList[i].x = (int)(x+dx**;

m_pointList[i].y = (int)(y+dx*+dy*;

}

= DELTA;

pointList[0].y = DELTA;

pointList[1].x = DELTA+CHIP_WIDTH;

pointList[1].y = DELTA;

pointList[2].x = DELTA+CHIP_WIDTH/2;

pointList[2].y = DELTA+CHIP_WIDTH/2;

m_chipList[0].SetChip(1, pointList, 3);

pointList[0].x = DELTA;

pointList[0].y = DELTA;

pointList[1].x = DELTA;

pointList[1].y = DELTA+CHIP_WIDTH;

pointList[2].x = DELTA+CHIP_WIDTH/2;

pointList[2].y = DELTA+CHIP_WIDTH/2;

m_chipList[1].SetChip(2, pointList, 3);

pointList[0].x = DELTA+CHIP_WIDTH;

pointList[0].y = DELTA;

pointList[1].x = DELTA+CHIP_WIDTH;

pointList[1].y = DELTA+CHIP_WIDTH/2;

pointList[2].x = DELTA+(CHIP_WIDTH*3)/4;

pointList[2].y = DELTA+CHIP_WIDTH/4;

m_chipList[2].SetChip(3, pointList, 3);

pointList[0].x = DELTA+CHIP_WIDTH/2;

pointList[0].y = DELTA+CHIP_WIDTH/2;

pointList[1].x = DELTA+CHIP_WIDTH/4;

pointList[1].y = DELTA+(CHIP_WIDTH*3)/4;

pointList[2].x = DELTA+(CHIP_WIDTH*3)/4;

pointList[2].y = DELTA+(CHIP_WIDTH*3)/4;

m_chipList[3].SetChip(4, pointList, 3);

pointList[0].x = DELTA+CHIP_WIDTH;

pointList[0].y = DELTA+CHIP_WIDTH/2;

pointList[1].x = DELTA+CHIP_WIDTH;

}

pointList[1].y = DELTA+CHIP_WIDTH;

pointList[2].x = DELTA+CHIP_WIDTH/2;

pointList[2].y = DELTA+CHIP_WIDTH;

m_chipList[4].SetChip(5, pointList, 3);

pointList[0].x = DELTA+(CHIP_WIDTH*3)/4;

pointList[0].y = DELTA+CHIP_WIDTH/4;

pointList[1].x = DELTA+CHIP_WIDTH/2;

pointList[1].y = DELTA+CHIP_WIDTH/2;

pointList[2].x = DELTA+(CHIP_WIDTH*3)/4;

pointList[2].y = DELTA+(CHIP_WIDTH*3)/4;

pointList[3].x = DELTA+CHIP_WIDTH;

pointList[3].y = DELTA+CHIP_WIDTH/2;

m_chipList[5].SetChip(6, pointList, 4);

pointList[0].x = DELTA;

pointList[0].y = DELTA+CHIP_WIDTH;

pointList[1].x = DELTA+CHIP_WIDTH/4;

[

pointList[1].y = DELTA+(CHIP_WIDTH*3)/4;

pointList[2].x = DELTA+(CHIP_WIDTH*3)/4;

pointList[2].y = DELTA+(CHIP_WIDTH*3)/4;

pointLis ¨t[3].x = DELTA+CHIP_WIDTH/2; pointList[3].y = DELTA+CHIP_WIDTH;

m_chipList[6].SetChip(7, pointList, 4); erialize(ar);

}

rawChip(pDC);

}

tInChip(point))

。

{

SetCapture();

m_bCaptured = TRUE;

m_pointMouse = point;

m_nCurrIndex = i;

break;

}

etRect());

CSize offset(point-m_pointMouse);

pDoc->m_chipList[m_nCurrIndex].MoveTo(offset);

InvalidateRect(pDoc->m_chipList[m_nCurrIndex].GetRect());

m_pointMouse = point;

pDoc->SetModifiedFlag();

}

、

tInChip(point))

{

InvalidateRect(pDoc->m_chipList[i].GetRect());

pDoc->m_chipList[i].Rotation();

InvalidateRect(pDoc->m_chipList[i].GetRect(), FALSE);

pDoc->SetModifiedFlag();

break;

}

MP）。

说明：首先建立Win32 Application空白项目和源代码文件（不要忘记设置项目使之可以使用MFC类库），然后按：“向项目中添加资源”的方法为项目建立资源文件，并将待显示的位图文件作为资源装入项目。

程序：

eft = rand()%m_nPuzzleWidth+20;

m_rectChips[index].top = rand()%m_nPuzzleHeight+20;

m_rectChips[index].right = m_rectChips[index].left

+m_nChipWidth;

m_rectChips[index].bottom = m_rectChips[index].top

+m_nChipHeight;

}

eft = col*m_nChipWidth;

m_rectChips[index].top = row*m_nChipHeight;

m_rectChips[index].right = m_rectChips[index].left

+m_nChipWidth;

m_rectChips[index].bottom = m_rectChips[index].top

+m_nChipHeight;

}

Invalidate();

}

tInRect(point))

{

SetCapture();

}

m_bCaptured = TRUE;

m_pointMouse = point;

m_nCurrIndex = index;

return;

}

eft,

！

m_rectChips[index].top,

m_nChipWidth,

m_nChipHeight,

&MemDC,

col*m_nChipWidth,

row*m_nChipHeight,

SRCCOPY);

}

、

}

eft);

InvalidateRect(), FALSE);

if(!()) eft);

}

.n"; }

~Mammal() { cout << ""; }

virtual void Speak() const { cout << "Mammal speak!n"; }

};

class Dog : public Mammal

{

public:

Dog() { cout << ""; }

~Dog() { cout << ""; }

void Speak()const { cout << "Woof!n"; }

};

—

int main()

{

Mammal *pDog = new Dog;

pDog->Speak();

return 0;

}

程序运行输出：

Woof!

8-9 定义一个Shape抽象类，在此基础上派生出Rectangle和Circle，二者都有GetArea()函数计算对象的面积，GetPerim()函数计算对象的周长。

解：

源程序：

#include <>

。

class Shape

{

public:

Shape(){}

~Shape(){}

virtual float GetArea() =0 ;

virtual float GetPerim () =0 ;

};

class Circle : public Shape

{

public:

Circle(float radius):itsRadius(radius){}

~Circle(){}

float GetArea() { return * itsRadius * itsRadius; }

float GetPerim () { return * itsRadius; }

private:

、

float itsRadius;

};

class Rectangle : public Shape

{

public:

Rectangle(float len， float width): itsLength(len)， itsWidth(width){};

~Rectangle(){};

virtual float GetArea() { return itsLength * itsWidth; }

float GetPerim () { return 2 * itsLength + 2 * itsWidth; }

virtual float GetLength() { return itsLength; }

virtual float GetWidth() { return itsWidth; }

private:

float itsWidth;

float itsLength;

};

void main()

{

Shape * sp;

sp = new Circle(5);

cout << "The area of the Circle is " << sp->GetArea () << endl;

cout << "The perimeter of the Circle is " << sp->GetPerim () << endl;

delete sp;

sp = new Rectangle(4，6);

cout << "The area of the Rectangle is " << sp->GetArea() << endl;

￥

cout << "The perimeter of the Rectangle is " << sp->GetPerim () << endl;

delete sp;

}

程序运行输出：

The area of the Circle is

The perimeter of the Circle is

The area of the Rectangle is 24

The perimeter of the Rectangle is 20

8-10 对Point类重载++（自增）、--（自减）运算符

解：

#include <>

class Point

{

public:

Point& operator++();

Point operator++(int);

Point& operator--();

Point operator--(int);

Point() { _x = _y = 0; }

int x() { return _x; }

int y() { return _y; }

private:

int _x, _y;

};

Point& Point::operator++()

{

_x++;

_y++;

return *this;

}

Point Point::operator++(int)

{

Point temp = *this;

++*this;

return temp;

}

Point& Point::operator--()

{

_x--;

_y--;

！

return *this;

}

Point Point::operator--(int)

{

Point temp = *this;

--*this;

return temp;

}

void main()

{

Point A;