读书笔记－高质量C++&C编程指南

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 在函数结束时被销毁（调用析构函数）。然而“创建一个临时对象并返回它”的过程是不同的，编译器直接把临时对象创建并初始化在外部存储单元中，省去了拷贝和析构的化费，提高了效率。
3）尽量避免函数带有“记忆”功能。相同的输入应当产生相同的输出。
4）使用断言捕捉不应该发生的非法情况。不要混淆非法情况与错误情况之间的区别，后者是必然存在的并且是一定要作出处理的。
5）在函数的入口处，使用断言检查参数的有效性（合法性）。
6）在编写函数时，要进行反复的考查，并且自问：“我打算做哪些假定？”。一旦确定了的假定，就要使用断言对假定进行检查。
7）引用和指针的区别
（1）引用被创建的同时必须被初始化（指针则可以在任何时候被初始化）。
（2）不能有NULL 引用，引用必须与合法的存储单元关联（指针则可以是NULL）。
（3）一旦引用被初始化，就不能改变引用的关系（指针则可以随时改变所指的对象）。
    以下示例程序中，k 被初始化为i 的引用。语句k = j 并不能将k 修改成为j 的引用，只是把k 的值改变成为6。由于k 是i 的引用，所以i 的值也变成了6。
    int i = 5;
    int j = 6;
    int &k = i;
    k = j; // k 和i 的值都变成了6;
8）“引用”可以做的任何事情“指针”也都能够做，为什么还要“引用”这东西？
答案是“用适当的工具做恰如其分的工作”。指针能够毫无约束地操作内存中的如何东西，尽管指针功能强大，但是非常危险。就象一把刀，它可以用来砍树、裁纸、修指甲、理发等等，谁敢这样用？
如果的确只需要借用一下某个对象的“别名”，那么就用“引用”，而不要用“指针”，以免发生意外。比如说，某人需要一份证明，本来在文件上盖上公章的印子就行了，如果把取公章的钥匙交给他，那么他就获得了不该有的权利。
9）内存分配方式有三种：
（1） 从静态存储区域分配。内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。例如全局变量，static 变量。
（2） 在栈上创建。在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。
（3） 从堆上分配，亦称动态内存分配。程序在运行的时候用malloc 或new 申请任意多少的内存，程序员自己负责在何时用free 或delete 释放内存。动态内存的生存期由我们决定，使用非常灵活，但问题也最多。
10）常见的内存错误及其对策如下：
     （1）内存分配未成功，却使用了它。编程新手常犯这种错误，因为他们没有意识到内存分配会不成功。常用解决办法是，在使用内存之前检查指针是否为 NULL。如果指针p 是函数的参数，那么在函数的入口处用assert(p!=NULL)进行检查。如果是用malloc 或new 来申请内存，应该用if(p==NULL)或if(p!=NULL)进行防错处理。
    （2）内存分配虽然成功，但是尚未初始化就引用它。犯这种错误主要有两个起因：一是没有初始化的观念；二是误以为内存的缺省初值全为零，导致引用初值错误（例如数组）。内存的缺省初值究竟是什么并没有统一的标准，尽管有些时候为零值，我们宁可信其无不可信其有。所以无论用何种方式创建数组，都别忘了赋初值，即便是赋零值也不可省略，不要嫌麻烦。
    （3）内存分配成功并且已经初始化，但操作越过了内存的边界。例如在使用数组时经常发生下标“多1”或者“少1”的操作。特别是在for 循环语句中，循环次数很容易搞错，导致数组操作越界。
    （4）忘记了释放内存，造成内存泄露。含有这种错误的函数每被调用一次就丢失一块内存。刚开始时系统的内存充足，你看不到错误。终有一次程序突然死掉，系统出现提示：内存耗尽。动态内存的申请与释放必须配对，程序中malloc 与free 的使用次数一定要相同，否则肯定有错误（new/delete 同理）。
    （5）释放了内存却继续使用它。有三种情况：1）程序中的对象调用关系过于复杂，实在难以搞清楚某个对象究竟是否已经释放了内存，此时应该重新设计数据结构，从根本上解决对象管理的混乱局面。2）函数的return 语句写错了，注意不要返回指向“栈内存”的“指针”或者“引用”，因为该内存在函数体结束时被自动销毁。3）使用free 或delete 释放了内存后，没有将指针设置为NULL。导致产生“野指针”。
