Question

填充此类型值的最佳方法是什么？

typedef std::map<std::string, std::pair<std::vector<double>, std::vector<double>>> buf;

所以，我需要这样的东西：

(“Label”, {1,2,3}, {100,200,300})

提前谢谢！

UP： 所以，我来到这里。但我觉得它看起来不太好：

double a[] = {0.1, 0.2};
double b[] = {0.0, 0.0};
foo.insert( make_pair("box", make_pair(vector<double>(a, a + sizeof(a) / sizeof(a[0])), vector<double>(b, b + sizeof(b) / sizeof(b[0]))) ) );

Answer 1

您可以使用insert

typedef std::map<std::string, std::pair<std::vector<double>, std::vector<double>>> buf;

int main()
{
    buf foo;
    foo.insert({"Label", {{1,2,3}, {100,200,300}}});
}

请注意，您需要附上{}以表明您的std::pair。

Answer 2

有很多大括号：

buf my_map {         // <== whole map
    {                // <== next individual map item
        "Label",     // <== key
        {            // <== value
            {1.0, 2.0, 3.0},       // <== value.first
            {100.0, 200.0, 300.0}  // <== value.second
        } 
    }  
};

当您将整个项目放在一行时，请输入：

buf my_map {
    {"Label", {{1.0, 2.0, 3.0}, {100.0, 200.0, 300.0}}}  
};

Answer 3

如果是C ++ 11或更新版

buf x = {{"Label", {{1,2,3}, {100, 200, 300}}};

修改

如果你真的想填充文字（如你的例子中），如果没有C ++ 11，请创建辅助函数：

template <int N, int M> std::pair<std::vector<double>, std::vector<double>> build_pair(double(&x)[N], double(&y)[M]) { return std::make_pair(std::vector<double>(x, x + N), std::vector<double>(y, y + M)); }

你可以使用它：

double x[] = { 1, 2, 3 }; double y[] = { 100, 200, 300 }; b["Label"] = build_pair(x, y);

Answer 4

万一你意味着向量已经存在并且你没有在构造时使用文字值初始化地图，那么你通常使用std::make_pair来创建这对向量，以及作为进入地图的键/值对。

#include <utility>

buf my_map;
my_map.insert(std::make_pair(label, std::make_pair(vector1, vector2)));

Answer 5

typedef std::map<std::string, std::pair<std::vector<double>, std::vector<double>>> buf;

buf mybuf {
    {
        "Label",
        {
            {1,2,3}, {100,200,300}
        }
    },

    {
        "Label2",
        {
            {4,5,6}, {400,500,600}
        }
    }
};

Answer 6

为了简化（使用编译时常量）填充映射的创建，我创建了这样的模板：

#include <map>
#include <type_traits>
template<typename... Ts>
constexpr auto make_map(Ts&&... ts)
    -> std::map<typename std::common_type_t<Ts...>::first_type,typename std::common_type_t<Ts...>::second_type>
{
    return { std::forward<Ts>(ts)... };
}//---------------------------------------------------------

可以像这样使用：

using namespace std;
auto myDict = make_map(make_pair(666,string("the number of the beast"))
                      ,make_pair(667,string("the neighbor of the beast"))
                      );

创建myDict作为＆＃34; map＆lt; int，string＆gt;＆＃34;。

或者在你的情况下使用它：

using namespace std;
auto myDict = make_map(make_pair(string("label")
                                , make_pair(make_vector(1.,2.,3.)
                                           ,make_vector(100.,200.,300.)
                                           )
                                )
                      );

（＆＃34; make_vector＆＃34;可以定义为非常类似于＆＃34; make_map＆＃34;）

make _...方法很有帮助（或者至少对我来说似乎是＃34;）因为它通过从参数中获取类型来省略显式模板类型声明。

也许这对其他人也有某种帮助（或至少鼓舞人心： - ））...

如何填充字符串的映射和双向量的映射

6 个答案: