高质量c/c++编程指南"读书笔记1

一个strcpy函数的代码
能考查三个方面
(1) 编程风格
(2) 出错处理
(3) 算法复杂度分析(用于提供性能)

定义编程老手和编程高手
定义1：能长期稳定地编写出高质量程序的程序员称为编程老手
定义2：能长期稳定地编写出高难度、高质量的程序与称为编程高手

第一章 文件结构

1.1 版权和版本的声明
版权和版本的声明位于头文件和定义文件的开头，主要内容有：
(1) 版权信息
(2) 文件名称、标识符、摘要
(3) 当前版本号、作者/修改者、完成日期
(4) 版本历史信息

/*
 * Copyright (c) 2001,上海贝尔有限公司网络应用事业部
 * All rights reserved.
 * 
 * 文件名称：filename.h
 * 文件标识：见配置管理计划书
 * 摘    要：简要描述本文件的内容
 * 
 * 当前版本：1.1 
 * 作    者：输入作者（或修改者）名字
 * 完成日期：2001年7 月20日
 *
 * 取代版本：1.0  
 * 原作者  ：输入原作者（或修改者）名字
 * 完成日期：2001年5 月10日
*/

1.2 头文件结构
    头文件由三部分内容组成
(1) 头文件开头处的版权和版本声明
(2) 预处理块
(3) 函数和类结构声明等
    为了防止头文件被重复用in用，应当用ifndef/define/endif结构产生预处理块
    头文件中只存放"声明"而不存放"定义"
  在C++语法中，类的成员函数可以在声明的同时被定义，并且自动成为内联函数。这虽然会带来书写上的方便，但却造成了风格不一致，弊大于利。建议将成员函数的定义与声明分开，不论该函数体有多么小。
    不提倡使用全局变量，尽量不要再头文件中出现像extern int value这类声明

1.3 头文件的作用
(1) 通过头文件来调用库功能。在很多场合，源代码不便(或不准)向用户公布，只要向用户提供头文件和二进制库即可。用户只需要按照头文件中的接口声明来调用库功能，而不必关系接口怎么实现的。编译器会从库中提取相应的代码。

(2) 头文件能加强类型安全监察。如果某个接口被实现或被使用时，其方式与头文件中的声明不一致，编译器就会指出错误，这一见到的规则能大大减轻程序员调试、改错的负担。

1.4 目录结构
    如果一个软件的头文件数目比较多(如超过十个)，通常应将头文件和定义文件分别保存于不同的目录，以便于维护。
    例如可将头文件保存于include目录，将定义文件保存于source目录(可以是多级目录)。
    如果某些头文件是私有的，他不会被用户的程序直接引用，则没有必要公开其"声明"。为了加强信息隐藏，这些私有的头文件可以和定义文件存放在同一目录。

第二章 程序的版式
    版式虽然不会影响程序的功能，但会影响可读性。程序的版式追求清晰、美观，是程序风格的重要构成因素。

2.1 空行
    空行起着分隔程序段落的作用。空行得体(不过多也不过少)将使程序的布局更加清晰。空行不会浪费内存，虽然打印含有空行的程序是会多消耗一些纸张，但是值得。
(1) 在每个类声明之后、每个函数定义结束之后都要加空行
void Function1(...)
{}

vodi Function2(...)
{}

(2) 在一个函数体内，逻辑上密切相关的语句之间不加空行，其他地方应加空行分隔
while( flag )
{
    statement1;
    // 空行
    if( condition )
    {
       statement2;
    }
    else
    {
       statement3;
    }
    // 空行
    statement4;
}

2.2 代码行
(1) 一行代码只做一件事情，如之定义一个变量，或只写一条语句。这样的代码容易阅读，并且方便于写注释
int width;
int height;

(2) if、for、while、do等语句自占一行，执行语句不得紧跟其后。不论执行语句有多少都要加{}。这样可以防止书写失误

2.3 代码行内的空格
(1) 关键字之后要留空格。像const、virtual、inline、case等关键字之后至少要留一个空格，否则无法辨析关键字。想if、for、while等关键字之后应留一个空格再跟左括号'('，以突出关键字

(2) 代码行最大长度宜控制在70至80个字符以内。代码行不要过长，否则眼睛看不过来，也不便于打印

(3) 长表达式要在低优先级操作符处拆分成新航，操作符放在新行之首(以便突出操作符)。拆分出的新行要进行适当的缩进，使排版整齐，语句刻度
if (( very_longer_variable1 >= very_longer_variable2 )
   && (very_longer_variable3 <= very_longer_variable4 )
   && (very_longer_variable5 <= very_longer_variable6 ))
{...}

