C++ 类型转换运算符

C++相比于C是一门面向对象的语言，面向对象最大的特点之一就是具有“多态性(Polymorphism)”。

要想很好的使用多态性，就免不了要使用指针和引用，也免不了会碰到转换的问题。

C++提供了四个转换运算符：

const_cast (expression)
static_cast (expression)
reinterpret_cast (expression)
dynamic_cast (expression)

const_cast

const_cast 转换符是用来移除变量的const 或volatile 限定符，主要说说const方面，因为volatile 涉及到多线程的设计；

对于const变量，我们不能修改它的值，这是这个限定符最直接的表现。但是我们就是想违背它的限定希望修改其内容怎么办呢？

下边的代码显然是达不到目的的：

const int constant = 10;
int modifier = constant;

因为对modifier的修改并不会影响到constant，这暗示了一点：const_cast转换符也不该用在对象数据上，因为这样的转换得到的两个变量/对象没有相关性；

只有用指针或者引用，让变量指向同一个地址才是解决方案，可惜下边的代码在C++中也是编译不过的：

const int constant = 21;
int* modifier = &constant 
// Error: invalid conversion from 'const int*' to 'int*'
//（上边的代码在C中是可以编译的，最多会得到一个warning，所在在 C 中上一步就可以开始对constant里面的数据胡作非为了）

把constant交给非const的引用也是不行的。

const int constant = 21;
int& modifier = constant;
// Error: invalid initialization of reference of type 'int&' from expression of type 'const int'

于是const_cast就出来消灭const，以求引起程序世界的混乱。
下边的代码就顺利编译功过了：

const int constant = 21;
const int* const_p = &constant;
int* modifier = const_cast<int*>(const_p);
*modifier = 7;

传统转换方式实现const_cast运算符

准转换运算符是可以用传统转换方式实现的。const_cast 实现的原因就在于C++对于指针的转换是任意的，它不会检查类型，任何指针之间都可以进行互相转换，因此const_cast 就可以直接使用显式转换（int *）来代替；

    const int constant = 21;
const int* const_p = &constant;
int* modifier = (int*)(const_p);
    ==================================
const int constant = 21;
int* modifier = (int*)(&constant);
    ==================================
const int constant = 21;
int* modifier = const_cast<int*>(&constant);
    *modifier = 7;

为什么要去除const限定

从前面代码中已经看到，我们不能对constant进行修改，但是我们可以对modifier进行重新赋值。

但是，程序世界真的混乱了吗？我们真的通过modifier修改了constant 的值了吗？修改const变量的数据真的是C++去const的目的吗？

如果我们把结果打印出来：

    cout << "constant: "<< constant <<endl;
cout << "const_p: "<< *const_p <<endl;
cout << "modifier: "<< *modifier <<endl;
/**
 constant: 21
 const_p: 7
 modifier: 7
 **/
cout << "constant: "<< &constant <<endl;
cout << "const_p: "<< const_p <<endl;
cout << "modifier: "<< modifier <<endl;

//constant还是保留了它原来的值。

/**
 constant: 0x7fff5fbff72c
 const_p: 0x7fff5fbff72c
 modifier: 0x7fff5fbff72c
 **/
//可是他们的确指向同一地址~~~

这是个奇怪的事情，但是件好事儿：说明C++里是const，就是const，外界千变万化，其就不变。不然全乱套了，const也就没有存在的意义了。

IBM的C++指南称呼“*modifier = 7; 为“未定义行为”。所谓未定义，是说这个语句在标准C++中没有明确的规定，由编译器来决定如何处理。

位运算的左移操作也可算一种未定义的行为，因为我们不确定是逻辑左移还是算术左移。

再比如下边的语句：v[i] = i++; 也是一种未定义行为，因为我们不知道是先做自增，还是先用来找数组中的位置。

对于未定义的行为，我们所能做的所要做的就是避免出现这样的语句。对于const数据我们更要这样保证：绝不对const数据重新赋值。
如果不想修改const变量的值，那为什么要去const呢？

原因是，我们可能调用了一个参数不是const 的函数，而我们传进去的实际参数确实是const的，但是我们知道这个函数是不会对参数做修改的。于是就需要使用const_cast 去除const限定，以便函数能够接受这个实际参数。

    #include <iostream>
using namespace std;

void Printer (int* val,string seperator = "\n"){
cout << val<< seperator;
    }

