const_cast

• 常量指针被转化成非常量的指针, 并且仍然指向原来的对象
• 常量引用被转换成非常量的引用, 并且仍然指向原来的对象
• const_cast一般用于修改指针, 如 const char* p

#include <iostream>
int main() {
 
    int ary[4] = { 1,2,3,4 };  
    const int* c_ptr = ary; // 常量化数组指针
    int *ptr = const_cast<int*>(c_ptr); // 通过const_cast<Ty> 去常量

    for (int i = 0; i < 4; i++)
        ptr[i] += 1;

    for (int i = 0; i < 4; i++)
        std::cout << ary[i] << "\t";
    std::cout << std::endl;
    return 0;
}

/*  out print
    2   3   4   5
*/

对于在定义为常量的变量，使用const_cast可能会有不同的结果：

#include <iostream>

int main() {
    const int c_val = 111;
    int &ref_val = const_cast<int&>(c_val);
    int *ptr_val = const_cast<int*>(&c_val);

    ref_val = 666;  //未定义行为
    std::cout << c_val << "\t" << ref_val << "\t" << *ptr_val << std::endl;
    *ptr_val = 555; //未定义行为
    std::cout << c_val << "\t" << ref_val << "\t" << *ptr_val << std::endl;

    return 0;
}

/*
./const_cast
111     666     666
111     555     555
*/

可以看出, reg_val 和 ptr_val对应的值都发生了改变，但原来的 c_val 的值并未改变。查看了<c++ primer>中内容，发现对 ref_val 和 ptr_val的写操作都是 “未定义的”。

未定义是说，这个测试结果只是在当前编译器下得到的结果，不过换了编译器，可能得到的结果不同，所以最好不要对 const_cast转换得到的结果进行写操作。

如果不对 const_cast转换的结果进行写操作，那么const_cast的转换意义在哪里？

因为实际工程中会有许多复杂的情况，有时可能会出现本不该是const的对象被const引用了(尤其是使用模板); 或者是调用了一个参数是const的函数，但我们要传入的参数不是const，这种时候可能会用到 const_cast.

static_cast

• static_cast 作用和C的强制转换效果基本一致，由于没有运行时类型检查来保证转换的安全性，所以这种类型转换和C风格的都具有安全隐患。
• 用于类层次结构中 基类 和 派生类之间的指针/引用转换。

  注意：进行上行转换(把派生类的指针或引用转换成基类表示)是安全的，进行下行转换是不安全的。

• 用于基础数据类型之间的转换, 如int –> char, int –> enum.
• static_cast不能转换掉原有类型的 const, volatile, __unaligned属性, (前两种可以使用const_cast去掉)
• c++ primer中讲, 任何的隐式转换都可以使用 static_cast 来实现。

/* 常规的使用方法 */
float f_pi=3.141592f
int   i_pi=static_cast<int>(f_pi); /// i_pi 的值为 3

/* class 的上下行转换 */
class Base{
    // something
};
class Sub:public Base{
    // something
}

//  上行 Sub -> Base
//编译通过，安全
Sub sub;
Base *base_ptr = static_cast<Base*>(&sub);  

//  下行 Base -> Sub
//编译通过，不安全
Base base;
Sub *sub_ptr = static_cast<Sub*>(&base);

dynamic_cast

• dynamic_cast强制转换,应该是这四种中最特殊的一个,因为他涉及到面向对象的多态性和程序运行时的状态,也与编译器的属性设置有关.所以不能完全使用C语言的强制转换替代,它也是最常有用的,最不可缺少的一种强制转换.

• static_cast只当c语言种的强制转换 () 使用，转化一些常规类型
• dynamic_cast只对有派生类的类使用，一般用在基类到子类的转化上。如：

  • Parents* mother_d = dynamic_cast<Parents*>(daughter_d);
  • Parents* father_d = static_cast<Parents*>(son_s);
  • 以上两个子类到基类的转换是不用写 dynamic_cast或static_cast的，因为多态！如果非要写，则dynamic_cast更为合适。

reinterpret_cast

reinterpret_cast是强制类型转换符用来处理无关类型转换的,通常为操作数的位模式提供较低层次的重新解释。 主要是用在不同类型的指针之间的转换、不同类型的引用之间的转换、以及指针和能容纳下指针的整数类型之间的转换。转换时候，执行的是逐比特拷贝操作。

implicit_cast

在muduo库实现中出现了 implicit_cast的转换。

/*
使用implicit_cast作为static_cast或const_cast的安全版本，
在类型层次结构中进行向上强制转换(即将指向Foo的指针强制转换为指向超类ffoo的指针，
或将指向Foo的指针强制转换为指向Foo的const指针)。

当您使用implicit_cast时，编译器会检查转换是否安全。
当c++要求精确的类型匹配，而不是可转换为目标类型的参数类型时，这种显式的隐式类型转换是必要的。
*/
template<typename To, typename From>
inline To implicit_cast(From const &f) {
    return f;
}

在up_cast时应该使用implicit_cast替换static_cast, 因为前者比后者要安全, 以一个例子说明, 在菱形继承中, 最底层的对象可以转换为中层对象.

#include<boost/implicit_cast.hpp>
#include<iostream>

class Top{};
class MiddleA:public Top{};
class MiddleB:public Top{};
class Bottom:public MiddleA,public MiddleB{};

void Function(MiddleA& A)
{
    std::cout<<"MiddleA Function"<<std::endl;
}
void Function(MiddleB& B)
{
    std::cout<<"MiddleB Function"<<std::endl;
}
int main()
{
    Bottom bottom;
    Function(bottom);
    return 0;
}

这时如果编译, 就会出现错误, 因为在调用函数Function时, bottom既可以默认转换为MiddleA, 也可以默认转换为MiddleB, 如果不明确指出就会出现歧义. 这时可以改为： Function(static_cast<MiddleA&>(bottom)); 或 Function(static_cast<MiddleB&>(bottom)); 程序可以运行了。但是如果不小心这样使用了：

Top top;
Function(static_cast<MiddleB&>top);

这样编译可以通过, 但是在运行时可能崩溃, 因为top不是“一种”MiddleB, 但是static_cast不能发现这个问题, 这时如果用implicit_cast就不会有这个问题了, 在编译时就会给出错误信息。 static_cast不进行真正的类型检查(在down_cast和up_cast的时候)。