C++98中能否创建类型在运行时指定的变量？

C98标准确实限制union成员必须为POD类型，因此无法直接容纳std::string这类带自定义构造/析构的非POD类型，但可以通过手动管理生命周期的可辨识联合（Tagged Union）方案实现单变量存储多类型的需求，完全适配C98标准。

方案1：手动管理的栈上可辨识联合（无额外堆开销，性能最优） #

核心思路是不直接将非POD类型放入union，而是使用对齐的原始字符数组作为统一存储，通过placement new在指定内存上手动构造、析构对应类型的对象，配合类型标签实现运行时类型判断。
完整实现代码如下：

#include <string>
#include <new>

class Instruction {
private:
    std::string name;
    enum valtype { STRING, INSTRUCTION } type;
    // 单块存储：大小取所有可能存储类型的最大值，通过嵌套union保证内存对齐
    union {
        char buf[sizeof(std::string) > sizeof(Instruction*) 
                    ? sizeof(std::string) 
                    : sizeof(Instruction*)];
        double align_guard;
        void* ptr_guard;
    } storage;

    // 统一清理当前存储的对象
    void destroy_stored_val() {
        switch (type) {
            case STRING:
                reinterpret_cast<std::string*>(storage.buf)->~basic_string();
                break;
            case INSTRUCTION:
                // 若需要持有指针所有权，可在此处执行delete逻辑
                break;
        }
    }

public:
    // 构造字符串类型值
    Instruction(const std::string& inst_name, const std::string& str_val)
        : name(inst_name), type(STRING)
    {
        new (storage.buf) std::string(str_val);
    }

    // 构造指令指针类型值
    Instruction(const std::string& inst_name, Instruction* inst_ptr)
        : name(inst_name), type(INSTRUCTION)
    {
        new (storage.buf) Instruction*(inst_ptr);
    }

    ~Instruction() {
        destroy_stored_val();
    }

    // 手动实现拷贝构造，避免默认浅拷贝导致的double free问题
    Instruction(const Instruction& other)
        : name(other.name), type(other.type)
    {
        switch (type) {
            case STRING:
                new (storage.buf) std::string(*reinterpret_cast<const std::string*>(other.storage.buf));
                break;
            case INSTRUCTION:
                new (storage.buf) Instruction*(*reinterpret_cast<Instruction* const*>(other.storage.buf));
                break;
        }
    }

    // 手动实现赋值运算符
    Instruction& operator=(const Instruction& other) {
        if (this == &other) return *this;
        destroy_stored_val();
        name = other.name;
        type = other.type;
        switch (type) {
            case STRING:
                new (storage.buf) std::string(*reinterpret_cast<const std::string*>(other.storage.buf));
                break;
            case INSTRUCTION:
                new (storage.buf) Instruction*(*reinterpret_cast<Instruction* const*>(other.storage.buf));
                break;
        }
        return *this;
    }

    // 取值接口
    valtype current_type() const { return type; }
    std::string& as_string() { return *reinterpret_cast<std::string*>(storage.buf); }
    const std::string& as_string() const { return *reinterpret_cast<const std::string*>(storage.buf); }
    Instruction* as_instruction() { return *reinterpret_cast<Instruction**>(storage.buf); }
    const Instruction* as_instruction() const { return *reinterpret_cast<const Instruction* const*>(storage.buf); }
};

方案注意事项 #

• 所有对象的构造、析构必须手动触发，尤其是std::string这类持有堆资源的类型，漏调析构会直接导致内存泄漏
• 必须手动实现拷贝构造、赋值运算符，默认生成的函数会直接复制原始内存块，对非POD类型会触发未定义行为
• 嵌套union里的对齐守卫可以根据实际存储的类型调整，加入double、void*、long等类型可以覆盖绝大多数场景的对齐要求，C++98全编译器兼容。

方案2：多态封装（实现简单，兼容性强） #

如果觉得手动管理生命周期容易出错，可以用多态的方式实现，仅用一个基类指针作为存储变量，运行时构造对应派生类对象：

// 抽象值基类
class ValueHolder {
public:
    virtual ~ValueHolder() {}
    virtual ValueHolder* clone() const = 0;
};

// 字符串值派生类
class StringHolder : public ValueHolder {
public:
    std::string val;
    StringHolder(const std::string& s): val(s) {}
    ValueHolder* clone() const { return new StringHolder(val); }
};

// 指令指针值派生类
class InstructionHolder : public ValueHolder {
public:
    Instruction* val;
    InstructionHolder(Instruction* i): val(i) {}
    ValueHolder* clone() const { return new InstructionHolder(val); }
};

// Instruction类内仅需定义单个成员：ValueHolder* value;
// 赋值、拷贝时通过clone()接口实现深拷贝，析构时delete value即可

方案优缺点 #

• 优点：不需要手动处理对象构造、析构、内存对齐，逻辑简单不易出错，完全符合C++98标准
• 缺点：每次存值需要额外堆分配派生类对象，相比栈上存储的方案有少量性能开销。

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