int main(void) {    

const int consatant = 20;
//Printer(consatant);//Error: invalid conversion from 'int' to 'int*'
        Printer(const_cast<int *>(&consatant));

return 0;
    }

出现这种情况的原因，可能是我们所调用的方法是别人写的。还有一种我能想到的原因，是出现在const对象想调用自身的非const方法的时候，因为在类定义中，const也可以作为函数重载的一个标示符。有机会，我会专门回顾一下我所知道const的用法，C++的const真的有太多可以说的了。

在IBM的C++指南中还提到了另一种可能需要去const的情况：

    #include <iostream>
using namespace std;

int main(void) {
int variable = 21;
const int* const_p = &variable;
int* modifier = const_cast<int*>(const_p);

        *modifier = 7
cout << "variable:" << variable << endl;

return 0;
    } 
/**
 variable:7
 **/

我们定义了一个非const的变量，但用带const限定的指针去指向它，在某一处我们突然又想修改了，可是我们手上只有指针，这时候我们可以去const来修改了。上边的代码结果也证实我们修改成功了。

不过这样并不是好的设计，还是应该遵从这样的原则：使用const_cast去除const 限定的目的绝对不是为了修改它的内容，只是出于无奈。

reinterpret_cast

用法：reinterpret_cast < new_type > (expression)

reinterpret_cast 运算符用来处理无关类型之间的转换，它会产生一个新的值，这个值会有与原始参数（expression）有完全相同的比特位；

reinterpret_cast的字面意思是：重新解释（类型的比特位），真的可以随意将一个类型值的比特位交给另一个类型作为它的值吗？其实不然。

IBM的C++指南里倒是明确告诉了我们reinterpret_cast可以，或者说应该在什么地方用来作为转换运算符：

从指针类型到一个足够大的整数类型
从整数类型或者枚举类型到指针类型
从一个指向函数的指针到另一个不同类型的指向函数的指针
从一个指向函数的指针到另一个不同类型的指向对象的指针
从一个指向类函数成员的指针到另一个指向不同类型的函数成员的指针
从一个指向类数据成员的指针到另一个指向不同类型的数据成员的指针

事实上reinterpret_cast的使用并不局限在上边所说的几项的，任何类型的指针之间都可以互相转换，都不会得到编译错误。上述列出的几项，可能是Linux下reinterpret_cast使用的限制，也可能是IBM推荐我们使用reinterpret_cast的方式。

所以总结来说，reinterpret_cast 用在任意指针（或引用）类型之间的转换，以及指针与足够大的整数类型之间的转换；从整数类型（包含枚举类型）到指针类型，无视大小。

所谓”足够大的整数类型”,取决于操作系统的参数，如果是32位的操作系统，就需要整形（int）以上的；如果是64位的操作系统，则至少需要长整形（long）。具体大小可以通过sizeof运算符来查看

reinterpret_cast有何作用
从上边对reinterpret_cast介绍，可以感觉出reinterpret_cast是个很强大的运算符，因为它可以无视种族隔离，随便搞。但就像生物的准则，不符合自然规律的随意杂交只会得到不能长久生存的物种。随意在不同类型之间使用reinterpret_cast，也之后造成程序的破坏和不能使用。

比如下面代码：

    typedef int (*FunctionPointer)(int); 
int value = 21; 
    FunctionPointer funcP; 
    funcP = reinterpret_cast<FunctionPointer> (&value); 
    funcP(value);

先用typedef定义了一个指向函数的指针类型，所指向的函数接受一个int类型作为参数。然后我用reinterpret_cast将一个整型的地址转换成该函数类型并赋值给了相应的变量。最后，我还用该整形变量作为参数交给了指向函数的指针变量。

这个过程编译器都成功的编译通过，不过一旦运行我们就会得到“EXC_BAD_ACCESS”的运行错误，因为我们通过funcP所指的地址找到的并不是函数入口。

由此可知，reinterpret_cast虽然看似强大，作用却没有那么广。IBM的C++指南、C++之父Bjarne Stroustrup的FAQ网页和MSDN的Visual C++也都指出：错误的使用reinterpret_cast 很容易导致程序的不安全，只有将转换后的类型值转换到其原始类型，这样才是正确使用reinterpret_cast 方式。

这样说起来，reinterpret_cast转换成其它类型的目的只是临时的隐藏自己的什么（做个卧底？），要真想使用那个值，还是需要让其露出真面目才行。那到底它在C++中有其何存在的价值呢？

