✨个人主页： 熬夜学编程的小林

💗系列专栏： 【C语言详解】 【数据结构详解】【C++详解】

目录

1. C语言中的类型转换

2. 为什么C++需要四种类型转换

2.1、内置类型   -> 自定义类型

2.2、自定义类型 -> 内置类型 

2.3、自定义类型 -> 自定义类型

2.4、隐式类型转换的坑

3. C++强制类型转换

3.1 static_cast

3.2 reinterpret_cast

3.3 const_cast

3.4 dynamic_cast

4. RTTI

1. C语言中的类型转换

在C语言中，如果赋值运算符左右两侧类型不同，或者形参与实参类型不匹配，或者返回值类型与

接收返回值类型不一致时，就需要发生类型转化，C语言中总共有两种形式的类型转换：隐式类型

转换(整型之间 整型浮点数之间)和显式类型转换(指针之间 整型指针之间)。没有关联的类型不支持转换。

1. 隐式类型转化：编译器在编译阶段自动进行，能转就转，不能转就编译失败。2. 显式类型转化：需要用户自己处理。

代码演示

<code>#include<iostream>

using namespace std;

int main()

{

int i = 1;

// 隐式类型转换

double d = i;

printf("%d, %.2f\n", i, d);

int* p = &i;

// 显示的强制类型转换

int address = (int)p;

printf("%p, %d\n", p, address);

// “类型强制转换”: 无法从“int *”转换为“double”

// double x = (double)p;// 没有关联的类型不支持转换

return 0;

}

 运行结果

缺陷：

转换的可视性比较差，所有的转换形式都是以一种相同形式书写，难以跟踪错误的转换。

2. 为什么C++需要四种类型转换

C风格的转换格式很简单，但是有不少缺点的：

1. 隐式类型转化有些情况下可能会出问题：比如数据精度丢失。2. 显式类型转换将所有情况混合在一起，代码不够清晰。

因此C++提出了自己的类型转化风格，注意因为C++要兼容C语言，所以C++中还可以使用C语言的

转化风格。

C++除了兼容C的转换用法之外还有三种转换方式：内置类型   -> 自定义类型  ；自定义类型 -> 内置类型  ； 自定义类型 -> 自定义类型。

2.1、内置类型   -> 自定义类型

内置类型转换为自定义类型通过 隐式类型转换 + 对应的构造函数 就能够实现。 

代码演示

<code>class A

{

public:

A(int a1)

:_a1(a1)

{}

A(int a1, int a2)

:_a1(a1)

, _a2(a2)

{}

private:

int _a1 = 1;

int _a2 = 1;

};

int main()

{

// 内置类型 -> 自定义类型

A aa1 = 1;// 单参数隐式类型转换

A aa2 = { 1,2 };// 多参数隐式类型转换，使用{}

// A aa3 = { 1,2,3 };// 没有实现3个参数的构造函数或者initializer_list，就不能隐式类型转换

return 0;

}

运行结果 

2.2、自定义类型 -> 内置类型 

自定义类型转化为内置类型，直接写不支持，需要写重载函数。

代码演示

<code>class A

{

public:

A(int a1)

:_a1(a1)

{}

// 自定义类 -> 内置类型 重载函数

operator int()

{

return _a1 + _a2;

}

private:

int _a1 = 1;

int _a2 = 1;

};

int main()

{

// 内置类型 -> 自定义类型

A aa1 = 1;

// 自定义类型 -> 内置类型 直接写不支持，需要重载

int x = aa1;

cout << x << endl;

return 0;

}

运行结果 

2.3、自定义类型 -> 自定义类型

自定义类型转换为自定义类型，直接写不支持，需要加拷贝构造。

代码演示

<code>class A

{

public:

A(int a1)

:_a1(a1)

{}

// 成员变量私有，类外不能获取，const对象需要加const

int get() const

{

return _a1;

}

private:

int _a1 = 1;

int _a2 = 1;

};

class B

{

public:

B(const A& aa)

:_b1(aa.get())

{}

private:

int _b1;

};

int main()

{

// 内置类型 -> 自定义类型

A aa1 = 1;

// 自定义类型 -> 自定义类型 直接写不支持，需要加拷贝构造

B bb = aa1;

return 0;

}

运行结果 

2.4、隐式类型转换的坑

代码演示

<code>// 隐式类型转换的坑

void Insert(size_t pos)

{

int end = 10;

while (end >= pos)

{

cout << end << endl;

--end;

}

}

int main()

{

Insert(5);

// 插入0就有坑，-1转换为无符号整数为最大值

Insert(0);

return 0;

}

运行结果 

3. C++强制类型转换

标准C++为了加强类型转换的可视性，引入了四种命名的强制类型转换操作符：

static_cast、reinterpret_cast、const_cast、dynamic_cast

3.1 static_cast

static_cast用于非多态类型的转换（静态转换），编译器隐式执行的任何类型转换都可用

