类型转换

最新推荐文章于 2020-09-06 23:41:45 发布

没有飘柔不洗头

最新推荐文章于 2020-09-06 23:41:45 发布

阅读量133

点赞数

分类专栏： C++

原文链接：http://blog.chinaunix.net/uid-26430381-id-4253503.html

版权

C++ 专栏收录该内容

39 篇文章 0 订阅

订阅专栏

//基本的向上构造

#include <iostream>                                                                                                                                                              
using namespace std;

class A{
    public:
        void myfunc(){
            cout << "A myfunc" << endl;
	}  
        virtual void mytest(){
            cout << "A mytest" << endl;		 
	}
};

class B:public A{
    public:
        void myfunc(){
            cout << "B myfunc" << endl;
        }
        virtual void mytest(){
            cout << "B mytest"  << endl;
        }

};

int main(void){
    A* pa = new A();
    B* pb = new B();
    pa = pb;//向上转型,隐式的,是安全的(pb = static_cast<B*>(pa)是向下转型,不安全的.)
    
    pb->myfunc();//B myfunc
    pb->mytest();//B mytest

    pa->myfunc();//A myfunc    pa->mytest();//B mytest   向上转型达到,多态的目的.
    return 0;
    }

//向上转型+虚函数

    #include <iostream>
    using namespace std;
    
    class Integer{
    public:
        Integer(int r):m_r(r){}
        virtual Integer& operator+=(const Integer& that){//虚函数可以为拷贝构造函数.
            m_r +=that.m_r;
            return *this;
        }
        int m_r;
    };
    
    class Complex:public Integer{
    public:
        Complex(int r,int i):Integer(r),m_i(i){}
        Complex& operator+=(const Integer& c){//这里向上转型,这样
        //形参既可以接受Integer也可以接受Complex类型的参数.
            Integer::operator+=(c);
            m_i += ((const Complex&)c).m_i;//这里是重点,c有可能是const Integer&类型的
                                        //所以强制转换,是可行的.
        }
        int m_i;
    };
    
    int main(void){
        Complex c1(1,2),c2(3,4);
        c1 += c2;
        cout << c1.m_r << '+' << c1.m_i << 'i' << endl;
        Integer& i1 = c1; // 4+6i;
        Integer& i2 = c2;//3+4i;
        i1+=i2;//i1调用子类Complex的拷贝赋值函数.
        cout << c1.m_r << '+' << c1.m_i << 'i' << endl;//7+10i;
        return 0;
    }
    
    转载于:https://blog.51cto.com/12218412/1867510展开阅读原文

//基本的向上构造

#include <iostream>   
                                                                                                                
using namespace std;

class A{
    public:
        void myfunc(){
            cout << "A myfunc" << endl;
        }

        virtual void mytest(){
            cout << "A mytest" << endl;
        }
};

class B:public A{
    public:
        void myfunc(){
            cout << "B myfunc" << endl;
        }
        virtual void mytest(){
            cout << "B mytest"  << endl;
        }

};

int main(void){
    A* pa = new A();
    B* pb = new B();
    pa = pb;//向上转型,隐式的,是安全的(pb = static_cast<B*>(pa)是向下转型,不安全的.)
    

    pb->myfunc();//B myfunc
    pb->mytest();//B mytest

    pa->myfunc();//A myfunc    
    pa->mytest();//B mytest   向上转型达到,多态的目的.
    return 0;
    }

//向上转型+虚函数

    #include <iostream>
    using namespace std;  
     
    class Integer{ 
    public:     
    Integer(int r):m_r(r){}     
    virtual Integer& operator+=(const Integer& that){//虚函数可以为拷贝构造函数.         
    m_r +=that.m_r;         
    return *this;     }     
    int m_r; 
    }; 
    
    class Complex:public Integer
    { 
    public:     
    Complex(int r,int i):Integer(r),m_i(i){}     
    Complex& operator+=(const Integer& c){//这里向上转型,这样     
    //形参既可以接受Integer也可以接受Complex类型的参数.         
    Integer::operator+=(c);         
    m_i += ((const Complex&)c).m_i;//这里是重点,c有可能是const Integer&类型的
    //所以强制转换,是可行的.     
    }     
    int m_i; 
    }; 
    
 int main(void)
 {     
        Complex c1(1,2),c2(3,4);     
        c1 += c2;     
        cout << c1.m_r << '+' << c1.m_i << 'i' << endl;     
        Integer& i1 = c1; // 4+6i;     
       Integer& i2 = c2;//3+4i;     
       i1+=i2;//i1调用子类Complex的拷贝赋值函数.     
       cout << c1.m_r << '+' << c1.m_i << 'i' << endl;//7+10i;     
       return 0;  
 }
 
 链接:http://blog.51cto.com/12218412/1867510展开阅读原文

