高质量程序设计－－第十四章 c++函数的高级特性 - 高质量程序设计指南第三版林锐

函数重载的概念

在C++程序中，可以将语义、功能相似的几个函数用同一个名字表示，即函数重载。

C++语言采用重载机制的另一个理由是：类的构造函数需要重载机制。

并不是两个函数的名字相同就能构成重载。全局函数和类的成员函数同名不算重载，因为函数的作用域不同。

当心隐式类型转换导致重载函数产生二义性

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

成员函数的重载、覆盖与隐藏

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

（1）如果派生类的函数与基类的函数同名，但是参数不同。此时，不论有无virtual关键字，基类的函数将被隐藏（注意别与重载混淆）。
（2）如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual关键字。此时，基类的函数被隐藏（注意别与覆盖混淆）。

运算符重载

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

如果运算符被重载为全局函数，那么只有一个参数的运算符叫做一元运算符，有两个参数的运算符叫做二元运算符。
如果运算符被重载为类的成员函数，那么一元运算符没有参数，二元运算符只有一个右侧参数，因为对象自己成了左侧参数。

运算符规则

所有的一元运算符建议重载为成员函数

= () [] -> 只能重载为成员函数

+= -= /= *= &= |= ~= %= >>= <<= 建议重载为成员函数

所有其它运算符建议重载为全局函数

不能被重载的运算符

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

重载++ 和 --

当一个类型重载 ++/-- 前置版本时，不需要参数；当为一个类型重载 ++/--的后置版本时，需要一个int类型的参数作为标志。
后置版本总是要创建一个临时对象，在退出函数时还要销毁它。

函数内联

预处理器用复制宏代码的方式代替函数调用，省去了参数压栈、生成汇编语言的CALL
调用、返回参数、执行return 等过程，从而提高了速度。使用宏代码最大的缺点是容
易出错。

内联函数的另一个优点是：函数被内联后，编译器就可以通过上下文相关的优化技术对结果代码执行更深入的优化，而这种优化在普通函数内是无法单独进行的，因为一旦进入函数体内它就脱离了调用环境的上下文。

类型转换函数

在构造函数前面添加关键字explicit将其声明为显式的，意即要求用户必须显式地调用构造函数来初始化对象，以明确表明它地意图。

四个类型转换符：

static_cast<dest_type>(src_obj) 作用相当于c风格的强制转换。

const_cast<dest_type>(src_obj) 用于去除一个对象的const/volatile属性。

reintepret_cast<dest_type>(src_obj) 把一个整数转换成为一个地址，或者在任何两种类型的指针之间转换。

dynamic_cast<desc_type>(src_obj) 在运行时遍历继承树来确定src_obj和dest_type的关系。

const成员函数

任何不会修改数据成员的成员函数都应该声明为const类型。

关于类型转换，找了下面一篇文章：

http://hi.baidu.com/choosn/blog/item/20b643f05bc1a5afa50f520e.html

使用标准C++的类型转换符：static_cast、dynamic_cast、reinterpret_cast、和const_cast2007-03-11 18:293.1 static_cast
用法：static_cast < type-id > ( expression )
该运算符把expression转换为type-id类型，但没有运行时类型检查来保证转换的安全性。它主要有如下几种用法：
①用于类层次结构中基类和子类之间指针或引用的转换。
　　进行上行转换（把子类的指针或引用转换成基类表示）是安全的；
　　进行下行转换（把基类指针或引用转换成子类表示）时，由于没有动态类型检查，所以是不安全的。
②用于基本数据类型之间的转换，如把int转换成char，把int转换成enum。这种转换的安全性也要开发人员来保证。
③把空指针转换成目标类型的空指针。
④把任何类型的表达式转换成void类型。

注意：static_cast不能转换掉expression的const、volitale、或者__unaligned属性。

3.2 dynamic_cast
用法：dynamic_cast < type-id > ( expression )
该运算符把expression转换成type-id类型的对象。Type-id必须是类的指针、类的引用或者void *；
如果type-id是类指针类型，那么expression也必须是一个指针，如果type-id是一个引用，那么expression也必须是一个引用。

dynamic_cast主要用于类层次间的上行转换和下行转换，还可以用于类之间的交叉转换。
在类层次间进行上行转换时，dynamic_cast和static_cast的效果是一样的；
在进行下行转换时，dynamic_cast具有类型检查的功能，比static_cast更安全。
class B{
public:
int m_iNum;
virtual void foo();
};

class D:public B{
public:
char *m_szName[100];
};

void func(B *pb){
D *pd1 = static_cast<D *>(pb);
D *pd2 = dynamic_cast<D *>(pb);
}

在上面的代码段中，如果pb指向一个D类型的对象，pd1和pd2是一样的，并且对这两个指针执行D类型的任何操作都是安全的；
但是，如果pb指向的是一个B类型的对象，那么pd1将是一个指向该对象的指针，对它进行D类型的操作将是不安全的（如访问m_szName），
而pd2将是一个空指针。

另外要注意：B要有虚函数，否则会编译出错；static_cast则没有这个限制。
这是由于运行时类型检查需要运行时类型信息，而这个信息存储在类的虚函数表（
关于虚函数表的概念，详细可见<Inside c++ object model>）中，只有定义了虚函数的类才有虚函数表，
没有定义虚函数的类是没有虚函数表的。

另外，dynamic_cast还支持交叉转换（cross cast）。如下代码所示。
class A{
public:
int m_iNum;
virtual void f(){}
};

class B:public A{
};

class D:public A{
};

void foo(){
B *pb = new B;
pb->m_iNum = 100;

     D *pd1 = static_cast<D *>(pb);     //compile error
     D *pd2 = dynamic_cast<D *>(pb);   //pd2 is NULL
     delete pb;
}

在函数foo中，使用static_cast进行转换是不被允许的，将在编译时出错；而使用 dynamic_cast的转换则是允许的，结果是空指针。

3.3 reinpreter_cast
用法：reinpreter_cast<type-id> (expression)
type-id必须是一个指针、引用、算术类型、函数指针或者成员指针。
它可以把一个指针转换成一个整数，也可以把一个整数转换成一个指针（先把一个指针转换成一个整数，
在把该整数转换成原类型的指针，还可以得到原先的指针值）。

该运算符的用法比较多。

3.4 const_cast
用法：const_cast<type_id> (expression)
该运算符用来修改类型的const或volatile属性。除了const 或volatile修饰之外， type_id和expression的类型是一样的。
常量指针被转化成非常量指针，并且仍然指向原来的对象；
常量引用被转换成非常量引用，并且仍然指向原来的对象；常量对象被转换成非常量对象。

Voiatile和const类试。举如下一例：
class B{
public:
      int m_iNum;
}
void foo(){
const B b1;
b1.m_iNum = 100;             //comile error
B b2 = const_cast<B>(b1);
b2. m_iNum = 200;            //fine
}
上面的代码编译时会报错，因为b1是一个常量对象，不能对它进行改变；
使用const_cast把它转换成一个常量对象，就可以对它的数据成员任意改变。注意：b1和b2是两个不同的对象。