---- 整理自狄泰软件唐佐林老师课程
文章目录
1. C 方式的强制类型转换
1.1 编程实验:粗暴的类型转换
#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;
}
1.2 C 方式强制类型转换存在的问题
- 过于粗暴
任意类型之间都可以进行转换,编译器很难判断其正确性 - 难于定位
在源码中无法快速定位所有使用强制类型转换的语句
1.3 问题
- 强制类型转换在实际工程中是很难完全避免的!如何进行更加安全可靠的转换?
2. C++ 将强制类型转换分为 4 种不同的类型
static_cast
const_cast
reinterpret_cast
dynamic_cast
- 用法:
xxx_cast<Type>(Expression)
#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()
{
const int& j = 1;
int& k = const_cast<int&>(j);
const int x = 2;
int& y = const_cast<int&>(x);
int z = const_cast<int>(x);
k = 5;
printf("k = %d\n", k);
printf("j = %d\n", j);
y = 8;
printf("x = %d\n", x);
printf("y = %d\n", y);
printf("&x = %p\n", &x);
printf("&y = %p\n", &y);
}
void reinterpret_cast_demo()
{
int i = 0;
char c = 'c';
int* pi = &i;
char* pc = &c;
pc = reinterpret_cast<char*>(pi);
pi = reinterpret_cast<int*>(pc);
pi = reinterpret_cast<int*>(i);
c = reinterpret_cast<char>(i);
}
void dynamic_cast_demo()
{
int i = 0;
int* pi = &i;
char* pc = dynamic_cast<char*>(pi);
}
int main()
{
static_cast_demo();
const_cast_demo();
reinterpret_cast_demo();
dynamic_cast_demo();
return 0;
}
2.1 static_cast 强制类型转换
- 用于 基本类型 间的转换
- 不能 用于基本类型 指针间 的转换
- 用于 有 继承关系 类对象之间 的转换和 类指针 之间的转换
#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); // 基本类型指针间不可以
}
int main()
{
static_cast_demo();
return 0;
}
2.2 const_cast 强制类型转换
- 用于 去除变量的只读属性
- 强制转换的目标类型 必须是 指针或引用
#include <stdio.h>
void const_cast_demo()
{
const int i = 1;
const int& j = 2;
int x = const_cast<int>(i); // 强制转换的类型必须是指针或引用
int y = const_cast<int&>(i);
int z = const_cast<int&>(j);
printf("x = %d, i = %d\n", x, i);
printf("y = %d, i = %d\n", y, i);
printf("z = %d, j = %d\n", z, j);
y = 11;
z = 22;
printf("y = %d, i = %d\n", y, i);
printf("z = %d, j = %d\n", z, j);
}
int main()
{
const_cast_demo();
return 0;
}
#include <stdio.h>
void const_cast_demo()
{
const int i = 1;
const int& j = 2;
// int x = const_cast<int>(i); // 强制转换的类型必须是指针或引用
int y = const_cast<int&>(i);
int z = const_cast<int&>(j);
// printf("x = %d, i = %d\n", x, i);
printf("y = %d, i = %d\n", y, i);
printf("z = %d, j = %d\n", z, j);
y = 11;
z = 22;
printf("y = %d, i = %d\n", y, i);
printf("z = %d, j = %d\n", z, j);
}
int main()
{
const_cast_demo();
return 0;
}
2.3 reinterpret_cast 强制类型转换
- 用于 指针类型间 的强制类型转换
- 用于 整数 和 指针类型 间的强制转换
#include <stdio.h>
void reinterpret_cast_demo()
{
int i = 0;
char c = 'c';
int* pi = &i;
char* pc = &c;
pc = reinterpret_cast<char*>(pi);
pi = reinterpret_cast<int*>(pc);
pi = reinterpret_cast<int*>(i);
c = reinterpret_cast<char>(i); // 基本类型间转换 static_cast
}
int main()
{
reinterpret_cast_demo();
return 0;
}
#include <stdio.h>
void reinterpret_cast_demo()
{
int i = 0;
char c = 'c';
int* pi = &i;
char* pc = &c;
pc = reinterpret_cast<char*>(pi);
pi = reinterpret_cast<int*>(pc);
pi = reinterpret_cast<int*>(i);
// c = reinterpret_cast<char>(i); // 基本类型间转换 static_cast
}
int main()
{
reinterpret_cast_demo();
return 0;
}
2.4 dynamic_cast 强制类型转换(后续补充)
(补充部分内容可参看 55 - 经典问题解析四 dynamic_cast 部分:)
55 - 经典问题解析四 – 继承中的强制类型转换
- 用于 有继承关系的类指针 间的转换
- 用于 有交叉关系的类指针 间的转换
- 具有类型检查的功能
- 需要虚函数的支持
#include <stdio.h>
void dynamic_cast_demo()
{
int i = 0;
int* pi = &i;
char* pc = dynamic_cast<char*>(pi);
}
int main()
{
dynamic_cast_demo();
return 0;
}