c++中的向下转型
c++类的实例化时候实现多态
1）静态转型（强制转换）
static_cast<子类指针或引用>(父类指针或引用):把父类的指针或引用强制转换为子类，返回子类的地址，是不安全的转换。
[总结]:static_cast< >( )
①< >中必须是子类的指针或引用。
②( )中的指针指向的是子类空间或者子类对象时，则转型是安全的。

2）动态转型(强制转换)dynamic_cast: 把父类指针或引用转换为子类指针或引用，转换成功则返回子类的地址,不成功返回NULL。
[总结]:dynamic_cast< >( )
①使用dynamic转换时，父类与子类要构成多态条件
②< >中必须是子类的指针或引用
③( )中的指针指向的是子类空间或者子类对象时，则转型是安全的

不懂可以参考以下代码理解以及运行结果

#include <iostream>
using namespace std;

class A{
public:
    A(int _a = 10){
        a = _a;
    }
    virtual void print(){
        cout<<"    a= "<<a<<endl;
    }
private:
    int a;
};

class B : public A{
public:
    B(int _a=11,int _b =12 ):A(_a){
        b = _b;
    }
    void print(){
        cout<<"    b= "<<b<<endl;
        A::print();
    }
private:
    int b;
};
int main(int argc, const char * argv[]) {
    A a;
    B b(20,30);
    
    //向下转换的两种形式
    /*静态转型(强制转换)static_cast: 把父类指针或引用强制转换为子类指针或引用，返回子类的地址,是不安全的转换。*/
    /*
     总结:static_cast<  >(   )
     1.<>中必须是子类的指针或引用
     2.()中的指针指向的是子类空间或者子类对象时，则转型是安全的
     */
    
    /* cout<<"***************静态转换的不安全事例(指针)******************"<<endl;
    A* a_ptr = &a;//父类指针指向子类空间 0x2
    //格式 使用静态转换(强转)
    B* q =  static_cast<B*>(a_ptr); //应该返回NULL表示不成功 把父类指针强转为子类空间 但是父类没有子类的b值，所以不安全 b为随机值
    q->print();//b 0 a 10 不安全(指针)
    
   cout<<"***************静态转换的安全形式(指针)***************"<<endl;
    B*w = &b;//0x1 这个空间里有子类的数据，安全
    A* m = w;//0x1
    B* y = static_cast<B*>(m);//0x1改变指针的类型 而没有改变空间的数据
    y->print();
    
    cout<<"***************静态转换的不安全事例(引用)******************"<<endl;
    B bb = static_cast<B&>(a);
    bb.print();
    
     cout<<"***************静态转换的安全事例(引用)******************"<<endl;
    B yy = static_cast<B&>(*m);
    yy.print();
    */
    
    //-----------------------------------------------------------------------------------------------------------------------------

    /*动态转型(强制转换)dynamic_cast: 把父类指针或引用转换为子类指针或引用，转换成功则返回子类的地址,不成功返回NULL。*/
    /*
     总结:dynamic_cast<  >(   )
     1.使用dynamic转换时，父类与子类要构成多态条件
     2.<>中必须是子类的指针或引用
     3.()中的指针指向的是子类空间或者子类对象时，则转型是安全的
     */
        
    //使用动态转换
    cout<<"**************动态转换对于不安全的处理，返回NULL(指针)*********\n";
    A* pp = &a;
    B* qq = dynamic_cast<B*>(pp);//不安全 qq为NULL
    if(qq){
        cout<<"转换成功\n";
        qq->print();
    }else{
        cout<<"转换不成功\n";
    }
    
    cout<<"**************动态转换对于不安全的处理，返回NULL(引用)*********\n";
    //   B Derived = dynamic_cast<B&>(a);//崩
    //   Derived.print();
    
    cout<<"**************安全动态转换(指针)*********\n";
    B* ptr = &b;
    A* ptr2 = ptr;
    B* ptr3 = dynamic_cast<B*>(ptr2);
    if(ptr3){
        cout<<"转换成功\n";
        ptr3->print();
    }
    
    cout<<"**************安全动态转换(引用)*********\n";
    B kk = dynamic_cast<B&>(*ptr2);
    cout<<"转换成功\n";
    kk.print();
    
  
    return 0;
}

