c++强制转换运算符

c++中存在几种转换运算符，这些运算符用于消除c语言中转换产生的多义性和危险继承。这些运算符分别是：

• dynamic_cast 用于多态的类型转换
• static_cast 用于非多态的类型转换
• const_cast 用于删除const 、volatile 、__unaligned的特性
• cc用于对位进行简单的重新解释

dynamic_cast 运算符

dynamic_cast 把expression转换为type-id类型的对象，其中type-id必须是之前被定义的类指针、引用或者void*，如果type-id是指针那expression必须是指针，如果是引用，expression必须是引用。

dynamic_cast <type-id>(expression)

dynamic_cast运算符在执行过程中决定真正的类型，如果执行正确（安全）的情况下返回适当类型的指针（或引用）如果不安全的话返回null。

在进行上行转换时，dynamic_cast和static_cast效果是一致的，在执行下行转换时，dynamic_cast会进行类型检查，比static_cast安全。

struct A {
    virtual void test() {
        printf_s("in A\n");
   }
};

struct B : A {
    virtual void test() {
        printf_s("in B\n");
    }

    void test2() {
        printf_s("test2 in B\n");
    }
};

struct C : B {
    virtual void test() {
        printf_s("in C\n");
    }

    void test2() {
        printf_s("test2 in C\n");
    }
};

void Globaltest(A& a) {
    try {
        C &c = dynamic_cast<C&>(a);
        printf_s("in GlobalTest\n");
    }
    catch(std::bad_cast) {
        printf_s("Can't cast to C\n");
    }
}

int main() {
    A *pa = new C;
    A *pa2 = new B;

    pa->test();

    B * pb = dynamic_cast<B *>(pa);
    if (pb)
        pb->test2();

    C * pc = dynamic_cast<C *>(pa2);
    if (pc)
        pc->test2();

    C ConStack;
    Globaltest(ConStack);

    B BonStack;
    Globaltest(BonStack);
}

输出

in C
test2 in B
in GlobalTest
Can't cast to C

static_cast 运算符

static_cast <type-id>(expression)

通常static_cast用于转换数值类型，例如将int转为float，或者将枚举类型转换为int，static_cast也可用于将只想基类的指针转换为子类的指针，但使用者需要确认参与的数据类型，因为static_cast不执行运行时类型检查，安全性比dynamic_cast差。static_cast对不明确的指针进行转换，执行虽然没问题，但这是危险的。

static_cast	dynamic_cast
不进行类型检查	运行时类型检查
适用于各种类型	只适用于指针和引用
没有类型检查开销小	存在类型检查时的额外开销

class B {};
class D : public B {};
void f(B* pb, D* pd) {
// 不安全，D 可以有 B 中没有的字段和方法
   D* pd2 = static_cast<D*>(pb);   
// 安全转换，D 总是包含所有 B。
   B* pb2 = static_cast<B*>(pd);   
}

与 dynamic_cast 不同，pb 的 static_cast 转换不执行运行时检查。 由 pb 指向的对象可能不是 D 类型的对象，在这种情况下使用 *pd2 会是灾难性的。 例如，调用 D 类（而非 B 类）的成员函数可能会导致访问冲突。

class B {
public:
   virtual void Test(){}
};
class D : public B {};
void f(B* pb) {
   D* pd1 = dynamic_cast<D*>(pb);
   D* pd2 = static_cast<D*>(pb);
}

如果 pb 确实指向 D 类型的对象，则 pd1 和 pd2 将获取相同的值。 如果 pb == null，它们也将获取相同的值。

如果 pb 指向 B 类型的对象，而非指向完整的 D 类，则 dynamic_cast 会判断返回null。 但static_cast 依赖于程序员的断言，即 pb 指向 D 类型的对象，因而只是返回指向那个假定的 D 对象的指针。 因此需要程序员来验证 static_cast 转换的结果是否安全。

const_cast 运算符

用来去除复合类型中const和volatile属性（没有真正去除）。变量本身的const属性是不能去除的，要想修改变量的值，一般是去除指针（或引用）的const属性，再进行间接修改。

const_cast<type>(expression)

通过const_cast运算符，也只能将const type转换为type，将const type&转换为type&。

reinterpret_cast 运算符

reinterpret_cast 允许将任何指针转换为任何其他指针类型。 也允许将任何整数类型转换为任何指针类型以及反向转换。

reinterpret_cast < type-id > ( expression )

备注：

• 滥用 reinterpret_cast 运算符可能很容易带来风险。 除非所需转换本身是低级别的，否则应使用其他强制转换运算符之一。
• reinterpret_cast 运算符无法强制转换掉 const、volatile 或 __unaligned 特性。
• reinterpret_cast 运算符可用于 char* 到 int* ，或者一个类指针A到另一个无关系的类指针B的转换，但不安全。
• reinterpret_cast 的结果不能安全地用于除强制转换回其原始类型以外的任何用途。 在最好的情况下，其他用途也是不可移植的。
• reinterpret_cast 运算符将空指针值转换为目标类型的空指针值。