C++联合体结构体的虚函数调用问题及动态解决方案诉求

你用联合体存储多态类型的思路本质上是错误的：联合体仅支持值类型存储，当你把派生类对象塞进BaseFootprint的联合体时，会触发对象切割——派生类的虚表指针、额外成员都会被丢弃，只保留基类部分的内存数据。这直接导致虚函数调用时无法找到正确的派生类实现，类型转换拿到的也只是残缺的内存块，自然会出现data[i]->empty这类错误。

以下是几种无需修改基类、支持动态添加派生类型的解决方案：

方案1：智能指针容器（最简单原生多态实现） #

直接用vector<unique_ptr<Base>>存储派生类对象的指针，完全利用C++原生多态特性，零额外修改成本，是最推荐的方案。

#include <vector>
#include <memory>
#include <string>
#include <iostream>

struct Base {
    virtual std::string toString() const = 0;
    virtual ~Base() = default; // 必须添加虚析构，避免内存泄漏
};

struct Top1 : Base {
    std::string toString() const override {
        return "Top1 instance";
    }
};

struct Top2 : Base {
    std::string toString() const override {
        return "Top2 instance";
    }
};

// 新增派生类示例，无需修改基础代码
struct Top3 : Base {
    std::string toString() const override {
        return "Top3 instance";
    }
};

int main() {
    std::vector<std::unique_ptr<Base>> container;
    container.emplace_back(std::make_unique<Top1>());
    container.emplace_back(std::make_unique<Top2>());
    container.emplace_back(std::make_unique<Top3>()); // 直接添加新类型

    for (const auto& ptr : container) {
        std::cout << ptr->toString() << std::endl;
    }
    return 0;
}

• 核心优势：原生多态可靠，代码简洁，维护成本极低。
• 扩展方式：新增派生类只需实现toString()，用make_unique塞进容器即可，无需改动任何基础代码。

方案2：std::any + 类型擦除（C++17+，值语义存储） #

如果必须用值语义存储（不想用指针），可以用std::any配合类型判断或std::variant实现类型擦除，同样无需修改基类。

基于std::any的直接实现 #

#include <vector>
#include <any>
#include <string>
#include <iostream>

struct Base {
    virtual std::string toString() const = 0;
    virtual ~Base() = default;
};

struct Top1 : Base {
    std::string toString() const override { return "Top1 instance"; }
};

struct Top2 : Base {
    std::string toString() const override { return "Top2 instance"; }
};

int main() {
    std::vector<std::any> container;
    container.emplace_back(Top1());
    container.emplace_back(Top2());

    for (const auto& item : container) {
        if (const auto* p = std::any_cast<Top1>(&item)) {
            std::cout << p->toString() << std::endl;
        } else if (const auto* p = std::any_cast<Top2>(&item)) {
            std::cout << p->toString() << std::endl;
        }
        // 新增类型时，仅需添加对应的else if分支
    }
    return 0;
}

基于std::variant的更优扩展 #

用std::variant统一管理所有派生类型，配合std::visit避免逐个判断：

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

struct Base {
    virtual std::string toString() const = 0;
    virtual ~Base() = default;
};

struct Top1 : Base {
    std::string toString() const override { return "Top1 instance"; }
};

struct Top2 : Base {
    std::string toString() const override { return "Top2 instance"; }
};

// 定义包含所有派生类的variant，新增类型仅需修改此处
using BaseVariant = std::variant<Top1, Top2>;

struct ToStringVisitor {
    std::string operator()(const auto& obj) const {
        return obj.toString();
    }
};

int main() {
    std::vector<BaseVariant> container;
    container.emplace_back(Top1());
    container.emplace_back(Top2());

    for (const auto& var : container) {
        std::cout << std::visit(ToStringVisitor(), var) << std::endl;
    }
    return 0;
}

方案3：自定义类型擦除容器（兼容C++11/14） #

如果无法使用C++17特性，可以自己实现轻量类型擦除包装类，核心是用非模板基类定义调用接口，模板子类包装具体类型。

#include <vector>
#include <string>
#include <memory>
#include <iostream>

struct Base {
    virtual std::string toString() const = 0;
    virtual ~Base() = default;
};

struct Top1 : Base {
    std::string toString() const override { return "Top1 instance"; }
};

struct Top2 : Base {
    std::string toString() const override { return "Top2 instance"; }
};

// 类型擦除基类，定义统一调用接口
struct ErasedCallable {
    virtual std::string toString() const = 0;
    virtual ~ErasedCallable() = default;
};

// 模板包装类，适配任意实现了toString()的类型
template<typename T>
struct ErasedWrapper : ErasedCallable {
    T obj;
    ErasedWrapper(T&& o) : obj(std::move(o)) {}
    std::string toString() const override {
        return obj.toString();
    }
};

// 辅助函数简化包装过程
template<typename T>
std::unique_ptr<ErasedCallable> wrap(T&& obj) {
    return std::make_unique<ErasedWrapper<T>>(std::forward<T>(obj));
}

int main() {
    std::vector<std::unique_ptr<ErasedCallable>> container;
    container.push_back(wrap(Top1()));
    container.push_back(wrap(Top2()));

    for (const auto& ptr : container) {
        std::cout << ptr->toString() << std::endl;
    }
    // 新增类型时，直接调用wrap()塞入容器即可
    return 0;
}

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