类型转换运算符

一、概述

在c语言中的类型转换太过松散。例：

struct Data
{
	double data[200];
};
struct Junk
{
	int junk[100];
};
Data d={2.5e33,3.5e-19,20.2e32};
char * pch=(char *)(&d);//转换string
char ch = char(&d);//转换char
Junk * pj = (Junk *)(&d);//转换为Junk的指针

上述的类型转换过去松散，对于这种松散情况，c++提供了更严格地限制允许的类型转换，并添加4个类型转换运算符：

1. dynamic_cast:动态转换。

2. const_cast:常量转换。

3. static_cast:静态类型转换。

4. reinterpret_cast:重新解释转换。

可以根据目的的选择一个合适的运算符，而不是使用通用的类型转换。这指
出了进行类型转换的原因，并让编译器能够检查程序的行为是否与设计想法吻合。

二、四种转换

1.static_cast

语法：static-cast<type-name>(expression)

//仅当type_name可被隐式转换为expression所属的类型或expression可被隐式转换为type_name所属的类型时，上述转换才是合法的，否则出错。
#include<iostream>
using namespace std;
class Animal{};
class Dog:public Animal{};
class Other{};

//静态转换static_cast
void test1()
{
    //static_cast用作于 基本类型
    char ch = 'a';
    double d = static_cast<double>(ch);
    cout<<"d = "<<d<<endl;
    //static_cat 作用于 自定义数据类型（结构体 类）
     //关系的类之间
     //上行转换 安全
     Animal *p1 = static_cast<Animal *>(new Dog);
     //下行转换 不全 容易越界
    Dog *p2 = static_cast<Dog *>(new Animal);
    // static_cast 不能作用域 不相关的类之间转换
    //Animal *p3 = static_cast<Animal *>(new Other);//err

}
int main()
{
    test1();
    return 0;
}

2.dynamic_cast

语法：dynamic_cast<type-name>(expression)

//用途：使得能够在类层次结构中进行向上转换，而不允许其他转换。
class Animal{};
class Dog:public Animal{};
class Other{};

 //dynamic_cast动态转换
void test02()

{
     //1、dynamic_cast不支持 基本类型
     char ch = 'a';
     //double d=dynamic_cast<double>(ch);//err

    //2、dynamic_cast 上行转换 （基类指针 指向 派生类空间 安全）
     Animal *p1 = dynamic_cast<Animal *>(new Dog);
    //3、dynamic_cast 下行转换 （派生类指针 指向 基类空间 不安全）
    //Dog *p2 = dynamic_cast<Dog *>(new Animal);//不支持 不安全 的转换
     //4、dynamic_cast 不支持 没有关系的 类型转换
     //Animal *p3 = dynamic_cast<Animal *>(new Other);//err
}
int main()
{
    test02();
    return 0;
}

3.const_cast

语法：const_cast<type-name>(expression)，type-name和expression的类型必须相同

//用途：改变值为const或volatile
class Animal{};
class Dog:public Animal{};
class Other{};

 //常量转换const_cast
 void test03()
{
    const int *p = NULL;
 int *p1 = const_cast<int *>(p) ;
     int *p2 = NULL;
     const int *p3 = const_cast<const int *>(p2);
     //const_cast 不支持 非指针或引用的转换
     const int a = 100;
     //int b = const_cast<int>(a);//err
     int data = 100;
     //常量引用 转换成 普通引用
     const int &ob = data;
     int &ob2 = const_cast<int &>(ob);
}
int main()
{
    test03();
    return 0;
}

4.reinterpret_cast

语法：reinterpret_cast<type_name>(expression)

//用途：用于天生危险的类型转换。它不允许删除const，但会执行其他令人生厌的操作。使用运算符可以简化对这种行为的跟踪工作。
#include<iostream>
using namespace std;
class Animal{};
class Dog:public Animal{};
class Other{};
void test04()
{
    //reinterpret_cast 不支持基本数据类型
    char ch='a';
    //double d = reinterpret_cast<double>(ch);//err
     //reinterpret_cast 支持 不相关的类型间转换
    Animal *p1 = reinterpret_cast<Animal *>(new Other);
     //上行转换 12 Animal *p2 = reinterpret_cast<Animal *>(new Dog);
     //下行转换 15 Dog *p3 = reinterpret_cast<Dog *>(new Animal);
     }
int main()
{
    test04();
    return 0;
}