第十章 类的继承与组合
继承
如果A 是基类，B 是A 的派生类，那么B 将继承A 的数据和函数。例如：
class A
{
public:
void Func1(void);
void Func2(void);
};
class B : public A
{
public:
void Func3(void);
void Func4(void);
};
main()
{
B b;
b.Func1(); // B从A 继承了函数Func1
b.Func2(); // B从A 继承了函数Func2
b.Func3();
b.Func4();
}
【规则10-1-1 】如果类 A 和类B 毫不相关，不可以为了使 B 的功能更多些而让 B 继承A
的功能和属性。不要觉得“白吃白不吃”，让一个好端端的健壮青年无缘无故地吃人参
补身体。
【规则10-1-2】若在逻辑上B 是A 的“一种”（a kind of ），则允许B 继承A 的功
能和属性。例如男人（Man）是人（Human）的一种，男孩（Boy）是男人的一种。那么
类Man 可以从类Human 派生，类Boy 可以从类Man 派生。
class Human
{
…
};
class Man : public Human
{
…
};
class Boy : public Man
{
…
};
【规则10-1-2】看起来很简单，但是实际应用时可能会有意外，继承的概念在程序世
界与现实世界并不完全相同。
例如从生物学角度讲，鸵鸟（Ostrich）是鸟（Bird）的一种，按理说类Ostrich 应该
可以从类Bird派生。但是鸵鸟不能飞，那么Ostrich::Fly是什么东西？
例如从数学角度讲，圆（Circle）是一种特殊的椭圆（Ellipse），按理说类 Circle应
该可以从类 Ellipse 派生。但是椭圆有长轴和短轴，如果圆继承了椭圆的长轴和短轴，
岂非画蛇添足？
所以更加严格的继承规则应当是：若在逻辑上B 是A 的“一种”，并且A 的所
有功能和属性对B 而言都有意义，则允许B 继承A 的功能和属性。
组合
【规则10-2-1 】若在逻辑上 A 是B 的“一部分”（a part of ），则不允许 B 从A 派生，
而是要用A 和其它东西组合出B。
例如眼（Eye）、鼻（Nose）、口（Mouth）、耳（Ear）是头（Head）的一部分，所以
类Head应该由类 Eye、Nose 、Mouth、Ear 组合而成，不是派生而成。如示例 10-2-1所
示。
如果允许Head从Eye、Nose 、Mouth、Ear 派生而成，那么Head将自动具有 Look 、 Smell、
Eat、Listen 这些功能。示例 10-2-2 十分简短并且运行正确，但是这种设计方法却是不
对的。
// 正确的设计，虽然代码冗长。
class Head
{
public:
void Look(void) { m_eye.Look(); }
void Smell(void) { m_nose.Smell(); }
void Eat(void) { m_mouth.Eat(); }
void Listen(void) { m_ear.Listen(); }
private:
Eye m_eye;
Nose m_nose;
Mouth m_mouth;
Ear m_ear;
};
如果允许Head从Eye、Nose 、Mouth、Ear 派生而成，那么Head将自动具有 Look 、 Smell、
Eat、Listen 这些功能。示例 10-2-2 十分简短并且运行正确，但是这种设计方法却是不
对的。
// 功能正确并且代码简洁，但是设计方法不对。
class Head : public Eye, public Nose, public Mouth, public Ear
{
};
第十一章 其它编程经验
使用const 提高函数的健壮性
看到const 关键字，C++程序员首先想到的可能是const 常量。这可不是良好的条件反
射。如果只知道用const 定义常量，那么相当于把火药仅用于制作鞭炮。const 更大的
魅力是它可以修饰函数的参数、返回值，甚至函数的定义体。
const 是constant 的缩写，“恒定不变”的意思。被 const 修饰的东西都受到强制保护，
可以预防意外的变动，能提高程序的健壮性。所以很多C++程序设计书籍建议：“Use
const whenever you need”。
用const 修饰函数的参数
如果参数作输出用，不论它是什么数据类型，也不论它采用“指针传递”还是“引用传
递”，都不能加const 修饰，否则该参数将失去输出功能。
const 只能修饰输入参数：
如果输入参数采用“指针传递”，那么加 const 修饰可以防止意外地改动该指针，起到
保护作用。
例如StringCopy函数：
void StringCopy(char *strDestination, const char *strSource);
其中strSource 是输入参数，strDestination是输出参数。给strSource 加上const
修饰后，如果函数体内的语句试图改动strSource 的内容，编译器将指出错误。
如果输入参数采用“值传递”，由于函数将自动产生临时变量用于复制该参数，该
输入参数本来就无需保护，所以不要加const 修饰。
例如不要将函数 void Func1(int x) 写成void Func1(const int x)。同理不要将函数
void Func2(A a) 写成void Func2(const A a)。其中A 为用户自定义的数据类型。
对于非内部数据类型的参数而言，象void Func(A a) 这样声明的函数注定效率
比较低。因为函数体内将产生A 类型的临时对象用于复制参数a，而临时对象的构造、
复制、析构过程都将消耗时间。
为了提高效率，可以将函数声明改为void Func(A &a)，因为“引用传递”仅借用一下
参数的别名而已，不需要产生临时对象。但是函数void Func(A &a) 存在一个缺点：“引
用传递”有可能改变参数a，这是我们不期望的。解决这个问题很容易，加 const 修饰
即可，因此函数最终成为void Func(const A &a)。
以此类推，是否应将void Func(int x) 改写为void Func(const int &x)，以便提高
效率？完全没有必要，因为内部数据类型的参数不存在构造、析构的过程，而复制也非
常快，“值传递”和“引用传递”的效率几乎相当。
用const 修饰函数的返回值
如果给以“指针传递”方式的函数返回值加 const 修饰，那么函数返回值（即指针）的
内容不能被修改，该返回值只能被赋给加const 修饰的同类型指针。
例如函数
const char * GetString(void);
如下语句将出现编译错误：
char *str = GetString();
正确的用法是
const char *str = GetString();
如果函数返回值采用“值传递方式”，由于函数会把返回值复制到外部临时的存储单元
中，加const 修饰没有任何价值。
例如不要把函数int GetInt(void) 写成const int GetInt(void)。
同理不要把函数 A GetA(void) 写成const A GetA(void) ，其中 A 为用户自定义的
数据类型。
如果返回值不是内部数据类型，将函数A GetA(void) 改写为 const A & GetA(void)
的确能提高效率。但此时千万千万要小心，一定要搞清楚函数究竟是想返回一个对象的
“拷贝”还是仅返回“别名”就可以了，否则程序会出错。
函数返回值采用“引用传递”的场合并不多，这种方式一般只出现在类的赋值函数中，
目的是为了实现链式表达。
例如
class A
{…
A & operate = (const A &other); // 赋值函数
};
A a, b, c; // a, b, c 为A 的对象
…
a = b = c; // 正常的链式赋值
(a = b) = c; // 不正常的链式赋值，但合法
如果将赋值函数的返回值加 const 修饰，那么该返回值的内容不允许被改动。上例中，
语句 a = b = c仍然正确，但是语句 (a = b) = c 则是非法的。
const成员函数
任何不会修改数据成员的函数都应该声明为const 类型。如果在编写const 成员函
数时，不慎修改了数据成员，或者调用了其它非 const 成员函数，编译器将指出错误，
这无疑会提高程序的健壮性。
以下程序中，类 stack 的成员函数 GetCount 仅用于计数，从逻辑上讲 GetCount 应当为
const 函数。编译器将指出GetCount函数中的错误。
class Stack
{
public:
void Push(int elem);
int Pop(void);
int GetCount(void) const; // const成员函数
private:
int m_num;
int m_data[100];
};
int Stack::GetCount(void) const
{
++ m_num; // 编译错误，企图修改数据成员m_num
Pop(); // 编译错误，企图调用非const 函数
return m_num;
}
const成员函数的声明看起来怪怪的：const 关键字只能放在函数声明的尾部，大概
是因为其它地方都已经被占用了。
提高程序的效率
程序的时间效率是指运行速度，空间效率是指程序占用内存或者外存的状况。
全局效率是指站在整个系统的角度上考虑的效率，局部效率是指站在模块或函数角度上
考虑的效率。
【规则11-2-1】不要一味地追求程序的效率，应当在满足正确性、可靠性、健壮性、
可读性等质量因素的前提下，设法提高程序的效率。
【规则11-2-2】以提高程序的全局效率为主，提高局部效率为辅。
【规则11-2-3】在优化程序的效率时，应当先找出限制效率的“瓶颈”，不要在无关
紧要之处优化。
【规则11-2-4】先优化数据结构和算法，再优化执行代码。
【规则11-2-5】有时候时间效率和空间效率可能对立，此时应当分析那个更重要，作
出适当的折衷。例如多花费一些内存来提高性能。
【规则11-2-6】不要追求紧凑的代码，因为紧凑的代码并不能产生高效的机器码。
一些有益的建议
【建议11-3-1】当心那些视觉上不易分辨的操作符发生书写错误。
我们经常会把“＝＝”误写成“＝”，象“|| ”、“&&”、“<= ”、“>= ”这类符号也
很容易发生“丢1”失误。然而编译器却不一定能自动指出这类错误。
【建议11-3-2】变量（指针、数组）被创建之后应当及时把它们初始化，以防止把未
被初始化的变量当成右值使用。
【建议11-3-3】当心变量的初值、缺省值错误，或者精度不够。
【建议11-3-4】当心数据类型转换发生错误。尽量使用显式的数据类型转换（让人们
知道发生了什么事），避免让编译器轻悄悄地进行隐式的数据类型转换。
【建议11-3-5】当心变量发生上溢或下溢，数组的下标越界。
【建议11-3-6】当心忘记编写错误处理程序，当心错误处理程序本身有误。
【建议11-3-7】当心文件I/O 有错误。
【建议11-3-8】避免编写技巧性很高代码。
【建议11-3-9】不要设计面面俱到、非常灵活的数据结构。
【建议11-3-10】如果原有的代码质量比较好，尽量复用它。但是不要修补很差劲的代
码，应当重新编写。
【建议11-3-11】尽量使用标准库函数，不要“发明”已经存在的库函数。
【建议11-3-12】尽量不要使用与具体硬件或软件环境关系密切的变量。
【建议11-3-13】把编译器的选择项设置为最严格状态。
【建议11-3-14】如果可能的话，使用PC-Lint、LogiScope 等工具进行代码审查。
重要考题
void GetMemory(char *p)
{
p = (char *)malloc(100);
}
void Test(void)
{
char *str = NULL;
GetMemory(str);
strcpy(str, "hello world");
printf(str);
}
请问运行Test函数会有什么样的结果？
答：程序崩溃。
因为GetMemory 并不能传递动态内存，
Test函数中的 str一直都是 NULL 。
strcpy(str, "hello world"); 将使程序崩
溃。
char *GetMemory(void)
{
char p[] = "hello world";
return p;
}
void Test(void)
{
char *str = NULL;
str = GetMemory();
printf(str);
}
请问运行Test函数会有什么样的结果？
答：可能是乱码。
因为GetMemory 返回的是指向“栈内存”
的指针，该指针的地址不是 NULL ，但其原
现的内容已经被清除，新内容不可知。
void GetMemory2(char **p, int num)
{
*p = (char *)malloc(num);
}
void Test(void)
{
char *str = NULL;
GetMemory(&str, 100);
strcpy(str, "hello");
printf(str);
}
请问运行Test函数会有什么样的结果？
答：
（1）能够输出hello
（2）内存泄漏
void Test(void)
{
char *str = (char *) malloc(100);
strcpy(str, “hello”);
free(str);
if(str != NULL)
{
strcpy(str, “world”);
printf(str);
}
}
请问运行Test函数会有什么样的结果？
答：篡改动态内存区的内容，后果难以预料，
非常危险。
因为free(str);之后，str 成为野指针，
if(str != NULL) 语句不起作用。
已知strcpy函数的原型是
char *strcpy(char *strDest, const char *strSrc);
其中strDest 是目的字符串，strSrc是源字符串。
（1）不调用C++/C 的字符串库函数，请编写函数 strcpy
char *strcpy(char *strDest, const char *strSrc);
{
assert((strDest!=NULL) && (strSrc !=NULL)); // 2 分
char *address = strDest; // 2分
while( (*strDest++ = * strSrc++) != ‘\0 ’ ) // 2 分
NULL ;
return address ; // 2 分
}
（2）strcpy能把strSrc的内容复制到strDest，为什么还要char * 类型的返回值？
答：为了实现链式表达式。 // 2
分
例如 int length = strlen( strcpy( strDest, “hello world”) );
编写类 String 的构造函数、析构函数和赋值函数（25分）
已知类String的原型为：
class String
{
public:
String(const char *str = NULL); // 普通构造函数
String(const String &other); // 拷贝构造函数
~ String(void); // 析构函数
String & operate =(const String &other); // 赋值函数
private:
char *m_data; // 用于保存字符串
};
请编写String的上述4 个函数。
标准答案：
// String 的析构函数
String::~String(void) // 3 分
{
delete [] m_data;
// 由于m_data是内部数据类型，也可以写成 delete m_data;
}
// String的普通构造函数
String::String(const char *str) // 6 分
{
if(str==NULL)
{
m_data = new char[1]; // 若能加 NULL 判断则更好
*m_data = ‘\0 ’;
}
else
{
int length = strlen(str);
m_data = new char[length+1]; // 若能加 NULL 判断则更好
strcpy(m_data, str);
}
}
// 拷贝构造函数
String::String(const String &other) // 3 分
{
int length = strlen(other.m_data);
m_data = new char[length+1]; // 若能加 NULL 判断则更好
strcpy(m_data, other.m_data);
}
// 赋值函数
String & String::operate =(const String &other) // 13 分
{
// (1) 检查自赋值 // 4分
if(this == &other)
return *this;
// (2) 释放原有的内存资源 // 3 分
delete [] m_data;
// （3）分配新的内存资源，并复制内容 // 3 分
int length = strlen(other.m_data);
m_data = new char[length+1]; // 若能加 NULL 判断则更好
strcpy(m_data, other.m_data);
// （4）返回本对象的引用 // 3分
return *this;
}
\
771
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