2.4 修饰符的位置
    应当将修饰符*和&紧靠变量名

2.5 注释
    C语言的注释符为"/*...*/"。C++语言中，程序块的注释常采用"/*...*/"，行注释一般采用"//..."。注释通常用于：
 版本、版权声明
 函数接口说明
 重要的代码行或段落提示
    虽然注释有助于理解代码，但注意不可过多地使用注释
(1) 注释是对代码的“提示”，而不是文档。程序中的注释不可喧宾夺主，注释太多了会让人眼花缭乱。注释的花样要少

(2) 如果代码本来就是清楚的，则不必加注释。否则多此一举，令人厌烦例如
    i++; // i加1，多余的注释

(3) 边写代码边注释，修改代码同时修改相应的注释，以保证注释与代码的一致性。不再有用的注释要删除
/*
 *  函数介绍：
 *  输入参数：
 *  输出参数：
 *  返回值  ：
*/
void Function(float x, float y, float z)
{
  …
}

2.6 类的版式
    类可以将数据和函数封装在一起，其中函数表示了类的行为(或称服务)。类提供关键字public、protected和private。这样可以达到信息隐藏的目的，即让类仅仅公开必须要让外界知道的内容，而隐藏其他一切内容。不可以滥用类的封装功能，不要把它当成火锅，什么东西都往里扔。
    将public类型的函数写在前面，而将private类型的数据写在后面，采用这种版式的程序员主张类的设计“以行为为中心”，重点关注的是类应该提供什么样的接口(或服务)
class A
{
  public:
  void Func1(void);
  void Func2(void);
  …
private:
  int    i, j;
  float  x, y;
  …
}

第三章 命名规则
    比较著名的命名规则当推MS公式的“匈牙利”法，该命名规则的主要思想是“在变量和函数名中加入前缀以增进人们对程序的理解”。例如所有的字符变量均以ch为前缀，若是指针变量则追加前缀p。如果一个变量有ppch开头，则表明它是指向字符指针的指针。
    匈牙利法最大缺点是繁琐

3.1 共性规则
(1) 标识符应当直观且可以品读，可望文知意，不必进行“解码”
标识符最好采用英文单词或其组合，便于记忆和阅读。切忌使用汉语拼音来命名。程序中的英文档次一般不会太复杂，用词应当准确。例如不要把CrurentValue写成NowValue

(2) 标识符的长度应当符合“min-length” && “max-information”原则。
几十年前老ANSI C规定名字不准超过6个字符，现今的C++/C不再有此限制。一般来说，长名字能更好地表达含义，所以函数名、变量名、类名长达十几个字符不足为奇。那么名字是否越长越好？不见得！例如变量名maxVal就比maxValueUntilOverflow好用。大字符的名字也是有用的，常见的如i，jk等，它们通常可以用作函数内的局部变量

(3) 命名规则尽量与所采用的操作系统或开发工具的风格保持一致。例如windows应用程序的标识符通常采用“大小写”混排的方式，如AddChild，而Unix应用程序的标识符通常采用“小写加下划线”的方式，如add_child。别把这两类风格混在一起用。

(4) 程序中不要出现紧靠大小写区分的相似的标识符。例如
int x, X; // 变量x与X容易混淆

(5) 变量的名字应当使用“名词”或者“形容词+名词”。例如
float value;
float oldValue;
float newValue;

(6) 全局函数的名字应当使用“动词”或者“动词+名词”(动宾词组)。类的成员函数应当只使用“动词”，被省略掉的名词就是对象本身。例如
DrawBox();   // 全局函数
bos->Draw(); // 类的成员函数

3.2 简单的windows应用程序命名规则
(1) 类名和函数名用大写字母开头的单词组合而成，例如：
class Node;     // 类名
class LeadNode; // 类名
void Draw( void );          // 函数名
void SetValue( int value ); // 函数名

(2) 变量和参数用小写字母开头的单词组合而成
BOOL flag;
int drawNode;

(3) 常量全用大写的字母，用下划线分隔单词，例如：
const int MAX = 100;
const int MAX_LENGTH = 100;

(4) 静态变量加前缀s_(表示static)，例如：
vodi Init(...)
{
    static int s_initValue; // 静态变量
}

(5) 如果不得已需要全局变量，则使全局变量加前缀g_(表示global)，例如：
int g_howManyPeople; // 全局变量
int g_howMuchMoney;  // 全局变量

