C++中单个容器存储多类型对象的可行性及动态二维容器问题

可行性说明 #

完全可行，C++提供了多种成熟方案来实现单一容器存储不同类型对象，以下是三种常用实现方式：

1. 基于继承与多态的方案 #

核心逻辑 #

定义一个公共基类，所有需要存储的对象都继承自该基类，容器存储基类的智能指针（优先用std::unique_ptr或std::shared_ptr避免内存泄漏），通过多态统一访问不同子类对象。

示例代码 #

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

// 公共基类：必须声明虚析构函数确保子类析构被调用
class BaseObject {
public:
    virtual ~BaseObject() = default;
    virtual void print() const = 0; // 纯虚函数定义统一接口
};

// 子类1：存储整数
class IntObject : public BaseObject {
    int val;
public:
    IntObject(int v) : val(v) {}
    void print() const override {
        std::cout << "整数值：" << val << std::endl;
    }
};

// 子类2：存储字符串
class StringObject : public BaseObject {
    std::string val;
public:
    StringObject(const std::string& v) : val(v) {}
    void print() const override {
        std::cout << "字符串值：" << val << std::endl;
    }
};

int main() {
    // 容器存储基类智能指针
    std::vector<std::unique_ptr<BaseObject>> obj_container;
    
    // 插入不同类型对象
    obj_container.emplace_back(std::make_unique<IntObject>(42));
    obj_container.emplace_back(std::make_unique<StringObject>("Hello C++"));
    
    // 遍历调用统一接口
    for (const auto& obj : obj_container) {
        obj->print();
    }
    return 0;
}

注意事项 #

• 基类必须声明虚析构函数，否则删除基类指针时不会触发子类析构，导致内存泄漏
• 访问对象时优先通过虚函数接口，如需类型转换可使用dynamic_cast（不推荐频繁使用，会破坏多态封装）

2. 使用std::variant（C++17及以上） #

核心逻辑 #

std::variant是类型安全的联合体，容器存储std::variant实例，每个实例可持有提前指定的类型集合中的一种类型，编译时就能做类型检查。

示例代码 #

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

// 定义variant支持的类型集合
using ObjectVariant = std::variant<int, std::string, double>;

int main() {
    std::vector<ObjectVariant> obj_container;
    
    // 插入不同类型对象
    obj_container.push_back(100);
    obj_container.push_back("Variant示例");
    obj_container.push_back(3.14);
    
    // 遍历处理：用std::visit访问不同类型
    for (const auto& var : obj_container) {
        std::visit([](const auto& val) {
            using T = std::decay_t<decltype(val)>;
            if constexpr (std::is_same_v<T, int>) {
                std::cout << "整数：" << val << std::endl;
            } else if constexpr (std::is_same_v<T, std::string>) {
                std::cout << "字符串：" << val << std::endl;
            } else if constexpr (std::is_same_v<T, double>) {
                std::cout << "浮点数：" << val << std::endl;
            }
        }, var);
    }
    return 0;
}

优缺点 #

• 优势：类型安全，无需继承，编译时检查类型错误
• 缺点：必须提前指定所有支持的类型，无法存储未知类型

3. 使用std::any（C++17及以上） #

核心逻辑 #

std::any可以存储任意类型的单个值，容器存储std::any实例，类型检查只能在运行时进行。

示例代码 #

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

int main() {
    std::vector<std::any> obj_container;
    
    // 插入任意类型对象
    obj_container.push_back(42);
    obj_container.push_back(std::string("Any示例"));
    obj_container.push_back(3.14f);
    
    // 遍历处理：手动判断类型
    for (const auto& a : obj_container) {
        if (a.type() == typeid(int)) {
            std::cout << "整数：" << std::any_cast<int>(a) << std::endl;
        } else if (a.type() == typeid(std::string)) {
            std::cout << "字符串：" << std::any_cast<const std::string&>(a) << std::endl;
        } else if (a.type() == typeid(float)) {
            std::cout << "浮点数：" << std::any_cast<float>(a) << std::endl;
        }
    }
    return 0;
}

优缺点 #

• 优势：可以存储任意类型，无需提前声明
• 缺点：类型检查仅在运行时有效，std::any_cast失败会抛出异常，需额外处理

动态二维容器的初始化与声明 #

声明位置 #

• 不推荐全局声明：易引发命名冲突和初始化顺序问题
• 推荐场景：
  • 函数内部（如main函数）：适用于仅在函数内使用的临时容器
  • 类成员变量：适用于属于类状态的容器

初始化方式 #

对应上述三种存储方案，二维容器的初始化示例如下：

1. 多态指针的二维容器

// 声明并初始化空的二维容器
std::vector<std::vector<std::unique_ptr<BaseObject>>> two_d_container;

// 插入第一行及元素
two_d_container.emplace_back();
two_d_container[0].emplace_back(std::make_unique<IntObject>(10));
two_d_container[0].emplace_back(std::make_unique<StringObject>("第一行"));

// 插入第二行及元素
two_d_container.emplace_back();
two_d_container[1].emplace_back(std::make_unique<IntObject>(20));
two_d_container[1].emplace_back(std::make_unique<StringObject>("第二行"));

2. std::variant的二维容器

using ObjectVariant = std::variant<int, std::string, double>;
// 声明并初始化空的二维容器
std::vector<std::vector<ObjectVariant>> two_d_variant_container;

// 直接初始化行并插入元素
two_d_variant_container.push_back({1, "第一行", 1.1});
two_d_variant_container.push_back({2, "第二行", 2.2});

3. std::any的二维容器

// 声明并初始化空的二维容器
std::vector<std::vector<std::any>> two_d_any_container;

// 插入行及元素
two_d_any_container.emplace_back();
two_d_any_container[0].push_back(100);
two_d_any_container[0].push_back(std::string("Any行"));

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