MSDN的Visual C++ Developer Center 给出了它的使用价值：用来辅助哈希函数。下边是MSNDN上的例子：

// expre_reinterpret_cast_Operator.cpp
// compile with: /EHsc
#include <iostream>
// Returns a hash code based on an address
unsigned short Hash( void *p ) {
unsigned int val = reinterpret_cast<unsigned int>( p );
return ( unsigned short )( val ^ (val >> 16));
}

using namespace std;
int main() {
int a[20];
for ( int i = 0; i < 20; i++ )
cout << Hash( a + i ) << endl;
}

//如果跟我一样是64位的系统，可能需要将unsigned int改成 unsigned long才能运行。

这段代码适合体现哈希的思想，暂时不做深究，但至少看Hash函数里面的操作，也能体会到，对整数的操作显然要对地址操作更方便。在集合中存放整形数值，也要比存放地址更具有扩展性（当然如果存void *扩展性也是一样很高的），唯一损失的可能就是存取的时候整形和地址的转换（这完全可以忽略不计）。

不过可读性可能就不高，所以在这种情况下使用的时候，就可以用typedef来定义个指针类型：

typedef unsigned int PointerType;

这样不是更棒，当我们在64位机器上运行的时候，只要改成：

typedef unsigned long PointerType;

当reinterpret_cast面对const

IBM的C++指南指出：reinterpret_cast 不能像const_cast那样去除const修饰符。这是什么意思呢？如下代码：

    int main() 
    {
typedef void (*FunctionPointer)(int);
int value = 21;
const int* pointer = &value;

//int * pointer_r = reinterpret_cast<int*> (pointer); 
// Error: reinterpret_cast from type 'const int*' to type 'int*' casts away constness

        FunctionPointer funcP = reinterpret_cast<FunctionPointer> (pointer);
    }

例子里，我们像前面const_cast一篇举到的例子那样，希望将指向const的指针用运算符转换成非指向const的指针。但是当实用reinterpret_cast的时候，编译器直接报错组织了该过程。这就体现出了const_cast的独特之处。

但是，例子中还有一个转换是将指向const int的指针付给指向函数的指针，编译顺利通过编译，当然结果也会跟前面的例子一样是无意义的。

如果我们换一种角度来看，这似乎也是合理的。因为
const int* p = &value; int * const q = &value;
这两个语句的含义是不同的，前者是”所指内容不可变”，后者则是”指向的地址不可变”。因此指向函数的指针默认应该就带有”所指内容不可变”的特性。

毕竟函数在编译之后，其操作过程就固定在那里了，唯一能做的就是传递一些参数给指针，而无法改变已编译函数的过程。所以从这个角度来想，上面例子使用reinterpret_cast 从const int * 到 FunctionPointer 转换就变得合理了，因为它并没有去除const 限定。

static_cast

用法：static_cast < new_type > (expression)

首先，static_cast不是用来去除变量的static引用；
static决定的是一个变量的作用域和生命周期，比如：在一个文件中将变量定义为static，则说明这个变量只能在本Package中使用；在方法中定义一个static变量，该变量在程序开始存在直到程序结束；类中定义一个static成员，该成员随类的第一个对象出现时出现，并且可以被该类的所有对象所使用。

对static限定的改变必然会造成范围性的影响，而const限定的只是变量或对象本身。但无论是哪一个限定，他们都是在变量一出生（完成编译的时候）就决定了变量的特性，所以实际上都是不容许改变的。这点在const_cast那部分已经体现出来。

static_cast 和 reinterpret_cast一样，在面对const的时候都无能为力：两者都不能去除const限定，两者也存在的很多的不同，比如static_cast 不仅可以用在指针和引用上，还可以用在基本数据和对象上；前面提到过的reinterpret_cast 可以用在“没有关系”的类型之间，而用static_cast 来处理的转换就需要两者具有“一定的关系”了。

在reinterpret_cast一段，已经提到过reinterpret_cast可以在任意指针之间进行互相转换，即使这些指针所指的内容是毫无关系的，也就是说一下语句，编译器是不会报错的，但是对于程序来说也是毫无意义可言的，只会造成程序崩溃：

#include <iostream>
using namespace std;
unsigned short Hash( void *p ) {
unsigned long val = reinterpret_cast<unsigned long>( p );
return ( unsigned short )( val ^ (val >> 16));
}