(6) 类的数据成员加前缀m_(表示member)，这样可以避免数据成员与成员函数的参数同名。例如：
void Object:L:SetValue( int width, int height )
{
    m_width = width;
    m_height = height;
}

第四章 表达式和基本语句
4.1 if语句
a、布尔变量与零值比较
    不可将不二变量直接与TRUE、FALSE或者1、0进行比较
    根据布尔类型的语义，零值为“假”(记为FALSE)，任何非零值都是“真”(记为TRUE)。TRUE的值究竟是什么病没有统一的标准。例如Virtual C++将TRUE定义为1，而VB则就爱那个TRUE定义为-1
假设布尔变量名字为flag，它与零值比较的标准if语句如下：
if ( flag )  // 表示flag为真
if ( !flag ) // 表示flag为假
其他的用法都属于不良风格，例如：
if ( TRUE == flag )
if ( 1 == flag )

b、整型变量与零值比较
if ( 0 == value )
if ( 0 != value )

c、浮点变量与零值比较
    不可将浮点变量用"=="或"!="与任何数字比较
    千万要留意，无论是float还是double类型的表露，都有精度限制。所以一定要避免将浮点变量用"=="或"!="与数字比较，应该设法转化成">="或"<="形式
假设浮点变量的名字为x，应当将
if ( 0.0 == x ) // 隐含错误的比较
转化为
if ( ( x >= -ESPINON) && ( x <= EPSINON) )
其中EPSINON是允许的误差(即精度)

d、指针变量与零值比较
if ( NULL == p )
if ( NULL != p )

4.2 循环语句的效率
C/C++循环语句中，for语句使用频率最高，while语句其次，do语句很少用。

a、在多重循环中，如果有可能，应当将最长的循环放在最内层，最短的循环放在最外层，以减少CPU跨切循环层的次数。例如
for ( row = 0; row < 100; row ++)
{
    for ( col = 0; col < 5; col++ )
    {
        sum = sum + a[ row ][ col ];
    }
}
这里的效率就比较低：长循环在最外层，应改成：
for ( col = 0; col < 5; col++ )
{
    for ( row = 0; row < 100; row ++)
    {
        sum = sum + a[ row ][ col ];
    }
}

b、如果循环体内存在逻辑判断，并且循环次数很大，宜将逻辑判断移到循环体的外面。比如(1)中的程序比(2)的程序多执行了N-1次逻辑判断。并且由于前者老妖进行逻辑判断，打断了循环“流水线”作业，是的编译器不能对循环进行优化处理，降低了小路。如果N非常大，最好采用(2)的写法，可以提高小路。如果N非常小，两者效率差别并不明显，但采用(1)的写法比较好，因为程序更加简洁
(1)
for ( i = 0; i < N; i++ )
{
    if ( condition )
    {
        DoSomething();
    }
    else
    {
        DoOtherthing();
    }
} // 效率低但程序简洁
(2)
if ( condition )
{
    for ( i = 0; i < N; i++ )
    {
        DoSomething();
    }
}
else
{
    for ( i = 0; i < N; i++ )
    {
        DoOtherthing();
    }
} // 效率高但程序简洁

4.3 for语句的循环控制变量
建议for语句的循环控制变量的取值采用“半开半闭区间”写法
(1)
for ( int i = 0; i < N; i++ )
{...}
x值属于半开半闭区间“0 =< x < N”，起点到终点的间隔为N，循环次数为N
(2)
for ( int i = 0 ; i <= N -1; i++ )
{...}
x值属于闭区间“0 =< x <= N-1”，起点到终点的间隔为N-1，循环次数为N
相比之下(1)的写法更加直观，尽管两者的功能是相同的

第五章 常量
    常量是一种标识符，它的值在运行期间恒定不变。C语言用#define来定义常量(成为宏常量)。C++语言除了#define外还可以用const来定义常量(成为const常量)

5.1 为什么需要常量
    如果不适用常量，直接在程序中填写数字或字符串，将会有什么麻烦？
(1) 程序的可读性(可理解性)变差。程序员自己会放假那些数字或字符串是什么意思，用户则更加不知他们从何而来、表示什么
(2) 在程序的很多地方输入同样的数字或字符串，难保不发生书写错误
(3) 如果要修改数字或字符串，则会在很多地方改动，既麻烦又容易出错

5.2 const与#define的比较
    C++语言可以用const来定义常量，也可以用#define来定义常量。但是前者比后者有更多的有点：
