精华内容
下载资源
问答
  • static_cast dynamic_cast reinpreter_cast const_cast  首先回顾一下C++类型转换: C++类型转换分为:隐式类型转换和显式类型转换   第1部分. 隐式类型转换 又称为“标准转换”,包括以下几种情况: 1) ...

    目录

    第1部分. 隐式类型转换

    第2部分. 显式类型转换

    static_cast

    dynamic_cast

    reinpreter_cast

    const_cast


     首先回顾一下C++类型转换:

    C++类型转换分为:隐式类型转换和显式类型转换
     

    第1部分. 隐式类型转换

    又称为“标准转换”,包括以下几种情况:
    1) 算术转换(Arithmetic conversion) : 在混合类型的算术表达式中, 最宽的数据类型成为目标转换类型。

    int ival = 3;
    double dval = 3.14159;
    ival + dval;//ival被提升为double类型

    2)一种类型表达式赋值给另一种类型的对象:目标类型是被赋值对象的类型

    int *pi = 0; // 0被转化为int *类型
    ival = dval; // double->int

    例外:void指针赋值给其他指定类型指针时,不存在标准转换,编译出错

    3)将一个表达式作为实参传递给函数调用,此时形参和实参类型不一致:目标转换类型为形参的类型

    extern double sqrt(double);
    cout << ”The square root of 2 is ” << sqrt(2) << endl;  //2被提升为double类型:2.0

    4)从一个函数返回一个表达式,表达式类型与返回类型不一致:目标转换类型为函数的返回类型

    double difference(int ival1, int ival2)
    {
        return ival1 - ival2;
        //返回值被提升为double类型
    }

    第2部分. 显式类型转换

    被称为“强制类型转换”(cast)
    C     风格: (type-id)
    C++风格: static_castdynamic_castreinterpret_cast、和const_cast..

    关于强制类型转换的问题,很多书都讨论过,写的最详细的是C++ 之父的《C++ 的设计和演化》。最好的解决方法就是不要使用C风格的强制类型转换,而是使用标准C++的类型转换符:static_cast, dynamic_cast。标准C++中有四个类型转换符:static_castdynamic_castreinterpret_cast、和const_cast。下面对它们一一进行介绍。
     

    static_cast

    用法:static_cast < type-id > ( expression )

    说明:该运算符把expression转换为type-id类型,但没有运行时类型检查来保证转换的安全性。

    来源:为什么需要static_cast强制转换?
    情况1:void指针->其他类型指针
    情况2:改变通常的标准转换
    情况3:避免出现可能多种转换的歧义


    它主要有如下几种用法:

    • 用于类层次结构中基类和子类之间指针或引用的转换。进行上行转换(把子类的指针或引用转换成基类表示)是安全的;进行下行转换(把基类指针或引用转换成子类指针或引用)时,由于没有动态类型检查,所以是不安全的。
    • 用于基本数据类型之间的转换,如把int转换成char,把int转换成enum。这种转换的安全性也要开发人员来保证。
    • 把void指针转换成目标类型的指针(不安全!!)
    • 把任何类型的表达式转换成void类型。

    注意:static_cast不能转换掉expression的const、volitale、或者__unaligned属性。

    • 编译器隐式执行的任何类型转换都可以由static_cast来完成,比如int与float、double与char、enum与int之间的转换等。
    double a = 1.999;
    int b = static_cast<double>(a); //相当于a = b ;

      当编译器隐式执行类型转换时,大多数的编译器都会给出一个警告:

    e:\vs 2010 projects\static_cast\static_cast\static_cast.cpp(11): warning C4244: “初始化”: 从“double”转换到“int”,可能丢失数据

      使用static_cast可以明确告诉编译器,这种损失精度的转换是在知情的情况下进行的,也可以让阅读程序的其他程序员明确你转换的目的而不是由于疏忽。

      把精度大的类型转换为精度小的类型,static_cast使用位截断进行处理。

    • 使用static_cast可以找回存放在void*指针中的值。
     double a = 1.999;
     void * vptr = & a;
     double * dptr = static_cast<double*>(vptr);
     cout<<*dptr<<endl;//输出1.999

    static_cast也可以用在于基类与派生类指针或引用类型之间的转换。然而它不做运行时的检查,不如dynamic_cast安全。static_cast仅仅是依靠类型转换语句中提供的信息来进行转换,而dynamic_cast则会遍历整个类继承体系进行类型检查,因此dynamic_cast在执行效率上比static_cast要差一些。现在我们有父类与其派生类如下:

    class ANIMAL {
     public: 
        ANIMAL():_type("ANIMAL"){};
        virtual void OutPutname(){cout<<"ANIMAL";}; 
     private: 
        string _type ; 
    }; 
    class DOG:public ANIMAL { 
     public: 
       DOG():_name("大黄"),_type("DOG"){}; 
       void OutPutname(){cout<<_name;}; 
       void OutPuttype(){cout<<_type;}; 
     private: 
       string _name ; string _type ; 
    };

     

    此时我们进行派生类与基类类型指针的转换:注意从下向上的转换是安全的,从上向下的转换不一定安全。

    int main()
    {
        //基类指针转为派生类指针,且该基类指针指向基类对象。
        ANIMAL * ani1 = new ANIMAL ;
        DOG * dog1 = static_cast<DOG*>(ani1);
        //dog1->OutPuttype();//错误,在ANIMAL类型指针不能调用方法OutPutType();在运行时出现错误。
    
        //基类指针转为派生类指针,且该基类指针指向派生类对象
        ANIMAL * ani3 = new DOG;
        DOG* dog3 = static_cast<DOG*>(ani3);
        dog3->OutPutname(); //正确
    
        //子类指针转为派生类指针
        DOG *dog2= new DOG;
        ANIMAL *ani2 = static_cast<DOG*>(dog2);
        ani2->OutPutname(); //正确,结果输出为大黄
    
        //
        system("pause");
    
    }

     

    • static_cast可以把任何类型的表达式转换成void类型。
    • static_cast把任何类型的表达式转换成void类型。
    • 另外,与const_cast相比,static_cast不能把换掉变量的const属性,也包括volitale或者__unaligned属性。

    dynamic_cast

    用法:dynamic_cast < type-id > ( expression )

    说明:该运算符把expression转换成type-id类型的对象。Type-id必须是类的指针、类的引用或者void *;如果type-id是类指针类型,那么expression也必须是一个指针,如果type-id是一个引用,那么expression也必须是一个引用。

    来源:为什么需要dynamic_cast强制转换?
    简单的说,当无法使用virtual函数的时候


    典型案例:
    Wicrosoft公司提供给我们一个类库,其中提供一个类Employee.以头文件Eemployee.h和类库.lib分发给用户
    显然我们并无法得到类的实现的源代码

    //Emplyee.h
    class Employee 
    {
    public:
        virtual int salary();
    };
    
    class Manager : public Employee
    {
    public: 
        int salary();
    };
    
    class Programmer : public Employee
    {
    public:
        int salary();
    };

    我们公司在开发的时候建立有如下类:

    class MyCompany
    {
    public:
        void payroll(Employee *pe);
        //
    };
    
    void MyCompany::payroll(Employee *pe)
    {
        //do something
    }

    但是开发到后期,我们希望能增加一个bonus()的成员函数到W$公司提供的类层次中。
    假设我们知道源代码的情况下,很简单,增加虚函数:

    //Emplyee.h
    class Employee 
    {
    public:
        virtual int salary();
        virtual int bonus();
    };
    
    class Manager : public Employee
    {
    public: 
        int salary();
    };
    
    class Programmer : public Employee
    {
    public:
        int salary();
        int bonus();
    };
    
    //Emplyee.cpp
    
    int Programmer::bonus()
    {
        //
    }
    
    
    payroll()通过多态来调用bonus()
    
    class MyCompany
    {
    public:
        void payroll(Employee *pe);
        //
    };
    
    void MyCompany::payroll(Employee *pe)
    {
        //do something
        //pe->bonus();
    }
    

    但是现在情况是,我们并不能修改源代码,怎么办?dynamic_cast华丽登场了!
    在Employee.h中增加bonus()声明,在另一个地方定义此函数,修改调用函数payroll().重新编译,ok

    //Emplyee.h
    class Employee 
    {
    public:
        virtual int salary();
    };
    
    class Manager : public Employee
    {
    public: 
        int salary();
    };
    
    class Programmer : public Employee
    {
    public:
        int salary();
        int bonus();//直接在这里扩展
    };
    
    //somewhere.cpp
    
    int Programmer::bonus()
    {
        //define
    }
    
    
    
    class MyCompany
    {
    public:
        void payroll(Employee *pe);
        //
    };
    
    void MyCompany::payroll(Employee *pe)
    {
        Programmer *pm = dynamic_cast<Programmer *>(pe);
        
        //如果pe实际指向一个Programmer对象,dynamic_cast成功,并且开始指向Programmer对象起始处
        if(pm)
        {
            //call Programmer::bonus()
        }
        //如果pe不是实际指向Programmer对象,dynamic_cast失败,并且pm = 0
        else
        {
            //use Employee member functions
        }
    }
    

    dynamic_cast主要用于类层次间的上行转换和下行转换,还可以用于类之间的交叉转换。

    在类层次间进行上行转换时,dynamic_cast和static_cast的效果是一样的;在进行下行转换时,dynamic_cast具有类型检查的功能,比static_cast更安全。

    class Base
    {
    public:
        int m_iNum;
        virtual void foo();
    };
    
    class Derived:public Base
    {
    public:
        char *m_szName[100];
    };
    
    void func(Base *pb)
    {
        Derived *pd1 = static_cast<Derived *>(pb);
    
        Derived *pd2 = dynamic_cast<Derived *>(pb);
    }

    在上面的代码段中,
    如果pb实际指向一个Derived类型的对象,pd1和pd2是一样的,并且对这两个指针执行Derived类型的任何操作都是安全的;
    如果pb实际指向的是一个Base类型的对象,那么pd1将是一个指向该对象的指针,对它进行Derived类型的操作将是不安全的(如访问m_szName),而pd2将是一个空指针(即0,因为dynamic_cast失败)。
    另外要注意:Base要有虚函数,否则会编译出错;static_cast则没有这个限制。这是由于运行时类型检查需要运行时类型信息,而这个信息存储在类的虚函数表(关于虚函数表的概念,详细可见<Inside c++ object model>)中,只有定义了虚函数的类才有虚函数表,没有定义虚函数的类是没有虚函数表的。

    另外,dynamic_cast还支持交叉转换(cross cast)。如下代码所示。

    class Base
    {
    public:
        int m_iNum;
        virtual void f(){}
    };
    
    class Derived1 : public Base
    {
    
    };
    
    class Derived2 : public Base
    {
    
    };
    
    void foo()
    {
        derived1 *pd1 = new Drived1;
    
        pd1->m_iNum = 100;
    
        Derived2 *pd2 = static_cast<Derived2 *>(pd1); //compile error
    
        Derived2 *pd2 = dynamic_cast<Derived2 *>(pd1); //pd2 is NULL
    
        delete pd1;
    }

    在函数foo中,使用static_cast进行转换是不被允许的,将在编译时出错;而使用 dynamic_cast的转换则是允许的,结果是空指针。
     

    reinpreter_cast

    用法:reinpreter_cast<type-id> (expression)

    说明:type-id必须是一个指针、引用、算术类型、函数指针或者成员指针。它可以把一个指针转换成一个整数,也可以把一个整数转换成一个指针(先把一个指针转换成一个整数,在把该整数转换成原类型的指针,还可以得到原先的指针值)。

    该运算符的用法比较多。
     

    const_cast

    用法:const_cast<type_id> (expression)

    说明:该运算符用来修改类型的const或volatile属性。除了const 或volatile修饰之外, type_id和expression的类型是一样的。


    常量指针被转化成非常量指针,并且仍然指向原来的对象;常量引用被转换成非常量引用,并且仍然指向原来的对象;常量对象被转换成非常量对象。

    Voiatile和const类试。举如下一例:

    class B{
    
    public:
    
    int m_iNum;
    
    }
    
    void foo(){
    
    const B b1;
    
    b1.m_iNum = 100; //comile error
    
    B b2 = const_cast<B>(b1);
    
    b2. m_iNum = 200; //fine
    }

    上面的代码编译时会报错,因为b1是一个常量对象,不能对它进行改变;使用const_cast把它转换成一个常量对象,就可以对它的数据成员任意改变。注意:b1和b2是两个不同的对象。

    转自:https://blog.csdn.net/u013246898/article/details/77929785

    https://www.cnblogs.com/QG-whz/p/4509710.html

    展开全文
  • 好在c++增加了static_cast和dynamic_cast运用于继承关系类间的强制转化 一、static_cast和dynamic_cast使用方式 static_cast< new_type >(expression) dynamic_cast< new_type >(expression) 备注:new_type为目标...

    转载自:链接

    类继承关系图

    在这里插入图片描述

    注:从图中可以看出,派生类不仅有自己的方法和属性,同时它还包括从父类继承来的方法和属性。当我们从派生类向基类转换时,不管用传统的c语言还是c++转换方式都可以百分百转换成功。但是可怕是向下转换类型,也就是我们从基类向派生类转换,当我们采用传统的C语言和c++转换时,就会出现意想不到的情况,因为转换后派生类自己的方法和属性丢失了,一旦我们去调用派生类的方法和属性那就糟糕了,这就是对类继承关系和内存分配理解不清晰导致的。好在c++增加了static_cast和dynamic_cast运用于继承关系类间的强制转化

    一、static_cast和dynamic_cast使用方式

    static_cast< new_type >(expression)
    dynamic_cast< new_type >(expression)
    备注:new_type为目标数据类型,expression为原始数据类型变量或者表达式。

    二、static_cast详解:

    static_cast相当于传统的C语言里的强制转换,该运算符把expression转换为new_type类型,用来强迫隐式转换如non-const对象转为const对象,编译时检查,用于非多态的转换,可以转换指针及其他,但没有运行时类型检查来保证转换的安全性。它主要有如下几种用法:

    ①用于类层次结构中基类(父类)和派生类(子类)之间指针或引用的转换。
    进行上行转换(把派生类的指针或引用转换成基类表示)是安全的;
    进行下行转换(把基类指针或引用转换成派生类表示)时,由于没有动态类型检查,所以是不安全的。
    ②用于基本数据类型之间的转换,如把int转换成char,把int转换成enum。
    ③把空指针转换成目标类型的空指针。
    ④把任何类型的表达式转换成void类型。
    注意:static_cast不能转换掉expression的const、volatile、或者__unaligned属性

    基本类型数据转换举例如下:

    char a = 'a';
    int b = static_cast<char>(a);//正确,将char型数据转换成int型数据
    
    double *c = new double;
    void *d = static_cast<void*>(c);//正确,将double指针转换成void指针
    
    int e = 10;
    const int f = static_cast<const int>(e);//正确,将int型数据转换成const int型数据
    
    const int g = 20;
    int *h = static_cast<int*>(&g);//编译错误,static_cast不能转换掉g的const属性
    

    类上行和下行转换:

    class Base
    {};
    
    class Derived : public Base
    {}
    
    Base* pB = new Base();
    if(Derived* pD = static_cast<Derived*>(pB))
    {}//下行转换是不安全的(坚决抵制这种方法)
    
    Derived* pD = new Derived();
    if(Base* pB = static_cast<Base*>(pD))
    {}//上行转换是安全的
    
    
    

    三、dynamic_cast详解:

    转换方式:
    dynamic_cast< type* >(e)
     type必须是一个类类型且必须是一个有效的指针
    dynamic_cast< type& >(e)
    type必须是一个类类型且必须是一个左值
    dynamic_cast< type&& >(e)
    type必须是一个类类型且必须是一个右值

    e的类型必须符合以下三个条件中的任何一个:
    1、e的类型是目标类型type的公有派生类
    2、e的类型是目标type的共有基类
    3、e的类型就是目标type的类型。

    如果一条dynamic_cast语句的转换目标是指针类型并且失败了,则结果为0。如果转换目标是引用类型并且失败了,则dynamic_cast运算符将抛出一个std::bad_cast异常(该异常定义在typeinfo标准库头文件中)。e也可以是一个空指针,结果是所需类型的空指针。

    dynamic_cast主要用于类层次间的上行转换和下行转换,还可以用于类之间的交叉转换(cross cast)。

    在类层次间进行上行转换时,dynamic_cast和static_cast的效果是一样的;在进行下行转换时,dynamic_cast具有类型检查的功能,比static_cast更安全。dynamic_cast是唯一无法由旧式语法执行的动作,也是唯一可能耗费重大运行成本的转型动作。

    (1)指针类型
    举例,Base为包含至少一个虚函数的基类,Derived是Base的共有派生类,如果有一个指向Base的指针bp,我们可以在运行时将它转换成指向Derived的指针,代码如下:

    if(Derived *dp = dynamic_cast<Derived *>(bp)){
      //使用dp指向的Derived对象  
    }
    else{
      //使用bp指向的Base对象  
    }
    

    值得注意的是,在上述代码中,if语句中定义了dp,这样做的好处是可以在一个操作中同时完成类型转换和条件检查两项任务。

    (2)引用类型

    因为不存在所谓空引用,所以引用类型的dynamic_cast转换与指针类型不同,在引用转换失败时,会抛出std::bad_cast异常,该异常定义在头文件typeinfo中。

    void f(const Base &b){
     try{
       const Derived &d = dynamic_cast<const Base &>(b);  
       //使用b引用的Derived对象
     }
     catch(std::bad_cast){
       //处理类型转换失败的情况
     }
    }
    

    四、转换注意事项:

    尽量少使用转型操作,尤其是dynamic_cast,耗时较高,会导致性能的下降,尽量使用其他方法替代。

    展开全文
  • static_cast 用法

    2021-05-24 09:07:40
    static_cast 用法语法:static_cast(expression)仅当 type-name 可以隐式转换为 expression 所属的类型,或者 expression 可以隐式转换为 type-name 所属的类型,转换才是合法的。否则,编译器会报错。可以将有继承...

    static_cast 用法

    语法:

    static_cast(expression)

    仅当 type-name 可以隐式转换为 expression 所属的类型,或者 expression 可以隐式转换为 type-name 所属的类型,转换才是合法的。否则,编译器会报错。

    可以将有继承关系的派生类对象的地址赋给基类指针。即使基类中没有虚函数也可以使用 static_cast 进行转换。

    可以将有继承关系的基类对象的地址赋给派生类指针。因为派生类指针可以隐式转换为基类指针,无需显式类型转换,所以可以用  static_cast 进行另一个方向的转换,即将基类指针转换为派生类指针。但是,这样做有什么意义呢?

    同理,因为枚举值可以隐式转换为整型,无需显式类型转换,所以可以用 static_cast 将整型转换为枚举类型。

    如果将没有继承关系的对象的地址赋给另一个类的指针,编译器会报错。

    请看代码一:#include

    class Base{

    int dat;

    public:

    explicit Base(int val) : dat(val){

    printf("%s, this=%p\n", __func__, this);

    }

    #if 0

    virtual void act(){

    #else

    void act(){

    #endif

    printf("%s, this=%p\n", __func__, this);

    }

    };

    class Sub : public Base{

    public:

    explicit Sub(int val) : Base(val){

    printf("%s, this=%p\n", __func__, this);

    }

    };

    class Other{

    int dat;

    public:

    explicit Other(int val) : dat(val){

    printf("%s, this=%p\n", __func__, this);

    }

    };

    int main(){

    Base obase(1);

    Sub osub(2);

    Base *pbase = NULL;

    if(pbase = static_cast(&osub) ){

    pbase->act();

    }

    printf("---------------\n");

    Base *ptr = &osub;

    ptr->act();

    printf("---------------\n");

    #if 1

    if(Sub *psub = static_cast(&obase) ){

    psub->act();

    }

    #endif

    #if 0

    Other oother(3);

    //error: invalid static_cast from type ‘Other*’ to type ‘Base*’

    if(pbase = static_cast(&oother) ){

    pbase->act();

    }

    #endif

    }

    测试结果:

    frank@userver:~/project/test/cpp/rtti$ ./a.out

    Base, this=0x7fff6d478100

    Base, this=0x7fff6d478110

    Sub, this=0x7fff6d478110

    act, this=0x7fff6d478110

    ---------------

    act, this=0x7fff6d478110

    ---------------

    act, this=0x7fff6d478100

    代码二:#include

    int main(){

    enum eSource{

    eAuxSource = 0,

    eOpticalSource,

    eBtSource,

    eFcSource,

    eSpotifySource,

    eGcSource

    };

    #if 0

    eSource src = eBtSource;

    #else

    //eSource src = 3; //error: invalid conversion from ‘int’ to ‘main()::eSource’ [-fpermissive]

    eSource src = static_cast(3.1);

    #endif

    printf("src: %p, %lu, %d\n", &src, sizeof(src), src);

    }

    展开全文
  • static_cast用法详解 静态类型转换(斯文的劝导,温柔的转换)。如int转换成char 主要用法: 1、用于类层次结构中基类(父类)和派生类(子类)之间指针或引用的转换。上行指针或引用(派生类到基类)转换安全,下行不...

    static_cast用法详解

    静态类型转换(斯文的劝导,温柔的转换)。如int转换成char

    主要用法:
    1、用于类层次结构中基类(父类)和派生类(子类)之间指针或引用的转换。上行指针或引用(派生类到基类)转换安全,下行不安全

    2、用于基本数据类型之间的转换,如把int转换成char,把int转换成enum。这种转换的安全性也要开发人员来保证。

    3、把空指针转换成目标类型的空指针。

    4、把任何类型的表达式转换成void类型。

    demo 代码(一)

    #include <iostream>
    
    using namespace std;
    
    class Animal
    {
    public:
    	virtual void cry() = 0;
    };
    
    class Cat :public Animal
    {
    public:
    	void cry()
    	{
    		cout << "喵喵" << endl;
    	}
    };
    
    class Dog :public Animal
    {
    public:
    	void cry()
    	{
    		cout << "旺旺" << endl;
    	}
    };
    
    int main(void)
    {
    	/* 第一种情况, 父子类之间的转换 */
    	Dog* dog1 = new Dog();
    	Animal* a1 = static_cast<Animal*> (dog1); /* 子类的指针转到父类 */
    	Dog* dog1_1 = static_cast<Dog*>(a1); /* 父类的指针转型到子类的指针 */
    
    	Cat* cat1 = static_cast<Cat*>(a1); /* 父类到子类, 会有风险, 这样会不行的会出问题 */
    
    	a1->cry();
    
    	Dog dog2;
    	Animal& a2 = static_cast<Animal&> (dog2); /* 子类的引用转到父类 */
    
    	Dog& dog2_2 = static_cast<Dog&>(a2); /* 父类引用转到子类引用 */
    
    
    	/* 第二种, 基本类型的转换 */
    	int kkk = 234;
    	char cc = static_cast<char>(kkk);
    
    
    	/* 第三中, 空指针转到目标类型的指针. */
    	int* p1 = NULL; /* 隐式类型转换 */
    	int* p2 = static_cast<int*>(NULL);
    	int* dp = NULL;
    
    
    	/* 第四种, 把任何类型的表达式转换成 void 类型 */
    	int* pi = new int[10];
    	void* vp = static_cast<void*>(pi);
    	vp = pi;
    
    	system("pause");
    	return 0;
    }
    

    结语:

    时间: 2020-07-02

    展开全文
  • 自学QT之static_cast<int>

    2019-09-11 12:08:25
    好吧,其实这个不算QT的内容,是一个c++语法。...static_cast<T>exp 其实就是把exp的部分转化成T类型。 比如这句:brushStytleBox->addItem(tr("Dense7"),static_cast<int>(Qt::Dens...
  • 发现个新的领域,参考代码:... ... double a = 1.999; int b = static_cast<double>(a); //相当于a = b ; 这种是C++中特殊的强制转换方式,用的较多的就是这种,后续遇到继续更新。。。 ...
  • 转发自:这个作者 c强制转换与c++强制转换 c语言强制类型转换主要用于基础的数据...c++除了能使用c语言的强制类型转换外,还新增了四种强制类型转换:static_cast、dynamic_cast、const_cast、reinterpret_cast,...
  • 最好的解决方法就是不要使用C风格的强制类型转换,而是使用标准C++的类型转换符:static_cast, dynamic_cast。标准C++中有四个类型转换符: static_cast 、 dynamic_cast 、 reinterpret_cast 、和 const_cast 。...
  • 地址:https://blog.csdn.net/youyoulg/article/details/6843332
  • C++ 强制类型转换 static_cast dynamic_cast const...文章目录C++ 强制类型转换 static_cast dynamic_cast const_cast reinterpret_cast@[toc]一.const_cast二.static_cast三.reinterpret_cast四.dynamic_cast 一.co...
  • static_cast, reinterpret_cast, const_cast 和 dynamic_cast. const_cast 用来移除 const,这个没什么好说的. dynamic_cast 需要 RTTI 支持, 主要用于把基类指针转换为派生类指针.这里的基类指针其实是指向...
  • https://www.cnblogs.com/chenyangchun/p/6795923.html
  • 当然我们也可以使用static_cast,只是dynamic_cast在进行下行转换的时候(即基类到派生类)具有类型检查功能,而static_cast没有。因此存在安全问题。 当我们使用智能指针时,如果需要进行类层次上的上下行转换时,...
  • 静态转换(static_cast)   使用方式: static_cast&lt;目标类型&gt;(原始对象) 用法: 用于父类和子类之间指针或引用的转换。 用于基本数据类型之间的转换,如把int转换成char,把char转换成int。这种...
  • 最好的解决方法就是不要使用C风格的强制类型转换,而是使用标准C++的类型转换符:static_cast, dynamic_cast。标准C++中有四个类型转换符: static_cast 、 dynamic_cast 、 reinterpret_cast 、和 const_cast 。...
  • static_cast、dynamic_cast、 const_cast、reinpreter_cast-详解

    万次阅读 多人点赞 2019-03-11 16:10:59
    显式类型转换-被称为“强制类型转换”(cast) C 风格: (type-id) C++风格: static_cast、dynamic_cast、reinterpret_cast、和const_cast.. 关于强制类型转换的问题,很多书都讨论过,写的最详细的是C++ 之父的...
  • template&... static_pointer_cast( shared_ptr&lt;U&gt; const &amp; r ) BOOST_NOEXCEPT { (void) static_cast&lt; T* &gt;( static_cast&lt; U* &gt;( 0 ) ); ...
  • 包这个错是因为缺少头文件 #include <QEvent> #include <QMouseEvent> #include <QKeyEvent> 使用示例: QKeyEvent *keyEvent = static_cast<QKeyEvent *>(event); QMouseEvent *...
  • 问题: Static_cast 与 Dynamic_cast的区别 来自书本上的解释:  用 static_cast ( expression )  1. static_cast(expression) The static_castlong, int->short etc.  用来数值之间的转化。 2. ...
  • C++为了增强转换的可视性,引入了四种强制转换的操作符分别是static_cast、const_cast、dynamic_cast、reinterpret_cast。 一、static_cast static_cast (expression):将expression转换为type-id 类型 最...
  • static_cast1. 基础类型之间互转。如:float转成int、int转成unsigned int等2. 指针与void*之间互转。如:float*转成void*、CBase*转成void*、函数指针转成void*、void*转成CBase*等3. 派生类指针【引用】转成...
  • C++ 中提供了四种强制类型转换操作符:static_cast, dynamic_cast, const_cast, reinterpret_cast。而关于shared_ptr 无法利用这些原始的操作符进行转换,其定义了自己的类型转换操作符:static_pointer_cast, ...
  • 标准C++中有四个类型转换符:static_cast、dynamic_cast、reinterpret_cast、和const_cast。下面对它们一一进行介绍。 static_cast   用法:static_cast < type-id > ( expression )   说明...
  • 最近在编程过程中了解到C++类型的层次转换(这就涉及到了多态和继承的相关概率),通常C语言中可以对内置类型进行强制转换,但是这样做不是很安全,在C++标准中,提供了关于类型层次转换中的两个关键字static_cast和...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 21,743
精华内容 8,697
关键字:

static_cast头文件