那些陌生的C++关键字

那些陌生的C++关键字

学过程序语言的人相信对关键字并不陌生。偶然间翻起了《C++ Primer》这本书，书中列举了所有C++的关键字。我认真核对了一下，竟然发现有若干个从未使用过的关键字。一时间对一个学了六年C++的自己狠狠鄙视了一番，下决心一定要把它们搞明白！图1红色字体给出的是我个人感觉一般大家都会比较陌生的关键字，下边我们逐个学习。

图1 C++ 关键字

一、typeid

从名字直观看来，该关键字应该是获取语言元素的类型ID。其实它和sizeof类似，是一个类型运算符。有时候代码可能需要获取某个变量或者类型的名字，这时候使用typeid就比较合适。

使用格式：typeid(int)或typeid(i+1)

这样操作后返回有个type_info类型的对象，比较常用的对象成员函数一般有比较是否相等和获取类型名。

例如：

typeid(int).name();//获取int类型名，结果为“int”。 typeid(1)!= typeid(1.0);//比较表达式类型，结果为true。

使用过Java的读者想必发现该运算符和Java关键字instanceof功能比较类似，相比而言，instanceof可能使用起来更方便些。对typeid用法更详细的内容请点击参考博文。

二、typename

这个关键字和上边的很相近，刚开始我还以为是这个关键字获取类型的名字呢（想当然害死人啊~），但是他们之间一点关系都没有！C++使用typename的情况有两种：

第一种情况是在函数模板和类模板声明中。一般模板声明中，使用class关键字指定类型参数，后来C++支持使用typename代替class关键字。这里仅仅是在语义上强调模板使用的类型参数不一定是类类型，可以是所有类型。这里typename和class没有任何区别。

使用格式：

template<class  T, class Y>

和

template<typename  T, typename Y>完全等价！

第二种情况使用情况比较特殊，简单说起来就是在使用类内成员类型的时候。类内成员类型就是在类定义内声明了一个类型，该类型属于类型内部，可见性由权限访问符限定。

下面就是一个类内的成员类型的声明。

class MyClass
{
public:
 typedef int MyType;
};

类内类型可以像类的静态成员一样使用，例如：

MyClass::MyType var;//定义变量
MyClass::MyType * pvar;//定义指针
typedef MyClass::MyType MyType;//重新命名类型

这些使用方式并没有太大问题，问题可能出现在带有模板的代码中，例如：

template<class T>
void MyMethod( T my )
{
       T::MyType * pvar;
 typedef T:: MyType MyType;
}

函数参数类型来自于模板，如果MyClass对象是实际参数，那么函数内将声明一个MyClass::MyType类型的指针，以及对MyClass::MyType类型重新命名为MyType。由于类内类型使用方式和类成员完全相同，对于第一种语句，可以解释为一个指针声明，也可以解释为一个类成员和变量的乘法操作。第二种语句把T::MyType解释为类型是没有问题的，但是解释为成员变量就产生了错误，因为typedef操作的对象只能是类型。这种二义性对于编译器是不愿意看到的，为了消除这种问题，就可以使用typename进行显示的类型声明。

使用格式：

typename T::MyType * pvar;

typedef typename T:: MyType MyType;

引发这种问题的本质原因来自于模板类型T的不确定性，和直接使用MyClass::MyType不同的是，后者能在编译时期检查出该引用的语法成分。通过typename明确的告诉编译器，这里使用的是类型。这样编译器就明确类型T引出的成员是类型，而不是变量或者函数名。因此，typename的使用范围也被限定在模板函数内部。

其实这些问题在目前的编译器中并不存在，使用VC6.0和VS2010测试发现，无论是否加上typename程序都不会出错。对该关键字的保留大概是为了兼容旧式编译器的代码。关于typename的用法读者感兴趣可以点击参考链接。

三、mutable

Mutable的含义是可变的，它和const关键字是相对的。同样是修饰变量的声明，但是mutable的使用范围比const要小。我们知道类的常成员函数在语义上是不允许修改类的成员变量的，但是有时候可能根据代码的需要并不是这么绝对。那么就可以使用mutable声明一个类的成员变量，它告诉编译器类的常成员函数可以修改这个变量。

使用格式：

mutable int var;//类内声明

例如：

class MyClass
{
 mutable int member;
 void constFun()const
       {
              member=0;
       }
};

如果不使用mutable修饰member定义，就会编译报错。

四、volatile