(1) const常量有数据类型，而宏常量没有数据类型。编译器可以对前者进行类型安全监察。而对后者只进行字符替换，没有类型安全监察，并且在字符替换可能会产生意料不到的错误(边界效应)
(2) 有些集成化调试工具可以对const常量进行调试，但是不能对宏常量进行调试

5.3 类的常量
    不能在类声明中初始化const数据成员。以下用法是错误的，因为累的对象未被创建时，编译器不知道SIZE的值是什么
class Test_A
{
    ...
private:
    const int SIZE = 100; // 错误，企图在类声明中初始化const数据成员
    int array[ SIZE ];    // 错误，未知而SIZE
};

const数据成员的初始化只能在类构造函数的初始化表中进行，例如：
class Test_A
{
public:
    Test_A( int size );   // 构造函数
    const int SIZE;
};

Test_A::Test_A( int size) : SIZE( size ) // 构造函数的初始化表
{}

怎样才能简历在整个类中都恒定的常量呢？别指望const数据成员了，应该用类中的枚举常量来实现。例如：
class Test_A
{
    ...
public:
    enum { SIZE1 = 100, SIZE2 = 200 }; // 枚举常量
    int array1[ SIZE];
    int array2[ SIZE];  
}
枚举常量不会占用对象的存储空间，他们在编译时被全部求职。枚举常量的缺点是：他的隐含数据类型是整数，其最大值优先，且不能表示浮点数(如PI = 3.14159)

第六章 函数设计
6.1 参数的规则
a、参数额书写要完整，不要贪图省事致谢参数的类型而省略参数名字，如果函数没有参数，则用void填充，例如：
void GetValue(void);

b、如果参数是指针，且仅作输入用，则应在类型前加const，以防止该指针在函数体内被意外修改

c、如果输入参数以值传递的方式传递对象，则宜改用“const &”方式来传递，这样可以省去临时对象的构造和析构过程，从而提高效率

6.2 返回值的规则
a、函数名字与返回值类型在语义上不可冲突
违反这条规则的典型带便是C标准库函数getchar，例如：
char c;
c = getchar();
if ( EOF == c )
{...}
按照getchar名字的意思，将变量c声明为char类型是很自然的事情。但不幸的是getchar的确不是char类型，而是int类型，其原型如下：
int getchar( void );
由于c是char类型，取值范围是[ -128, 127 ],如果宏EOF的值在char的取值范围之外，那么if语句将总是失败，这种“危险”人们一般不会料到，导致本例错误的责任是函数getchar误导了使用者

b、不要将正常值和错误标识混在一起返回。正常值用输出参数获得，而错误标志用return语句返回
    回顾上例，C标准库函数的设计者为什么要将getchar声明为令人迷糊的int类型？
    在正常情况下，getchar的确返回单个字符。但如果getchar碰到文件结束标志或发生读错误，它必须返回一个标志EOF。为了区别于正常的字符，志豪将EOF定义为负数(通常为-1)。因此函数getchar就成了int类型。

c、有时候函数原本不需要返回值，但为了增加灵活性如支持链式表达，可以附加返回值
例如字符串拷贝函数strcpy的原型：
char *strcpy( char *strDest, const char *strSrc );
strcpy函数将strSrc拷贝至输出参数strDest中，同时函数的返回值又是strDest。这样做并非多次一举，可以获得如下灵活性：
char str[ 20 ];
int length = strlen( strcpy( str, "hello world" ));

6.3 函数内部实现的规则
    不同功能的函数其内部实现各不相同，看起来似乎无法就“内部实现”达成一致的观点。但根据经验，可以在函数体的“入口处”和“出口处”从严把关，从而提高函数的质量
a、在函数体的“入口处”，对参数的有效性进行检查
看6.5

b、在函数体的“出口处”，对return语句的正确性和效率进行检查
如果函数有返回值，那么函数的“出口处”是return语句。如果return语句写得不好，函数要么出错，要么效率低下。
注意事项如下：
(1) return语句不可反悔指向“栈内存”的“指针”或者“引用”，因为该内存在函数体结束时被自动销毁，例如：
char *Func( void )
{
    char str[] = "hello world"; // str的内存位于栈上
    return str;    // 将导致错误
}
(2) 如果函数返回值是一个对象，要考虑return语句的效率。例如：
return String( s1 + s2 );
    这是临时对象的语法，表示“创建一个临时对象并返回他”。不要以为他与“先创建一个局部对象temp并返回他的结果”是等价的，如：
