C语言void* - 技术栈

一、开篇灵魂拷问：为什么 void * 能 "通吃" 所有数据？

在 C 语言的指针家族里，int*专情于整数，char*痴迷于字符，float*执着于浮点 ------ 唯独void*像个无边界的探险家，能指向任意类型的数据。它没有明确的类型归属，却能在各种数据类型间灵活切换，堪称指针界的 "万能瑞士军刀"。

你可能写过这样的代码：

cpp 复制代码

void* ptr;
int a = 10;
char b = 'A';
ptr = &a;  // 指向整型变量
ptr = &b;  // 无缝切换指向字符型变量

没有编译报错，没有类型冲突，void*就像一个兼容所有接口的适配器，这背后藏着 C 语言最精妙的设计哲学之一：剥离类型束缚，保留内存本质。

二、void * 的核心本质：内存地址的 "裸奔者"

要理解void*，首先要明白：C 语言中所有指针的本质都是 "内存地址"，而void*是唯一不附带 "类型解读规则" 的指针。

当你用int* p = &a时，编译器不仅记录了变量a的内存地址，还默认了 "从这个地址开始，连续 4 个字节（32 位系统）是一个整数"；

而void* ptr = &a只记录地址，不规定如何解读这片内存 ------ 它就像一个没有标签的快递盒，你知道它在仓库的位置，但不知道里面装的是手机还是书本。

这种 "裸奔" 特性带来两个关键优势：

通用性

：无需关心指向数据的具体类型，统一用void*接收，减少类型转换冗余；

抽象性

：为通用函数、数据结构提供底层支撑，这也是 C 语言能写出跨类型组件的核心原因。

三、实战场景：void * 的 3 大 "封神" 用法

1. 通用函数设计：一招搞定所有类型

最经典的场景就是标准库函数memcpy和qsort。以memcpy为例，它的原型是：

void* memcpy(void* dest, const void* src, size_t n);

如果没有void*，我们需要为int、char、float甚至自定义结构体分别写一份拷贝函数 ------ 这不仅冗余，还会让代码变得臃肿。而void*让memcpy只关注 "从 src 地址拷贝 n 个字节到 dest 地址"，完全不关心数据类型，实现了真正的通用。

再比如自定义通用交换函数：

cpp 复制代码

// 支持任意类型的交换函数
void swap(void* a, void* b, size_t size) {
  char temp[size];  // 用char数组承载任意类型的字节
  memcpy(temp, a, size);
  memcpy(a, b, size);
  memcpy(b, temp, size);
}
// 调用示例
int x=1, y=2;
swap(&x, &y, sizeof(int));  // 交换整数
char c1='A', c2='B';
swap(&c1, &c2, sizeof(char));  // 交换字符

这就是void*的魔力：用字节操作的底层逻辑，实现跨类型的通用功能。

2. 数据结构抽象：链表 / 栈的 "万能容器"

在实现链表、栈等数据结构时，void*能让容器摆脱类型限制，成为 "万能储物箱"。比如一个通用链表节点：

cpp 复制代码

typedef struct Node {
  void* data;  // 存储任意类型数据
  struct Node* next;
} Node;

这样的链表可以存储int、char*、自定义结构体等任何数据：

cpp 复制代码

// 存储整数
int num = 100;
Node* intNode = createNode(&num);
// 存储字符串
char* str = "Hello void*";
Node* strNode = createNode(str);
// 存储自定义结构体
typedef struct Person {
  char name[20];
  int age;
} Person;
Person p = {"张三", 25};
Node* personNode = createNode(&p);

没有void*，我们需要为每种数据类型写一套链表代码 ------ 这也是为什么很多开源库的基础数据结构都离不开void*。

3. 跨模块数据传递：回调函数的 "桥梁"

在回调函数设计中，void*常作为 "用户数据指针"，实现跨模块的灵活数据传递。比如定时器回调：

cpp 复制代码

// 定时器回调函数类型
typedef void (*TimerCallback)(void* userData);
// 定时器初始化函数
void initTimer(int interval, TimerCallback callback, void* userData) {
// 内部逻辑：定时后调用callback，并传入userData
}
// 自定义业务数据
typedef struct BusinessData {
  int id;
  char* msg;
} BusinessData;
// 具体回调实现
void myCallback(void* userData) {
  BusinessData* data = (BusinessData*)userData;  // 强制类型转换
  printf("ID: %d, Msg: %s\n", data->id, data->msg);
}
// 调用示例
BusinessData data = {1, "定时器触发！"};
initTimer(1000, myCallback, &data);  // 传递自定义数据

