c++ - 如何在 C++ 中将值从向量转换为地图？

Question

我想做这样的事情。是否有一个 stl 算法可以轻松做到这一点？

 for each(auto aValue in aVector)
                {
                aMap[aValue] = 1;
                }

Answer 1

如果您有一个对向量，其中对中的第一项将是映射的键，第二项将是与该键关联的值，您可以使用插入迭代器将数据复制到映射：

std::vector<std::pair<std::string, int> > values {   
    {"Jerry", 1},
    { "Jim", 2},
    { "Bill", 3} };

std::map<std::string, int> mapped_values;

std::copy(values.begin(), values.end(), 
          std::inserter(mapped_values, mapped_values.begin()));

或者，您可以从向量初始化地图：

std::map<std::string, int> m2((values.begin()), values.end());

Answer 2

也许是这样的：

std::vector<T> v;   // populate this

std::map<T, int> m;

for (auto const & x : v) { m[x] = 1; }

Answer 3

你可能会std::transform变成std::vector一个std::map

std::vector<std::string> v{"I", "want", "to", "do", "something", "like", "this"};
std::map<std::string, int> m;
std::transform(v.begin(), v.end(), std::inserter(m, m.end()),
               [](const std::string &s) { return std::make_pair(s, 1); });

这会从向量的元素创建std::pairs，然后将其插入到地图中。

---

或者，正如@BenFulton 所建议的，将两个向量压缩到一张地图中

std::vector<std::string> k{"I", "want", "to", "do", "something", "like", "this"};
std::vector<int> v{1, 2, 3, 4, 5, 6, 7};
std::map<std::string, int> m;

auto zip = [](const std::string &s, int i) { return std::make_pair(s, i); };
std::transform(k.begin(), k.end(), v.begin(), std::inserter(m, m.end()), zip);

Answer 4

尝试这个：

for (auto it = vector.begin(); it != vector.end(); it++) {
  aMap[aLabel] = it;
  //Change aLabel here if you need to
  //Or you could aMap[it] = 1 depending on what you really want.
}

我认为这就是你想要做的。

编辑：如果要更新 的值aLabel，可以在循环中更改它。另外，我回头看最初的问题，不清楚他想要什么，所以我添加了另一个版本。

Answer 5

假设向量中的项目按顺序相关，也许这个例子可以帮助：

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

std::map<std::string, std::string> convert_to_map(const std::vector<std::string>& vec)
{
    std::map<std::string, std::string> mp;
    std::pair<std::string, std::string> par;

    for(unsigned int i=0; i<vec.size(); i++)
    {
        if(i == 0 || i%2 == 0)
        {
            par.first = vec.at(i);
            par.second = std::string();
            if(i == (vec.size()-1))
            {
                mp.insert(par);
            }
        }
        else
        {
            par.second = vec.at(i);
            mp.insert(par);
        }
    }

    return mp;
}

int main(int argc, char** argv)
{
    std::vector<std::string> vec;
    vec.push_back("customer_id");
    vec.push_back("1");
    vec.push_back("shop_id");
    vec.push_back("2");
    vec.push_back("state_id");
    vec.push_back("3");
    vec.push_back("city_id");

    // convert vector to map
    std::map<std::string, std::string> mp = convert_to_map(vec);

    // print content:
    for (auto it = mp.cbegin(); it != mp.cend(); ++it)
        std::cout << " [" << (*it).first << ':' << (*it).second << ']';

    std::cout << std::endl;

    return 0;
}

Answer 6

一个非常通用的方法，因为你没有指定任何类型，可以按如下方式完成：

template<class Iterator, class KeySelectorFunc,
         class Value = std::decay_t<decltype(*std::declval<Iterator>())>,
         class Key = std::decay_t<decltype(std::declval<KeySelectorFunc>()(std::declval<Value>()))>>
std::map<Key, Value> toMap(Iterator begin, Iterator end, KeySelectorFunc selector) {
    std::map<Key, Value> map;
    std::transform(begin, end, std::inserter(map, map.end()), [selector](const Value& value) mutable {
        return std::make_pair(selector(value), value);
    });
    return map;
}

用法：

struct TestStruct {
    int id;
    std::string s;
};

std::vector<TestStruct> testStruct = {
    TestStruct{1, "Hello"},
    TestStruct{2, "Hello"},
    TestStruct{3, "Hello"}
};

std::map<int, TestStruct> map = toMap(testStruct.begin(), testStruct.end(), 
    [](const TestStruct& t) {
        return t.id;
    }
);

for (const auto& pair : map) {
    std::cout << pair.first << ' ' << pair.second.id << ' ' << pair.second.s << '\n';
}

// yields:
// 1 1 Hello
// 2 2 Hello
// 3 3 Hello

参数selector函数用于选择std::map.

Answer 7

为了将数组或向量的值直接转换为映射，我们可以这样做。

map<int, int> mp; 
for (int i = 0; i < m; i++) 
    mp[a[i]]++;

其中 a[i] 是我们拥有的数组。

Answer 8

还有一种方式：

#include <map>
#include <vector>
#include <boost/iterator/transform_iterator.hpp>

int main() {
    using T = double;
    std::vector<T> v;
    auto f = [](T value) { return std::make_pair(value, 1); };
    std::map<T, int> m(boost::make_transform_iterator(v.begin(), f),
                       boost::make_transform_iterator(v.end(), f));
}

但我不认为它在可读性和执行速度方面胜过 range-for 循环。