【备战2014笔面试】读书笔记-高质量C/C++编程指南(2)

第十章  类的继承与组合

继承
如果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;
}  

 

\