String temp( s1 + s2 );
return temp;
是指不然，上述代码发生三件事。首先，temp对象被创建，同时完成初始化；然后拷贝够咱函数吧temp拷贝到保存返回值存储单元中；最后，temp在函数结束时被销毁(调用析构函数)。然后“创建一个临时对象并返回他”的过程是不同的，编译器直接把临时对象创建并初始化在外部存储单元中，省去了拷贝和析构的花费，提高了效率

6.4 其他建议
(1) 函数的功能要单一，不要涉及多用途的函数
(2) 函数体的规模要小，尽量控制在50行代码之内
(3) 函数中尽量少用static局部变量，除非必要
(4) 不仅要检查输入蚕食的有效性，还要检查通过其他途径进入函数体内的变量的有效性，例如全局变量、文件句柄等
(5) 用于出错处理的返回值一定要清楚，让使用者不容易忽视或误解错误情况

6.5 使用断言
    程序一般分为Debug版本和Release版本。
    断言assert是尽在Debug版本其作用的宏，他用于检测“不应该”发生的情况。
void *memory( void *pvTo, const void *pvFrom, size_t size )
{
    assert( ( NULL != pvTo) && ( NULL != pvFrom ) ); // 使用断言
    byte *pbTo = ( byte * )pvTo;     // 防止改变pvTo的地址
    byte *pbFrom = ( byte * )pvFrom; // 防止改变pvFrom的地址
    while( size-- > 0 )
    {
        *pbTo++ = *pbFrom++;
    }
    return pvTo;
}
    在函数的入口处，使用断言检查参数的有效性(合法性)
    在编写函数时，要进行反复的考查，并且自问：“我打算做哪些假定？”，一旦确定了假定，就要使用断言对假定进行检查

6.6 引用于指针的比较
引用的一些规则
(1) 引用被创建的同事必须被初始化(指针则可以在任何时候被初始化)
(2) 不能有NULL引用，引用必须与合法的存储单元关联(指针则可以是NULL)
(3) 一旦引用被初始化，就不能改变引用的关系(指针则可以随时改变所指的对象)
    指针能够毫无约束地操作内存中的任何东西，尽管指针功能强大，但是非常危险。就像一把刀，他可以用来砍树、裁纸、修指甲、理发等等，谁敢这样用？
    如果的确只需要借用一下某个对象的“别名”，那么就用“引用”，而不要用“指针”，以免发生意外。比如说，某人需要一份证明，本来在文件上盖上公章的印子就行了，如果把取公章的钥匙交给他，那么他就获得了不该有的权利。

第七章 内存管理
7.1 内存分配方式
内存的分配方式有三种：
(1) 从静态存储区域分配。内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。例如全局变量，static变量
(2) 在栈上创建。在执行函数时，函数内局部变量存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的执行集中，效率很高，但是分配的内存容量有限
(3) 从堆上分配，亦称动态内存分配。程序在运行的时候用malloc或new申请任意多少的内存，程序员自己负责在何时用free或delete释放内存。动态内存的生存期由我们决定，使用非常灵活，但问题也最多

7.2 常见的内存错误及其对策
(1) 内存分配未成功，却使用了它
    常用的解决办法是，在使用内存之前检查指针是否为NULL。如果指针p是函数的参数，那么在函数的入口处用assert(NULL != p)进行检查。如果是malloc或者new来申请内存，应该用if ( NULL == p )或if ( NULL != p )进行放错处理

(2) 内存分配虽然成功，但是尚未初始化就引用它
    犯这种错误主要有两个原因：一时没有初始化的观念；二是误以为内存的缺省初值全为零，导致引用初值错误(例如数组)
    内存的缺省初值究竟是什么并没有统一的标准，尽管有些时候全为零值，我们宁可信其无不可信其有。所以无论用何种方式创建数组，都别忘了赋初值，即便是赋零值也不可省略，不要嫌麻烦

(3) 释放了内存却继续使用它
    有三种情况：
a、程序中的对象调用关系过于复杂，是在难以搞清楚某个对象究竟是否已经释放了内存。此时应该重新设计数据结构，从根本上解决对象管理的混乱局面
b、函数的return语句写错了，注意不要返回指向“栈内存”的“指针”或者“引用”，因为该内存在函数体结束时被自动销毁
c、使用free或delete释放了内存后，没有将指针设置为NULL。导致产生“野指针”

(4) 用free或delete释放了内存之后，立即将指针设置为NULL，防止产生“野指针”