运行结果：
在这里插入图片描述

c++中的向下转型
从RTTI谈C++的向下转型

一、什么是RTTI？
RTTI 是“Runtime Type Information”的缩写，意思是：运行时类型信息。它提供了运行时确定对象类型的方法。允许“用指向基类的指针或引用来操纵对象”的程序能够获取到“这些指针或引用所指对象”的实际派生类型。在 c++中，为了支持 RTTI 提供了两个操作符：
1 dynamic_cast 操作符：它允许在运行时刻进行类型转换，从而使程序能够在一个类层次结构中安全地转换类型（安全的向下转型）。把基类指针转换成派生类指针，或把指向基类的左值转换成派生类的引用。当然只有在保证转换能够成功的情况下才可以；
2 typeid操作符：它指出指针或引用指向的对象的实际派生类型。
但是，对于要获得的派生类类型的信息，dynamic_cast 和 typeid操作符的操作数的类型必须是带有一个或多个虚拟函数的类类型，即对于带有虚拟函数的类而言，RTTI 操作符是运行时刻的事件，而对于其他类而言，它只是编译时刻的事件。

二、 RTTI如何实现
C++的RTTI是最简单的，只能获得类名和相关的继承信息；而VB、Delphi、Java等确复杂得多，甚至于支持属性名、方法名、事件名等。
在这里插入图片描述
如图，C++使用type_info类的对象保存每个对象的相关信息如对象名称、对象类型等。而所谓RTTI就是在执行期取得对象的type_info。所以C++采用了和虚函数同样的办法，使用vtable（通常为第一个slot）保存需要执行期获得type_info的对象的type_info对象地址。那么由pt指向的class object的type_info可在执行期通过如下方式获得：(type_info)(type_info)(pt->vptr[0]);
通过上述实现分析我们也可以知道，C++的RTTI只能用于那些展现“多态”（内含虚函数）的类型有效。因为只有这样的类才有vtable。

三、向下转型
将一个Base class对象的指针转为Derived class对象的指针或将Base class的左值转为Derived class的引用称为向下转型。
注：不能讲Base class的对象转为Derived class的对象（除非定义相应转换操作符）。如下语句是错误的：
Base bobj;
Derived dobj=static_cast(bobj) ;//error
Derived dobj=(Derived)(bobj) ;//error 但如下语句是正确的：

Derived dobj;
Base bobj=(Base)dobj;//正确，造成对象切割
Base bobj=static_cast(dobj);//正确，造成对象切割向下转型示例：

(1) 基类指针转为子类指针
Base bobj;
Base *pb=&bobj;
Derived pd=(Derived)pb; //方式一
Derived pd=static_cast<Derived>(pb); //方式二
Derived pd=dynamic_cast<Derived>(pb); //方式三，只有Base class中有虚函数才能使用，否则编译错误（Derived class中有虚函数也不行）

(2) 基类左值转子类引用
Base bobj;
Derived dobj;
Derived &dref=(Derived&)(bobj); //方式一
Derived &dref=static_cast<Derived&>(bobj); //方式二
Derived &dref=dynamic_cast<Derived&>(bobj);//方式三，只有Base class中有虚函数才能使用，否则编译错误（Derived class中有虚函数也不行）

(3) 基类左值转子类引用
Derived dobj;
Base& bref=dobj;
Derived &dref=(Derived&)(bref);
Derived &dref=static_cast<Derived&>(bref);
Derived &dref=dynamic_cast<Derived&>(bref);

向下转型的隐患
向下转型有着潜在的危险，因为当基类指针指向的是基类对象，而将基类指针转为子类指针时，如果通过转换后的子类指针访问子类的专有成员，就会造成内存错误，因为实际指向的是基类对象，而基类对象中不存在这些成员。（引用转换类似）

四、安全的向下转型——dynamic_cast<>()
所谓“安全的向下转型”即只有当Base class的指针确实指向Derived class对象时才能将其转为Derived class的指针。但是我们知道Base class的指针指向的对象类型在执行期是可以改变的（指向Base class对象或Derived class对象），所以要想保证向下转型的安全性，就必须在执行期对Base class的指针有所查询，看看它所指向对象的真正类型。dynamic_cast运算符可以在执行期确定指针指向的真正类型（前提是Base class中要有虚函数）。

