如何在映射中使用STL未排序键值作为对 我需要使用STL C++映射来存储键值对。 我需要在stl映射中存储多个数据信息。 e、 g

需要以字符串格式存储数据类型、数据及其行为（在param/outparam中）。 但map总是使用键值对

所以如果我 把它储存起来

std::map<map<"int","50",>"behavior">. 

std:：map。

但它总是根据我不想要的键对数据进行排序。如果我使用like

pair<string, pair<string,string> >;
pair<string, pair<string,string>>("int",("100","in"));

pair；
成对的（整数，（“100”，“英寸”）；

这会提示编译时错误

错误C2664:'std:：pair:：pair（const std:：pair&'）：无法将参数1从'const char*'转换为'const std:：pair&'

上述问题的确切解决方案应该是什么

问候

需要存储数据类型、数据及其 行为为（在参数/输出参数中）全部输入 字符串格式。但地图总是用钥匙 值对

在我看来，您需要使用不同的数据结构，例如

typedef std::tuple<std::string,               // DataType
                   std::string,               // Data
                   std::string> element_type; // behaviour

// use can replace tuple with sth like: 
//struct element_type {
//    std::string m_DataType;
//    std::string m_Data;
//    std::string m_Behaviour;
//    ... ctors, operators ...
//};
// or even with std::array<std::string, 3>

std::set<element_type> elements_set;

// or

typedef int32_t element_id;

std::map<element_id, element_type> elements_map;

typedef std:：tuple元素\u type；//行为
//使用可以将元组替换为以下内容：
//结构元素类型{
//std：：字符串m_数据类型；
//std：：字符串m_数据；
//std：：字符串m_行为；
//…运营商、运营商。。。
//};
//甚至使用std:：array
std：：集合元素\u集合；
//或
typedef int32_t element_id；
std：：映射元素\u映射；

你遇到的是设计问题，而不是编程问题

需要存储数据类型、数据及其 行为为（在参数/输出参数中）全部输入 字符串格式。但地图总是用钥匙 值对

在我看来，您需要使用不同的数据结构，例如

typedef std::tuple<std::string,               // DataType
                   std::string,               // Data
                   std::string> element_type; // behaviour

// use can replace tuple with sth like: 
//struct element_type {
//    std::string m_DataType;
//    std::string m_Data;
//    std::string m_Behaviour;
//    ... ctors, operators ...
//};
// or even with std::array<std::string, 3>

std::set<element_type> elements_set;

// or

typedef int32_t element_id;

std::map<element_id, element_type> elements_map;

typedef std:：tuple元素\u type；//行为
//使用可以将元组替换为以下内容：
//结构元素类型{
//std：：字符串m_数据类型；
//std：：字符串m_数据；
//std：：字符串m_行为；
//…运营商、运营商。。。
//};
//甚至使用std:：array
std：：集合元素\u集合；
//或
typedef int32_t element_id；
std：：映射元素\u映射；

---

而且，您遇到的是设计问题，而不是编程问题。

如果您不想排序，请不要使用像map或set这样的排序容器。您可以使用一个类和一个向量来实现您想要的。std:：map的排序特性使按键查找变得高效。如果您想要/需要未排序且更像散列的查找行为，请查看。请注意，这并不能保证输入的订单就是输出的订单。我假设您希望保留放入容器中的类型的顺序，下面的示例可以做到这一点

#include <iostream>
#include <vector>

using namespace std;

class DataBehavior
{
public:
    DataBehavior(const string &type, 
                 const string &data,
                 const string &behavior)
        :type(type), data(data), behavior(behavior)
    {
    }

    const string &getType() const     { return type; }
    const string &getData() const     { return data; }
    const string &getBehavior() const { return behavior; }

private:
    string type;
    string data;
    string behavior;
};

typedef vector<DataBehavior> Ctr;

int main (int argc, char *argv[])
{
    Ctr ctr;
    ctr.push_back(DataBehavior("int",    "50", "behavior"));
    ctr.push_back(DataBehavior("int",    "80", "behavior"));
    ctr.push_back(DataBehavior("string", "25", "behavior2"));

    for (Ctr::const_iterator it = ctr.begin(); it != ctr.end(); ++it)
    {
        cout << "Type: " << it->getType() << "  " 
             << "Data: " << it->getData() << "  "
             << "Behavior: " << it->getBehavior() << "\n";
    }
    return 1;
}

