C ++中四种类型转换方式

最新推荐文章于 2024-04-16 07:30:00 发布

青山依旧在几度夕阳红

最新推荐文章于 2024-04-16 07:30:00 发布

阅读量618

点赞数

文章标签： c++

本文链接：https://blog.csdn.net/qq_36382119/article/details/114910094

版权

1、const_cast 用于取出const属性，去掉类型的const或volatile属性，把const类型的指针变为非const类型的指针

例子：
#include <iostream>
using namespace std;
int main(){
const int n = 100;
int *p = const_cast<int*>(&n); //&n的类型为const int*，只有将其类型转换为int *才可以对p（类型为int *)进行赋值                                           常量不能给非常量赋值，导致常量可能被修改。
*p = 234; //变量n防止在栈内存中，有写入权限可以通过p来修改n的值
cout<<"n = "<<n<<endl;
cout<<"*p = "<<*p<<endl;
return 0;
}

由于编译器对于常量的处理类似于#define的处理，是一个简单的值的替换过程，代码中所有使用到n的地方全部被替换成了100。

2、dynamic_cast 主要是用来”向下安全转型“，决定了某一对象是否归属于继承体系中的某一个类型，用在类继承层次之间的转换可以进行向上类型的转换（
   在进行向上类型转换的时候，不进行安全检测。主要作用：将基类类型的指针或者是引用安全的转化为子类类型的引用和指针。
       语法：dynamic_cast < type-id > ( expression )

   情况1、如果 type-id 是指向 expression的明确的可访问的直接或间接基类的指针，则结果是指向 type-id 类型的唯一子对象的指针
       class B { };
       class C : public B { };
       class D : public C { };

       void f(D* pd) {
       C* pc = dynamic_cast<C*>(pd); // ok: C is a direct base class，pc points to C subobject of pd
       B* pb = dynamic_cast<B*>(pd); // ok: B is an indirect base class，pb points to B subobject of pd
       }
   情况2、如果 type-id 为 void*，则做运行时进行检查确定 expression的实际类型。结果是指向 expression 的完整的对象的指针。
       class A {virtual void f();};
       class B {virtual void f();};

       void f() {
       A* pa = new A;
       B* pb = new B;
       void* pv = dynamic_cast<void*>(pa); // pv now points to an object of type A
       pv = dynamic_cast<void*>(pb); // pv now points to an object of type B
       }
   情况3、如果 expression 类型是 type-id的基类，则做运行时检查来看是否 expression 确实指向 type-id类型的完整对象。
   如果为 true，则结果是指向type-id类型的完整对象的指针
       class B {virtual void f();};
       class D : public B {virtual void f();};

       void f() {
       B* pb = new D; // unclear but ok
       B* pb2 = new B;
       D* pd = dynamic_cast<D*>(pb); // ok: pb actually points to D object
       D* pd2 = dynamic_cast<D*>(pb2); // pb2 points to B object not D object，此时基类指针没有指向子类对象。
       }
   此转换类型称为“向下转换”，因为它将在类层次结构下的指针，从给定的类移到该类派生的类。


   完整示例：
       #include <iostream>
       #include <assert.h>
       using namespace std;
       class Tfather
       {
       public:
           virtual void f() { cout << "father's f()" << endl; }
       };
       class Tson : public Tfather
       {
       public:
           void f() { cout << "son's f()" << endl; }
           int data;
       };

       int main()
       {
           Tfather father;
           Tson son;
           son.data = 123;

           Tfather *pf;
           Tson *ps;

           /* 上行转换：没有问题，多态有效 */
           ps = &son;
           pf = dynamic_cast<Tfather *>(ps);
           pf->f();

           /* 下行转换（pf实际指向子类对象）：没有问题 */
           pf = &son;
           ps = dynamic_cast<Tson *>(pf);
           ps->f();
           cout << ps->data << endl;       // 访问子类独有成员有效

           /* 下行转换（pf实际指向父类对象）：含有不安全操作，dynamic_cast发挥作用返回NULL */
           pf = &father;
           ps = dynamic_cast<Tson *>(pf);
           assert(ps != NULL);              // 违背断言，阻止以下不安全操作
           ps->f();
           cout << ps->data << endl;       // 不安全操作，对象实例根本没有data成员

           /* 下行转换（pf实际指向父类对象）：含有不安全操作，static_cast无视 */
           pf = &father;
           ps = static_cast<Tson *>(pf);
           assert(ps != NULL);
           ps->f();
           cout << ps->data << endl;           // 不安全操作，对象实例根本没有Data成员
           system("pause");
       }