C++型変換解析

dynamic_cast:       
static_cast:       
reinterpret_cast:         
const_cast:       

1. dynamic_cast   
  ：               
  ：              
2. static_cast   
  ：      
  ：                
3. reinterpret_cast   
  ：      ,             
  ：        ，                        ，                 
4. const_cast   
  ：       const volatile  


//TODO: dynamic_cast static_cast  
    dynamic_cast<type-id>(expression)
    (1) type-id       、      void*
    (2)       (downcast)    ,     ；      (downcast)   ,   ,     
    (3)          (upcast) ,dynamic_cast static_cast       ；       (downcast) ,dynamic_cast        , static_cast   
    (4) dynamic_cast       ,          ,      (err:source type is not polymorphic)； static_cast    ,static_cast      
    (5) dynamic_cast              ,               
    (6) dynamic_cast      ； static_cast     
    
    static_cast<type-id>(expression)
    (1)        /     ;      (upcast-     /         )     ,      (downcast-    /          )      
    (2)              , int   char、int   enum,         
    (3)                
    (4)             void  
    // static_cast     expression const、volatile、  __unaligned  
    (5) C++  static_cast        ,    C        ,           
    
    reinterpret_cast<type-id>(expression)
    (1) type-id       /  /    /    /    ；              ，               
    (2) reinterpret_cast   const_cast    const   
    
    
    const_cast<type_id> (expression)
    (1)               ，           ；
    (2)               ，           ；
    (3) const_cast         。 const char *p  。
    
    
    
//Sample:
class A {
public:
        int m_memberA;
        virtual void foo() {// virtual for dynamic_cast
                printf("foo
");
        }
};

class B : public A {
public:
        int m_memberB;
};

class D : public A {
public:
};

void func(A* pa) {
        B* pb1 = static_cast<B*>(pa);
        B* pb2 = dynamic_cast<B*>(pa);
}


int main(int argc, char* argv[]) {
        B* pb = new B();
        func(pb);

        //D* pd0 = static_cast<D*>(pb); //compile error
        D* pd1 = dynamic_cast<D*>(pb);

        int i;
        float f = 16.1;
        i = static_cast<int>(f);

        return 0;
}


//TODO: const_cast
class B
{
public:
    B() { }
public:
    int m_iNum;
};
void foo()
{
    const B b1;
    //b1.m_iNum = 100; //compile error
    //        ，          
    B *b2 = const_cast<B*>(&b1);
    //             ，   b2 b3        ，   b1      
    B &b3 = const_cast<B&>(b1);
    b2->m_iNum = 200;    //fine
    b3.m_iNum = 300;    //fine
}
int main( int argc, char * argv[] )
{
    foo();
    return 0;
}