c++ advanced features – beantech

C++ 函数高级特征

重载（overload）、内联（inline）、const 和virtual是C++独有而C不具有的四种机制。其中重载和内联机制既可用于全局函数也可用于类的成员函数，const 与virtual机制仅用于类的成员函数。重载和内联是一把双刃剑，用的好可以提高效率，精简程序；而一味滥用也会影响程序的效果。这里根据笔试面试中常碰到的问题，探究一下重载和内联的优点与局限性，说明应该不应该使用的场景。

1. 函数重载

1.1 重载的定义和意义
在C++程序中，可以将语义、功能相似的同名函数（参数不同），即函数重载，如下程序所示。使用重载的两个理由：这样便于记忆，提高函数易用性；类的构造函数需要重载机制，因为C++规定构造函数与类同名，构造函数只能有一个名字，但有时候我们需要几种方法构造对象。

1
2
3

void (Beef …);     
void (Fish …);     // 吃鱼肉
void (Chicken …);  // 吃鸡肉

1.2 重载的实现方法
只能靠参数而不能靠返回值类型的不同来区分重载函数。编译器根据参数为每个重载函数产生不同的内部标识符。例如编译器为上节中的三个Eat函数产生象_eat_beef、eat_fish、_eat_chicken之类的内部标识符（不同的编译器可能产生不同风格的内部标识符）。

常见的笔试面试题了：如果C++程序要调用已经被编译后的C函数，该怎么办？

C++程序不能直接调用已编译后的C函数的，这是因为名称问题，举个例，一个函数叫做void foo(int x, int y)，该函数被C编译器编译后在库中的名字为_foo，而C++编译器则会产生像_foo_int_int之类的名字用来支持函数重载和类型安全连接，名称就不一样，因此不能直接调用的。那要调用的话怎么办呢？

C++提供了一个C连接交换指定符号extern“C”来解决这个问题。

1
2
3
4
5

extern “C”
{
void foo(int x, int y);
... // other functions
}

Or

1
2
3
4
5

extern “C”
{
... // other C header files
}

这就告诉C++编译译器，函数foo 是个C连接，应该到库中找名字_foo而不是找_foo_int_int。C++编译器开发商已经对C标准库的头文件作了extern“C”处理，所以我们可以用＃include 直接引用这些头文件。
这里还需要注意一点：并不是两个函数的名字相同就能构成重载。全局函数和类的成员函数同名不算重载，因为函数的作用域不同。例如：

1
2
3
4
5
6

void Print();      // 全局函数
class A
{
    ...
    void Print();  // 成员函数
};

不论两个Print 函数的参数是否不同，如果类的某个成员函数要调用全局函数Print，为了与成员函数Print区别，全局函数被调用时应加‘::’标志。如

::Print(…); // 表示Print是全局函数而非成员函数

2. 成员函数重载（Overload）、覆盖（Override）和隐藏（hide）

2.1. 关于重载和覆盖
成员函数被重载特征：
（1）相同的范围，即同一个类中
（2）函数名字相同（同名）
（3）参数不同（异参）
（4）virtual关键字可有可无
覆盖指派生类成员函数覆盖基类函数，特征：
（1）不同的范围，分别位于基类和派生类
（2）函数名字相同（同名）
（3）参数相同（同参）
（4）基类函数必须有_virtual_关键字

如下例中，函数Base::foo(int)与Base::foo(float)相互重载，而Base::goo(void)被Derived::goo(void)覆盖。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

class Base 
{ 
public: 
    void foo(int x)
    {
        cout << "Base::foo(int) " << x << endl;
    }
    void foo(float x)
    {
        cout << "Base::foo(float) " << x << endl;
    }
    virtual void goo(void)
    {
        cout << "Base::goo(void)" << endl;
    } 
};
class Derived : public Base 
{
public: 
    virtual void goo(void)
    {
        cout << "Derived::goo(void)" << endl;
    } 
};
void main(void) 
{ 
    Derived d;
    Base *pb = &d;
    pb -> foo(42);     // Base::foo(int) 42 
    pb -> foo(3.14f);  // Base::foo(float) 3.14 
    pb -> goo();       // Derived::goo(void) 
}

