#include <stdio.h>
int main()
{
    int* p = new int;
    *p = 5;
    *p = *p + 10;
    printf("p = %p\n", p); //p 保存堆上开辟空间的地址
    printf("*p = %d\n", *p);//15
    delete p;
    p = new int[10];//申请 10 个 int 型空间
    for(int i=0;i<10; i++)
    {
        p[i] = i + 1;
        printf("p[%d] = %d\n", i, p[i]);
    }
    delete[] p; //注意:释放数组时[]不能漏掉
    return 0;
}

int* pi = new int(1);
float* pf = new float(2.0f);
char* pc = new char(‘c‘);

#include <stdio.h>

int main()
{
    int* pi = new int(1); //开辟1个int型空间，并初始化为1
    //int* pa = new int[1];//注意，这时申请一个数组，与前一行含义不同

    float* pf = new float(2.0f);
    char* pc = new char(‘c‘);

    printf("*pi = %d\n", *pi); //1
    printf("*pf = %f\n", *pf); //2.000000
    printf("*pc = %c\n", *pc); //c

    delete pi;
    delete pf;
    delete pc;

    return 0;   
}

#include <stdio.h>

namespace First
{
    int i = 0;
}

namespace Second
{
    int  i = 1;

    //命名空间的嵌套
    namespace Internal
    {
        struct P
        {
            int x;
            int y;
        };
    }
}

int main()
{
    using namespace First;//使用First整个命名空间
    using Second::Internal::P;//使用命名空内部的P结构体

    printf("Fisrt::i = %d\n", i); //0。可以直接写i，因为使用了First整个命名空间
    printf("Second::i = %d\n", Second::i);//1。须带命名空间的名字

    P  p = {2, 3};

    printf("p.x = %d\n", p.x);//2
    printf("p.y = %d\n", p.y);//3

    return 0;   
}

#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;
}