Volatile是易变的意思，编译器在编译时期可能不能获取变量是否被多个线程或者进程修改的信息。这时候一个变量是否在两次“读操作”之间发生改变，编译器肯定无法确定。然而编译优化的技术针对一般的变量都会做出优化，例如：

int a=0;
int b=a;
int c=a+1;

编译器极可能把a放在寄存器中，供b，c的计算使用。更有甚者，编译器确定a的值是0，会直接计算出b=0，c=1！如果在实际运行中a的值被其他线程修改，这么做就改变了代码的语意。

使用格式：

volatile int a;//这里对a是否初始化已经不再重要了

为了消除这种问题，使用volatile关键字告诉编译器每次访问a的时候都需要读内存，而不对其优化。

五、explicit

Explicit的含义是显式的，它和C++中的隐式转换相关。例如：

double a=100;

编译器会自动将整数100转化为浮点类型。对于用户数据类型，C++提供了转换构造函数和类型转换函数实现用户数据类型和内置类型的相互转换。而explicit是因为转换构造函数而存在的。下面给出一个转换构造函数的例子：

class A
{
public:
       A(int x)
       {
       }
};
void fun(A a)
{
}
fun(1);

最后的函数调用语句是合法的，虽然fun只接受A类型的参数，但是因为A的构造函数除了初始化A外，还提供了整数转换为A类型的方式——转换构造函数。但是有些情况下，这样做可能是不利的，比如fun可能有单独处理整形参数的重载，或者fun根本不需要转换构造函数生成的对象。

使用格式：

explicit A(int x)

{}

通过使用explicit限制构造函数必须是显式调用，禁止隐式类型转换就可以按照程序作者的需要限定构造函数的功能。

六、static_cast、const_cast、dynamic_cast、reinterpret_cast

之所以把这四个关键字放在一起，是因为它们处理相似的问题——显式类型转换。C++延续了C风格的强制类型转换的语法：

(类型)表达式

但是C风格的转换具体很大的风险性，为此，C++支持四种关键字对不同形式的类型转换进行分别处理。

使用格式：

转换关键字<类型>(表达式)

static_cast和C风格类型转换功能完全相同，它属于在编译时期静态的类型转换。如果把一个double类型转换为整形，形式如下：

static_cast<int>(0.1);

static_cast功能有所限制，比如不能转化struct类型到int，不能转化指针到double等。另外，它不能在转换中消除const和volatile属性。

const_cast用于消除引用或者指针的const或者volatile属性。

const int &ci=100;
int &i=const_cast<int&>(ci);

通过这种方式，ci引用的内存单元虽然无法通过修改ci改变，但是可以修改i改变内存的值。这里是把const属性消除，这里想多说一点的是把const加上的问题。例如：

int x=100;
const int &cx=x;
const int &cy=x+1;

对const对象的引用允许使用表达式初始化，比如cy引用的内存单元的值应该就是x+1的值即101。正因为此《C++ Primer》也假设了编译器了的工作方式：

int temp=x+1;
const int &cy=temp;

如果按照这种工作方式，cx引用的内存单元应该不是x的内存单元，但是在VS2010下测试结果表明cx和x的地址为同一内存单元！

显然，使用单独的变量初始化const引用的值不会产生额外的存储空间，通过修改原先的变量是可以修改常量引用的值的。

dynamic_cast一般出现在类到子类或兄弟类的转换，并要求基类有虚函数。而且它能提供转换后的结果和状态，一旦转换失败则返回空指针。如果没有继承关系的转换一般使用static_cast。

对于dynamic_cast使用方式如下：

class Base
{
 virtual void fun(){};//必须拥有虚函数
};
class A:public Base//必须是供有继承才能默认转换
{
};
Base b;
A *a=dynamic_cast<A*>(&b);//基类到子类，显式转换
Base*pb=a;//子类到基类，默认转换

reinterpret_casts一般用作函数指针的转换，而且使用它的代码可移植性很差，因为无法确定编译器的函数调用方式等。有可能会导致函数调用出错，一般不常用。例如：

typedef void (*FuncPtr)();//funcPtr是指向无参无返回值类型函数的指针
int func()//一个无参返回整数的函数定义
{
 return 0;
}
FuncPtr pf=reinterpret_cast<FuncPtr>(func);

直接把func赋值给pf是不行的，使用reinterpret_cast将函数指针强制转换即可。

至此，我们把那些陌生的C++关键字的“老底”摸了个遍，相信以后应该不会再碰到搞不清楚的C++关键字了，希望本文对你有所帮助！