类型转换

c语言中强制类型转换很简单，不管类型什么类型都可以：Type b = (Type) a；

c++中的类型转换

static_cast	静态类型转换。如int转换成char
reinterpreter_cast	重新解释类型
dynamic_cast	命名上理解是动态类型转换。如子类和父类之间的多态类型转换
const_cast	字面上理解就是去const属性

static_cast<>()，静态类型转换，在编译时C++编译器对做类型检查；基本类型可以转换，但指针类型不行

reinterpreter_cast<>()，进行重新类型解释，出现在不同类型之间的强制类型转换

c中的隐式类型转换，都可用static_cast<>()进行类型转换，c中不能隐式转换的可以用reinterpreter_cast<>()进行强制类型转换

dynamic_cast<>()，动态类型转换，安全的基类和子类之间转换；运行时类型检查

const_cast<>()，去除变量的只读属性

int main()
{
    double pi = 3.1415926;
    int a = pi;						//c的隐式转换
    int b = (int)pi;				//c的强制类型转换
    int c = static_cast<int>(pi);	//c++类型转换
    cout << a <<" "<< b <<" "<< c << endl;

    //注意：char* str = "hello C++";//左右类不同不能把const char*转换为char*，有限制字符const
    char str[] = "hello C++";
    char *p1 = str;
    int *p2 = (int *)p1;
    //int *b = static_cast<int *>(p1);//无法从char*转换到int*(基本类型可以转换，指针类型不能)
    int *p3 = reinterpret_cast<int *> (p1);//使用重新解释类型可以转换指针类型
    cout << p1 <<" "<< p2<<" " << p3 << endl;
}

注意：

c标准规定，指针间的赋值，左值必须包含右值的所有限定词。
把const char*赋值给char*，作为左值的char *并没有包含作为右值的const char *的限定词const，因此非法。

cont char *str;// 是内容不可修改, 并不是指针不可修改.
char *cont str;// 是指针不可修改, 并不是内容不可修改.

    //子类对象可以当做父类对象使用
    //子类对象可以直接赋值给父类对象
    //子类对象可以直接初始化父类对象
    //父类指针可以直接指向子类对象
    //父类引用可以直接引用子类对象

class Animal
{
public:
    virtual void cry()
    {
        cout << "动物叫" << endl;
    }
};

class Dog:public Animal
{
public:
    virtual void cry()
    {
        cout << "汪汪汪" << endl;
    }
};

class Cat:public Animal
{
public:
    virtual void cry()
    {
        cout << "喵喵喵" << endl;
    }
};

class Tree
{
public:
    Tree()
    {
        cout << "我是树" << endl;
    }
};

void PlayObj(Animal *base)
{
    base->cry();
    Dog *dog = dynamic_cast<Dog *>(base);
    if (dog != NULL)
    {
        dog->cry();
    }

    Cat *cat = dynamic_cast<Cat *>(base);
    if (cat != NULL)
    {
        cat->cry();
    }
}

int main()
{
    {
        Animal *base = NULL;
        Dog *dog = new Dog();
        Cat *cat = new Cat();
        base = dog;
        base = cat;
        //dog = animal;//err
        //cat = animal;//err

        //可以把子类指针赋给 父类指针 但是反过来是不可以的 需要 如下转换
        Dog *d1 = static_cast<Dog *>(base);
        Cat *c1 = static_cast<Cat *>(base);

        //把动物类转换成其他 非动物相关的
        //base = new Tree();					//err
        //Tree *t = static_cast<Tree *>(base);	//err

        // reinterpret_cast //可以强制类型转换(重新解释)
        Tree *t1 = reinterpret_cast<Tree *>(base);

        PlayObj(dog);
        PlayObj(cat);
    }

    system("pause");
    return 0;
}

const_cast典型用法 把形参的只读属性去掉

//典型用法 把形参的只读属性去掉
void OutPBuf(const char *str)
{
    cout << str << endl;
    //str[0] = 'A';//左值不可被修改（只读）

    char *p = const_cast<char *>(str);
    p[0] = 'A';

    cout << p << endl;
}

int mian()
{
    const char *p = "ppppp123123";
    char *p1 = const_cast<char *>(p);

    //要保证指针所执行的内存空间能修改才行 若不能修改 还是会引起程序异常
    char str[] = "zhngoioo231";
    OutPBuf(str);
    system("pause");
    return 0;
}