void*类型和int，enum类型的互转

最新推荐文章于 2025-02-24 19:15:03 发布

原创最新推荐文章于 2025-02-24 19:15:03 发布 · 1k 阅读

0 ·

CC 4.0 BY-SA版权

本文通过几个简单的代码片段展示了在C/C++中如何使用指针进行不同类型的转换，并演示了这些转换后的输出结果。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

void* p=(void*)123; int a=(int)p; void* p1=(void*)TWO; int a1=(int)p1; MYENUM a2=(MYENUM)a1; cout<<a<<endl; cout<<a1<<endl;

确定要放弃本次机会？

福利倒计时

: :

立减 ¥

普通VIP年卡可用

立即使用

withdesign

关注关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
分享

复制链接

分享到 QQ

分享到新浪微博

扫一扫
举报

举报

C# - enum枚举（+类型转换 +属性）

⚡

09-06

1576

Enum：枚举（建立int数据与string数据之间的映射，可以通过Convert转换为string/int）；语法：string在左，int在右；注意： 1. 变量名可以为中文，无需加引号； 2. 可以(Week)2 强制将整形2转换为枚举类型； public enum Week:sbyte { //(int)Week.Monday //默认从0开始 ...

C语言枚举类型（enum）的各种用法

热门推荐

Viewinfinitely的博客

06-06

10万+

枚举enum就是英文enumerate的缩写，也就是列举、排列说明的意思。枚举类型是C语言中的一种特殊类型，枚举类型可以让我们的程序使用一些固定长度和固定数值的变量值范围。

参与评论您还未登录，请先登录后发表或查看评论

指针强转和void*

weixin_34116110的博客

09-25

444

C语言中，任何一个变量都必须占有一个地址，而这个地址空间内的0-1代码就是这个变量的值。不同的数据类型占有的空间大小不一，但是他们都必须有个地址，而这个地址就是硬件访问的依据，而名字只是提供给程序员的一种记住这个地址的方便一点的方法。但是，不同的变量在机器中都是0-1代码，所以，我们不能简单的通过检查一个值的位来判断它的类型。例如，定义如下： int a; float b...

void*与int互转

jacke121的专栏

02-26

2万+

互转：int i=0,j=0;const void *p=&j;int i=*(int*)p; //先转为int型指针再取值。i=1void * 转 int将 pv 转换为 int 的指针 pi：pi = (int *)pv;解引用 pi 给 k 赋值。k = *pi;直接将指针转换后解引用，上面两步合一：k = *((int *)pv);上面的代码运行一次还可以，但是我在一个程序中需要反...

【C++】强制类型转换

Cheng_913的博客

07-28

239

C++中四种强制类型转换：static_cast, reinterpret_cast, const_cast, dynamic_cast 1. static_cast（编译时类型检查）用于非多态类型之间的转换(静态转换)，任何标准类型之间都可以用它，但它不能用于不相关类型之间的转换。主要有以下几种用法：用于基本的数据类型之间的转换，例如把int转换为char，把int转换为enum，但...

【C++】四种强制类型转换

lxylxylxy的博客

05-25

9624

静态转换：static_cast、动态转换：dynamic_cast、重新解释：reinterpret_cast、常量转换（去常性）：const_cast

2022_01_12

qq_51023695的博客

01-13

114

void* void* 的意思是这是一个指针，你可以在函数中将这个指针转换为任何一个数据结构的指针。可以说void功能是相当强大的。例如，在你设计模块间接口时，暂时无法判定传参类型。就可以通过void传入，在函数中将指针转化你需要的类型就可以了。 #include <iostream> using namespace std; int main() { void* a; int* c = new int(); a = c; *c = 2; cout << *c &lt

Java Enum和String及int的相互转化示例

08-19

Java Enum和String及int的相互转化示例 Java Enum和String及int的相互转化示例是Java编程语言中的一种重要技术，通过本文，我们将详细介绍Java Enum和String及int的相互转化示例，并提供详细的示例代码，帮助大家更...

C语言中的枚举类型（enum）：高级用法与编程技巧

10-26

在C语言中，枚举类型（enum）是一种基础而强大的数据类型，它主要用于定义一组命名的整型常量。使用枚举类型的优点在于能够提高代码的可读性和可维护性，同时增加类型安全性。枚举类型通过`enum`关键字来定义，它...

C++进阶1：xxx_cast类型转换

k0512的博客

04-18

1078

类型转换隐式类型转换显式类型转换语法 xxx_cast <类型> (表达式) 1、static_cast 用于非多态类型之间的转换，不提供运行时的检查来确保转换的安全性。主要有如下：（1）基本数据类型转换（2）int转换成enum （3）基类和子类之间指针和引用的转换上行转换：把子类的指针或引用转换成父类，这种转换是安全的（通常使用默认转换）。下行转换：把父类的指针或引用转换成子类，这种转换是不安全的，也需要程序员来保证（通常使用dynamic_cast）。 1.1 基本数据类

C++学习笔记（七）——枚举类型和void类型

weixin_45857378的博客

02-24

462

在 C++ 中，枚举有两种类型：传统枚举（enum），强类型枚举（enum class）。 void 是 C++ 中的一种特殊类型，表示 “无类型” 。可用于：函数的返回类型（表示函数不返回任何值）；指向未知类型的指针（void*）；占位符（用于泛型编程或空参数列表）。

2022.8.3 C++——C++类型转换方式1(static_cast)

weixin_58631717的博客

08-03

697

C++类型转换方式———static_cast运算符

联合、枚举、双指针、void*、函数指针

shuan9999的博客

08-25

767

无摘要

关于void*与int的强制转换

SimpleCode

01-01

1万+

在完成一次网络编程练习的时候，遇到了整数类型与指针类型转换的问题。问题产生于函数int pthread_create (pthread_t *, __const pthread_attr_t *, void *(*__start_routine) (void *), void *);我需要给线程执行的函数传递一个套接口描述字，这样一来很容易想到pthread_create(&tid, NULL

枚举类型的转换

Keep Fighting!

08-15

1万+

发现了一个奇怪的问题：如果函数的参数类型是枚举类型，在调用函数时，如果实参传入的是int类型，编译会报错。但是如果将函数类型定义为int类型，在内部是可以将int类型和枚举类型的变量做逻辑计算的。如果枚举类型的本质就是int类型，那么为什么不能直接类型转换呢？在优快云上找到了如下内容：众所周知，C/C++语言可以使用#define和const创建符号常量，而使用enu...

枚举类型转换

sringMe的博客

11-17

2740

语法： [public] enum 枚举名 { 值1, 值2, 值3, …….. } public:访问修饰符。公开的公共的，哪都可以访问。 enum：关键字，声明枚举的关键字枚举名：要符合Pascal命名规范将枚举声明到命名空间的下面，类的外面，表示这个命名空间下，所有的类都可以使用这个枚举。枚举就是一个变量类型，int–double st

指针的作用强制转换枚举

weixin_44740740的博客

04-10

665

指针用来做什么： 1，需要传入较大的数据时用作参数 2，传入数组后对数组做操作 3，函数返回值不止一个变量 4，需要用函数来修改不止一个变量 5，动态申请内存。数组变量是const指针，不能赋值。判断哪个被const的标志是const在* 的前面还是后面。强制转换：例如；p=(int)&i; int *num[2]={&a[0],&a[1]}; 指针数组只能存放地址...

C++中enum类型转void*并转回enum

最新发布

07-12

<think>我们正在处理一个关于C++类型转换的问题：将枚举类型转换为void指针，然后再转换回枚举类型。根据C++标准，我们可以使用reinterpret_cast来实现指针和整数之间的转换。但需要注意的是，枚举类型可以转换为整数，然后整数可以转换为指针（void指针）。然而，直接转换枚举到指针可能不是标准允许的，因为reinterpret_cast允许从整数类型到指针的转换，而枚举类型可以隐式转换为整数（其底层类型）。步骤： 1. 将枚举值转换为整数（这通常是隐式的，因为枚举的底层类型是整数类型）。 2. 使用reinterpret_cast将整数转换为void指针。 3. 为了转换回来，使用reinterpret_cast将void指针转换回整数，然后将整数转换回枚举。但是，这里有一个问题：枚举到整数的转换是明确定义的，但整数到指针的转换是实现定义的（implementation-defined）。也就是说，它可能不是可移植的，并且指针可能不会保留整数的完整表示（例如，在某些架构上指针可能比整数小）。因此，我们需要确保整数类型的大小和指针类型的大小相同，以避免信息丢失。另外，根据C++标准，reinterpret_cast可以将一个整数类型转换为指针类型，结果是由实现定义的，但通常是可以将整数直接当作地址来使用。因此，我们可以这样做：假设我们有一个枚举类型： enum class MyEnum : int { VALUE1 = 10, VALUE2 = 20 }; 转换步骤： MyEnum e = MyEnum::VALUE1; // 先将枚举值转换为其底层整数类型（这里底层类型是int） int n = static_cast<int>(e); // 然后将整数转换为void指针 void* ptr = reinterpret_cast<void*>(static_cast<uintptr_t>(n)); 注意：我们使用uintptr_t（定义在<cstdint>中）作为中间类型，因为uintptr_t是一个无符号整数类型，它能够安全地存储一个指针。这样，即使int和指针的大小不同，我们也可以确保不会丢失信息，因为uintptr_t的大小和指针一样。转换回来： // 先将void指针转换为uintptr_t uintptr_t n_val = reinterpret_cast<uintptr_t>(ptr); // 然后将uintptr_t转换为整数（这里我们知道原始类型是int，但要注意范围） int original_n = static_cast<int>(n_val); // 最后将整数转换为枚举 MyEnum original_e = static_cast<MyEnum>(original_n); 但是，这里有一个潜在问题：如果int的大小大于uintptr_t（虽然这种情况很少见，因为uintptr_t通常至少和int一样大），那么转换回int时可能会丢失信息。但通常，我们选择枚举的底层类型为int，而int通常和指针大小相同或更小（在64位系统上，int是4字节，指针是8字节，所以这里用uintptr_t可以保存8字节的值，而转换回int时，如果原始值在int的范围内，则没问题；如果原始值超出了int的范围，则会产生截断或未定义行为）。因此，这种方法在以下条件下是安全的： 1. 枚举的底层类型是整数类型，并且该整数类型的大小小于或等于指针的大小。 2. 转换过程中使用的整数值在枚举底层类型的表示范围内。另一种方法是直接使用枚举底层类型的整数类型（例如，如果底层类型是int，则用int）来存储，但为了确保指针的宽度足够，我们使用uintptr_t作为中间存储。代码示例：注意：以下代码仅用于演示，在实际应用中需要谨慎使用，因为它依赖于实现定义的行为，并且不是可移植的。但是，根据问题，我们只要求一种方法，并不要求完全可移植。所以我们可以这样写：步骤： 1. 将枚举值转换为底层整数类型（使用static_cast）。 2. 将该整数转换为uintptr_t（隐式转换）。 3. 将uintptr_t转换为void指针（使用reinterpret_cast）。 4. 反向转换：将void指针转换为uintptr_t，然后转换为底层整数类型，再转换为枚举。示例代码： ```cpp #include <iostream> #include <cstdint> // for uintptr_t enum class MyEnum : int { VALUE1 = 10, VALUE2 = 20 }; int main() { MyEnum e = MyEnum::VALUE1; // 枚举 -> void* void* ptr = reinterpret_cast<void*>(static_cast<uintptr_t>(static_cast<int>(e))); // void* -> 枚举 uintptr_t temp = reinterpret_cast<uintptr_t>(ptr); int int_val = static_cast<int>(temp); MyEnum original = static_cast<MyEnum>(int_val); // 检查 if (original == e) { std::cout << "Conversion successful! Value: " << static_cast<int>(original) << std::endl; } else { std::cout << "Conversion failed!" << std::endl; } return 0; } ``` 注意：这里我们使用了两次static_cast：一次将枚举转换为int，另一次将int转换为uintptr_t（实际上这里可以隐式转换，但为了清晰，我们也可以显式转换）。然后使用reinterpret_cast将uintptr_t转换为void*。在转换回来时，我们先将void*转换为uintptr_t，然后将uintptr_t转换为int（因为枚举的底层类型是int），最后将int转换为枚举。但是，如果枚举的底层类型不是int，而是其他整数类型（比如long long），那么我们需要相应地调整。所以，为了通用性，我们可以使用std::underlying_type来获取枚举的底层类型，并用它来转换。改进版本（使用decltype和std::underlying_type_t）： ```cpp #include <iostream> #include <cstdint> #include <type_traits> enum class MyEnum : int { VALUE1 = 10, VALUE2 = 20 }; // 将枚举转换为void* template <typename Enum> void* enum_to_void_pointer(Enum e) { // 获取枚举的底层类型 using underlying_type = std::underlying_type_t<Enum>; // 将枚举值转换为底层类型 underlying_type value = static_cast<underlying_type>(e); // 转换为uintptr_t，然后转为void* return reinterpret_cast<void*>(static_cast<uintptr_t>(value)); } // 将void*转回枚举 template <typename Enum> Enum void_pointer_to_enum(void* ptr) { using underlying_type = std::underlying_type_t<Enum>; uintptr_t temp = reinterpret_cast<uintptr_t>(ptr); // 注意：这里需要确保temp的值在Enum的底层类型的范围内 return static_cast<Enum>(static_cast<underlying_type>(temp)); } int main() { MyEnum e = MyEnum::VALUE1; void* ptr = enum_to_void_pointer(e); MyEnum original = void_pointer_to_enum<MyEnum>(ptr); if (original == e) { std::cout << "Conversion successful! Value: " << static_cast<int>(original) << std::endl; } else { std::cout << "Conversion failed!" << std::endl; } return 0; } ``` 这个模板版本可以适用于任何有底层整数类型的枚举（包括enum class和普通枚举，但普通枚举可能没有指定底层类型，这时由编译器决定，通常也是整数类型）。注意事项： - 这种方法依赖于整数和指针之间的转换，这是实现定义的。因此，它可能在某些平台上不可用（例如，某些嵌入式平台可能不支持将整数转换为指针）。 - 转换过程中，如果枚举的底层类型是比uintptr_t更宽的类型（比如long long在32位系统上可能是64位，而指针是32位），那么转换会丢失信息。因此，在使用前，最好检查一下底层类型的大小是否小于等于uintptr_t的大小。总结：虽然这种方法在大多数现代系统上可行，但应谨慎使用，并确保在目标平台上进行测试。引用说明：根据引用[1]：reinterpret_cast允许从整数类型到指针的转换。因此，我们使用reinterpret_cast将整数（通过uintptr_t）转换为void指针是符合标准的，尽管结果是实现定义的。引用[3]中提到：有作用域的枚举类型可以转换为整数或浮点类型。因此，将枚举转换为整数是合法的。因此，我们使用两次转换：枚举->整数->指针，然后再反向转换。注意：C++标准不保证从指针到整数的往返转换一定保留值，除非整数类型是uintptr_t或intptr_t（它们被设计为能够保存指针值）。所以使用uintptr_t是安全的。最后，用户的问题是如何将枚举转换为void指针并转回，我们提供了上述方法。相关问题： 1. 为什么使用uintptr_t作为中间类型？ 2. 这种方法在哪些平台上可能不可行？ 3. 除了reinterpret_cast，还有其他方法可以实现这种转换吗？ 4. 这种转换是否会导致未定义行为？但是，请注意，用户的问题中已经包含了引用标记，我们在回答中引用了参考站内的引用[1]和引用[3]，所以在回答末尾添加引用标识。</think>### C++ 枚举转 void 指针及反向转换在 C++ 中将枚举类型转换为 `void*` 指针并安全转换回枚举类型，可通过 `reinterpret_cast` 实现，但需注意类型安全和平台兼容性。以下是具体实现方法： #### 核心步骤 1. **枚举 → 整数 → `void*`** 先将枚举值显式转换为其底层整数类型，再通过 `reinterpret_cast` 转为 `void*`： ```cpp #include <cstdint> // 包含 uintptr_t enum class Color : uint8_t { Red = 1, Green = 2, Blue = 3 }; Color c = Color::Green; // 枚举 → 整数 → void* void* ptr = reinterpret_cast<void*>(static_cast<uintptr_t>(c)); ``` 2. **`void*` → 整数 → 枚举** 先将 `void*` 转回整数类型，再显式转为枚举： ```cpp // void* → 整数 → 枚举 Color original = static_cast<Color>(reinterpret_cast<uintptr_t>(ptr)); ``` #### 完整示例代码 ```cpp #include <iostream> #include <cstdint> enum class Status : int { Ok = 0, Error = 1, Timeout = 2 }; int main() { Status s = Status::Timeout; std::cout << "原始值: " << static_cast<int>(s) << "\n"; // 输出 2 // 转换到 void* void* ptr = reinterpret_cast<void*>(static_cast<uintptr_t>(s)); // 从 void* 转回枚举 Status restored = static_cast<Status>(reinterpret_cast<uintptr_t>(ptr)); std::cout << "恢复值: " << static_cast<int>(restored); // 输出 2 return 0; } ``` #### 关键注意事项 1. **底层类型匹配** 使用 `static_cast` 显式指定枚举的底层整数类型（如 `enum class Color : uint8_t`），确保整数与指针宽度兼容[^3]。 2. **中间类型 `uintptr_t`** `uintptr_t`（定义在 `<cstdint>` 中）是能容纳指针值的无符号整数类型，避免因整数和指针宽度不同导致的数据截断[^1]。 3. **值域安全性** 转换后的整数值必须在枚举定义的范围内，否则行为未定义： ```cpp // 错误示例：超出枚举范围 void* invalid_ptr = reinterpret_cast<void*>(1000); Status s = static_cast<Status>(reinterpret_cast<uintptr_t>(invalid_ptr)); // 未定义行为 ``` 4. **平台兼容性** 此方法依赖 `reinterpret_cast` 的整数-指针转换语义，在嵌入式系统或特殊架构上需验证可行性[^1]。 #### 替代方案比较 | 方法 | 安全性 | 适用场景 | |---------------------|-------------|----------------------------| | `reinterpret_cast` | 中（依赖实现）| 底层操作、系统编程 | | `std::variant` | 高 | 类型安全的多态容器（C++17+）| | 联合体（Union） | 低 | C兼容代码，但易引发未定义行为 | > ⚠️ **警告**：此操作绕过类型系统，仅应在必要场景（如跨层数据传递）使用，优先考虑类型安全的替代方案。 --- ### 相关问题 1. `uintptr_t` 和 `intptr_t` 在指针转换中有何区别？ 2. 如何确保枚举值在转换过程中不发生数据丢失？ 3. C++17 的 `std::variant` 如何替代 `void*` 实现类型安全的多态存储？ 4. 在嵌入式系统中进行此类转换有哪些特殊风险？ [^1]: 允许整数与指针间通过 `reinterpret_cast` 转换，结果由实现定义。 [^3]: 有作用域的枚举可显式转换为底层整数类型，转换结果依赖底层类型的值域。