class Something{
/* Some codes here */
};

class Otherthing{
/* Some codes here */
};

int main() {

typedef unsigned short (*FuncPointer)( void *) ;
    FuncPointer fp = Hash;  //right, this is what we want

int a[10];
const int* ch = a; //right, array is just like pointer
char chArray[4] = {'a','b','c','d'};
    fp = reinterpret_cast<FuncPointer> (ch); //no error, but does not make sense
    ch = reinterpret_cast<int*> (chArray);  //no error

cout <<hex<< *ch;   //output: 64636261 //it really reinterpret the pointer

    Something * st = new Something();
    Otherthing * ot = reinterpret_cast<Otherthing*> (st); //cast between objects with on relationship
}

而以上转换，都是static_cast所不能完成的任务，也就是说把上边程序里所有的reinterpret_cast换成static_cast的话，就会立即得到编译错误，因为目标指针和原始指针之间不存在”关系”。

从上边的程序，也就一下子看出来了reinterpret_cast和static_cast之间最本质的区别。

对于static_cast 所需要的关系，“继承”绝对是其中之一，所以static_cast支持指向基类的指针和指向子类的指针之间的相互转换；

class Parents{
public:
virtual ~Parents(){}
/*codes here*/
};

class Children : public Parents{
/*codes here*/
};

int main() {    

    Children * daughter = new Children();
    Parents * mother = static_cast<Parents*> (daughter); //right, cast with polymorphism

    Parents * father = new Parents();
    Children * son = static_cast<Children*> (father); //no error, but not safe
}

但是从基类到子类的转换，用static_cast并不是安全的，具体的问题会在dynamic_cast一篇阐述。

在指针和引用方便，似乎也只有继承关系是可以被static_cast接受的，其他情况的指针和引用转换都会被static_cast直接扔出编译错误，而这层关系上的转换又几乎都可以被dynamic_cast所代替。这样看起来static_cast运算符的作用就太小了。

实际上static_cast 真正用处并不在指针和引用上，而在基础类型和对象的转换上。而对于基础类型和对象的转换是其他三个运算符办不到的。

基础类型转换

float floatValue = 21.7;
int intValue = 7;

cout << floatValue / 7 << "\t\t" << static_cast<int> (floatValue)/7 <<endl;
cout << intValue/3 << "\t\t" << static_cast<double> (intValue)/3 << endl;

//Output:
//3.1 3
//2 2.33333

对于对象的转换，也是需要关系的，这层关系就是C++用户自定义类型转换中提到的方法；
- 构造函数
- 类型转换运算符
  会根据上述顺序找到合适的方法进行类型转换。
  赋值运算符不会被算在内，因为其自身已经是一种运算符，不能再当做转换运算符用。

    //macro definitions
#define IDER_DEBUG 1
#define FUNC_TRAC(info) {if(IDER_DEBUG)cout<<"----"<<info<<"----"<<endl;}

//class declaration
class Human;
class Ape;
class Programmer;

//class definition
class Programmer
    {
public:
        Programmer(string where = "genius")
        {
            FUNC_TRAC("Programmer Default Constructor"); 
            from = where;
        }
/*Programmer(Programmer& p)
 {
 FUNC_TRAC("Programmer Copy Constructor"); 
 from = p.from;
 }*/
void Speach(){cout<<"I am a Programmer, I am "<< from <<endl;}
private:
string from;
    };

class Human 
    {
public:
        Human(string where = "delivered by Parents"):heart("Human with Training")
        {
            FUNC_TRAC("Human Default Constructor"); 
            from = where;
        }
        Human(Ape& a):heart("Human with Practice")
        {
            FUNC_TRAC("Hummer Ape-Promotion Constructor");
            from = "Evolution from an Ape";
        } 
operator Programmer() //here is weird, it is really different whether we have "&" or not
        {
            FUNC_TRAC("Hummer Programmer-Cast Operator"); 
return heart; 
//Programmer("Human with Practice"); // it is not good to return temporary variable
        }
        Human& operator =(Human& h)
        {
            FUNC_TRAC("Hummer Assignment Operator"); 
cout<<"Call assignment"<<endl; 
return *this;
        }
void Speach(){cout<<"I am a Human, I am "<< from <<endl;}    
private:
string from;
        Programmer heart; //Every one has a heart to be a programmer
    };

