将多个类型作为值存储在C++；字典？ 我想编写一个C++对象，它几乎等价于Python字典。C++的std:：map和std:：unordered_map提供了Python字典已经具备的一些功能，但缺少最重要的功能之一，即能够添加任意对象和类型。即使不可能，您离实现Python字典的功能还有多远

前面的几个问题（和）无法处理向字典中添加多个类型的问题

例如，我希望能够在C++中执行类似的操作：

my_dict={'first'：1，
'秒'：“字符串”，
"三":3.5,，
“第四”：我的对象}
my_dict['fifth']=列表（[1,2,3]）

我能想到的最好的解决方案是使用

void

指向重新解释的数据的指针，或者使用某种类型限制的运行时多态性

我认为最好的解决方案是使用void指针指向重新解释的数据，或者使用某种类型限制的运行时多态性

我认为，现代C++中的许多空指针和指针的重新解释应该是一个坏设计的信号。我相信多态性将是一条出路

此外，如果您想要使用固定数量的类型，请考虑使用C++ 17或更为现代的<代码>联合< /COD>

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

typedef std::map<std::variant<int, std::string>, std::variant<int, std::string>> Dict;

int main(){
    Dict d;
    d["key"] = 1;
    d[5] = "woah";
    std::cout << std::get<int>(d["key"]) << std::endl; // prints 1

    // edit: print all the keys in d
    for(auto& k_v: d){
        std::visit(
            [](auto& value){std::cout << value << ' ';},
            k_v.first // k_v.second to print all values in d
        );
    }

}

#包括
#包括
#包括
#包括
typedef std:：map Dict；
int main（）{
Dict d；
d[“键”]=1；
d[5]=“哇”；
std：：cout我正在寻找一种类似的解决方案，用于将我的
python
实验的参数硬编码到
c++
中。我发现
std'17 variant
模块非常有用

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

int main(){
    typedef std::map<std::string, std::variant<int, double, float, std::string>> Dict;

    std::vector<Dict> params = {
        {
            {"label", "Labs"},
            {"dir", "/media/sf_Data/"},
            {"num_frames", 4},
            {"scale_factor", 1.0},
        }, // Dict 0
        {
            {"label", "Airplanes"},
            {"dir", "/media/m_result/"},
            {"num_frames", 5},
            {"scale_factor", 0.5},
        } // Dict 1
    };

    int idx = 0;
    std::string label   = std::get<std::string>(params[idx]["label"]);
    std::string folder  = std::get<std::string>(params[idx]["dir"]);
    int num_frames      = std::get<int>(params[idx]["num_frames"]);
    double scf          = std::get<double>(params[idx]["scale_factor"]);
    
    std::cout << label << std::endl;
    std::cout << folder << std::endl;
    std::cout << num_frames << std::endl;
    std::cout << scf << std::endl;

    return 0;
}

#包括
#包括
#包括
#包括
#包括
int main（）{
typedef std:：map Dict；
标准：：向量参数={
{
{“标签”，“实验室”}，
{“dir”，“/media/sf_Data/”}，
{“num_frames”，4}，
{“比例系数”，1.0}，
}，//Dict 0
{
{“标签”，“飞机”}，
{“dir”，“/media/m_result/”}，
{“num_frames”，5}，
{“比例系数”，0.5}，
}//第1条
};
int-idx=0；
std:：string label=std:：get（params[idx][“label]”）；
std:：string folder=std:：get（params[idx][“dir”]）；
int num_frames=std:：get（参数[idx][“num_frames”]）；
双scf=std:：get（参数[idx][“比例因子]）；
STD：：可能的CalbGooman复制品，我并不这么认为。OP询问插入任意类型的元素。坦率地说，在Python容器中使用异构类型，虽然是绝对可能的，但不是我认为的“最重要的能力”之一。事实上，我想说的是，在容器中使用异构类型几乎总是糟糕的设计。相关：（包括值）。也相关：。这表明使用boost是可行的，在没有boost的情况下这样做（至少在被问到问题的时候）是有限的。不知道C++17是否添加了（例如，
std:：variant
/
std:：any
）这里有帮助。另外，不要这样做。希望总是知道需要处理的值的接口。不要这样做是什么意思？首先，使用这样的多类型dict不是一个好主意，因此如果不这样做，我同意。你能添加一个简短的示例，说明如何使用
std:：visit
？这是首选方法用于
std:：variant
的接口，通常比调用
std:：get