C++中void指针的用途探讨：适用场景与异构链表实现可行性

Great question! Let's break this down into two parts: first, the practical uses of void* pointers in C++ and how they add flexibility, then how to implement a linked list that holds different data types.

一、void指针的实际用途与灵活场景 #

Even though you have to cast void* to a concrete type before dereferencing it, they're incredibly useful for building generic, flexible code. Here are the most common use cases with examples:

1. 通用工具函数（避免重复重载） #

void* lets you write functions that work with any data type without writing dozens of overloads. A classic example is a generic swap function:

#include <cstring>

void swap(void* a, void* b, size_t data_size) {
    // 用临时缓冲区存储数据，也可以用动态分配避免栈溢出
    char temp[data_size];
    std::memcpy(temp, a, data_size);
    std::memcpy(a, b, data_size);
    std::memcpy(b, temp, data_size);
}

// 使用示例
int main() {
    int x = 5, y = 10;
    swap(&x, &y, sizeof(int));
    // x现在是10，y是5

    double pi = 3.14, e = 2.71;
    swap(&pi, &e, sizeof(double));
    // pi现在是2.71，e是3.14
    return 0;
}

This single swap function works for integers, doubles, structs, or any other type—no need to write separate overloads for each.

2. 底层内存操作 #

Functions like malloc, calloc, and realloc return void* because they don't care what kind of data you'll store in the memory they allocate. You cast the pointer to the type you need when using it:

#include <cstdlib>

int main() {
    // 分配1KB的通用内存块
    void* buffer = std::malloc(1024);
    
    // 用作int数组
    int* int_buffer = static_cast<int*>(buffer);
    int_buffer[0] = 42;
    int_buffer[1] = 100;

    // 也可以用作char数组
    char* char_buffer = static_cast<char*>(buffer);
    char_buffer[0] = 'a';

    std::free(buffer); // 释放时不用转换回void*，但转换也没问题
    return 0;
}

This design makes memory allocation functions universal—they're not tied to any specific data type.

3. 回调函数的通用参数 #

Many asynchronous APIs or frameworks use void* to let you pass any custom data to a callback function. This avoids locking the API into a single data type:

#include <iostream>
#include <string>

// 模拟异步任务函数
void run_async_task(void (*callback)(void*), void* user_data) {
    // 模拟任务完成后调用回调
    callback(user_data);
}

// 处理int类型数据的回调
void handle_int_data(void* data) {
    int* num = static_cast<int*>(data);
    std::cout << "Received integer: " << *num << "\n";
}

// 处理string类型数据的回调
void handle_string_data(void* data) {
    std::string* msg = static_cast<std::string*>(data);
    std::cout << "Received string: " << *msg << "\n";
}

int main() {
    int my_num = 123;
    std::string my_msg = "Hello Async!";

    run_async_task(handle_int_data, &my_num);
    run_async_task(handle_string_data, &my_msg);
    return 0;
}

Without void*, the API would need separate callback signatures for every possible data type, making it rigid and hard to extend.

4. C风格的"多态"（与C代码交互） #

C doesn't have classes or polymorphism, so void* paired with a type tag is a common way to create generic data structures. This is still useful in C++ when working with legacy C code:

#include <iostream>
#include <string>

// 类型标签，标记存储的数据类型
enum DataType { TYPE_INT, TYPE_STRING };

// 通用数据结构
struct GenericData {
    DataType type;
    void* data;
};

void print_generic_data(GenericData* gd) {
    switch(gd->type) {
        case TYPE_INT:
            std::cout << "Int value: " << *static_cast<int*>(gd->data) << "\n";
            break;
        case TYPE_STRING:
            std::cout << "String value: " << *static_cast<std::string*>(gd->data) << "\n";
            break;
    }
}

int main() {
    GenericData int_data = {TYPE_INT, new int(42)};
    GenericData str_data = {TYPE_STRING, new std::string("C++ Generic")};

    print_generic_data(&int_data);
    print_generic_data(&str_data);

    // 记得释放内存
    delete static_cast<int*>(int_data.data);
    delete static_cast<std::string*>(str_data.data);
    return 0;
}

In pure C++, we'd use classes with virtual functions, but this approach is lightweight and works well in cross-language scenarios.

二、实现存储不同数据类型的链表（异构链表） #

Yes, you absolutely can implement a linked list that holds different data types in C++. There are two main approaches: one using void* (similar to the C-style example above), and a safer C++-native approach using std::variant.

方法1：用void* + 类型标签 #

This is the manual approach, where each node stores a void* to the data plus a tag to track its type:

#include <iostream>
#include <string>

enum DataType { TYPE_INT, TYPE_STRING };

struct Node {
    Node* next;
    DataType type;
    void* data;
};

// 创建节点的辅助函数
Node* create_int_node(int value) {
    Node* node = new Node;
    node->type = TYPE_INT;
    node->data = new int(value);
    node->next = nullptr;
    return node;
}

Node* create_string_node(const std::string& value) {
    Node* node = new Node;
    node->type = TYPE_STRING;
    node->data = new std::string(value);
    node->next = nullptr;
    return node;
}

// 遍历打印链表
void print_linked_list(Node* head) {
    Node* current = head;
    while(current != nullptr) {
        switch(current->type) {
            case TYPE_INT:
                std::cout << *static_cast<int*>(current->data) << " -> ";
                break;
            case TYPE_STRING:
                std::cout << *static_cast<std::string*>(current->data) << " -> ";
                break;
        }
        current = current->next;
    }
    std::cout << "nullptr\n";
}

// 释放链表内存
void free_linked_list(Node* head) {
    Node* current = head;
    while(current != nullptr) {
        Node* temp = current;
        // 根据类型释放数据
        switch(current->type) {
            case TYPE_INT:
                delete static_cast<int*>(current->data);
                break;
            case TYPE_STRING:
                delete static_cast<std::string*>(current->data);
                break;
        }
        delete temp;
        current = current->next;
    }
}

int main() {
    Node* head = create_int_node(10);
    head->next = create_string_node("Hello");
    head->next->next = create_int_node(20);

    print_linked_list(head);
    free_linked_list(head);
    return 0;
}

Note: This requires careful memory management and type checking—you have to make sure you cast to the correct type every time.

方法2：用std::variant（C++17+，更安全） #

std::variant is a C++17 feature that lets you store one value from a set of types, and it tracks which type is currently stored. This avoids manual type tags and unsafe casts:

#include <iostream>
#include <string>
#include <variant>

struct Node {
    Node* next;
    std::variant<int, std::string> data;
    // 构造函数简化节点创建
    Node(std::variant<int, std::string> val) : data(val), next(nullptr) {}
};

// 用std::visit遍历打印，自动处理类型
void print_linked_list(Node* head) {
    Node* current = head;
    while(current != nullptr) {
        std::visit([](auto&& arg) {
            std::cout << arg << " -> ";
        }, current->data);
        current = current->next;
    }
    std::cout << "nullptr\n";
}

// 释放内存（无需手动类型检查）
void free_linked_list(Node* head) {
    Node* current = head;
    while(current != nullptr) {
        Node* temp = current;
        current = current->next;
        delete temp;
    }
}

int main() {
    Node* head = new Node(10);
    head->next = new Node(std::string("World"));
    head->next->next = new Node(30);

    print_linked_list(head);
    free_linked_list(head);
    return 0;
}

This is the recommended approach in modern C++ because it's safer—std::variant prevents invalid casts and handles type tracking automatically.

内容的提问来源于stack exchange，提问作者tusharRawat