class Ape 
    {
public:
        Ape(string where = "from Nature")
        {
            FUNC_TRAC("Ape Default Constructor"); 
            from = where;
        }
        Ape& operator =(Programmer& p)
        {
            FUNC_TRAC("Ape Programmer-Assignment Operator"); 
            from="Degeneration from a Programmer"; 
return *this;
        }
/*Ape& operator =(Ape& p)
 {
 FUNC_TRAC("Ape Assignment Operator"); 
 cout<<"Ape assign"<<endl; 
 return *this;
 }*/
void Speach(){cout<<"#(*%^, !@#$&)( "<< from <<endl;}
private:
string from;
    };

int main(void) {
        Ape a;
        Human h = static_cast<Human> (a); // using promtion constructor

        Programmer p;
        p = static_cast<Programmer> (h); // using Programmer-cast operaotor

//Ape a2;
//a2 = static_cast<Ape> (p); //Error, assignment operator should be used directly

return 0;
    }

传统转换方式实现static_cast运算符
从上边对static_cast分析可以跟看，static_cast跟传统转换方式几乎是一致的，所以只要将static_cast和圆括号去掉，再将尖括号改成圆括号就变成了传统的显示转换方式。

dynamic_cast

应用：dynamic_cast < new_type > (expression)

dynamic_cast运算符，应该是四个里面最特殊的一个，因为它涉及到编译器的属性设置，而且牵扯到的面向对象的多态性跟程序运行时的状态也有关系，所以不能完全的使用传统的转换方式来替换。但是也因此它是最常用，最不可缺少的一个运算符。

与static_cast一样，dynamic_cast的转换也需要目标类型和源对象有一定的关系：继承关系，更准确的说，dynamic_cast是用来检查两者是否有继承关系，因此该运算符实际上只接受基于类对象的指针和引用的类转换，从这个方面来看，似乎dynamic_cast又和reinterpret_cast是一致的，但实际上，他们还是存在很大的差别；

代码如下所示：

#include <string>
#include <iostream>
using namespace std;

class Parents
{
public:
    Parents(string n="Parent"){ name = n;}
virtual ~Parents(){}

virtual void Speak()
    {
cout << "\tI am " << name << ", I love my children." << endl;
    }
void Work()
    {
cout << "\tI am " << name <<", I need to work for my family." << endl;;
    }
protected:
string name;
};

class Children : public Parents
{
public:
    Children(string n="Child"):Parents(n){ }

virtual ~Children(){}

virtual void Speak()
    {
cout << "\tI am " << name << ", I love my parents." << endl;
    }
/*
 **Children inherit Work() method from parents,
 **it could be treated like part-time job.
 */
void Study()
    {
cout << "\tI am " << name << ", I need to study for future." << endl;;
    }

private:
//string name; //Inherit "name" member from Parents
};

class Stranger 
{
public:
    Stranger(string n="stranger"){name = n;}
virtual ~Stranger(){}

void Self_Introduce()
    {
cout << "\tI am a stranger" << endl;
    }
void Speak()
    {
//cout << "I am a stranger" << endl;
cout << "\tDo not talk to "<< name << ", who is a stranger." << endl;
    }
private:
string name;
};

