第11课 新型的类型转换

#include <stdio.h>

typedef void PF(int);

struct Point
{
    int x;
    int y;
};

int main()
{
    int v = 0x12345;
    PF* pf = (PF*)v;
    char c = char(v);//老式写法，很像函数调用
    Point* p = (Point*)v;

    pf(5);

    printf("p->x = %d\n", p->x);
    printf("p->y = %d\n", p->y);

    return 0;
}

#include <stdio.h>

void static_cast_demo()
{
    int i = 0x12345;
    char c = ‘c‘;
    int* pi = &i;
    char* pc = &c;

    c = static_cast<char>(i);//基本类型

    //基本类型的指针间，非法
    //pc = static_cast<char*>(pi);  
}

void const_cast_demo()
{

    //用常量初始化引用，要分配内存。故j为变量，因加const而成只读变量
    const int& j = 1;//j为引用--》只读变量，说明j不能做为左值而己
    int& k = const_cast<int&>(j); //转为普通引用，k就是j的别名

    k = 5;

    printf("k = %d\n", k); //5
    printf("j = %d\n", j); //5

    const int x = 2; //x为常量
    int& y = const_cast<int&>(x);//此时，会为x分配内存
    //int z = const_cast<int>(x);  //oops，目标类型只能是引用或指针

    y = 3;

    printf("x = %d\n", x); //2
    printf("y = %d\n", y); //3
    printf("&x = %d\n", &x);
    printf("&y = %d\n", &y); //x与y的内存地址是相同的
}

void reinterpret_cast_demo()
{
    int i = 0;
    char c = ‘c‘;
    int* pi = &i;
    char* pc = &c;

    pc = reinterpret_cast<char*>(pi); //ok，指针间
    pi = reinterpret_cast<int*>(pc);  //ok，指针间
    pi = reinterpret_cast<int*>(i);   //ok，整数与指针间
    //c  = reinterpret_cast<char>(i);   //oops，基本类型间转换，要用static_cast

}

void dynamic_cast_demo()
{
    int i = 0;
    int* pi = &i;
    char* pc = dynamic_cast<char*>(pi);//oops，目标类型应为类的指针或引用
}

int main()
{
    static_cast_demo();
    const_cast_demo();

    reinterpret_cast_demo();
    dynamic_cast_demo();
    return 0;
}