函数参数为void*时，如何获取其转换前的原始数据类型？

嘿，这个问题戳中了C++里void*的核心局限——一旦把某个类型的指针转换成void*，原始的类型信息就被彻底丢弃了，你没办法直接从这个void*本身判断它原来指向的是std::string还是FILE*。不过别慌，我们有几种实用的办法来解决这个问题，让你能安全区分两种类型并执行对应逻辑：

方案1：添加类型标签参数（最直接安全） #

给你的函数加一个额外的枚举参数，让调用者明确告诉函数传入的void*是什么类型。这是最简单也最不容易出错的方式：

#include <string>
#include <cstdio>

// 定义枚举标记数据类型
enum class DataType { String, FilePointer };

void myFunction(int param1, int param2, void* data, DataType type) {
    if (type == DataType::String) {
        // 安全转换回std::string*
        std::string* strPtr = static_cast<std::string*>(data);
        // 执行字符串相关逻辑
        printf("处理字符串：%s\n", strPtr->c_str());
    } else if (type == DataType::FilePointer) {
        // 安全转换回FILE*
        FILE* filePtr = static_cast<FILE*>(data);
        // 执行文件指针相关逻辑
        printf("处理文件指针：%p\n", filePtr);
    }
}

// 调用示例
int main() {
    std::string myStr = "Hello World";
    FILE* myFile = fopen("test.txt", "r");

    myFunction(1, 2, &myStr, DataType::String);
    if (myFile) {
        myFunction(1, 2, myFile, DataType::FilePointer);
        fclose(myFile);
    }
    return 0;
}

方案2：用多态重构（更符合C++面向对象设计） #

如果你的代码架构允许调整，可以定义一个抽象基类，让std::string和FILE*的包装类继承它，函数参数换成基类指针，彻底抛弃void*：

#include <string>
#include <cstdio>

// 抽象基类，定义统一的处理接口
class DataProcessor {
public:
    virtual ~DataProcessor() = default; // 必须有虚析构函数
    virtual void process() = 0; // 纯虚函数，子类实现具体逻辑
};

// 字符串包装类
class StringProcessor : public DataProcessor {
private:
    std::string m_str;
public:
    StringProcessor(const std::string& str) : m_str(str) {}
    void process() override {
        printf("处理字符串：%s\n", m_str.c_str());
    }
};

// 文件指针包装类
class FileProcessor : public DataProcessor {
private:
    FILE* m_file;
public:
    FileProcessor(FILE* file) : m_file(file) {}
    void process() override {
        printf("处理文件指针：%p\n", m_file);
    }
};

// 现在函数参数是基类指针，无需void*
void myFunction(int param1, int param2, DataProcessor* processor) {
    processor->process(); // 自动调用对应类型的处理逻辑
}

// 调用示例
int main() {
    StringProcessor strProc("Hello World");
    FILE* myFile = fopen("test.txt", "r");

    myFunction(1, 2, &strProc);
    if (myFile) {
        FileProcessor fileProc(myFile);
        myFunction(1, 2, &fileProc);
        fclose(myFile);
    }
    return 0;
}

这种方式完全避免了类型转换的风险，代码可读性和可维护性更高，是C++里更优雅的解决方案。

方案3：用std::variant（C++17及以上适用） #

如果你的项目支持C++17，可以用std::variant来包装两种类型，再把variant的地址转换成void*，函数内部再转换回来判断类型：

#include <string>
#include <cstdio>
#include <variant>
#include <type_traits>

void myFunction(int param1, int param2, void* data) {
    // 转换回variant指针
    auto* varPtr = static_cast<std::variant<std::string*, FILE*>*>(data);
    // 用std::visit处理不同类型
    std::visit([](auto* ptr) {
        using Type = std::decay_t<decltype(*ptr)>;
        if constexpr (std::is_same_v<Type, std::string>) {
            printf("处理字符串：%s\n", ptr->c_str());
        } else if constexpr (std::is_same_v<Type, FILE>) {
            printf("处理文件指针：%p\n", ptr);
        }
    }, *varPtr);
}

// 调用示例
int main() {
    std::string myStr = "Hello World";
    FILE* myFile = fopen("test.txt", "r");

    std::variant<std::string*, FILE*> strVar(&myStr);
    myFunction(1, 2, &strVar);

    if (myFile) {
        std::variant<std::string*, FILE*> fileVar(myFile);
        myFunction(1, 2, &fileVar);
        fclose(myFile);
    }
    return 0;
}

这种方式兼顾了类型安全和灵活性，不需要手动传递类型标签，但依赖C++17及以上的特性。

绝对要避免的错误做法 #

• 不要试图用dynamic_cast：void*不是多态类型，而且std::string和FILE*之间没有继承关系，dynamic_cast完全无效。
• 不要靠指针大小或内存布局判断：不同平台/编译器下，std::string*和FILE*的大小可能相同，内存布局也没有统一标准，这样做会导致未定义行为。

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