11）指针与数组的对比
（1）修改内容
char a[] = “hello”;
a[0] = ‘X’;
cout << a << endl;
char *p = “world”; // 注意p 指向常量字符串
p[0] = ‘X’; // 编译器不能发现该错误
cout << p << endl;
（2）内容复制与比较
// 数组…
char a[] = "hello";
char b[10];
strcpy(b, a); // 不能用 b = a;
if(strcmp(b, a) == 0) // 不能用 if (b == a)
…
// 指针…
int len = strlen(a);
char *p = (char *)malloc(sizeof(char)*(len+1));
strcpy(p,a); // 不要用 p = a;
if(strcmp(p, a) == 0) // 不要用 if (p == a)
（3）计算内存容量
char a[] = "hello world";
char *p = a;
cout<< sizeof(a) << endl; // 12 字节
cout<< sizeof(p) << endl; // 4 字节
sizeof(a)的值是12（注意别忘了’\0’）。指针p 指向a，但是sizeof(p)的值却是4。这是因为sizeof(p)得到的是一个指针变量的字节数，相当于sizeof(char*)，而不是p 所指的内存容量
void Func(char a[100])
{
    cout<< sizeof(a) << endl; // 4 字节而不是100 字节
}
当数组作为函数的参数进行传递时，该数组自动退化为同类型的指针
12）指针参数是如何传递内存的？
void GetMemory(char *p, int num)
{
    p = (char *)malloc(sizeof(char) * num);
}
void Test(void)
{
    char *str = NULL;
    GetMemory(str, 100); // str 仍然为 NULL
    strcpy(str, "hello"); // 运行错误
}
毛病出在函数GetMemory 中。编译器总是要为函数的每个参数制作临时副本，指针参数p 的副本是 _p，编译器使 _p = p。如果函数体内的程序修改了_p 的内容，就导致参数p 的内容作相应的修改。这就是指针可以用作输出参数的原因。在本例中，_p 申请了新的内存，只是把_p 所指的内存地址改变了，但是p 丝毫未变。所以函数GetMemory并不能输出任何东西。事实上，每执行一次GetMemory 就会泄露一块内存，因为没有用free 释放内存。如果非得要用指针参数去申请内存，那么应该改用“指向指针的指针”
void GetMemory2(char **p, int num)
{
    *p = (char *)malloc(sizeof(char) * num);
}
void Test2(void)
{
    char *str = NULL;
    GetMemory2(&str, 100); // 注意参数是 &str，而不是str
    strcpy(str, "hello");
    cout<< str << endl;
    free(str);
}
由于“指向指针的指针”这个概念不容易理解，可以用函数返回值来传递动态内存。这种方法更加简单
char *GetMemory3(int num)
{
    char *p = (char *)malloc(sizeof(char) * num);
    return p;
}
void Test3(void)
{
    char *str = NULL;
    str = GetMemory3(100);
    strcpy(str, "hello");
    cout<< str << endl;
    free(str);
}
13）free 和delete只是把指针所指的内存给释放掉，但并没有把指针本身干掉
char *p = (char *) malloc(100);
strcpy(p, “hello”);
free(p); // p 所指的内存被释放，但是p 所指的地址仍然不变
…
if(p != NULL) // 没有起到防错作用
{
    strcpy(p, “world”); // 出错
}
p 被free 以后其地址仍然不变（非NULL），只是该地址对应的内存是垃圾，p 成了“野指针”。如果此时不把p 设置为NULL，会让人误以为p 是个合法的指针。
14）指针和内存的关系
（1）指针消亡了，并不表示它所指的内存会被自动释放。
void Func(void)
{
    char *p = (char *) malloc(100); // p会消亡，但动态内存不会
}
（2）内存被释放了，并不表示指针会消亡或者成了NULL 指针。如上提到的free
15）杜绝“野指针”
“野指针”不是NULL 指针，是指向“垃圾”内存的指针。人们一般不会错用NULL指针，因为用if 语句很容易判断。但是“野指针”是很危险的，if 语句对它不起作用。“野指针”的成因主要有两种：
（1）指针变量没有被初始化。
（2）指针p 被free 或者delete 之后，没有置为NULL，让人误以为p 是个合法的指针。
（3）指针操作超越了变量的作用范围
16）有了malloc/free 为什么还要new/delete ？
malloc 与free 是C++/C 语言的标准库函数，new/delete 是C++的运算符，对于非内部数据类型的对象而言，光用maloc/free 无法满足动态对象的要求。对象在创建的同时要自动执行构造函数， 对象在消亡之前要自动执行析构函数。由于malloc/free 是库函数而不是运算符，不在编译器控制权限之内，不能够把执行构造函数和析构函数的任务强加于malloc/free。
class Obj
{
    public :
    Obj(void){ cout << “Initialization” << endl; }
    ~Obj(void){ cout << “Destroy” << endl; }
    void Initialize(void){ cout << “Initialization” << endl; }
    void Destroy(void){ cout << “Destroy” << endl; }
};
void UseMallocFree(void)
{
    Obj *a = (obj *)malloc(sizeof(obj)); // 申请动态内存
    a->Initialize(); // 初始化
    //…
    a->Destroy(); // 清除工作
    free(a); // 释放内存
}
void UseNewDelete(void)
{
    Obj *a = new Obj; // 申请动态内存并且初始化
    //…
    delete a; // 清除并且释放内存
}
类Obj 的函数Initialize 模拟了构造函数的功能，函数Destroy 模拟了析构函数的功能。函数UseMallocFree 中，由于malloc/free 不能执行构造函数与析构函数，必须调用成员函数Initialize 和Destroy 来完成初始化与清除工作。函数UseNewDelete 则简单得多
17）内存耗尽怎么办？
（1）判断指针是否为NULL，如果是则马上用return 语句终止本函数。
（2）判断指针是否为NULL，如果是则马上用exit(1)终止整个程序的运行。
（3）为new 和malloc 设置异常处理函数。
对于32 位以上的应用程序而言，无论怎样使用malloc 与new，几乎不可能导致“内存耗尽”，因为32 位操作系统支持“虚存”，内存用完了，自动用硬盘空间顶替。
18）当心隐式类型转换导致重载函数产生二义性
# include <iostream.h>
void output( int x); // 函数声明
void output( float x); // 函数声明
void output( int x)
{
    cout << " output int " << x << endl ;
}
void output( float x)
{
    cout << " output float " << x << endl ;
}
void main(void)
{
    int x = 1;
    float y = 1.0;
    output(x); // output int 1
    output(y); // output float 1
    output(1); // output int 1
    // output(0.5); // error! ambiguous call, 因为自动类型转换
    output(int(0.5)); // output int 0
    output(float(0.5)); // output float 0.5
}
19）重载与覆盖
成员函数被重载的特征：
（1）相同的范围（在同一个类中）；
（2）函数名字相同；
（3）参数不同；
（4）virtual 关键字可有可无。
覆盖是指派生类函数覆盖基类函数，特征是：
（1）不同的范围（分别位于派生类与基类）；
（2）函数名字相同；
（3）参数相同；
（4）基类函数必须有virtual 关键字。
20）令人迷惑的隐藏规则
（1）如果派生类的函数与基类的函数同名，但是参数不同。此时，不论有无virtual关键字，基类的函数将被隐藏（注意别与重载混淆）。
（2）如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual关键字。此时，基类的函数被隐藏（注意别与覆盖混淆）。
#include <iostream.h>
class Base
{
    public:
    virtual void f(float x){ cout << "Base::f(float) " << x << endl; }
    void g(float x){ cout << "Base::g(float) " << x << endl; }
    void h(float x){ cout << "Base::h(float) " << x << endl; }
};
class Derived : public Base
{   
    public:
    virtual void f(float x){ cout << "Derived::f(float) " << x << endl; }
    void g(int x){ cout << "Derived::g(int) " << x << endl; }
    void h(float x){ cout << "Derived::h(float) " << x << endl; }
};
（1）函数Derived::f(float)覆盖了Base::f(float)。
（2）函数Derived::g(int)隐藏了Base::g(float)，而不是重载。
（3）函数Derived::h(float)隐藏了Base::h(float)，而不是覆盖。
void main(void)
{
    Derived d;
    Base *pb = &d;
    Derived *pd = &d;
    // Good : behavior depends solely on type of the object
    pb->f(3.14f); // Derived::f(float) 3.14
    pd->f(3.14f); // Derived::f(float) 3.14
    // Bad : behavior depends on type of the pointer
    pb->g(3.14f); // Base::g(float) 3.14
    pd->g(3.14f); // Derived::g(int) 3 (surprise!)
    // Bad : behavior depends on type of the pointer
    pb->h(3.14f); // Base::h(float) 3.14 (surprise!)
    pd->h(3.14f); // Derived::h(float) 3.14
}
21）参数的缺省值
（1）参数缺省值只能出现在函数的声明中，而不能出现在定义体中。例如：
void Foo(int x=0, int y=0); // 正确，缺省值出现在函数的声明中
void Foo(int x=0, int y=0) // 错误，缺省值出现在函数的定义体中
{
⋯
}
（2）如果函数有多个参数，参数只能从后向前挨个儿缺省
正确的示例如下：
void Foo(int x, int y=0, int z=0);
错误的示例如下：
void Foo(int x=0, int y, int z=0);
（3）不合理地使用参数的缺省值将导致重载函数output 产生二义性。
#include <iostream.h>
void output( int x);
void output( int x, float y=0.0);
void output( int x)
{
    cout << " output int " << x << endl ;
}
void output( int x, float y)
{
    cout << " output int " << x << " and float " << y << endl ;
}
void main(void)
{
    int x=1;
    float y=0.5;
    // output(x); // error! ambiguous call
    output(x,y); // output int 1 and float 0.5
}
22）重载函数的建议
（1）所有的一元运算符，建议重载为成员函数
（2）= () [] -> ，只能重载为成员函数
（3）+= -= /= *= &= |= ~= %= >>= <<= ，建议重载为成员函数
（4）所有其它运算符 ，建议重载为全局函数
23）不能被重载的运算符
（1）不能改变C++内部数据类型（如int,float 等）的运算符。
（2）不能重载‘.’，因为‘.’在类中对任何成员都有意义，已经成为标准用法。
（3）不能重载目前C++运算符集合中没有的符号，如#,@,$等。原因有两点，一是难以理解，二是难以确定优先级。
（4）对已经存在的运算符进行重载时，不能改变优先级规则，否则将引起混乱。
24）内联函数的机制
对于任何内联函数，编译器在符号表里放入函数的声明（包括名字、参数类型、返回值类型）。如果编译器没有发现内联函数存在错误，那么该函数的代码也被放入符号表里。在调用一个内联函数时，编译器首先检查调用是否正确（进行类型安全检查，或者进行自动类型转换，当然对所有的函数都一样）。如果正确，内联函数的代码就会直接替换函数调用，于是省去了函数调用的开销。这个过程与预处理有显著的不同，因为预处理器不能进行类型安全检查，或者进行自动类型转换。假如内联函数是成员函数，对象的地址（this）会被放在合适的地方，这也是预处理器办不到的。
25）内联函数的编程风格
（1）关键字inline 必须与函数定义体放在一起才能使函数成为内联，仅将inline 放在函数声明前面不起任何作用。如下风格的函数Foo 不能成为内联函数：
inline void Foo(int x, int y); // inline 仅与函数声明放在一起
void Foo(int x, int y)
{
⋯
}
而如下风格的函数Foo 则成为内联函数：
void Foo(int x, int y);
inline void Foo(int x, int y) // inline 与函数定义体放在一起
{
⋯
}
（2）定义在类声明之中的成员函数将自动地成为内联函数，例如
class A
{
public:
    void Foo(int x, int y) { ⋯ } // 自动地成为内联函数
}
将成员函数的定义体放在类声明之中虽然能带来书写上的方便，但不是一种良好的编程风格，上例应该改成：
// 头文件
class A
{
    public:
    void Foo(int x, int y)；
}
// 定义文件
inline void A::Foo(int x, int y)
{
    ⋯
}
26）慎用内联
内联是以代码膨胀（复制）为代价，仅仅省去了函数调用的开销，从而提高函数的执行效率。如果执行函数体内代码的时间，相比于函数调用的开销较大，那么效率的收获会很少。另一方面，每一处内联函数的调用都要复制代码，将使程序的总代码量增大，消耗更多的内存空间。以下情况不宜使用内联：
（1）如果函数体内的代码比较长，使用内联将导致内存消耗代价较高。
（2）如果函数体内出现循环，那么执行函数体内代码的时间要比函数调用的开销大。
27）拷贝构造函数与赋值函数
（1），如果不主动编写拷贝构造函数和赋值函数，编译器将以“位拷贝”的方式自动生成缺省的函数。倘若类中含有指针变量，那么这两个缺省的函数就隐含了错误。以类 String 的两个对象a,b 为例，假设a.m_data 的内容为“hello”，b.m_data 的内容为“world”。现将a 赋给b，缺省赋值函数的“位拷贝”意味着执行b.m_data =a.m_data。这将造成三个错误：一是b.m_data 原有的内存没被释放，造成内存泄露；二是b.m_data 和a.m_data 指向同一块内存，a 或b 任何一方变动都会影响另一方；三是在对象被析构时，m_data 被释放了两次。
（2）拷贝构造函数是在对象被创建时调用的，而赋值函数只能被已经存在了的对象调用。
String a(“hello”);
String b(“world”);
String c = a; // 调用了拷贝构造函数，最好写成 c(a);
c = b; // 调用了赋值函数
28）如何在派生类中实现类的基本函数
（1）派生类的构造函数应在其初始化表里调用基类的构造函数
（2）基类与派生类的析构函数应该为虚（即加virtual 关键字）。例如
#include <iostream.h>
class Base
{
    public:
    virtual ~Base() { cout<< "~Base" << endl ; }
};
class Derived : public Base
{
    public:
    virtual ~Derived() { cout<< "~Derived" << endl ; }
};
void main(void)
{
    Base * pB = new Derived; // upcast
    delete pB;
}
输出结果为：
~Derived
~Base
如果析构函数不为虚，那么输出结果为
~Base
（3）在编写派生类的赋值函数时，注意不要忘记对基类的数据成员重新赋值。例如：
class Base
{
    public:
    …
    Base & operate =(const Base &other); // 类Base 的赋值函数
    private:
    int m_i, m_j, m_k;
};
class Derived : public Base
{
    public:
    …
    Derived & operate =(const Derived &other); // 类Derived 的赋值函数
    private:
    int m_x, m_y, m_z;
};
Derived & Derived::operate =(const Derived &other)
{
    //（1）检查自赋值
    if(this == &other)
    return *this;
    //（2）对基类的数据成员重新赋值
    Base::operate =(other); // 因为不能直接操作私有数据成员
    //（3）对派生类的数据成员赋值
    m_x = other.m_x;
    m_y = other.m_y;
    m_z = other.m_z;
    //（4）返回本对象的引用
    return *this;
}
29）用const 修饰函数的参数
（1）如果输入参数采用“指针传递”，那么加const 修饰可以防止意外地改动该指针，起到保护作用。例如StringCopy 函数：
void StringCopy(char *strDestination, const char *strSource);其中strSource 是输入参数，strDestination 是输出参数。给strSource 加上const修饰后，如果函数体内的语句试图改动strSource 的内容，编译器将指出错误。
（2）如果输入参数采用“值传递”，由于函数将自动产生临时变量用于复制该参数，该输入参数本来就无需保护，所以不要加const 修饰。
（3）对于非内部数据类型的参数而言，象void Func(A a) 这样声明的函数注定效率比较底。因为函数体内将产生A 类型的临时对象用于复制参数a，而临时对象的构造、
复制、析构过程都将消耗时间。为了提高效率，可以将函数声明改为void Func(A &a)，因为“引用传递”仅借用一下参数的别名而已，不需要产生临时对象。但是函数void Func(A &a) 存在一个缺点：“引用传递”有可能改变参数a，这是我们不期望的。解决这个问题很容易，加const修饰即可，因此函数最终成为void Func(const A &a)。
30）用const 修饰函数的返回值
1）如果给以“指针传递”方式的函数返回值加const 修饰，那么函数返回值（即指针）的内容不能被修改，该返回值只能被赋给加const 修饰的同类型指针。例如函数
const char * GetString(void);
如下语句将出现编译错误：
char *str = GetString();
正确的用法是
const char *str = GetString();
2）如果函数返回值采用“值传递方式”，由于函数会把返回值复制到外部临时的存储单元中，加const 修饰没有任何价值。
31）关于效率
（1）不要一味地追求程序的效率，应当在满足正确性、可靠性、健壮性、可读性等质量因素的前提下，设法提高程序的效率。
（2）以提高程序的全局效率为主，提高局部效率为辅。
（3）在优化程序的效率时，应当先找出限制效率的“瓶颈”，不要在无关紧要之处优化。
（4）先优化数据结构和算法，再优化执行代码。
32）其他建议
（1）当心那些视觉上不易分辨的操作符发生书写错误。我们经常会把“＝＝”误写成“＝”，象“||”、“&&”、“<=”、“>=”这类符号也很容易发生“丢1”失误。然而编译器却不一定能自动指出这类错误。
（2）变量（指针、数组）被创建之后应当及时把它们初始化，以防止把未被初始化的变量当成右值使用。
（3）当心忘记编写错误处理程序，当心错误处理程序本身有误。
（4）避免编写技巧性很高代码。
（5）尽量不要使用与具体硬件或软件环境关系密切的变量。