如何将含不同类型列表值的Python嵌套字典转换为C++实现？

Python的动态嵌套字典可以在C++中通过两种常见方式实现，下面分别给出对应代码和说明：

方案一：强类型结构体 + 映射（推荐） #

由于C++是静态类型语言，针对你固定的ints和floats列表结构，定义自定义结构体是最安全、高效的做法：

#include <map>
#include <vector>
#include <iostream>

// 对应Python内层字典的强类型结构体
struct InnerData {
    std::vector<int> ints;
    std::vector<double> floats;
};

int main() {
    // 外层映射，键为int类型，值为InnerData结构体
    std::map<int, InnerData> outer_dict;

    // 初始化键0对应的内层数据
    outer_dict[0].ints = {0};
    outer_dict[0].floats = {0.0};

    // 向列表添加元素（对应Python的append）
    outer_dict[0].ints.push_back(1);
    outer_dict[0].floats.push_back(1.2);

    // 初始化键1对应的内层数据
    outer_dict[1].ints = {0};
    outer_dict[1].floats = {0.5};

    // 验证输出示例
    for (const auto& outer_pair : outer_dict) {
        std::cout << "Key: " << outer_pair.first << "\n";
        std::cout << "  ints: ";
        for (int num : outer_pair.second.ints) {
            std::cout << num << " ";
        }
        std::cout << "\n  floats: ";
        for (double num : outer_pair.second.floats) {
            std::cout << num << " ";
        }
        std::cout << "\n";
    }

    return 0;
}

方案优势 #

• 类型安全：编译时就能检查类型错误，避免运行时意外
• 性能更优：无需动态类型转换开销
• 可读性高：结构清晰，直接对应业务逻辑

方案二：动态类型嵌套映射（贴近Python写法） #

如果需要保留Python中字符串键的动态特性，可以使用C++17引入的std::variant来存储不同类型的列表：

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

// 内层字典：字符串键，值为int列表或double列表的变体
using InnerDict = std::map<std::string, std::variant<std::vector<int>, std::vector<double>>>;
// 外层字典：int键，值为内层字典
using OuterDict = std::map<int, InnerDict>;

int main() {
    OuterDict outer_dict;

    // 初始化键0的内层字典
    outer_dict[0]["ints"] = std::vector<int>{0};
    outer_dict[0]["floats"] = std::vector<double>{0.0};

    // 向列表添加元素，需用std::get获取变体中的对应类型
    std::get<std::vector<int>>(outer_dict[0]["ints"]).push_back(1);
    std::get<std::vector<double>>(outer_dict[0]["floats"]).push_back(1.2);

    // 初始化键1的内层字典
    outer_dict[1]["ints"] = std::vector<int>{0};
    outer_dict[1]["floats"] = std::vector<double>{0.5};

    // 验证输出示例
    for (const auto& outer_pair : outer_dict) {
        std::cout << "Key: " << outer_pair.first << "\n";
        const auto& inner_dict = outer_pair.second;
        
        std::cout << "  ints: ";
        for (int num : std::get<std::vector<int>>(inner_dict.at("ints"))) {
            std::cout << num << " ";
        }
        std::cout << "\n  floats: ";
        for (double num : std::get<std::vector<double>>(inner_dict.at("floats"))) {
            std::cout << num << " ";
        }
        std::cout << "\n";
    }

    return 0;
}

方案说明 #

• 需要C++17及以上标准支持std::variant
• 使用std::get时必须指定正确的类型，否则会抛出std::bad_variant_access异常
• 灵活性更高，但类型安全性和性能弱于结构体方案

内容的提问来源于stack exchange，提问作者Dr. Prasanna Date