int main() {

/******* cast from child class to base class *******/
cout << "dynamic_cast from child class to base class:" << endl;
    Children * daughter_d = new Children("Daughter who pretend to be my mother");
    Parents * mother_d = dynamic_cast<Parents*> (daughter_d); //right, cast with polymorphism
    mother_d->Speak();
    mother_d->Work();
//mother_d->Study(); //Error, no such method

cout << "static_cast from child class to base class:" << endl;
    Children * son_s = new Children("Son who pretend to be my father");
    Parents * father_s = static_cast<Parents*> (son_s); //right, cast with polymorphism
    father_s->Speak();  
    father_s->Work();
//father_s->Study(); //Error, no such method

cout << endl;

/******* cast from base class to child class *******/   
cout << "dynamic_cast from base class to child class:" << endl;
    Parents * father_d = new Parents("Father who pretend to be a my son");
    Children * son_d = dynamic_cast<Children*> (father_d); //no error, but not safe
if (son_d)
    {
        son_d->Speak();
        son_d->Study();
    }
else cout << "\t[null]" << endl;

cout << "static_cast from base class to child class:" << endl;
    Parents * mother_s = new Parents("Mother who pretend to be a my daugher");
    Children * daughter_s = static_cast<Children*> (mother_s);  //no error, but not safe
if (daughter_s)
    {
        daughter_s->Speak();
        daughter_s->Study();
    }
else cout << "\t[null]" << endl;

cout << endl;

/******* cast between non-related class *******/    
cout << "dynamic_cast to non-related class:" << endl;
    Stranger* stranger_d = dynamic_cast<Stranger*> (daughter_d);
if (stranger_d)
    {
        stranger_d->Self_Introduce();
        stranger_d->Speak();    
    }
else cout <<"\t[null]"<<endl;

//Stranger* stranger_s = static_cast<Stranger*> (son_s); //Error, invalid cast

cout << "reinterpret_cast to non-related class:" << endl;
    Stranger* stranger_r = reinterpret_cast<Stranger*> (son_s);
if (stranger_r)
    {
        stranger_d->Self_Introduce();
//stranger_d->Speak(); //This line would cause program crush,
//as "name" could not be found corretly.
    }
else cout << "\t[null]" << endl;

cout << endl;

/******* cast back*******/
cout << "use dynamic_cast to cast back from static_cast:" << endl;
    Children* child_s = dynamic_cast<Children*> (father_s);
if (child_s)
    {
        child_s->Speak();
        child_s->Work();
    }
else cout << "\t[null]" << endl;

//cout<<typeid(stranger_r).name()<<endl;

cout << "use dynamic_cast to cast back from reinterpret_cast:" << endl;
    Children* child_r = dynamic_cast<Children*> (stranger_r);
if (child_r)
    {
        child_r->Speak();
        child_r->Work();
    }
else cout << "\t[null]" << endl;

delete daughter_d;
delete son_s;
delete father_d;
delete mother_s;

return 0;
}

/********************* Result *********************/

//dynamic_cast from child class to base class:
// I am Daughter who pretend to be my mother, I love my parents.
// I am Daughter who pretend to be my mother, I need to work for my family.
//static_cast from child class to base class:
// I am Son who pretend to be my father, I love my parents.
// I am Son who pretend to be my father, I need to work for my family.
//
//dynamic_cast from base class to child class:
// [null]
//static_cast from base class to child class:
// I am Mother who pretend to be a my daugher, I love my children.
// I am Mother who pretend to be a my daugher, I need to study for future.
//
//dynamic_cast to non-related class:
// [null]
//reinterpret_cast to non-related class:
// I am a stranger
//
//use dynamic_cast to cast back from static_cast:
// I am Son who pretend to be my father, I love my parents.
// I am Son who pretend to be my father, I need to work for my family.
//use dynamic_cast to cast back from reinterpret_cast:
// [null]

从上边的代码和输出结果可以看出：

对于从子类到基类的指针转换，static_cast 和 dynamic_cast都是成功且正确的（所谓成功是说转换没有编译错误或者运行异常；所谓正确是指方法的调用和数据的访问输出是期望的结果），这是面向对象多态性的完美体现。
从基类到子类的转换，static_cast 和 dynamic_cast 都是成功的，但是正确性方面，对两者的结果都先进行了是否非空的判别：
- dynamic_cast 的结果显示是空指针，而static_cast 则是非空指针，很显然，static_cast 的结果应该算是错误的，子类指针实际所指的是基类的对象，而基类对象并不具有子类的Study()方法(除非妈妈又想去接受个”继续教育”)。
对于没有关系的两个类之间的转换，输出结果表明，dynamic_cast 依然是返回一个空指针以表示转换是不成立的，static_cast直接在编译期就拒绝了这种转换。
reinterpret_cast成功进行了转换，而且返回的值并不是空指针，但是结果显然是错误的，因为Children类显然不具有Stranger的Self_Introduce()。虽然两者都具有name数据成员和Speak()方法，，Speak()方法也只是调用了该相同名称的成员而已，但是对于Speak()的调用直接造成了程序的崩溃。
其实前面static_cast的转换的结果也会跟reinterpret_cast一样造成的程序的崩溃，只是类的方法都只有一份，只有数据成员属于对象，所以在调用那些不会访问对象的数据的方法时（如Stranger的Self_Introduce()）并不会造成崩溃。而daughter_s->Speak();和daughter_s->Study();调用了数据成员却没有出现运行错误，则是因为该成员是从基类继承下来的，通过地址偏移可以正确的到达数据成员所在的地址以读取出数据。
最后，程序里还用dynamic_cast希望把用其他转换运算符转换过去的指针转换回来。对于使用static_cast转换后指向了子类对象的基类指针，dynamic_cast判定转换是合理有效的，因此转换成功获得一个非空的指针并且正确输出了结果；而对于reinterpret_cast转换的类型，的确如它的功能一样——重新解析，变成新的类型，所以才得到dynamic_cast判定该类型已经不是原来的类型结果，转换得到了一个空指针。
总得说来，static_cast 和 reinterpret_cast运算符要么直接被编译器拒绝进行转换，要么一定会得到相应的目标类型的值。而dynamic_cast 却会进行判别，确定源指针所指的内容，是否真的被目标指针接受，如果是否定的，那么dynamic_cast则会返回null。这是通过检查“运行期类型信息”（Runtime type information，RTTI）来判定的，它还受到编译器的影响，有些编译器需要设置开启才能让程序正确运行，因此dynamic_cast 也就不能用传统的转换方式来实现。
虚函数（virtual function）对dynamic_cast的作用