这里的void*就像一座桥梁，把业务层的数据无缝传递到回调函数中，同时不耦合具体数据类型。

四、避坑指南：使用 void * 的 3 个 "红线"

void*虽强，但不是无懈可击 ------ 它的灵活性背后藏着风险，这 3 个坑一定要避开：

1. 禁止直接解引用："裸指针" 不能直接用

void*没有类型解读规则，直接解引用会让编译器 confusion：

cpp 复制代码

void* ptr = &a;
// printf("%d", *ptr);  // 编译报错：void*无法直接解引用
int* intPtr = (int*)ptr;  // 必须先强制类型转换
printf("%d", *intPtr);    // 正确

这是 C 语言的语法规定，也是避免内存解读错误的关键。

2. 强制类型转换要 "匹配"：别把猫当成狗

void*可以强制转换成任何指针类型，但转换后必须与实际指向的数据类型一致，否则会出现 "内存越界" 或 "数据错乱"：

cpp 复制代码

int a = 0x12345678;
void* ptr = &a;
char* cPtr = (char*)ptr;
printf("%x", *cPtr);  // 输出78（只取了int的最低1字节）

这种错误在调试时很难发现，尤其在复杂项目中，一定要确保类型转换的一致性。

3. 注意指针运算：void*不能直接加减

指针运算的本质是 "按类型大小偏移"，而void*没有明确的类型大小，所以 C 语言不允许直接进行指针运算：

cpp 复制代码

void* ptr = malloc(10);
// ptr++;  // 编译报错：void*的增减无意义
char* cPtr = (char*)ptr;
cPtr++;  // 正确：按char大小（1字节）偏移

五、总结：void * 的核心价值

void*之所以能成为 C 语言的 "万能工具"，核心在于它抓住了 "内存即字节流" 的本质 ------ 剥离上层类型约束，回归底层存储逻辑。它让 C 语言在强类型的严谨性与通用性之间找到了完美平衡，既能写出高效紧凑的代码，又能实现灵活复用的组件。

但记住：void*的灵活性建立在开发者的自律之上 ------ 合理的类型转换、明确的数据边界、清晰的文档注释，才能让这把 "瑞士军刀" 发挥最大价值，而不是成为 bug 的温床。

下次再写通用函数或数据结构时，不妨试试void*------ 你会发现 C 语言的底层魅力，往往藏在这些看似简单的关键字里。

cpp 复制代码

#include <stdio.h>

/*
1.void*（空指针类型）是一种通用指针类型,可以指向任意数据类型的地址;
2.不能直接使用解引用(*),因为无法确定要读取的字节数;
3.不能进行指针运算;
*/
typedef struct myStuct
{
char name;
float c;
}myStuct;

int main()
{
int i = 0;
int a = 1;
int array[5] = {1,2,3,4,5};
double b = 0.222;
       myStuct stuct;
	stuct.name = 'a';
	stuct.c = 0.666;

void* p_Int = &a; // 指向int类型
void* p_array = &array; //指向数组类型
void* p_double = &b; //指向double类型
void* p_struct = &stuct; //指向结构体类型

//输出 0096FC24
printf("p_Int 指向地址：%p\n", p_Int);
//输出 0096FC14
printf("p_double 指向地址：%p\n", p_double);
//输出 0096FC04
printf("p_struct 指向地址：%p\n", p_struct);

//错误，不允许使用不完整类型 (无法确定要从内存中读取多少个字节)
//printf("*p_Int：%p\n", *p_Int);

//错误,不允许使用不完整类型,从而不能进行指针运算
//printf("*(p_array+0)：%d\n", *(p_array + 0));
//printf("*(p_array+1)：%d\n", *(p_array + 1));
for ( i = 0; i < sizeof(array)/sizeof(array[0]); i++)
	{
/* 输出:
	*(p_array+0)：1
        *(p_array+1)：2
        *(p_array+2)：3
        *(p_array+3)：4
        *(p_array+4)：5	
		*/
printf("*(p_array+%d)：%d\n",i, *( (int*)(p_array) + i ));
	}

//输出 1
printf("*p_Int：%d\n", *((int*)p_Int));
//输出 0.222
printf("*p_double：%f\n", *((double*)p_double));

	myStuct* pMyStuct = (myStuct*)p_struct;
//输出 字符a
printf("pMyStuct->name：%c\n", pMyStuct->name);
//输出 0.666
printf("pMyStuct->c：%f\n", pMyStuct->c);

return 0;
}