强制转换符--const-cast

强制转换符 —const_cast

问题

• 基类---->派生类 ： 可能越界

• 函数指针的转换

• 整数转换成指针

• 常量指针转换成非常量指针

强制转换符

• const_cast
• static_cast
• reinterpret_cast
• dynamic_cast

c语言强制转换符的缺点

主要是为了克服一下三个缺点

• 没有从形式上体现转换功能和风险的不同
• 多态基类指针转换为派生类指针不检查安全性
• 难以发现强制转换的位置

1.const_cast

• 只针对指针，引用，this指针

• 针对于指针引用和this指针可以去 const

 const int  n = 5;
 const string  s = "CX";

 int* k = const_cast<int*>(&n);
*k = 123;
int& m = const_cast<int&>(&n);
k = 123;

class Test{
   	public:Test m_nTest(2){}
    		//常成员函数----不能改变
    		void foo(int t)const {
                vois *p =this;
                const_cast<Test*const>(this)->m_nTest = nTest;
            }
    		int m_nTest;
}

2.static_cast

int main(){
   int n = 5;
   float f =10.0f;
   double d = 1.0;
   char ch = 'a';

    //本质山发生了隐式转换
   f =  n;

   f = static_cast<float>(n);

   //低风险的转换
   //整型和浮点型
   n =  static_cast<int>(d);

   //字符和整型
   n = static_cast<int>(ch);

    //void*指针的转换
    void* p = nullptr;
    int *pn  = static_cast<int*>(p);

3.dynamic_cast

RTTI

用于虚函数基类与派生类之间的引用和指针的转换

• 基类必须具备虚函数
• 运行时检查，转型不成功则返回一个空指针
• 非必要不使用，有额外的开销

使用

#include<iostream>
using namespace std;
class Base{
    public:
	    virtual void foo(){}
};
class subClass: public Base{
    public:
        void foo() override{} 
};
int main(){
    Base a;
    subClass b;
    
    Base* c = &a;
    subClass* d = &b;

    //向下转换， 父类转子类 不安全
    
    //使用dynamic_cast可以检测这种转换是不安全的
    //再运行时检测是否安全
    
    //在运行的时间检测被转换指针的类型
    d = static_cast<Base*>(c);
    d = dynamic_cast<Base*>(c);		//null
   

    //向上转换，子类转成父类 安全
    c = d;
    c = static_cast<Base*>(d);
}

4.reinterpret_cast