📄 chapter5.htm
字号:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312">
<title>无标题文档</title>
<style type="text/css">
<!--
.style1 {
font-family: "宋体";
font-size: 16px;
color: #FF0000;
font-weight: bold;
font-style: italic;
}
.style2 {
font-family: "宋体";
font-size: 14px;
}
.style3 {font-size: 14px}
-->
</style>
</head>
<body>
<p><span
class=style1>第 五 章 C++程序的基本结构</span><br>
</p>
<p><b><span class=style2>5-1 什么叫做作用域？有哪几种类型的作用域？</span></b><span class=style2style2 style3><br>
</span></p>
<p class="style2"><span class=style2>解： <br>
作用域讨论的是标识符的有效范围，作用域是一个标识符在程序正文中有效的区域。C++的作用域分为函数原形作用域、块作用域(局部作用域)、类作用域和文件作用域.<br>
</span></p>
<p class="style2"><span class=style2><b>5-2 什么叫做可见性？可见性的一般规则是什么？</b><br>
</span></p>
<p class="style2"><span class=style2>解： <br>
可见性是标识符是否可以引用的问题；<br>
可见性的一般规则是：标识符要声明在前，引用在后，在同一作用域中，不能声明同名的标识符。对于在不同的作用域声明的标识符，遵循的原则是：若有两个或多个具有包含关系的作用域，外层声明的标识符如果在内层没有声明同名标识符时仍可见，如果内层声明了同名标识符则外层标识符不可见。 <br>
</span></p>
<p class="style2"><span class=style2><b>5-3 下面的程序的运行结果是什么，实际运行一下，看看与你的设想有何不同。</b><br>
#include <iostream.h><br>
void myFunction(); </span></p>
<p class=style2>int x = 5， y = 7; <br>
int main()<br>
{</p>
<p class=style2>cout << "x from main: " << x << "\n";<br>
cout << "y from main: " << y << "\n\n";<br>
myFunction();<br>
cout << "Back from myFunction!\n\n";<br>
cout << "x from main: " << x << "\n";<br>
cout << "y from main: " << y << "\n";<br>
return 0;<br>
}<br>
void myFunction()<br>
{<br>
int y = 10;</p>
<p class=style2>cout << "x from myFunction: " << x << "\n";<br>
cout << "y from myFunction: " << y << "\n\n";<br>
}<br>
</p>
<p class=style2>解： <br>
程序运行输出：<br>
x from main: 5<br>
y from main: 7</p>
<p class=style2>x from myFunction: 5<br>
y from myFunction: 10</p>
<p class=style2>Back from myFunction!</p>
<p class=style2>x from main: 5<br>
y from main: 7<br>
</p>
<p class=style2> </p>
<p class=style2><b>5-4 假设有两个无关系的类Engine和Fuel，使用时，怎样允许Fuel成员访问Engine中的私有和保护的成员?</b><br>
</p>
<p class=style2>解： <br>
源程序：<br>
class fuel;<br>
class engine<br>
{<br>
friend class fuel;<br>
private;<br>
int powerlevel;<br>
public;<br>
engine(){ powerLevel = 0;}<br>
void engine_fn(fuel &f);<br>
};<br>
class fuel<br>
{<br>
friend class engine;<br>
private;<br>
int fuelLevel;<br>
public:<br>
fuel(){ fuelLevel = 0;}<br>
void fuel_fn( engine &e);<br>
};</p>
<p class=style2> </p>
<p class=style2><b>5-5 什么叫做静态数据成员？它有何特点？</b><br>
</p>
<p class=style2>解： <br>
类的静态数据成员是类的数据成员的一种特例，采用static关键字来声明。对于类的普通数据成员，每一个类的对象都拥有一个拷贝，就是说每个对象的同名数据成员可以分别存储不同的数值，这也是保证对象拥有自身区别于其它对象的特征的需要，但是静态数据成员，每个类只要一个拷贝，由所有该类的对象共同维护和使用，这个共同维护、使用也就实现了同一类的不同对象之间的数据共享。<br>
</p>
<p class=style2><b>5-6 什么叫做静态函数成员？它有何特点？</b><br>
</p>
<p class=style2>解： <br>
使用static关键字声明的函数成员是静态的，静态函数成员属于整个类，同一个类的所有对象共同维护，为这些对象所共享。静态函数成员具有以下两个方面的好处，一是由于静态成员函数只能直接访问同一个类的静态数据成员，可以保证不会对该类的其余数据成员造成负面影响；二是同一个类只维护一个静态函数成员的拷贝，节约了系统的开销，提高程序的运行效率。<br>
</p>
<p class=style2><b>5-7 定义一个Cat类，拥有静态数据成员HowManyCats，记录Cat的个体数目；静态成员函数GetHowMany（），存取HowManyCats。设计程序测试这个类，体会静态数据成员和静态成员函数的用法。</b><br>
</p>
<p class=style2>解： <br>
源程序：<br>
#include <iostream.h></p>
<p class=style2>class Cat<br>
{<br>
public:<br>
Cat(int age):itsAge(age){HowManyCats++; }<br>
virtual ~Cat() { HowManyCats--; }<br>
virtual int GetAge() { return itsAge; }<br>
virtual void SetAge(int age) { itsAge = age; }<br>
static int GetHowMany() { return HowManyCats; }<br>
private:<br>
int itsAge;<br>
static int HowManyCats;<br>
};</p>
<p class=style2>int Cat::HowManyCats = 0;</p>
<p class=style2>void TelepathicFunction();</p>
<p class=style2>int main()<br>
{<br>
const int MaxCats = 5;<br>
Cat *CatHouse[MaxCats]; int i;<br>
for (i = 0; i<MaxCats; i++)<br>
{<br>
CatHouse[i] = new Cat(i);<br>
TelepathicFunction();<br>
}</p>
<p class=style2>for ( i = 0; i<MaxCats; i++)<br>
{<br>
delete CatHouse[i];<br>
TelepathicFunction();<br>
}<br>
return 0;<br>
}</p>
<p class=style2>void TelepathicFunction()<br>
{<br>
cout << "There are " << Cat::GetHowMany() << " cats alive!\n";<br>
}</p>
<p class=style2>程序运行输出：<br>
There are 1 cats alive!<br>
There are 2 cats alive!<br>
There are 3 cats alive!<br>
There are 4 cats alive!<br>
There are 5 cats alive!<br>
There are 4 cats alive!<br>
There are 3 cats alive!<br>
There are 2 cats alive!<br>
There are 1 cats alive!<br>
There are 0 cats alive!<br>
</p>
<p class=style2><b>5-8 什么叫做友元函数？什么叫做友元类？</b><br>
</p>
<p class=style2>解： <br>
友元函数是使用friend关键字声明的函数，它可以访问相应类的保护成员和私有成员。友元类是使用friend关键字声明的类，它的所有成员函数都是相应类的友元函数。</p>
<p class=style2> </p>
<p class=style2><b>5-9 如果类A是类B的友元，类B是类C的友元，类D是类A的派生类，那么类B是类A的友元吗？类C是类A的友元吗？类D是类B的友元吗？</b><br>
</p>
<p class=style2>解： <br>
类B不是类A的友元，友元关系不具有交换性；<br>
类C不是类A的友元，友元关系不具有传递性；<br>
类D不是类B的友元，友元关系不能被继承。<br>
</p>
<p class=style2><b>5-10 静态成员变量可以为私有的吗？声明一个私有的静态整型成员变量。</b><br>
</p>
<p class=style2>解： <br>
可以，例如：<br>
private:<br>
static int a;<br>
</p>
<p class=style2><b>5-11 在一个文件中定义一个全局变量n，主函数main()，在另一个文件中定义函数fn1()，在main()中对n赋值，再调用fn1()，在fn1()中也对n赋值，显示n最后的值。</b><br>
</p>
<p class=style2>解： <br>
#include <iostream.h><br>
#include "fn1.h"</p>
<p class=style2>int n;</p>
<p class=style2>void main()<br>
{<br>
n = 20;<br>
fn1();<br>
cout << "n的值为" <<n;<br>
}</p>
<p class=style2>// fn1.h文件 <br>
extern int n; </p>
<p class=style2>void fn1()<br>
{<br>
n=30;<br>
}</p>
<p class=style2>程序运行输出：<br>
n的值为30<br>
</p>
<p class=style2><b>5-12 在函数fn1()中定义一个静态变量n，fn1()中对n的值加1，在主函数中，调用fn1()十次，显示n的值。</b><br>
</p>
<p class=style2>解： <br>
#include <iostream.h></p>
<p class=style2>void fn1()<br>
{<br>
static int n = 0;<br>
n++;<br>
cout << "n的值为" << n <<endl;<br>
}</p>
<p class=style2>void main()<br>
{<br>
for(int i = 0; i < 10; i++)<br>
fn1();<br>
}</p>
<p class=style2>程序运行输出：<br>
n的值为1<br>
n的值为2<br>
n的值为3<br>
n的值为4<br>
n的值为5<br>
n的值为6<br>
n的值为7<br>
n的值为8<br>
n的值为9<br>
n的值为10<br>
</p>
<p class=style2><b>5-13 定义类X、Y、Z，函数h(X*)，满足：类X有私有成员i，Y的成员函数g(X*)是X的友元函数，实现对X的成员i加1，类Z是类X的友元类，其成员函数f(X*)实现对X的成员i加5，函数h(X*)是X的友元函数，实现对X的成员i加10。在一个文件中定义和实现类，在另一个文件中实现main()函数。<br>
</b></p>
<p class=style2>解： <br>
#include "my_x_y_z.h"<br>
void main() <br>
{<br>
X x;<br>
Z z;<br>
z.f(&x);<br>
}</p>
<p class=style2>// my_x_y_z.h文件<br>
#ifndef MY_X_Y_Z_H</p>
<p class=style2>class X; <br>
class Y {<br>
void g(X*);<br>
};</p>
<p class=style2>class X <br>
{ <br>
private:<br>
int i;<br>
public:<br>
X(){i=0;}<br>
friend void h(X*);<br>
friend void Y::g(X*);<br>
friend class Z;<br>
};</p>
<p class=style2>void h(X* x) { x->i =+10; }</p>
<p class=style2>void Y::g(X* x) { x->i ++; }</p>
<p class=style2>class Z {<br>
public:<br>
void f(X* x) { x->i += 5; }<br>
};</p>
<p class=style2>#endif // MY_X_Y_Z_H</p>
<p class=style2>程序运行输出：无<br>
</p>
<p class=style2><b>5-14 定义Boat与Car两个类，二者都有weight属性，定义二者的一个友元函数totalWeight()，计算二者的重量和。</b><br>
</p>
<p class=style2>解： <br>
源程序：<br>
#include <iostream.h></p>
<p class=style2>class Boat;<br>
class Car<br>
{<br>
private:<br>
int weight;<br>
public:<br>
Car(int j){weight = j;}<br>
friend int totalWeight(Car &aCar， Boat &aBoat);<br>
};</p>
<p class=style2>class Boat<br>
{<br>
private:<br>
int weight;<br>
public:<br>
Boat(int j){weight = j;}<br>
friend int totalWeight(Car &aCar， Boat &aBoat);<br>
};</p>
<p class=style2>int totalWeight(Car &aCar， Boat &aBoat)<br>
{<br>
return aCar.weight + aBoat.weight;<br>
}</p>
<p class=style2>void main()<br>
{<br>
Car c1(4);<br>
Boat b1(5);</p>
<p class=style2>cout << totalWeight(c1， b1) << endl;<br>
}<br>
程序运行输出：<br>
9<br>
</p>
<p class=style2><b>5-15 如果在类模板的定义中有一个静态数据成员，则在程序运行中会产生多少个相应的静态变量？</b><br>
</p>
<p class=style2>解： <br>
这个类模板的每一个实例类都会产生一个相应的静态变量。</p>
<p class="style2"></p>
<p class="style2"></p>
<p class="style2"> </p>
</body>
</html>
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -