static_cast<>和reinterpret_cast<>

最新推荐文章于 2025-03-10 22:03:05 发布
转载 最新推荐文章于 2025-03-10 22:03:05 发布 · 473 阅读 · 0

本文深入探讨了C++中的static_cast和reinterpret_cast操作符，通过实例解释了这两种转换方式在不同类型间的应用及其可能导致的问题。重点讲解了在泛型、指针类型及void*之间的转换细节。

本文讨论static_cast<> 和 reinterpret_cast<>。

介绍

大多程序员在学C++前都学过C，并且习惯于C风格（类型）转换。当写C++（程序）时，有时候我们在使用static_cast<>和reinterpret_cast<>时可能会有点模糊。在本文中，我将说明static_cast<>实际上做了什么，并且指出一些将会导致错误的情况。

泛型（Generic Types）

01.float f = 12.3;
02. 
03.float* pf = &f;
04.// static cast<>
05. 
06.// 成功编译, n = 12
07. 
08.int n = static_cast(f);
09. 
10.// 错误,指向的类型是无关的（译注：即指针变量pf是float类型，现在要被转换为int类型）
11.//int* pn = static_cast(pf);
12. 
13.//成功编译
14. 
15.void* pv = static_cast(pf);
16. 
17.//成功编译, 但是 *pn2是无意义的内存（rubbish）
18. 
19.int* pn2 = static_cast(pv);
20.// reinterpret_cast<>
21. 
22.//错误,编译器知道你应该调用static_cast<>
23. 
24.//int i = reinterpret_cast(f);
25. 
26.//成功编译, 但是 *pn 实际上是无意义的内存,和 *pn2一样
27. 
28.int* pi = reinterpret_cast(pf);

简而言之，static_cast<> 将尝试转换，举例来说，如float-到-integer，而reinterpret_cast<>简单改变编译器的意图重新考虑那个对象作为另一类型。

指针类型（Pointer Types）

指针转换有点复杂，我们将在本文的剩余部分使用下面的类：

01.class CBaseX
02. 
03.{
04. 
05.public:
06. 
07.int x;
08. 
09.CBaseX() { x = 10; }
10. 
11.void foo() { printf("CBaseX::foo() x=%d\n", x); }
12. 
13.};
14.class CBaseY
15. 
16.{
17. 
18.public:
19. 
20.int y;
21. 
22.int* py;
23. 
24.CBaseY() { y = 20; py = &y; }
25. 
26.void bar() { printf("CBaseY::bar() y=%d, *py=%d\n", y, *py);
27.}
28. 
29.};
30.class CDerived : public CBaseX, public CBaseY
31. 
32.{
33. 
34.public:
35. 
36.int z;
37. 
38.};

情况1：两个无关的类之间的转换

01.// Convert between CBaseX* and CBaseY*
02. 
03.// CBaseX* 和 CBaseY*之间的转换
04. 
05.CBaseX* pX = new CBaseX();
06. 
07.// Error, types pointed to are unrelated
08. 
09.// 错误， 类型指向是无关的
10. 
11.// CBaseY* pY1 = static_cast(pX);
12. 
13.// Compile OK, but pY2 is not CBaseX
14. 
15.// 成功编译, 但是 pY2 不是CBaseX
16. 
17.CBaseY* pY2 = reinterpret_cast(pX);
18. 
19.// System crash!!
20. 
21.// 系统崩溃!!
22. 
23.// pY2->bar();

正如我们在泛型例子中所认识到的，如果你尝试转换一个对象到另一个无关的类static_cast<>将失败，而reinterpret_cast<>就总是成功“欺骗”编译器：那个对象就是那个无关类。

情况2：转换到相关的类

01.1. CDerived* pD = new CDerived();
02. 
03.2. printf("CDerived* pD = %x\n", (int)pD);
04. 
05.3.
06. 
07.4. // static_cast<> CDerived* -> CBaseY* -> CDerived*
08. 
09.//成功编译，隐式static_cast<>转换
10. 
11.5. CBaseY* pY1 = pD;
12. 
13.6. printf("CBaseY* pY1 = %x\n", (int)pY1);
14. 
15.// 成功编译, 现在 pD1 = pD
16. 
17.7. CDerived* pD1 = static_cast(pY1);
18. 
19.8. printf("CDerived* pD1 = %x\n", (int)pD1);
20. 
21.9.
22. 
23.10. // reinterpret_cast
24. 
25.// 成功编译, 但是 pY2 不是 CBaseY*
26. 
27.11. CBaseY* pY2 = reinterpret_cast(pD);
28. 
29.12. printf("CBaseY* pY2 = %x\n", (int)pY2);
30. 
31.13.
32. 
33.14. // 无关的 static_cast<>
34. 
35.15. CBaseY* pY3 = new CBaseY();
36. 
37.16. printf("CBaseY* pY3 = %x\n", (int)pY3);
38. 
39.// 成功编译,尽管 pY3 只是一个 "新 CBaseY()"
40. 
41.17. CDerived* pD3 = static_cast(pY3);
42. 
43.18. printf("CDerived* pD3 = %x\n", (int)pD3);
01.---------------------- 输出 ---------------------------
02. 
03.CDerived* pD = 392fb8
04. 
05.CBaseY* pY1 = 392fbc
06. 
07.CDerived* pD1 = 392fb8
08. 
09.CBaseY* pY2 = 392fb8
10. 
11.CBaseY* pY3 = 390ff0
12. 
13.CDerived* pD3 = 390fec

注意：在将CDerived*用隐式 static_cast<>转换到CBaseY*（第5行）时，结果是（指向）CDerived*（的指针向后） 偏移了4（个字节）（译注：4为int类型在内存中所占字节数）。为了知道static_cast<> 实际如何，我们不得不要来看一下CDerived的内存布局。

CDerived的内存布局（Memory Layout）

 

如图所示，CDerived的内存布局包括两个对象，CBaseX 和 CBaseY，编译器也知道这一点。因此，当你将CDerived* 转换到 CBaseY*时，它给指针添加4个字节，同时当你将CBaseY*转换到CDerived*时，它给指针减去4。然而，甚至它即便不是一个CDerived你也可以这样做。

当然，这个问题只在如果你做了多继承时发生。在你将CDerived转换 到 CBaseX时static_cast<> 和 reinterpret_cast<>是没有区别的。

情况3：void*之间的向前和向后转换

因为任何指针可以被转换到void*，而void*可以被向后转换到任何指针（对于static_cast<> 和 reinterpret_cast<>转换都可以这样做），如果没有小心处理的话错误可能发生。

01.CDerived* pD = new CDerived();
02. 
03.printf("CDerived* pD = %x\n", (int)pD);
04.CBaseY* pY = pD; // 成功编译, pY = pD + 4
05. 
06.printf("CBaseY* pY = %x\n", (int)pY);
07.void* pV1 = pY; //成功编译, pV1 = pY
08. 
09.printf("void* pV1 = %x\n", (int)pV1);
10.// pD2 = pY, 但是我们预期 pD2 = pY - 4
11. 
12.CDerived* pD2 = static_cast(pV1);
13. 
14.printf("CDerived* pD2 = %x\n", (int)pD2);
15. 
16.// 系统崩溃
17. 
18.// pD2->bar();
01.---------------------- 输出 ---------------------------
02. 
03.CDerived* pD = 392fb8
04. 
05.CBaseY* pY = 392fbc
06. 
07.void* pV1 = 392fbc
08. 
09.CDerived* pD2 = 392fbc

一旦我们已经转换指针为void*，我们就不能轻易将其转换回原类。在上面的例子中，从一个void* 返回CDerived*的唯一方法是将其转换为CBaseY*然后再转换为CDerived*。

但是如果我们不能确定它是CBaseY* 还是 CDerived*，这时我们不得不用dynamic_cast<> 或typeid[2]。

注释：

1. dynamic_cast<>，从另一方面来说，可以防止一个泛型CBaseY* 被转换到CDerived*。

2. dynamic_cast<>需要类成为多态，即包括“虚”函数，并因此而不能成为void*。

wesson08
关注
C++类型转换运算符dynamic_cast、static_cast 和 reinterpret_cast
啊渊的专栏
04-19 1228
和。这些转换运算符可以用来在不同的上下文中进行类型转换，但它们的行为和使用场景是不同的。
【037】C++中的四种强制类型转换：static_cast、const_cast、dynamic_cast和reinterpret_cast详解
Lion_Long的博客
07-05 1129
在学习C++类型转换之前，了解正确的转换方式至关重要。本文深入探讨了C++中的类型转换方法，从隐式转换到动态转换，展示了安全转换的重要性。通过上行和下行转换的比较，引领读者探寻类型转换的安全边界。静态转换、动态转换和常量转换的细致解读，助您在C++编程中运用恰当的转换技巧。
static_cast揭密
orichisonic的专栏
07-16 832
http://www.vckbase.com/document/viewdoc/?id=1651 原文链接：What static_cast本文讨论static_cast。 介绍大多程序员在学C++前都学过C，并且习惯于C风格（类型）转换。当写C++（程序）时，有时候我们在使用static_cast时可能会有点模糊。在本文中，我将说明static_cast泛型（Generic Types）
C++—— static_cast＜＞
w85203555的博客
03-10 685
也可以用于指针类型之间的转换，但需要注意的是，它只能用于具有继承关系的类指针之间，或者用于 void 指针与其它类型指针之间的转换。是 C++ 中最常用的类型转换运算符，它可以用于基本数据类型、指针类型和引用类型之间的转换。是在编译时进行类型检查的，因此它无法检测运行时的类型错误。用于进行低级别的类型转换，例如将指针转换为整数，或者将整数转换为指针。用于在继承体系中进行安全的向下转型，会在运行时进行类型检查。不能用于不同类型指针之间的转换，例如，不能将。时，需要注意其局限性，避免出现类型错误。
static_cast
qingsong1001的专栏
11-06 763
static_cast conversion 使用了隐式转换和用户定义的转换的结合的方式，进行类型间转换。 Syntax static_cast < new_type > ( expression ) 返回类型为“new_type”的值。 Explanation 只有如下的转换可以使用static_cast来完成，除非这些转换破坏了“constness”或“volatili...
C++中的类型转换static_cast、dynamic_cast、const_cast和reinterpret_cast总结
09-04
本文将详细介绍四种主要的显式类型转换：`static_cast`、`dynamic_cast`、`const_cast`和`reinterpret_cast`。 首先，`static_cast`主要用于非多态类型的转换，它不提供运行时的类型检查。例如，当进行基类与子类...
精选资源
类型转换操作符:static_cast,dynamic_cast,const_cast,reinterpret_cast.
01-31
特别是在指针转换和数值转换时用到的非常多。只要编写程序的人知道自己要做什么转换，并知道应该怎样转换的话，我认为上边的转换方式非常之好。但是没有清楚的了解每个转换的细节的话，就有可能
static_cast,dynamic_cast,reinterpret_cast,const_cast的区别及用法详解
12-31
1.static_cast对类的指针只能转换有继承关系的类。对普通的指针来说只能在void*和其他指针之间转换。它还可转换简单的类型，比如int到char等。不能提供数字到指针的转换。不能提供不同类型指针之间的转换比如int*到...
C++新特性07_强制转换static_cast(隐式转换：基本等价于隐式转换的一种类型转换运算符，可使用于需要明确隐式转换的地方；大端序、小端序；适用于低风险转换及子类转父类)
分享学习成长历程，Winter is coming！
11-16 7615
1. 隐式转换 在C语言中，存在不通过强制转换就可以将类型进行转换的隐式转换。 例子： int main() { int n = 5; float f = 10.0f; //本质上发生了隐式转换，将int类型的5转换为float类型 f = n; return 0; } 运行结果： 计算机数据存储方式： 计算机数据存储有两种字节优先顺序：高位字节优先（称为大端模式）和低位字节优先（称为小端模式）。 大端模式，是指数据的高字节保存在内存的低地址中，而数据的低字节保存在内存的高地址中，这样的
static_cast 剖析
qq_45853229的博客
05-11 7084
前言 语法 ：static_cast< 想要的类型> (原数据)， 是C++中的关键字 -------在C++中，我们经常用到 隐式的类型 转换，比如 char->int , int ->double, 类层次结构中基类 和 派生类之间指针或引用的转换。 -------编译器隐式执行的任何类型转换都可以由 static_cast显式完成。 -------需要注意的是， 我们要 确保 目标数据类型 是 我们想要的类型，因为static_cast 不做 运行时的类型检查。 -----
static_cast,const_cast,dynamic_cast,reinterpret_cast
忍冬的专栏
03-31 611
<br />C++通过引进四个新的类型转换操作符克服了C风格类型转换的缺点，这四个操作符是,   static_cast,   const_cast,   dynamic_cast,   和reinterpret_cast。在大多数情况下，对于这些操作符你只需要知道原来你习惯于这样写，   <br />  (type)   expression   <br />  而现在你总应该这样写：   <br />  1、static_cast<type>(expression)   <br />  例如，假设你想把
C++类型转换----static_cast
FAS ------ 一颗好奇心，一页好代码！
07-01 1683
static_cast无法像const_cast一样对将常量转换为non-const类型，无法将某种类型的指针转换为其他不相关的其他类型的指针，也无法将指针转换为int（毕竟在64位系统下指针为64位而int为32位）等等，也就是说无法完成C++规则认为的没有意义的转换。
【C++提高】static_cast 静态类型转换
Fanjufei的博客
06-15 4710
目录1、static_cast 静态类型转换 2、实例演练static_cast：静态类型转换。如int转换成char。static_cast() ：静态类型转换，编译的时c++编译器会做类型检查；基本类型能转换 但是不能转换指针类型。静态的类型转换: 在编译的时 进行基本类型的转换 能替代c风格的类型转换 可以进行一部分检查。 注意：不可以转换指针类型C语言能隐式类型转换的，在c++中可以用 static_cast()进行类型转换 。C++编译器在编译检查一般都能通过。......
C++基础#22：C++中的静态强制static_cast
热门推荐
记录和分享程序人生的点点滴滴
02-06 1万+
与dynamic_cast对应的是static_cast（静态强制）。static_cast关键字一般用来将枚举类型转换成整型，或者短整形转换成长整形，又或者整型转换成浮点型。也可以用来将指向父类的指针转换成指向子类的指针。static_cast可以用于类层次结构中基类和子类之间指针或引用的转换。static_cast仅仅是依靠类型转换语句中提供的信息（尖括号中的类型）来进行转换。
static_cast<DWORD64>
最新发布
11-21
<think> 我们正在讨论的是C++中的static_cast<DWORD64>。DWORD64是Windows平台定义的数据类型，通常表示64位无符号整数（在头文件<windows.h>或<WinDef.h>中定义）。static_cast是C++中的静态类型转换，用于在编译时进行类型转换。下面我将详细介绍static_cast<DWORD64>的用法、适用场景和注意事项。 ### 1. **基本用法** `static_cast<DWORD64>`用于将其他类型的数据转换为`DWORD64`类型（即64位无符号整数）。其基本语法为： ```cpp DWORD64 result = static_cast<DWORD64>(expression); ``` 其中`expression`可以是整型、浮点型、枚举类型或指针类型（但指针转换需谨慎，通常推荐使用`reinterpret_cast`）。 #### 示例1：整型转换 ```cpp int a = 42; DWORD64 b = static_cast<DWORD64>(a); // 将int转换为DWORD64 ``` #### 示例2：浮点型转换 ```cpp double d = 3.14; DWORD64 e = static_cast<DWORD64>(d); // 将double转换为DWORD64（小数部分被截断） ``` #### 示例3：枚举类型转换 ```cpp enum MyEnum { VALUE = 100 }; DWORD64 f = static_cast<DWORD64>(MyEnum::VALUE); // 枚举值转DWORD64 ``` ### 2. **适用场景** - **整型提升**：将较小整数类型（如`int`、`DWORD`）提升为64位无符号整数，避免运算溢出。 - **位操作**：在需要64位掩码或位运算时，将其他类型转为`DWORD64`。 - **API兼容**：调用Windows API时需要`DWORD64`参数（如文件操作、时间戳处理）。 - **内存地址处理**：将指针转换为整数进行地址运算（但需注意平台差异，如32/64位系统）。 ### 3. **注意事项** #### (1) 数据截断与溢出 - **浮点转整型**：小数部分被丢弃（非四舍五入）。若浮点数值超出`DWORD64`范围（0 ~ $2^{64}-1$），行为未定义（UB）。 ```cpp double d = -1.5; DWORD64 u = static_cast<DWORD64>(d); // 结果为0xFFFFFFFFFFFFFFFF（UB，实际取决于编译器） ``` - **有符号转无符号**：若源值为负数，会按模运算规则转换（即加上$2^{64}$）。例如： ```cpp int a = -1; DWORD64 b = static_cast<DWORD64>(a); // 结果为0xFFFFFFFFFFFFFFFF ``` #### (2) 指针转换风险 将指针转换为`DWORD64`虽可行，但需注意： - **平台兼容性**：32位系统上指针为4字节，64位系统为8字节。直接转换可能导致32位系统数据丢失。 - **语义问题**：指针与整数本质不同，转换后失去类型信息，应优先使用`reinterpret_cast`[^1]。 ```cpp void* p = malloc(100); DWORD64 addr = reinterpret_cast<DWORD64>(p); // 更安全的指针转整数方式 ``` #### (3) 编译时检查 `static_cast`在编译时执行类型检查，拒绝无关类型转换（如`std::string`转`DWORD64`）： ```cpp std::string s = "error"; DWORD64 x = static_cast<DWORD64>(s); // 编译错误：无效的静态转换 ``` ### 4. **与其他转换对比** | 转换方式 | 特点 | |-------------------|----------------------------------------------------------------------| | `static_cast` | 安全编译时转换，支持数值、枚举、类层次上行转换[^2][^3] | | `reinterpret_cast`| 低级二进制重解释，用于指针/整数互转（如`DWORD64 addr = reinterpret_cast<DWORD64>(ptr);`） | | `dynamic_cast` | 运行时类型检查，用于多态类下行转换（不适用基本类型）[^4] | | `const_cast` | 移除`const`或`volatile`属性 | ### 5. **总结** - **何时使用**：需安全地将数值类型（整数、浮点、枚举）转为`DWORD64`时。 - **避免使用**： - 指针转整数（用`reinterpret_cast`更合适）。 - 涉及多态类下行转换（用`dynamic_cast`）。 - **关键风险**：数据截断（浮点）、负数溢出、指针大小兼容性。 §§相关问题§§ 1. 如何在不同平台安全地将指针转换为整数类型？ 2. `static_cast`和`reinterpret_cast`在转换指针时的底层区别是什么？ 3. 在Windows编程中，`DWORD64`与`unsigned long long`有何异同？ </think>### `static_cast<DWORD64>` 的用法与相关知识 `DWORD64` 是 Windows API 中定义的 64 位无符号整数类型（等价于 `unsigned long long`）。`static_cast<DWORD64>` 用于在编译时进行安全的类型转换，将其他数据类型显式转换为 64 位无符号整数。以下是详细解析： --- ### 一、核心用法 #### 1. **基本类型转换** 将整数、浮点数等基础类型转换为 `DWORD64`： ```cpp int a = 42; DWORD64 b = static_cast<DWORD64>(a); // int → DWORD64 double c = 3.14; DWORD64 d = static_cast<DWORD64>(c); // double → DWORD64（小数部分截断） ``` - **底层汇编**： ```asm fild dword ptr [a] ; 加载int值到浮点寄存器 fstp qword ptr [b] ; 存储为64位整数 ``` 浮点转换会调用类似 `__ftol2_sse` 的指令处理截断[^1]。 #### 2. **指针类型转换** 将指针转换为 `DWORD64`（常用于存储地址值）： ```cpp void* p = malloc(100); DWORD64 addr = static_cast<DWORD64>(reinterpret_cast<uintptr_t>(p)); ``` > ⚠️ **注意**： > - 直接 `static_cast<DWORD64>(p)` 可能编译失败（无关类型需用 `reinterpret_cast` 过渡）。 > - 更安全的做法是先用 `uintptr_t` 中转[^1]。 #### 3. **枚举类型转换** ```cpp enum class Color { Red = 0xFF0000 }; DWORD64 colorVal = static_cast<DWORD64>(Color::Red); // 输出 0xFF0000 ``` --- ### 二、适用场景 1. **Windows API 交互** 需要 64 位整数的 API（如文件操作、时间戳处理）： ```cpp FILETIME fileTime; DWORD64 timestamp = static_cast<DWORD64>(fileTime.dwHighDateTime) << 32 | fileTime.dwLowDateTime; ``` 2. **位运算与掩码操作** ```cpp DWORD64 mask = static_cast<DWORD64>(1) << 40; // 创建 2^40 的掩码 ``` 3. **跨平台数据序列化** 确保数据在 32/64 位系统间兼容： ```cpp size_t size = buffer.size(); // size_t 可能为32/64位 DWORD64 safeSize = static_cast<DWORD64>(size); // 强制64位存储 ``` --- ### 三、注意事项 #### 1. **数据截断风险** - **浮点数转换**：小数部分直接丢弃（非四舍五入）。 ```cpp double pi = 3.1415926535; DWORD64 intPi = static_cast<DWORD64>(pi); // 结果为 3 ``` - **大整数溢出**： 若源值超过 $2^{64}-1$（如 `__int128`），结果未定义。 #### 2. **类型安全性限制** - **无关类型禁止转换**： ```cpp char* str = "hello"; DWORD64 num = static_cast<DWORD64>(str); // 编译错误！需用 reinterpret_cast ``` `static_cast` 仅允许语义相关的转换（如数值类型、继承类指针）[^2][^5]。 #### 3. **符号处理** 将有符号数转为无符号 `DWORD64` 时，负值会按补码规则转换： ```cpp int negative = -1; DWORD64 largeNum = static_cast<DWORD64>(negative); // 结果为 0xFFFFFFFFFFFFFFFF ``` #### 4. **与 `dynamic_cast` 的区别** | 特性 | `static_cast<DWORD64>` | `dynamic_cast` | |--------------------|-----------------------------|-----------------------------| | **检查时机** | 编译时 | 运行时 | | **适用类型** | 基础类型/非多态类 | 多态类（含虚函数） | | **失败处理** | 未定义行为 | 返回 `nullptr` 或抛异常[^4] | | **性能开销** | 零开销（直接转换） | 需 RTTI 检查 | --- ### 四、总结 - **何时使用**： - 基础类型（`int`/`double`/`enum`）转 64 位无符号整数。 - 需编译时确定的类型转换（无运行时开销）。 - **避免场景**： - 指针直接转换（用 `reinterpret_cast` 过渡）。 - 涉及多态类的向下转换（需 `dynamic_cast`）[^3][^4]。 - **关键规则**： $$ \text{安全转换} \iff \text{编译器可验证的逻辑关系} $$ ---
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值