高质量C/C++编程指南总结（八）—— C++高级特性

1. 成员函数重载特征

• 相同的范围（在同一个类中）
• 函数名称相同
• 参数不同
• virtual 关键字可有可无

2. 覆盖的特征

• 覆盖是指派生类函数覆盖基类函数，所以范围不同（分别位于派生类和基类）
• 函数名称相同
• 参数相同
• 基类函数必须有 virtual 关键字

        如下示例中，函数 Base::f（int）与 Base::f（float）相互重载，而 Base::g（void）被 Derived::g（void）覆盖。

#include <iostream.h>
class Base
{
public:
    void f(int x){ cout << "Base::f(int) " << x << endl; }
    void f(float x){ cout << "Base::f(float) " << x << endl; }
    virtual void g(void){ cout << "Base::g(void)" << endl;}
};

class Derived : public Base
{
public:
    virtual void g(void){ cout << "Derived::g(void)" << endl;}
};

void main(void)
{
    Derived d;
    Base *pb = &d;
    pb->f(42); // Base::f(int) 42
    pb->f(3.14f); // Base::f(float) 3.14
    pb->g(); // Derived::g(void)
}

3. 隐藏规则

• 如果派生类的函数与基类函数同名，但是参数不同。此时，无论有无 virtual 关键字，基类的函数都被隐藏。（主要与重载的区别，重载要在同一个类中）
• 如果派生类的函数与基类函数同名，并且参数也相同，但是基类函数没有 virtual 关键字。此时，基类的函数被隐藏。（注意与覆盖的区别，覆盖有 virtual 关键字）

如下示例中：

• 函数 Derived::f(float)覆盖了 Base::f(float)。
• 函数 Derived::g(int)隐藏了 Base::g(float)，而不是重载。
• 函数 Derived::h(float)隐藏了 Base::h(float)，而不是覆盖。

#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; }
};

4. 参数的缺省值

• 参数缺省值只能出现在函数的声明中，而不能出现在定义体中。
• 如果函数有多个参数，参数只能从后向前挨个儿缺省。
• 不合理地使用参数的缺省值将导致重载函数产生二义性。

5. 不能被重载的运算符

• 不能改变 C++内部数据类型（如 int,float 等）的运算符。
• 不能重载‘ .’，因为‘ .’在类中对任何成员都有意义，已经成为标准用法。
• 不能重载目前 C++运算符集合中没有的符号，如#,@,$等。原因有两点，一是难以
  理解，二是难以确定优先级。
• 对已经存在的运算符进行重载时，不能改变优先级规则，否则将引起混乱。

6. 函数内联

1）内联的工作过程：

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

2）内联函数的编程风格

• 关键字 inline 必须与函数定义体放在一起才能使函数成为内联，仅将 inline 放在函数声明前面不起任何作用。
• 定义在类声明之中的成员函数将自动地成为内联函数。

3）内联的注意事项

• •  内联是以代码膨胀（复制）为代价，仅仅省去了函数调用的开销，从而提高函数的执行效率。如果执行函数体内代码的时间，相比于函数调用的开销较大，那么效率的收获会很少。另一方面，每一处内联函数的调用都要复制代码，将使程序的总代码量增大，消耗更多的内存空间。
  • 以下情况不宜使用内联：
    （ 1）如果函数体内的代码比较长，使用内联将导致内存消耗代价较高。
    （ 2）如果函数体内出现循环，那么执行函数体内代码的时间要比函数调用的开销大。
  • 类的构造函数和析构函数容易让人误解成使用内联更有效。要当心构造函数和析构函数可能会隐藏一些行为，如“偷偷地”执行了基类或成员对象的构造函数和析构函数。所以不要随便地将构造函数和析构函数的定义体放在类声明中。