当对Base class的指针向下转型时，如果向下转型时是安全的（也就是Base type pointer指向一个Derived class object），则这个运算符传回相应的Derived class指针，如果向下转型是不安全的，则这个运算符传回0。
当对Base class的引用向下转型时，如果向下转型时是安全的（也就是Base type reference引用一个Derived class object），则这个运算符传回相应的Derived class引用，否则抛出一个bad_cast exception，而不是返回0. 不返回0的原因是，若将一个引用设为0，会使一个临时性对象产生出来，该临时性对象的初值为0，这个引用被设置为这个对象的别名。
dynamic_cast的成本由于要在执行期获取对象类型信息（type_info），类似虚函数调用：(type_info)(type_info)(pt->vptr[0]);
当使用dynamic_cast进行Base class指针向下转型时，dynamic_cast会采用这种方法获取Base class指针和Derived class指针指向对象的type_info对象，并将两个type_info对象中的类型描述器交给一个runtime library函数，比较之后告诉我们是否吻合。这显然比static_cast的开销昂贵的多，但是安全的多。

五、Typeid运算符
Typeid运算符传回一个type_info对象的const引用。
1.typeid操作符必须与表达式或类型名一起使用。例如，内置类型的表达式和常量可以被用作 typeid的操作数。
(1) 当操作数不是类类型时，typeid操作符会指出操作数的类型，此时type_info对象的引用是在编译期获得，如：
int iobj;
cout << typeid( iobj ).name() << endl; // 打印: int
cout << typeid( 8.16 ).name() << endl; // 打印: double
(2) 当typeid操作符的操作数是类类型，但不是带有虚拟函数的类类型时，typeid操作符会指出操作数的类型，而不是底层对象的类型，此时type_info对象的引用是在编译期获得，如：
class Base { /* 没有虚拟函数 / };
class Derived : public Base { / 没有虚拟函数 */ };
Derived dobj;
Base pb = &dobj;
cout << typeid( pb ).name() << endl; // 打印: class Base
由于typeid操作符的操作数是 Base 类型的，即表达式pb 的类型。而 Base 不是一个带有虚拟函数的类类型，所以typeid的结果是Base。尽管 pb 指向的底层对象的类型是 Derived。
(3) 当typeid操作符的操作数是类类型，且该类是带有虚拟函数的类类型时，typeid操作符会指出实际底层对象的类型，此时type_info对象的引用是在执行期获得，如：
class Base { / 有虚拟函数 */ };
class Derived : public Base {};
Derived dobj;
Base *pb = &dobj;
cout << typeid( *pb ).name() << endl; // 打印: class Derived
2. 可以对 typeid的结果进行比较。例如

 #include <type_info> 
 employee *pe = new manager; 
 employee& re = *pe; 
 
 if ( typeid( pe ) == typeid( employee* ) ) // true 
 if ( typeid( pe ) == typeid( manager* ) ) // false 
 if ( typeid( pe ) == typeid( employee ) ) // false 
 if ( typeid( pe ) == typeid( manager ) ) // false 
 
 if语句的条件子句比较“在一个表达式上应用typeid操作符的结果”和“用在类型名操作数上的typeid操作符的结果”。注意比较

 typeid( pe ) == typeid( employee* )  的结果为true。这是因为操作数pe 是一个指针，而不是一个类类型。为了要获取到派生类类型 ，typeid的操作数必须是一个类类型（带有虚拟函数）。
 表达式 typeid(pe)指出pe 的类型，即指向employee 的指针，它与表达式 typeid(employee*)相等。而其他比较的结果都是false。  
当表达式*pe 被用在typeid上时，结果指出pe 指向的底层对象的类型  
typeid( *pe ) == typeid( manager ) // true 
typeid( *pe ) == typeid( employee ) // false

在这两个比较中，因为*pe 是一个类类型的表达式，该类带有虚拟函数，所以typeid的结果指出操作数所指的底层对象的类型，即manager 。
typeid操作符也可以被用在引用上。例如

   typeid( re ) == typeid( manager ) // true 
   typeid( re ) == typeid( employee ) // false 
   typeid( &re ) == typeid( employee* ) // true 
   typeid( &re ) == typeid( manager* ) // false

在前两个比较中，操作数re 是带有虚拟函数的类类型。因此 typeid操作数的结果指出 re指向的底层对象的类型。在后两个比较中，操作数&re 是一个类型指针，因此 typeid操作符的结果指出操作数的类型，即 employee* 。

const_cast不能修改全局区的内容，只是去掉const属性。

http://blog.chinaunix.net/uid-26430381-id-4253503.html
http://www.cppblog.com/mzty/archive/2006/01/05/2446.html