static_cast，但它不能用于两个不相关的类型进行转换。

代码演示(内置类型)

<code>int main()

{

int i = 1;

// 隐式类型转换 : static_cast

double d = static_cast<double>(i);

cout << d << endl;

// 强制类型转换

int* p = &i;

//int address = static_cast<int>(p);

//printf("%p %d\n", p, address);

return 0;

}

运行结果 

代码演示(自定义类型)

<code>class A

{

public:

A(int a1)

:_a1(a1)

{}

private:

int _a1 = 1;

int _a2 = 1;

};

int main()

{

// 隐式类型转换，使用static

A aa1 = 1;

A aa2 = static_cast<int>(1);

return 0;

}

运行结果 

3.2 reinterpret_cast

reinterpret_cast操作符通常为操作数的位模式提供较低层次的重新解释，用于将一种类型转换

为另一种不同的类型(强制类型转换)

代码演示

<code>int main()

{

int i = 1;

// 强制类型转换 : reinterpret_cast

int* p = &i;

int address = reinterpret_cast<int>(p);

printf("%p %d\n", p, address);

return 0;

}

运行结果 

3.3 const_cast

const_cast最常用的用途就是删除变量的const属性，方便赋值 。

先看一个代码

代码演示

<code>int main()

{

const int i = 1;// 存放到寄存器中

int* ptr = (int*)&i;

(*ptr)++;

cout << *ptr << endl;

cout << i << endl;

return 0;

}

运行结果 

我们能够看到一个很奇怪的现象，我们将 i 地址处的数据++，该地址处的值修改了，但是  i 的值却没有修改，这是为什么呢？ 

实际是在C++程序中，使用const 修饰的变量是存放在寄存器中的，最终打印该值是直接打印寄存器存储的值。

汇编代码

如果想要 i 的值能够修改，需要加  volatile 修饰。

代码演示

<code>int main()

{

volatile const int i = 1;

int* ptr = (int*)&i;

(*ptr)++;

cout << *ptr << endl;

// 不加volatile，打印的值就是1，不会修改，监视窗口是查看对应地址的值

// 加上volatile表示i 是不稳定的，可能被修改，因此打印的值是修改之后值

cout << i << endl;

return 0;

}

 运行结果 

汇编代码

 删除变量的const属性就可以使用const_cast。

代码演示

<code>// const_cast -> 删除变量的const属性

int main()

{

const int i = 1;

int* ptr = const_cast<int*>(&i);

(*ptr)++;

cout << *ptr << endl;

// 不加volatile，打印的值就是1，不会修改，监视窗口是查看对应地址的值

// 加上volatile表示i 是不稳定的，可能被修改，因此打印的值是修改之后值

cout << i << endl;

return 0;

}

运行结果 

3.4 dynamic_cast

dynamic_cast用于将一个父类对象的指针/引用转换为子类对象的指针或引用(动态转换)

向上转型：子类对象指针/引用->父类指针/引用(不需要转换，赋值兼容规则)向下转型：父类对象指针/引用->子类指针/引用(用dynamic_cast转型是安全的)

注意：

1. dynamic_cast只能用于父类含有虚函数的类 。

2. dynamic_cast会先检查是否能转换成功，能成功则转换，不能则返回0。

直接将父类对象指针/引用->子类指针/引用

 代码演示

<code>class A

{

public:

virtual void f(){}

int _a1 = 1;

};

class B : public A

{

public:

int _b1 = 1;

};

void func(A* pa)

{

// 不差别转换，存在风险

// 传A对象的地址，没有_b1成员，修改_b1成员则程序崩溃

B* pb = (B*)pa;

cout << pb << endl;

pb->_b1++;

}

int main()

{

A a;

B b;

func(&a);

func(&b);

return 0;

}

运行结果 

使用dynamic_cast

代码演示

<code>class A

{

public:

virtual void f(){}

int _a1 = 1;

};

class B : public A

{

public:

int _b1 = 1;

};

// 使用dynamic_cast，父类必须有虚函数

void func(A* pa)

{

// pa指向a对象，转换成功

// pa指向b对象，转换失败，返回nullptr

B* pb = dynamic_cast<B*>(pa);

if (pb)

{

cout << pb << endl;

pb->_b1++;

}

else

{

cout << "转换失败" << endl;

}

}

int main()

{

A a;

B b;

func(&a);

func(&b);

return 0;

}

运行结果 

注意

强制类型转换关闭或挂起了正常的类型检查，每次使用强制类型转换前，程序员应该仔细考虑是否还有其他不同的方法达到同一目的，如果非强制类型转换不可，则应限制强制转换值的作用域，以减少发生错误的机会。强烈建议：避免使用强制类型转换 。

4. RTTI

RTTI：Run-time Type identification的简称，即：运行时类型识别。

C++通过以下方式来支持RTTI：

1. typeid运算符2. dynamic_cast运算符3. decltype