2.2 令人迷惑的隐藏规则
本来仅仅区别重载与覆盖并不算困难，但是C++的隐藏规则使问题复杂性陡然增加。
这里“隐藏”是指派生类的函数屏蔽了与其同名的基类函数，规则如下：
（1）如果派生类的函数与基类的函数同名，但是参数不同。此时，不论有无virtual关键字，基类的函数将被隐藏（注意别与重载混淆）。解析：注意是比较基类和派生类的函数，不是在同一个类中，所以不是重载。
（2）如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual关键字。此时，基类的函数被隐藏。自己的理解，当我们用派生类指针指向一个派生类对象时，派生类指针想调用基类和派生类中难以区别的同名同参无virtual关键字的方法，那这时就应用隐藏的规则，派生类的方法将基类的方法隐藏了；但是如果是一个基类的指针指向派生类的对象，那么这时应该运用虚函数表去理解调用的是哪个方法。（注意别与覆盖混淆，覆盖的特征是基类函数必须有virtual关键字）。

如下面要给出的例子中：
（1）函数 Derived::foo(float) 覆盖了 Base::foo(float)。
（2）函数 Derived::goo(int) 隐藏了 Base::goo(float)，而不是重载。
（3）函数 Derived::hoo(float) 隐藏了 Base::hoo(float)，而不是覆盖。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

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

练习，下例的输出结果应该是：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

void main(void) 
{ 
    Derived d; 
    Base *pb = &d; 
    Derived *pd = &d; 
    // Good : behavior depends solely on type of the object 
    pb -> foo(3.14f);
    pd -> foo(3.14f);
    
    // Bad : behavior depends on type of the pointer 
    pb -> goo(3.14f);
    pd -> goo(3.14f);  // (surprise!) 
    
    // Bad : behavior depends on type of the pointer 
    pb -> hoo(3.14f);  // (surprise!) 
    pd -> hoo(3.14f);
}

输出结果：

1
2
3
4
5
6
7

Derived::foo(float) 3.14
Derived::foo(float) 3.14
Base::goo(float) 3.14
Derived::goo(int) 3
Base::hoo(float) 3.14
Derived::hoo(float) 3.14
Program ended with exit code: 0

3. 关于函数参数的缺省值

对于函数的缺省值，建议大家遵照以下一些规则：
3.1 参数缺省值只能出现在函数的声明中，而不能出现在定义体中
例如：

1
2
3
4
5

void foo(int x = 0, int y = 0);  // Right
void foo(int x = 0, int y = 0)   // Error
{
    statement
}

3.2 如果函数有多个参数，参数只能从后向前挨个儿缺省
正确的示例：

1

void foo(int x, int y=0, int z=0);

错误的示例：

1

void foo(int x = 0, int y, int z = 0);

要注意，使用参数的缺省值并没有赋予函数新的功能，仅仅是使书写变得简洁一些。它可能会提高函数的易用性，但是也可能会降低函数的可理解性。所以我们只能适当地使用参数的缺省值，要防止使用不当产生负面效果。下例中，不合理地使用参数的缺省值将导致重载函数Print产生二义性。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

void Print(int x);
void Print(int x, float y = 0.0);
void Print(int x)
{
    cout << " output int " << x << endl ;
}
void Print(int x, float y)
{
    cout << " output int " << x << " and float " << y << endl ;
}
void main(void)
{
    int x = 1;
    float y = 0.5;
    // Print(x);     // error! ambiguous call
    Print(x,y);      // output int 1 and float 0.5
}

4. 关于运算符重载

4.1 概念和定义
在C++语言中，可以用关键字operator加上运算符来表示函数，叫做运算符重载。运算符与普通函数在调用时的不同之处是：对于普通函数，参数出现在圆括号内；而对于运算符，参数出现在其左、右侧。

1
2
3
4
5
6
7

Complex Add(const Complex &a, const Complex &b);
Complex operator+(const Complex &a, const Complex &b);
Complex a, b, c;
...
c = Add(a, b);  // 用普通函数
c = a + b;      // 用运算符+

如果运算符被重载为全局函数，那么只有一个参数的运算符叫做一元运算符，有两个参数的运算符叫做二元运算符。如果运算符被重载为类的成员函数，那么一元运算符没有参数，二元运算符只有一个右侧参数，因为对象自己成了左侧参数。
从语法上讲，运算符既可以定义为全局函数，也可以定义为成员函数。但是我们有以下建议：

由于C++ 语言支持函数重载，才能将运算符当成函数来用，C语言就不行。我们要以平常心来对待运算符重载：
(1) 不要过分担心自己不会用，它的本质仍然是程序员们熟悉的函数。
(2) 不要过分热心地使用，如果它不能使代码变得更加易读易写，那就别用，否则会自找麻烦。

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

