C++_enhance-Record08—C++的类型转换
目录
类型转换名称和语法
C风格的强制类型转换
C++风格的强制类型转换
类型转换一般性介绍
static_cast<>() 静态类型转换
C风格下的转换
C++风格下的转换
静态类型转换的特点
reinterpret_cast<>() 强制类型转换
强制类型转换的特点
dynamic_cast<>() 动态类型转换
const_cast<>() const类型转换
经验之谈
总体代码
所谓的类型转换，就是类型转换--\\,打个比方说，把int类型的变量转换为double类型的变量，这就叫类型转换，具体怎么个转法儿，下面详谈。
类型转换名称和语法
C风格的强制类型转换
C风格的强制类型转换(Type Cast)很简单，不管什么类型的转换统统是：
TYPE b = (TYPE)a
C++风格的强制类型转换
C++风格的类型转换提供了4种类型转换操作符来应对不同场合的应用：
static_cast 静态类型转换。如int转换成char
reinterpreter_cast 重新解释类型
dynamic_cast 命名上理解是动态类型转换。如子类和父类之间的多态类型转换。
const_cast 字面上理解就是去const属性。
4种类型转换的格式：
TYPE B = static_cast
类型转换一般性介绍
static_cast<>() 静态类型转换
C风格下的转换
double dpi = 3.1415926;
int num1 = (int)dpi; //C类型转换C++风格下的转换
double dpi = 3.1415926;
int num2 = static_cast(dpi); //静态类型转换 编译的时c++编译器会做类型检查
这就是所谓的静态类型转换。
那如果直接进行隐式类型转换呢：
double dpi = 3.1415926;
int num3 = dpi; //c语言中 隐式类型转换的地方 均可使用 static_cast<>() 进行类型转换
其实，这个隐式类型转换和静态类型转换的操作过程是一样的，只不过如果是按隐式类型转换这种方式，编译器会报警告：
所以，c语言中，隐式类型转换的地方，均可使用静态类型转换的方式进行转换。
但是，也有静态类型不能转换的类型形式：
//char* ===> int *
char *p1 = "hello...itcast ";
int *p2 = NULL;
//p2 = static_cast(p1); // 使用static_cast, 编译器编译时,会做类型检查 若有错误 提示错误 最后一行，如果不注释掉，会报错：
静态类型转换的特点
- 进行静态类型转换时，在编译的过程中，编译器会做类型检查。即如果C语言中，能进行隐式类型转换的，在C++中进行静态类型转换一般不会错。
- 基本类型能转换,但是不能转换指针类型
reinterpret_cast<>() 强制类型转换
接着上面的问题，那如果我就是想转换指针类型，怎么办？那就得用到强制类型转换了！
char *p1 = "hello...itcast ";
int *p2 = NULL;
p2 = reinterpret_cast(p1); //若不同类型之间，进行强制类型转换，用reinterpret_cast<>() 进行重新解释
cout << "p1:" << p1 << endl; //%s
cout <<"p2" << p2 << endl; //%d 运行结果：
这样就把p1类型的强制转换为"int*"类型的了！
强制类型转换的特点
- 若不同类型之间，进行强制类型转换，用reinterpret_cast<>() 进行重新解释
- C语言中不能隐式类型转换的，在c++中可以用 reinterpret_cast<>() 进行强行类型 解释。
- static_cast<>()和reinterpret_cast<>() 基本上把C语言中的 强制类型转换给覆盖
- 编译器的大牛规定的，是基础类型之间的转换就用静态类型转换，不能用静态的，才能用强制，不要也不能用强制转换去转换基础类型的（比如用强制类型转换去将"double"转成"char"，是通不过的），各自的类型用各自的转换方式去做，各司其职，不能混用，这叫小鸡不撒尿——各走各的道。
dynamic_cast<>() 动态类型转换
应用在子类与父类之间的多态类型转换，并且，动态类型转换，是在安全的基类和子类之间进行转换；运行时进行类型检查。
举例说明的话，就得先设计一个继承关系：
class Animal
{
public:
virtual void cry() = 0;
};
class Dog : public Animal
{
public:
virtual void cry()
{
cout << "汪汪" << endl;
}
void doHome()
{
cout << "看家" << endl;
}
};
class Cat : public Animal
{
public:
virtual void cry()
{
cout << "喵喵" << endl;
}
void doThing()
{
cout << "抓老鼠" << endl;
}
};搭建个舞台,让对象"唱戏"，想实现一个能识别子类对象的功能:
void playObj(Animal *base)
{
base->cry(); // 1有继承 2虚函数重写 3 父类指针 指向子类对象 ==>多态
//能识别子类对象
// dynamic_cast 运行时类型识别 RIIT
Dog *pDog = dynamic_cast(base);
if (pDog != NULL)
{
pDog->doHome(); //让够 做自己 特有的工作
}
Cat *pCat = dynamic_cast(base); //父类对象 ===> 子类对象
//向下转型
//把老子 转成 小子
if (pCat != NULL)
{
pCat->doThing(); //让够 做自己 特有的工作
}
} 创建一个基类创建的对象，然后，把这个基类所创建的对象转换为子类所创建的对象的类型（把爸爸所创建的对象的类型转换为儿子所创建的对象的类型），再次强调，类本身就是一种数据类型，所以，就可以把刚才的说法给变一下：就可以直接把父类所创建的对象转成了子类所创建的对象了！牛逼卡拉斯！
进行调用:
void main02()
{
Dog d1;
Cat c1;
Animal *pBase = NULL;
pBase = &d1;
pBase = static_cast(&d1); //静态转换的设计理念：让C++编译在编译的时候进行 类型检查
playObj(&d1);
playObj(&c1);
system("pause");
} 下面再举个例子，加深对强制类型转换的理解，还是在主函中：
//强制类型转换
pBase = reinterpret_cast(&d1);
{
Tree t1;
//pBase = static_cast(&t1); // C++编译器会做类型检查
pBase = reinterpret_cast(&t1); //reinterpret_cast 重新解释 ....强制类转换的味道
} 定义一个新的"Tree"类，然后，看看通过强制转换命令，能不能将"Animal"所创建的对象，给转换为"Tree"类型的，发现是可以的， 这也就是强制转换，可以把类型强制的进行转换，但话说回来，虽然可以转换，但转换后的效果就不敢保证了！
const_cast<>() const类型转换
const可以修饰指针变量，也可以修饰指针，这个cosnt类型转换，最重要的真正的应用场景就是：去除变量的只读属性。
void printBuf(const char * p)
{
p[0] = 'Z';
}如上，定义了个"p"，它的类型被const所修饰，说明其是一个指向常整形数的指针(所指向的内存数据不能被修改，但是本身可以修改);，所以，当执行"p[0] = 'Z';" 的时候，就会报错！那如果，这个时候就想给其所指向的内存空间赋值，那么"const_cast"就派上用场了！就需要把这个变量，去除只读属性：
char *p1 = NULL;
//程序员 要清楚的知道 变量:转换之前是什么类型 ,转换之后是什么类型
//const char * ===> char * //把只读属性 去掉
p1 = const_cast(p);
p1[0] = 'Z' ; //通过p1 去修改了内存空间
cout << p << endl; 这样，将p转换为p1，然后，同样的方式修改p1,就可以修改成功了！
在主函中进行调用：
void main()
{
char buf[] = "aaaaaaaaafffffddd";
printBuf (buf)；
system("pause");
}
提示，如上的操作，必须确保"p"所指向的内存空间，可读才行，如果不可读，就是再转，也无济于事。比如说：
void main()
{
//程序员 要确保 p所指向的内存空间 确实能修改 ;如果不能修改会带来灾难性后果
char *myp = "aaaaaaaaafffffddd"; //没有分配内存
printBuf (myp);
system("pause");
}这样一运行就报错：
经验之谈
-
程序员要清除的知道: 要转的变量，类型转换前是什么类型，类型转换后是什么类型。转换后有什么后果。
-
一般情况下，不建议进行类型转换；避免进行类型转换。
-
不管是C风格的类型转换还是C++风格的类型转换，于工程开发而言，都无所谓，能用就行。
总体代码
dm01_类型转换.cpp
#include
using namespace std;
/*
C风格的强制类型转换(Type Cast)很简单，不管什么类型的转换统统是：
TYPE b = (TYPE)a
C++风格的类型转换提供了4种类型转换操作符来应对不同场合的应用。
static_cast 静态类型转换。如int转换成char
reinterpreter_cast 重新解释类型
dynamic_cast 命名上理解是动态类型转换。如子类和父类之间的多态类型转换。
const_cast， 字面上理解就是去const属性。
4种类型转换的格式：
TYPE B = static_cast (a)
*/
//const char *p 的const修饰 让p指向的内存空间 变成只读属性
void printBuf(const char * p)
{
//p[0] = 'Z';
char *p1 = NULL;
//程序员 要清楚的知道 变量:转换之前是什么类型 ,转换之后是什么类型
//const char * ===> char * //把只读属性 去掉
p1 = const_cast(p);
p1[0] = 'Z' ; //通过p1 去修改了内存空间
cout << p << endl;
}
void main()
{
char buf[] = "aaaaaaaaafffffddd";
char *myp = "aaaaaaaaafffffddd";
//程序员 要确保 p所指向的内存空间 确实能修改 ;如果不能修改会带来灾难性后果
//printBuf (buf);
printBuf (myp);
system("pause");
}
class Tree {};
class Animal
{
public:
virtual void cry() = 0;
};
class Dog : public Animal
{
public:
virtual void cry()
{
cout << "汪汪" << endl;
}
void doHome()
{
cout << "看家" << endl;
}
};
class Cat : public Animal
{
public:
virtual void cry()
{
cout << "喵喵" << endl;
}
void doThing()
{
cout << "抓老鼠" << endl;
}
};
void playObj(Animal *base)
{
base->cry(); // 1有继承 2虚函数重写 3 父类指针 指向子类对象 ==>多态
//能识别子类对象
// dynamic_cast 运行时类型识别 RIIT
Dog *pDog = dynamic_cast(base);
if (pDog != NULL)
{
pDog->doHome(); //让够 做自己 特有的工作
}
Cat *pCat = dynamic_cast(base); //父类对象 ===> 子类对象
//向下转型
//把老子 转成 小子
if (pCat != NULL)
{
pCat->doThing(); //让够 做自己 特有的工作
}
}
void main02()
{
Dog d1;
Cat c1;
Animal *pBase = NULL;
pBase = &d1;
pBase = static_cast(&d1); //让C++编译在编译的时候进行 类型检查
//强制类型转换
pBase = reinterpret_cast(&d1);
{
Tree t1;
//pBase = static_cast(&t1); // C++编译器会做类型检查
pBase = reinterpret_cast(&t1); //reinterpret_cast 重新解释 ....强制类转换的味道
}
//
playObj(&d1);
playObj(&c1);
system("pause");
}
void main01()
{
double dpi = 3.1415926;
int num1 = (int)dpi; //C类型转换
int num2 = static_cast(dpi); //静态类型转换 编译的时c++编译器会做类型检查
int num3 = dpi; //c语言中 隐式类型转换的地方 均可使用 static_cast<>() 进行类型转换
//char* ===> int *
char *p1 = "hello...itcast ";
int *p2 = NULL;
//p2 = static_cast(p1); // 使用static_cast, 编译器编译时,会做类型检查 若有错误 提示错误
p2 = reinterpret_cast(p1); //若不同类型之间，进行强制类型转换，用reinterpret_cast<>() 进行重新解释
cout << "p1:" << p1 << endl; //%s
cout <<"p2" << p2 << endl; //%d
//总结:通过 reinterpret_cast<>() 和 static_cast<>()把C语言的强制类型转换 都覆盖了..
cout<<"hello..."<