C++_新特性1-类型转换运算符

C++的创始人认为C语言的类型转换运算符太过于松散。他采取了更加严格的限制允许的类型转换。并添加了4个类型转换运算符。

这部分特性比较高阶，我把它归于奇技淫巧的范畴。这里简单介绍一下，以后实际有用到再深入研究。

struct Data

{

　　double data[200];

};

struct Junk

{

　　int junk[100];

};

Data d = {2.5e33, 3.5e-19, 20.2e32};

char * pch = (char *) (&d);    //type cast #1

char ch = char (&d);              //type cast #2

Junk * pj = (Junk *) (&d);       //type cast #3

首先，上述3种类型转换中，哪一种更有意义？除非不讲理，否则它们中没有一个是有意义的。其次，这3种类型转换中哪种是允许的呢？在C语言中都是允许的。

对于这种松散的情况，Stroustrop采取的措施是，更严格地限制允许的类型转换，并添加4个类型转换运算符，使转换过程更加规范：

dynamic_cast;

const_cast;

static_cast;

reinterpret_cast;

可以根据目的选择一个合适的运算符，而不是使用通用的类型转换。

这指出了进行类型转换的原因，并让编译器能够检查程序的行为是否与设计者想法吻合。

======================================================

举个例子dynamic_cast运算符在前面已经介绍过了，假设High和Low是两个类，而ph和pl的类型分别为High *和Low *。

则仅当Low是High的可访问基类时，下面的语句才将一个Low*指针赋给pl：

pl = dynamic_cast<Low *> ph;

否则，该语句将空指针赋给pl。

该运算符的语法如下：

dynamic_cast <type_name> (expression)

该运算符的用途是，使得能够在类层次结构中进行向上转换（由于是is-a关系，这种转换是安全的），而不允许其他转换。

======================================================

const运算符用于执行只有一种用途的类型转换。

即改变值为const或volatile，其语法与dynamic_cast运算符相同：

const_cast <type_name>(expression)

如果类型的其他方面也被修改，则上述类型的转换将出错。

也就是说除了const和volatile特征可以不同外，type_name和expression的类型必须相同。

再次假设High和Low是两个类：

High bar;

const High * pbar = &bar;

...

High * pb = const_cast<High *> (pbar);                     //valid

const  Low * pl = const_cast<const Low *> (pbar);   //invalid

第一个类型转换使得*pb成为一个可用于修改bar对象值的指针，它删除const标签。

第二个类型转换是非法的，因为它同时尝试将类型从const High*改为const Low*。

提供该运算符的原因是，有时候可能需要这样一个值，它在大多数时候是常量，而有时又是可修改的。

在这种情况下，可以将这个值声明为const，并在需要修改它的时候，使用const_cast。

这也可以通过通过类型转换实现，但通用转换也可能同时改变类型：

High bar;

const High * pbar = &bar;

...

High * pb =(High *)(pbar);

Low * pl = (Low *) (pbar);

由于编程时可能无意间同时改变类型和常量特征，因此使用const_cast运算符更安全；

const_cast不是万能的。它可以修改指向一个值的值，但修改const的值的结果是不确定的。

 //constcast.cpp  -- using const_cast<>
 #include <iostream>
 using std::cout;
 using std::endl;

 void change(const int * pt, int n);

 int main()
 {
     int popl = ;
     const int pop2 = ;

     cout<<"pop1, pop2:"<<pop1<<", "<<pop2<<endl;
     change(&pop1, -);
     change(&pop2, -);
     cout<<"pop1, pop2:"<<pop1<<", "<<pop2<<endl;
     return ;
 }

 void change(const int * pt, int n)
 {
     int * pc;
     pc = const_cast<int *>(pt);
     *pc += n;
 }

const_cast运算符可以删除const int *中的const，使得编译器能够接受change()中的语句：

*pc += n;

但由于pop2被声明为const，因此编译器可能禁止修改它，如下面的输出所示：

pop1, pop2 : 38383, 2000

pop1, pop2 : 38280, 2000

正如您所看到的，调用change()时，修改了pop1，但没有修改pop2.。

在change()中，指针被声明为const int * ，因此不能用来修改指向的int。

指针pc删除了const特征，因此可用来修改指向的值，但仅当指向的值不是const时才行。

因此，pc可用于修改pop1，但不能用于修改pop2。

======================================================

static_cast运算符的语法与其他类型转换运算符相同：

static_cast <type-name> (expression)

仅当type_name可被隐式转换为expression所属的类型或expression可被隐式转换为type_name所属的类型时，上述转换才是合法的，否则将会出错。

假设High是Low的基类，而Pond是一个无关的类，则从High到Low的转换，从Low到High的转换都是合法的，而从Low到Pond的转换时不允许的。

High bar;

Low blow;

...

High * pb = static_cast<High *> (&blow);    //valid upcast

Low * pl = static_cast<Low *>(&bar);    //valid downcast

Pond * pmer = static_cast<Pond *>(&blow);   //invalid, Pond unrelated

第一种转换是合法的，因为向上转换可以显式地进行。

第二种转换是从基类指针到派生类指针，在不进行显式转换的情况下，将无法进行。但由于无需进行类型转换，便可以进行另一个方向的类型转换，因此使用static_cast进行向下转换是合法的。

同理，由于无需进行类型转换，枚举值就可以被转换为整型，所以可以用static_cast将整型转换为枚举值。同样，可以使用static_cast将double转换为int、将float转换为long以及其他各种数值转换。

//完全被绕晕了

======================================================

reinterpret_cast运算符用于天生危险的类型转换。它不允许删除const，但会执行其他令人生厌的操作。

有时程序员必须做一些依赖于实现的、令人生厌的操作，使用reinterpret_cast运算符可以简化对这种行为的跟踪工作。该运算符的语法与另外3个相同：

reinterpret_cast <type-name> (expression)

下面是一个使用示例：

struct dat { short a; short b;}

long value = 0xA224B118;

dat * pd = reinterpret_cast<dat *> (&value);

cout << hex << pd->a;  //display first 2 bytes of value

通常，这样的转换适用于依赖于实现的底层编程技术，是不可移植的。

例如，不同系统在存储多字节整型时，可能以不同的顺序存储其中的字节。

然而，reinterpret_cast运算符并不支持所有的类型转换。例如，可以将指针类型转换为足以存储指针表示的整型，但不能将指针转换为更小的整型或浮点型。

另一个限制是，不能将函数指针转换为数据指针，反之亦然。

　　在C++中，普通类型转换也受到限制。基本上，可以执行其他类型转换可执行的操作，加上一些组合，如static_cast或reintepret_cast后跟const_cast，但不能执行其他转换。

因此，下面的类型转换在C语言中是允许的，但在C++中通常不允许，因为对于多数C++shixian ,char类型都太小，不能存储指针。

char ch =char (&d)    //type cast #2 - convert address to a char

这些限制是合理的，如果您觉得这种限制难以忍受，可以使用C语言。

//这段也是晦涩难懂