已经在前面反复提到过面向对象的多态性，但是这个多态性到底要如何体现呢？dynamic_cast真的允许任意对象指针之间进行转换，只是最后返回个null值来告知转换无结果吗？

实际上，这一切都是虚函数在起作用。

在C++的面向对象思想中，虚函数起到了很关键的作用，当一个类中拥有至少一个虚函数，那么编译器就会构建出一个虚函数表，来只是这些函数的地址，假如继承该类的子类定义并实现了一个同名并具有同样函数签名的方法重写了基类的方法，那么虚函数表会将该函数指向新的地址。此时，多态性就体现出来了：当我们将基类的指针或引用指向子类的对象的时候，调用方法时，就会顺着虚函数表找到相应的子类的方法而非基类的方法。

当然虚函数表的存在对于效率上有一定的影响，首先构建虚函数表需要时间，根据虚函数表找到函数也需要时间。

因为这个原因如果没有继承的需要，一般不必在类中定义虚函数。但是对于继承来说，虚函数就变得很重要了，这不仅仅是实现多态性的一个重要标志，同时也是dynamic_cast 转换能够进行的前提条件。

假如去掉上个例子中Stranger类析构函数前的virtual，那么语句：

Children* child_r = dynamic_cast<Children*> (stranger_r);

在编译时期就会直接报出错误，具体原因不是很清楚，我猜测可能是因为当类没有虚函数表的时候，dynamic_cast 就不能用RTTI 来确定类的具体类型，于是就直接不通过编译。

这不仅仅是没有继承关系的类之间的情况，如果基类或者子类没有任何虚函数（如果基类有虚函数表，子类当然是自动继承了该表），当他们作为dynamic_cast的源类型进行转换时，编译也会失败。

这种情况是有可能存在的，因为在设计的时候，我们可能不需要让子类重写任何基类的方法。但实际上，这是不合理的。强调一点：如果要用继承，那么一定要让析构函数是虚函数；如果一个函数是虚函数，那么在子类中也要是虚函数。

为何继承中析构函数必须是虚函数
C++类有继承时，析构函数必须是虚函数，如果不是虚函数，则使用时可能出现内存泄漏的问题。

    class a{
int aa;
public:
virtual ~a(){};
    };
    class b : public a{
int bb;
    };
    a *pa = new b; // upcast
    delete pa;

如果基类的析构函数不为虚的，就会造成内存泄漏，具体表现为基类的内存被释放了而派生类所占用的内存未被释放。

由于pa是个基类的指针, 只能识别属于基类的部分, 所以如果没有虚析构函数的话, 那么子类中特有的部分就不会被释放, 造成”经典”的释放一半, 泄露一半的内存泄露.也就是说delete pa只能调用基类的析构函数，而不能调用继承类的析构函数，相当于输出基类析构函数的输出，而派生累的析构函数没有被调用，也就不会有输出产生。

一般，只要一个类为其他类的基类，那么它就一定是虚函数，只要一个类中有虚函数，那么它的析构函数就一定也要是虚的。

基类析构函数要声明为虚函数这样派生类调用析构函数时才能层层回调，释放资源，这也是虚函数的作用—-提供回调的指针。

秒客网

C++ 类型转换运算符

const_cast

reinterpret_cast

static_cast

dynamic_cast

相关文章