5. 关于内联（inline）函数

5.1 用内联取代宏代码
C++ 语言支持函数内联，其目的是为了提高函数的执行效率（速度）。

在C程序中，可以用宏代码提高执行效率。宏代码本身不是函数，但使用起来象函数。预处理器用复制宏代码的方式代替函数调用，省去了参数压栈、生成汇编语言的CALL调用、返回参数、执行return等过程，从而提高了速度。使用宏代码最大的缺点是容易出错，由于宏是直接替代展开，预处理器在复制宏代码时常常产生意想不到的边际效应。例如

1
2
3

#define MAX(a, b) (a) > (b) ? a : b
result = MAX(i, j) + 2;

将被预处理器解释为

1

result = (i) > (j) ? (i) : (j) + 2;

由于运算符‘+’比运算符‘:’的优先级高，所以上述语句并不等价于期望的

1

result = ( (i) > (j) ? (i) : (j) ) + 2;

如果把宏代码改写为

1

#define MAX(a, b) ( (a) > (b) ? (a) : (b) )

则可以解决由优先级引起的错误。但是即使使用修改后的宏代码也不是万无一失的，例如语句

1

result = MAX(i++, j);

将被预处理器解释为

1

result = (i++) > (j) ? (i++) : (j);

对于C++ 而言，使用宏代码还有另一种缺点：无法操作类的私有数据成员。

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

C++ 语言的函数内联机制既具备宏代码的效率，又增加了安全性，而且可以自由操作类的数据成员。所以在C++ 程序中，应该用内联函数取代所有宏代码，“断言assert”恐怕是唯一的例外。assert是仅在Debug版本起作用的宏，它用于检查“不应该”发生的情况。为了不在程序的Debug版本和Release版本引起差别，assert 不应该产生任何副作用。如果assert是函数，由于函数调用会引起内存、代码的变动，那么将导致Debug版本与Release版本存在差异。所以assert 不是函数，而是宏。

5.2 内联的函数编程风格
关键字inline必须与函数定义体放在一起才能使函数成为内联，仅将inline放在函数声明前面不起任何作用。如下风格的函数Foo则成为内联函数：

1
2
3
4
5

void foo(int x, int y);
inline void foo(int x, int y)  // inline与函数定义体放在一起
{
    ...
}

所以说，inline是一种“用于实现的关键字”，而不是一种“用于声明的关键字”。一般地，用户可以阅读函数的声明，但是看不到函数的定义。尽管在大多数教科书中内联函数的声明、定义体前面都加了inline关键字，但我认为inline不应该出现在函数的声明中。这个细节虽然不会影响函数的功能，但是体现了高质量C++/C程序设计风格的一个基本原则：声明与定义不可混为一谈，用户没有必要、也不应该知道函数是否需要内联。

定义在类声明之中的成员函数将自动地成为内联函数，例如

1
2
3
4
5

class A
{
public:
    void foo(int x, int y) { ... } // 自动地成为内联函数
} ;

将成员函数的定义体放在类声明之中虽然能带来书写上的方便，但不是一种良好的编程风格，上例应该改成

1
2
3
4
5
6
7
8
9
10
11
12

// 头文件
class A
{
public:
    void foo(int x, int y);
}
// 定义文件
inline void A::foo(int x, int y)
{
    ...
}

5.3 慎用内联
内联能提高函数的执行效率，为什么不把所有的函数都定义成内联函数？如果所有的函数都是内联函数，还用得着“内联”这个关键字吗？内联是以代码膨胀（复制）为代价，仅仅省去了函数调用的开销，从而提高函数的执行效率。如果执行函数体内代码的时间，相比于函数调用的开销较大，那么效率的收获会很少。另一方面，每一处内联函数的调用都要复制代码，将使程序的总代码量增大，消耗更多的内存空间。以下情况不宜使用内联：
（1）如果函数体内的代码比较长，使用内联将导致内存消耗代价较高。
（2）如果函数体内出现循环，那么执行函数体内代码的时间要比函数调用的开销大。

类的构造函数和析构函数容易让人误解成使用内联更有效。要当心构造函数和析构函数可能会隐藏一些行为，如“偷偷地”执行了基类或成员对象的构造函数和析构函数。所以不要随便地将构造函数和析构函数的定义体放在类声明中。

一个好的编译器将会根据函数的定义体，自动地取消不值得的内联（这进一步说明了inline不应该出现在函数的声明中）。