C++嵌套容器存任意类型数据：兼顾操作与高效迭代的方案问询

针对你遇到的嵌套容器存储任意类型数据的矛盾需求，这里提供几种更优的实现思路，兼顾操作便利性与执行效率：

方案一：轻量类型擦除（仅封装所需操作） #

无需为整个容器重写大量虚函数，仅针对你实际需要的操作（如erase、元素方法调用）做类型擦除，既保留外层容器直接调用内层方法的能力，又避免全多态的冗余开销。

示例代码：

#include <vector>
#include <memory>

// 仅定义需要对外暴露的核心操作接口
class ContainerBase {
public:
    virtual ~ContainerBase() = default;
    virtual void erase(size_t index) = 0;
    virtual void invoke_element_method() = 0;
};

// 模板子类，封装具体类型的vector
template<typename T>
class ContainerImpl : public ContainerBase {
private:
    std::vector<T> data_;
public:
    // 按需实现元素添加等方法
    void push_back(T elem) { data_.push_back(std::move(elem)); }

    void erase(size_t index) override {
        if (index < data_.size()) {
            data_.erase(data_.begin() + index);
        }
    }

    void invoke_element_method() override {
        for (auto& elem : data_) {
            elem.target_method(); // 假设T包含该方法
        }
    }

    // 可选：提供底层容器的类型安全访问
    std::vector<T>& get_raw() { return data_; }
};

// 外层容器使用智能指针存储基类对象
using NestedContainer = std::vector<std::unique_ptr<ContainerBase>>;

使用时，外层容器可直接遍历调用erase或invoke_element_method，内层仅封装你实际需要的操作，比全多态基类更轻量。

方案二：std::variant + 编译期多态（已知类型范围时首选） #

如果能提前枚举所有可能存储的数据类型，用std::variant替代std::any，结合std::visit实现编译期分发，既避免any_cast的运行时检查开销，又能直接调用内层vector的方法。

示例代码：

#include <vector>
#include <variant>

// 提前枚举所有可能的类型
struct TypeA { void target_method() {} };
struct TypeB { void target_method() {} };
struct TypeC { void target_method() {} };

using ValueVariant = std::variant<TypeA, TypeB, TypeC>;
using NestedContainer = std::vector<std::vector<ValueVariant>>;

// 迭代内层容器调用元素方法
void process_inner_container(std::vector<ValueVariant>& inner) {
    for (auto& val : inner) {
        std::visit([](auto& elem) {
            elem.target_method(); // 所有variant类型需统一实现该方法
        }, val);
    }
}

// 外层循环直接调用内层vector的erase
void erase_first_element(NestedContainer& outer) {
    for (auto& inner : outer) {
        if (!inner.empty()) {
            inner.erase(inner.begin());
        }
    }
}

该方案无虚函数间接调用，std::visit的分发开销接近直接调用，是类型范围明确时的最优选择。

方案三：std::function 替代虚函数的类型擦除 #

用std::function封装所需操作，避免虚表的间接调用，同时保留任意类型存储的灵活性。

示例代码：

#include <vector>
#include <functional>

class ContainerWrapper {
private:
    std::function<void(size_t)> erase_op_;
    std::function<void()> invoke_op_;
    void* raw_data_;
    std::function<void(void*)> destroy_op_;

public:
    // 模板构造函数，封装具体vector<T>的操作
    template<typename T>
    ContainerWrapper(std::vector<T> vec)
        : raw_data_(new std::vector<T>(std::move(vec)))
    {
        erase_op_ = [this](size_t index) {
            auto& data = *static_cast<std::vector<T>*>(raw_data_);
            if (index < data.size()) {
                data.erase(data.begin() + index);
            }
        };

        invoke_op_ = [this]() {
            auto& data = *static_cast<std::vector<T>*>(raw_data_);
            for (auto& elem : data) {
                elem.target_method();
            }
        };

        destroy_op_ = [](void* ptr) {
            delete static_cast<std::vector<T>*>(ptr);
        };
    }

    ~ContainerWrapper() { destroy_op_(raw_data_); }

    // 禁用拷贝，支持移动
    ContainerWrapper(const ContainerWrapper&) = delete;
    ContainerWrapper& operator=(const ContainerWrapper&) = delete;
    ContainerWrapper(ContainerWrapper&&) = default;
    ContainerWrapper& operator=(ContainerWrapper&&) = default;

    // 对外暴露操作接口
    void erase(size_t index) { erase_op_(index); }
    void invoke_element_method() { invoke_op_(); }
};

using NestedContainer = std::vector<ContainerWrapper>;

该方案用函数对象替代虚函数，开销与std::function调用相当，比any_cast更高效，且无需定义基类虚函数。

方案选择建议 #

• 若能提前确定所有存储类型：优先选方案二，效率最高，代码最简洁。
• 若类型完全任意：优先选方案一或方案三，前者更易维护，后者避免虚函数开销。
• 避免使用std::vector<std::vector<std::any>>，频繁的any_cast会带来明显的运行时开销与类型安全风险。

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