7.3 指针与数组的对比
(1) 例
char *p = "hello world";
p[ 0 ] = 'X';
cout << p << endl;
指针p指向常量字符串"hello world"(位于静态存储区，内容为hello world\0)，常量字符串的内容是不可以被修改的。从语法上看，编译器并不觉得语句p[ 0 ] = 'X'有什么不妥，但是该语句企图修改常量字符串的内容而导致运行错误

(2) 把数组中的数据赋给指针p
int Length = strlen( a );
char *p = ( char *)malloc( sizeof( char ) * ( len + 1 ) );
strcpy( p, a );
if( 0 == strcmp( p, a ) )
语句p = a并不能把a的内容复制到指针p，而是把a的地址赋给了p。要像复制a的内容，可以先用库函数malloc为p申请一块容量为strlen( a ) + 1个字符的内容，再用strcpy进行字符串复制。同理，语句if( p == a )比较的不是内容而是地址，应该用库函数strcmp来比较
注意：strcpy自动会给字符串的末尾加上\0；memcpy却不会

一个例子:
char str[ 6 ] = "world";
cout << strlen( str ) << endl;
char *p = new char[ strlen( str ) + 1 ];
memcpy( p, str, strlen( str ) + 1 );
cout << p << endl;
cout << strlen( p ) << endl;

另一个例子:
char str[ 6 ] = "world";
cout << strlen( str ) << endl;
char *p = new char[ strlen( str ) + 1 ];
strcpy( p, str );
cout << p << endl;
cout << strlen( p ) << endl;

(3) 计算内存容量
    用运算符sizeof可以计算出数组的容量(字节数)。但是sizeof( p )的值却是4.这是因为sizeof( p )得到的是一个指针变量的字节数，相当于sizeof( char * )，而不是p所指向的内存容量。C/C++语言没有办法知道指针所指的内存容量，除非在申请内存时记住它。
    注意当数组作为函数的参数继续参数传递时，该数组自动退化为同类型的指针，例如
