如何使用 std::set 的每个值作为映射的键

Question

假设我们有一张带有int 和一组strings 的地图

std::map < int , std::set<std::string> >  myString;

1=> "set1"
1=> "set2"
2=> "set1"
2=> "set2"

现在，是否可以将上述集合的每个唯一值设为映射键
粗略地说，数据就像

1=>
  set1=> "Hello"
  set1=> "Hey"
  set1=> "Wow"
1=>  
  set2=> "Hello"
  set2=> "Hey"
  set2=> "Wow"
2=>

  set1=> "Hello"
  set1=> "Hey"
  set1=> "Wow"
2=>  
  set2=> "Hello"
  set2=> "Hey"
  set2=> "Wow"

简单来说，我正在尝试设计一个映射，它有一个指向字符串集的整数键，并且每个字符串又有多个值，因此我认为一组字符串作为一个纯字符串到整数会覆盖这些值我们将只有一个最终值。

我认为下面的语法不能解决问题：

std::map < std::set<std::string>, std::string >  myString;

您的建议将非常有帮助，因为我正在尝试将更大的问题分解为简短的内容，并将加入所有这些子问题。

对不起，如果我的解释不好且令人困惑。 这是我尝试过的代码

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

struct values
{
    std::string a;
    std::string b;
    values():a("milepost"),b("dummyval"){};
    values( std::string ab, std::string bc)
    {
        a=ab;
        b=bc;

    };
    bool operator<(const values& other) const { return a< other.a;}

};

int main(int argc, const char * argv[]) {

    //Create set of types firstly
    std::set<std::string> types ;
    types.insert("et");
    types.insert("pt");

    typedef std::map< int,std::set<std::string> > myGroupsMap;
    typedef std::map<std::string,values>  myWsData;
    typedef std::map< std::string , std::set<myWsData> > myFinalData;
    typedef std::map< int,std::set<myFinalData> > myGroupData;


    //Create the group  with all types in each of them
   // groupname  type
   //    1        et
   //    2        et
   //    1        pt
   //    2        pt

    myGroupsMap groupTypeMap;

    groupTypeMap.insert(std::make_pair(1, types) );


 groupTypeMap.insert(std::make_pair(2, types) );
    groupTypeMap.insert(std::make_pair(3, types) );
    groupTypeMap.insert(std::make_pair(4, types) );
    groupTypeMap.insert(std::make_pair(5, types) );

    //Create the object of structure
    values a,b,c;

    //Create map and insert the string and its corresponding structure
    myWsData et_Data1,pt_Data2;
    et_Data1.insert(std::make_pair("780256", a));
et_Data1.insert(std::make_pair("780255", b));
et_Data1.insert(std::make_pair("780254", c));

pt_Data2.insert(std::make_pair("780256", a));
pt_Data2.insert(std::make_pair("780255", b));
pt_Data2.insert(std::make_pair("780254", c));

std::set<myWsData> myet_pt_data;
myet_pt_data.insert(et_Data1);
myet_pt_data.insert(pt_Data2);



  myFinalData fd , fd1 , fd2 ;
    fd.insert(std::make_pair ("ET",myet_pt_data) );
    fd.insert(std::make_pair ("PT",myet_pt_data) );

    fd1.insert(std::make_pair ("ET",myet_pt_data) );
    fd1.insert(std::make_pair ("PT",myet_pt_data) );

    fd2.insert(std::make_pair ("ET",myet_pt_data) );
    fd2.insert(std::make_pair ("PT",myet_pt_data) );


    std::set<myFinalData> mfd;
    mfd.insert(fd);
    mfd.insert(fd1);
    mfd.insert(fd2);


    myGroupData mygd;
    mygd.insert(std::make_pair (1,mfd) );
    mygd.insert(std::make_pair (2,mfd) );
    mygd.insert(std::make_pair (3,mfd) );


    return 0;

 }

谢谢。 光辉

Answer 1

映射有一个整数键指向一组字符串，并且每个字符串又有多个值

如果我只是从字面上理解并假设“多个值”是指一些自定义类型，那么我可能会想出这样的东西：

#include <map>
#include <set>
#include <vector>
#include <string>

struct Foo{
        int _id;
        Foo(int id):_id(id){}
        bool operator<(const Foo& other) const { return _id < other._id;}
};

typedef std::vector<Foo>                      multiple_values;
typedef std::string                           each_string;
typedef std::map<each_string,multiple_values> again_has;
typedef std::set<again_has>                   set_of_strings_and;
typedef std::map<int,set_of_strings_and>      map_which_has;

int main(){
    multiple_values    mv   = {Foo(1),Foo(2)};
    again_has          ah   = {{"test",mv}};
    set_of_strings_and sosa = {ah};
    map_which_has      mwh  = {{0,sosa}};
};