学习四种类型转换

C++的四种类型转换的练习代码，该说的都在注释中，培养大家看代码的耐心～～

代码:

#include <iostream>
#include <stdlib.h>

/**
* @author:zanzan101
*/

using namespace std;

class A
{
private:
    int data;

    // 小知识：引用可以出现在类中，它的初始化和const类型类似，都是必须放到初始化列表中
    int& ref;
public:

    // 小知识：初始化列表中初始化的顺序，根据类中变量定义的顺序而定，与参数列表中的顺序无关
    A():data(1), ref(data){}
    int doSomething(){
        cout<< "A do something ..." <<endl;
        return 123;
    }
    void toString()
    {
        cout<< "A" <<endl;
    }
};
class B : public A
{
public:
    // 当仅仅返回值类型不同时
    // 视为无多态行为的重写
    // 和下面的toString函数类似
    void doSomething(){
        cout<< "B do something ..." <<endl;
    }
    // 非虚函数的重写合法，但是无法触发多态行为
    // 触发多态行为的唯一途径是父类的指针或者引用调用子类实现的虚函数
    void toString()
    {
        cout<< "B" <<endl;
    }
};

class C
{
private:
    int data;
public:
    virtual void doSomething(){
        cout<< "C do something ..." <<endl;
    }
};
class D : public C
{
public:
    // 错误演示：
    // error C2555: “D::doSomething”: 重写虚函数返回类型有差异，且不是来自“C::doSomething”的协变
//     virtual int doSomething(){
//         cout<< "B do something ..." <<endl;
//     }

    // 正确方法：
    virtual void doSomething(){
        cout<< "D do something ..." <<endl;
    }
};

void func_void()
{
    cout<< "func_void" << endl;
    return;
}

int func_int()
{
    cout<< "func_int" << endl;
    return 1;
}

void do_func(void(*ptr_func)())
{
    ptr_func();
}

int main()
{
    // static_cast        如同普通转型一样
    
    // const_cast        去掉常量性
    
    // dynamic_cast        向下转换指针类型，前提是该指针或引用必须确实是指向的子类对象，否则返回NULL，
    //                    即最终结果不能出现子类指针指向父类对象的情况

    // reinterpret_cast    转换函数指针

    int num = 0;
    char ch = 'A';
    num = static_cast<int>(ch);
    cout<<"num = " << num << endl;

    const int c_num = 1;

    // 错误演示：
//    c_num = 2;

    // 错误演示：
    // const_cast 只能处理指针或者引用
//    int nc_num = const_cast<int>(c_num);

    const int * p = &c_num;
    int* q = const_cast<int*>(p);    
    *q = 2;    
    // 如果这个对象处于常量区，即使做了转型，也是无法修改
    cout<<"c_num = " << c_num << endl;

    p = &num;
    
    // 错误演示：
    // 对const类型指针所指对象赋值
//    *p = 2;
    
    // 正确方法：
    q = const_cast<int*>(p);
    *q = 2;
    // 如果这个对象不处于常量区，则转型之后可以修改
    cout<<"num = " << num << endl;

    A a;
    B b;
    a.doSomething();

    // 错误演示
    //int res = b.doSomething();
    // 看看有返回值对重载的影响
    //cout<< "res = " << res << endl;

    // 错误演示：
    // error C2440: “初始化”: 无法从“A *”转换为“B *”
//    B* ptr = &a;

    // 正确方法：
    // 向上转型，天生就可以转，但是向下转型必须用dynamic_cast
    A* ptr1 = &b;
    ptr1->doSomething();

    // 错误演示：
    // error C2440: “初始化”: 无法从“A *”转换为“B *”
    // 这里很有意思的是：ptr1明明指向的是B的对象，却不能赋值给ptr2，因此，dynamic_cast就有了用武之地
//    B* ptr2 = ptr1;

    // 错误演示：
    // error C2683: “dynamic_cast”:“A”不是多态类型
    // 用了dynamic_cast，却依然出错，因为A类没有虚函数，即：没有多态行为
//    B* ptr2 = dynamic_cast<B*>(ptr1);

    C c;
    D d;
    c.doSomething();
    d.doSomething();
    C* ptr3 = &d;
    D* ptr4 = dynamic_cast<D*>(ptr3);
    ptr3->doSomething();
    ptr4->doSomething();

    // 错误演示：
    // 违背“该指针或引用必须确实是指向的子类对象”的前提
    D* ptr5 = dynamic_cast<D*>(&c);
    if(!ptr5)
        cout<< "ptr5 is NULL...dynamic_cast failed!" << endl;

    // 正常调用
    do_func(func_void);

    // 错误调用
    // error C2664: “do_func”: 不能将参数 1 从“int (__cdecl *)(void)”转换为“void (__cdecl *)(void)”
//    do_func(func_int);

    // 正确方法：
    // 使用reinterpret_cast
    do_func(reinterpret_cast<void(*)()>(func_int));

    system("pause");
    
    return 0;
}

输出结果:

num = 65
c_num = 1
num = 2
A do something ...
A do something ...
C do something ...
D do something ...
D do something ...
D do something ...
ptr5 is NULL...dynamic_cast failed!
func_void
func_int
请按任意键继续. . .