C++强制类型转换

在我们编程过程中经常遇到一些需要进行转换的数据操作，比如把整型转换为字符型。在C语言中我们进场这么做，转换也分隐式和显示转换。下面我们从C语言出发，通过代码来看看类型转换：

#include<stdio.h>
{
    int a = 65;
    int b = 70;
    char ch = (char)a;//强制显示转换
    printf("%d , %f, %c",a,b,c);//这里存在一个隐式转换那就是这里的b，从整型转换为浮点型
    return 0;//习惯性的加上还是比较完美的0.0
}

为了在我们学的C++中更能自如的使用多态，不免我们就要遇到类型的转换问题，在这里我们主要针对C++的类型转换来进行分析，在C++中为了实现类型之间的相互赋值操作，专门设有四个函数来做这个工作，分别是：

const_cast <new_type> (expression)//去常性
static_cast <new_type> (expression)//静态转换，就是类型相关的转换，（隐式 ）；int转flaot,double转int等等。
reinterpret_cast <new_type> (expression)//将一种类型转换成为另外一种类型。

dynamic_cast <new_type> (expression)//用于将一个父类对象的指针转换成为一个子类对象的指针或者引用。1.向上转型：子类对象的指针->指向父类对象的指针或者引用。2.向下转型：父类对象的指针->指向子类对象的指针和引用。

它们有着相同的结构，看起来像是模板方法。这些方法就是提供给开发者用来进行指针和引用的转换的。

1、const_cast ：

const_cast转换符是用来移除变量的const或volatile限定符。先者是去除常性，因为很多时候我们不得不设定变量为常变量，防止其他操作改变他的值，对于数据也是一种保护，但我们在设定了常变量之后有时迫不得已需要在函数中修改常变量的值得时候就会需要去常性，用const_cast来去除const限定对于const变量，我们就能修改它的值，这是这个限定符最直接的表现；后者是在线程先使用的关键字，它的作用就是保证取数据从内存中取，保证取得数据是原值，意思就是在多线程中存在CPU竞争现象，如果有一个线程取了内存中的一个变量值正要操作，就被夺去CPU执行权，为了防止下次该线程执行时候取数值取得是原值而不是在被夺去CPU执行权候由于其他线程对该数据的拒不改变导致取值错误而设置的，在这里我们不做过多详细的展示和讲解。

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

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运算符实现原因就在于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

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

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

可是它们的确指向了同一个地址呀：

cout << "constant: "<< &constant <<endl;
cout << "const_p: "<< const_p <<endl;
cout << "modifier: "<< modifier <<endl;

/**
constant: 0x7fff5fbff72c
const_p: 0x7fff5fbff72c
modifier: 0x7fff5fbff72c
**/

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

IBM的C++指南称呼“*modifier = 7;”为“未定义行为（Undefined Behavior）”。所谓未定义，是说这个语句在标准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;
    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限定的目的绝对不是为了修改它的内容，只是出于无奈。（如果真像我说是种无奈，似乎const_cast就不太有用到的时候了，但的确我也很少用到它）

Director: Jim Fawcett
C++ Language Tutorial - Type Casting
Object Oriented Design
IBM Complilers - XL C/C++ V9.0 for Linux - The const_cast operator (C++ only)
stackoverflow: Is const_cast safe?

2、static_cast (expression)：

static_cast,用于静态转换，就是类型相关的转换，从内存深处对数据类型进行转换，（隐式 ）；int转flaot,double转int等等。

3、reinterpret_cast

(expression):reinterpret_cast用于将一种类型转换成为另外一种类型。

4、dynamic_cast (expression)

#include<iostream>
//#include"stl_alloc.h"
using namespace std;
class A
{
public:  
    virtual void fun1()  
    {  
        cout << "A:fun1()" << endl;  
    }     
};  
class B : public  A  
{  
    void fun1()  
    {  
        cout << "B:fun1()" << endl;  
    }  
};  
void fun(A*p)  
{  
    B *p1 = static_cast<B*>(p); ///
    B *p2 = dynamic_cast<B*>(p);  ///

    cout <<"p1:"<< p1 << endl;  
    cout << "p2:"<<p2 << endl;  

}  
int main()  
{  
    A a;  
    B b;  //子类给父类赋值
    fun(&a);  
    fun(&b);  
    system("pause");  
    return 0;  
}

这里主函数在调用fun函数时子类可以直接给父类赋值是因为，在子类里继承了父类所有的成员和方法，在构造子类的时候会先调用父类构造方法构造父类之后再构造子类，但是反过来是不行的。

如代码中所示，需要使用强制才可以实现父类给子类赋值。
在这里我们主要针对const_cast进行了分析和解释，因为后面这三个我用到的不多 ，就只讲解了简单的代码使用和方法。