void Func( char a[ 100 ])
{
    cout << sizeof(a ) << endl; // 4字节而不是100字节}
不论数组a的容量是多少，sizeof( a )始终是等于sizeof( char *)

(4) 指针参数是如何传递内存的
    如果函数的参数是一个指针，不要指望用该指针去申请动态内存
void GetMemory( char *p, int num )
{
    p = ( char * )malloc( sizeof( char ) * num );
}
void Test( void )
{
    char *str = { 0 };
    GetMemory( str, 100 );  // str仍然为NULL
    strcpy( str, "hello" ); // 运行错误
}
毛病出在函数GetMemory中。编译器总是要为函数的每个参数制作临时副本，指针参数p的副本是_p，编译器使_p = p。如果函数体内的程序修改了_p的内容，就导致参数p的内容作相应的修改。这就是指针可以用作输出参数的原因。在上面的例子中，_p申请了新的内存，只是_p所指的内存地址改变了，但是p丝毫未变。所以函数GetMemory并不能输出任何东西。事实上，每执行一次GetMemory就会泄露一块内存，因为没有用free释放掉。

    如果非得要用指针参数去申请内存，那么应该改用“指向指针的指针”
void GetMemory( char **p, int num )
{
    *p = ( char * )malloc( sizeof( char ) * num );
}
void Test( void )
{
    char *str = { 0 };
    GetMemory( &str, 100 );
    strcpy( str, "hello" );
    free( str );
}

    由于“指向指针的指针”这个概念不容易理解，我们可以用函数返回值i来传递动态内存。这种方法更加简单：
char *GetMemory( int num )
{
    char *p = ( char * )malloc( sizeof( char ) * num );
    return p;
}
void Test( void )
{
    char *str = { 0 };
    str = GetMemory( 100 );
    strcpy( str, "hello" );
    free( str );
}

    用函数返回值来传递动态内存这种方法虽然好用，但是常常有人把return语句用错了。这里强调不要用return语句返回指向“栈内存”的指针，因为该内存在函数结束时自动消亡：
char *GetString( void )
{
    char p[] = "hello world";
    return p; // 编译器将发出警告
}
void Test( void )
{
    char *str = NULL;
    str = GetString(); // str的内容是垃圾
    cout << str << endl;
}
用调试器逐步跟踪Test，发现执行str = GetString语句后str不再是NULL指针，但是str的内容不是"hello world"而是垃圾。

    如果改成如下：
char *GetString( void )
{
    char *p = "hello world";
    return p; // 编译器将发出警告
}
void Test( void )
{
    char *str = NULL;
    str = GetString(); // str的内容是垃圾
    cout << str << endl;
}
函数Test运行虽然不会出错但是函数GetString的设计概念却是错误的。因为GetString内的"hello world"是常量字符串，位于静态存储区，他在程序生命期内恒定不变。无论什么时候调用GetString，他返回的始终是同一个"只读"的内存块

(5) free和delete把指针怎么啦？
    别看free和delete的名字恶狠狠的(尤其是delete)，他们只是把指针所指的内存给释放掉，但并没有把指针本身干掉
char *p = new char[ 5 ];
strcpy( p, "zeng" );
cout << p << endl;
delete p;
if ( NULL !=  p )
{
 cout << "p is not NULL, p value is：" << p << endl;
}
可以看到在delete之后if ( NULL !=  p )进行放错处理并不起作用，因为即便p不是NULL指针，他也不指向合法的内存块

(6) 动态内存会被自动释放吗？
void Func( void )
{
    char *p = ( char * )malloc( 100 ); // 动态内存会自动释放吗？
}
    当函数Func结束时，指针消亡了，并不表示它所指向的内存会被自动释放；内存被释放了，并不表示指针会消亡或者成了NULL指针。

(7) 杜绝“野指针”
    “野指针”不是NULL指针，是指向“垃圾”内存的指针。“野指针”的成因主要有两种：
a、指针变量没有被初始化。任何贺子珍变量刚被创建时不会自动成为NULL指针，它的缺省值是随机的，它会乱指一气。所以，指针变量在创建的同事应当被初始化，要么将指针设置为NULL，要么让他指向合法的内存。例如：
char *p = NULL;
char *str = ( char * )malloc( 100 );

b、指针p被free或者delete之后，没有被置为NULL，让人误以为p是个合法的指针

c、指针操作超越了变量的作用范围。这种情况让人防不胜防：
class TestA
{
public:
    void Func( void ){ cout << "Func of class TestA" << endl; }
};
void Test( void )
{
    A *p;
    {
        A a;
        p = &a; // 注意a的生命期
    }
    p->Func();  // p是“野指针”
}
函数Test在执行语句p->Func()时面对像a已经消失，而p是指向a的，所以p就成了“野指针”。但是要论编译器而定，留意指针的生命期即可

第八章 C++函数的高级特性
8.1 如果C++程序要调用已经被编译后的C函数，该怎么办？
假设某个C函数的声明如下：
void foo( int x, int y );
该函数被C编译器编译后在库中的名字为_foo，而C++编译器则会产生像_foo_int_int之类的名字用来指出函数重载和类型安全连接。由于编译后的名字不同，C++程序不能直接调用C函数。C++提供了一个C连接交换指定符号extern "C"来解决这个问题。例如：
extern "C"
{
    void foo( int x, int y );
    ... // 其他函数
}
或者写成
extern "C"
{
    #include "myheader.h"
    ... // 其他C头文件
}
这就告诉C++编译器，函数foo是个C连接，应该到库中找名字_foo而不是找_foo_int_int。C++编译器开发商
依旧对C标准库头文件做了extern "C"处理，所以可以用#include直接引用这些头文件

8.2 成员函数的重载、覆盖与隐藏
(1) 重载与覆盖
    成员函数被重载的特征
a、相同的范围(在同一个类中)
b、函数名字相同
c、参数不同
d、virtual关键字可有可无

    覆盖是指派生类函数覆盖基类函数，特征是：
a、不同的范围(分别位于派生类与基类)
b、函数名字相同
c、参数相同
d、积累函数必须有virtual关键字

(2) 令人迷惑的隐藏规则
    本来仅仅区别重载与覆盖并不算困难，但是C++的隐藏规则使问题复杂性突然增加。这里“隐藏”是指派生类的函数屏蔽了与其同名的基类函数，规则如下：
a、如果派生类的函数与基类函数同名，但是参数不同。此时，不论有无virtual关键字，基类的函数将被影藏
b、如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual关键字。此时，基类的函数被隐藏
#include <iostream>
class Base
{
public:
    virtual void f( float x ){ cout << "Base::f( float ) " << endl; }
            void g( float x ){ cout << "Base::g( float ) " << endl; }
            void h( float x ){ cout << "Base::h( float ) " << endl; }
};
class Derived : public Base
{
public:
    virtual void f( float x ){ cout << "Derived::f( float ) " << endl; }
            void g( int x ){ cout << "Derived::g( float ) " << endl; }
            void h( float x ){ cout << "Derived::h( float ) " << endl; }
};
void main( void )
{
    Derived d;
    Base *pb = &d;
    Derived  *pd = &d;

    pb->f( 3.14f ); // Derived::f( float ) 3.14
    pd->f( 3.14f ); // Derived::f( float ) 3.14

    pb->g( 3.14f ); // Base::g( float ) 3.14
    pd->g( 3.14f ); // Derived::g( int ) 3

    pb->h( 3.14f ); // Base::h( float ) 3.14
    pd->h( 3.14f ); // Derived::h( int ) 3
}

函数Derived::f( float )覆盖了Base::f( float )
函数Derived::g( float )隐藏了Base::g( float )，而不是重载
函数Derived::h( float )隐藏了Base::h( float )，而不是覆盖
根据类的virtual很容易就能判断出来

(3) 摆脱隐藏
    隐藏规则引起来不少麻烦
class Base
{
public:
    void f( int x );
};
class Derived : public Base
{
public:
    void f( char *str );
};
void Test( void )
{
    Derived *pd = new Derived;
    pd->f( 10 ); // error
}
语句pd->f( 10 )的本意是想调用函数Base::f( int )，但是Base::f( int )不行被Derived::f( char * )隐藏了。由于数字10不能被隐式地转化为字符串，所以在编译时出错。
    隐藏规则至少有两个存在的理由：
a、写语句pd->f( 10 )的人可能真的想调用Derived::f( char * )函数，只是他误将函数参数写错了。有了隐藏规则，编译器就可以明确指出错误，这未必不是好事。否则，编译器会静悄悄地将错就错，程序员将很难发现这个错误，留下祸根。
b、加入类Derived有多个基类(多重继承)，有时搞不清楚哪些基类定义了函数f。如果没有隐藏规则，那么pd->f( 10 )可能会调用一个出乎意料的基类函数f，尽管隐藏规则看起来不怎么有道理，但它的确能消灭这些意外

如果要调用基类的函数，需要使用域操作符Base::f( int );

8.3 参数的缺省值
    参数缺省值的使用规则：
(1) 参数缺省值只能出现在函数的声明中，而不能出现在定义体重。例如：
void Foo( int x = 0, int y = 0 ); // 正确，缺省值出现在函数的声明中
void Foo( int x = 0, int y = 0 )  // 错误，缺省值出现在函数的定义体重
{
    ...
}
可能的原因：
一、函数的实现(定义)本来就与参数是否有缺省值无关，所以没有必要让缺省值出现在函数的定义体重
二、参数的缺省值可能会改动，显然修改函数的声明比修改函数的定义要方便

8.4 不能被重载的运算符
    在C++运算符集合中，有一些运算符是不允许被重载的。这种限制是出于安全方面的考虑，可防止错误和混乱
(1) 不能改变C++内部数据类型(如int、float等)的运算符
(2) 不能重载'.'，因为'.'在类中对任何成员都有意义，已成成为标准用法
(3) 不能重载目前C++运算符集合中没有的符号，如#、@、$等。原因有两点，一时难以理解，而是难以确定优先级
(4) 对已存在的运算符进行重载时，不能改变优先级规则，否则将引起混乱

8.5 内联函数
    对于任何内联函数，编译器在符号表里放入函数的声明(包括名字、参数类型、返回值)。如果编译器没有发现内联函数存在错误，那么该函数的代码也被放入符号表里。在调用一个内联函数时，编译器首先检查调用是否正确(进行类型安全检查，或者进行自动类型串行，当然对所有的函数都一样)。如果正确，内联函数的代码就会直接替换函数调用，于是省去了函数调用的开销。这个过程与预处理有显著的不同，因为预处理器不能进行类型安全检查，或者进行自动类型转换。加入内联函数是成员函数，对象的地址(this)会被放在合适的地方，这也是预处理器办不到

(1) inline是一种“用于实现的关键字”，而不是一种“用于声明的关键字”。
(1) 慎用内联内联能提供函数的执行效率，但是内联是以代码膨胀(复制)为代价，仅仅省去了函数调用的开销，从而提高函数的执行效率。如果执行函数体内代码的时间，相比于函数调用的开销较大，那么效率的收获会很少。另一方面，每一次内联函数的的调用都要复制代码，将使程序的总代码量增大，消耗更多的内存空间。以下情况不宜使用内联：
a、如果函数体内的代码比较长，使用内联将导致内存消耗代价较高
b、如果函数体内出现循环，那么执行函数体内代码的时机要比函数调用的开销大