读书笔记——《高质量C++/C编程指南》（6）

类的继承与组合

对象是类的一个实例——如果将对象比作房子，那么类就是房子的设计图纸。

所以面向对象设计的重点是类的设计，而不是对象的设计。

对于 C++程序而言，设计孤立的类是比较容易的，难的是正确设计基类及其派生类。

继承

 
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();
}

这个简单的示例程序说明了一个事实：C++的“继承”特性可以提高程序的可复用性。

“继承”立一些使用规则：

【规则1】如果类A 和类B 毫不相关，不可以为了使B 的功能更多些而让B继承A 的功能和属性。

【规则2】若在逻辑上B 是A 的“一种”，并且A 的所有功能和属性对B 而言都有意义，则允许B 继承A 的功能和属性。

组合

【规则1】若在逻辑上A 是B 的“一部分”，则不允许B 从A 派生，而是要用A 和其它东西组合出B。

例如眼（Eye）、鼻（Nose）、口（Mouth）、耳（Ear）是头（Head）的一部分，所以类Head 应该由类Eye、Nose、Mouth、Ear 组合而成，不是派生而成。

class Eye
{
public:
    void Look(void);
};
 
class Nose
{
public:
    void Smell(void);
};
 
class Mouth
{
public:
    void Eat(void);
};
 
class Ear
{
public:
    void Listen(void);
};
 
// 正确的设计，虽然代码冗长。
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 这些功能。下面代码十分简短并且运行正确，但是这种设计方法却是不对的。

// 功能正确并且代码简洁，但是设计方法不对。
class Head : public Eye, public Nose, public Mouth, public Ear
{
 
};

其他编程经验

使用const 提高函数的健壮性

看到 const 关键字，const 更大的魅力是它可以修饰函数的参数、返回值，甚至函数的定义体。

被const 修饰的东西都受到强制保护，可以预防意外的变动，能提高程序的健壮性。

建议：“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)。

将“const &”修饰输入参数的用法总结一下：

对于非内部数据类型的输入参数，应该将“值传递”的方式改为“const 引用传递”，目的是提高效率。

例如：将void Func(A a) 改为void Func(const A &a)。

对于内部数据类型的输入参数，不要将“值传递”的方式改为“const 引用传递”。否则既达不到提高效率的目的，又降低了函数的可理解性。

例如：void Func(int x) 不应该改为void Func(const int &x)。

用const 修饰函数的返回值

       如果给以“指针传递”方式的函数返回值加const 修饰，那么函数返回值（即指针）的内容不能被修改，该返回值只能被赋给加const 修饰的同类型指针。

例如函数

const char * GetString ( void ) ;//函数返回值的内容不能被修改

如下语句将出现编译错误：

char *str = GetString() ; //返回值是const char*类型，不能赋给char*类型

正确的用法是

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 类型。

以下程序中，类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 关键字只能放在函数声明的尾部

提高程序的效率

程序的时间效率是指运行速度；

空间效率是指程序占用内存或者外存的状况。

全局效率是指站在整个系统的角度上考虑的效率；

局部效率是指站在模块或函数角度上考虑的效率。

【规则1】以提高程序的全局效率为主，提高局部效率为辅。

【规则2】在优化程序的效率时，应当先找出限制效率的“瓶颈”，不要在无关紧要之处优化。

【规则3】先优化数据结构和算法，再优化执行代码。

【规则4】有时候时间效率和空间效率可能对立，此时应当分析那个更重要，作出适当的折衷。

【规则5】不要追求紧凑的代码，因为紧凑的代码并不能产生高效的机器码。

建议

【建议1】当心那些视觉上不易分辨的操作符发生书写错误。

我们经常会把“＝＝”误写成“＝”，象“||”、“&&”、“<=”、“>=”这类符号也很容易发生“丢1”失误。然而编译器却不一定能自动指出这类错误。

【建议2】变量（指针、数组）被创建之后应当及时把它们初始化，以防止把未被初始化的变量当成右值使用。

【建议3】当心变量的初值、缺省值错误，或者精度不够。

【建议4】当心数据类型转换发生错误。尽量使用显式的数据类型转换（让人们知道发生了什么事），避免让编译器轻悄悄地进行隐式的数据类型转换。

【建议5】当心变量发生上溢或下溢，数组的下标越界。

【建议6】避免编写技巧性很高代码。

【建议7】不要设计面面俱到、非常灵活的数据结构。

【建议8】如果原有的代码质量比较好，尽量复用它。但是不要修补很差劲的代码，应当重新编写。

【建议9】尽量使用标准库函数，不要“发明”已经存在的库函数。

【建议10】尽量不要使用与具体硬件或软件环境关系密切的变量。

【建议11】把编译器的选择项设置为最严格状态。

【建议12】如果可能的话，使用PC-Lint、LogiScope 等工具进行代码审查。