#包括
#包括
使用名称空间std；
类数据行为
{
公众：
数据行为（常量字符串和类型，
常量字符串和数据，
常量字符串和行为）
：类型（类型）、数据（数据）、行为（行为）
{
}
常量字符串&getType（）常量{return type；}
常量字符串&getData（）常量{return data；}
常量字符串&getBehavior（）常量{return behavior；}
私人：
字符串类型；
字符串数据；
字符串行为；
};
类型定义向量Ctr；
int main（int argc，char*argv[]）
{
Ctr-Ctr；
中心推回（数据行为（“int”、“50”、“behavior”）；
中心推回（数据行为（“int”、“80”、“behavior”）；
中心推回（数据行为（“字符串”、“25”、“行为2”）；
对于（Ctr:：const_迭代器it=Ctr.begin（）；it！=Ctr.end（）；++it）
{
cout如果你不想排序，不要使用像map或set这样的有序容器。你可以使用类和向量来实现你想要的。std:：map的排序特性使按键查找变得高效。如果你想/需要未排序和更类似散列的查找行为，请查看。注意，这并不能保证顺序r in将是order out。我假设您希望保留放入容器中的类型的顺序，下面的示例将这样做

#include <iostream>
#include <vector>

using namespace std;

class DataBehavior
{
public:
    DataBehavior(const string &type, 
                 const string &data,
                 const string &behavior)
        :type(type), data(data), behavior(behavior)
    {
    }

    const string &getType() const     { return type; }
    const string &getData() const     { return data; }
    const string &getBehavior() const { return behavior; }

private:
    string type;
    string data;
    string behavior;
};

typedef vector<DataBehavior> Ctr;

int main (int argc, char *argv[])
{
    Ctr ctr;
    ctr.push_back(DataBehavior("int",    "50", "behavior"));
    ctr.push_back(DataBehavior("int",    "80", "behavior"));
    ctr.push_back(DataBehavior("string", "25", "behavior2"));

    for (Ctr::const_iterator it = ctr.begin(); it != ctr.end(); ++it)
    {
        cout << "Type: " << it->getType() << "  " 
             << "Data: " << it->getData() << "  "
             << "Behavior: " << it->getBehavior() << "\n";
    }
    return 1;
}

#包括
#包括
使用名称空间std；
类数据行为
{
公众：
数据行为（常量字符串和类型，
常量字符串和数据，
常量字符串和行为）
：类型（类型）、数据（数据）、行为（行为）
{
}
常量字符串&getType（）常量{return type；}
常量字符串&getData（）常量{return data；}
常量字符串&getBehavior（）常量{return behavior；}
私人：
字符串类型；
字符串数据；
字符串行为；
};
类型定义向量Ctr；
int main（int argc，char*argv[]）
{
Ctr-Ctr；
中心推回（数据行为（“int”、“50”、“behavior”）；
中心推回（数据行为（“int”、“80”、“behavior”）；
中心推回（数据行为（“字符串”、“25”、“行为2”）；
对于（Ctr:：const_迭代器it=Ctr.begin（）；it！=Ctr.end（）；++it）
{
不能您将变量声明为错误的

pair<string, pair<string,string> >;
pair<string, pair<string,string>>("int",("100","in"));

另外，正如其他人所说，如果您不想排序，请使用TR1或Boost中的
unordered\u map
。如果您在MS上，则可以使用
hash\u map
。
您在

pair<string, pair<string,string> >;
pair<string, pair<string,string>>("int",("100","in"));

另外，正如其他人所说，如果你不想按顺序排序，请使用TR1或Boost中的
无序映射
。如果你在MS上，你可以使用
哈希映射
。
为什么首先要使用映射？你想用什么作为查找键？数据类型？值？参数/输出参数特征

无论您想用作键的是什么，都应该先使用，其余的可以是struct/pointer/string（*urg*）/

因此，我建议您更多地考虑您的需要，并相应地设计一个数据结构。
首先为什么要使用映射？您想使用什么作为查找键—数据类型？值？参数/输出参数特性

无论您想用作键的是什么，都应该先使用，其余的可以是struct/pointer/string（*urg*）/

因此，我建议您考虑一下自己的需要，并相应地设计一个数据结构。
我不太理解您的问题，但是
std:：multimap
是您想要的吗？我认为最大的问题是