如何将 std：：unordered_multimap<uint， T> 转储到 std：：vector<T>？

How to dump an std::unordered_multimap<uint, T> to a std::vector<T>?

本文关键字：gt lt std 转储 vector multimap unordered uint      更新时间：2023-10-16

我正在尝试从std::unordered_multimap<uint, T> lookup到std::vector<T> v

So far I try 

std::vector<T> v(lookup.begin(), lookup.end());

，但它显然不起作用，因为begin()和end()的迭代器是pair<uint, T>类型，所以什么是最快的正确方法来做到这一点?

谢谢你的帮助!

提取散列映射中std::pair的值部分，并将其放入vector:

#include <iostream>
#include <unordered_map>
#include <vector>
int main() {
    using Map = std::unordered_multimap<int, int>;
    auto m = Map { {1, 1}, {1, 2}, {1, 3}, {2, 4}, {2, 5}, {3, 6} };
    std::vector<int> v;
    v.reserve(m.size());
    for (auto const& elem : m)
        v.push_back(elem.second);
    for (auto const& elem : v)
        std::cout << elem << "n";
}

请注意，在c++ 11中，您可以使用范围for循环+ auto来避免必须显式表示映射元素的类型。此外，您还可以使用初始化器列表语法来快速初始化映射。

注意:在实际示例中，请务必在vector上使用reserve()，以避免过多的内存分配。

<<p> 生活例子/strong>。

试试这个:

std::vector<T> v;
v.reserve(lookup.size()); // optimization (allocate enough memory for all elements)
std::transform(std::begin(lookup), std::end(lookup), std::back_inserter(v),
    [](const std::pair<uint, T>& p) { return p.second; });

使用一个循环来push_back vector中的元素。当然，它要求类型T是可复制构造的:

for ( auto it = map.begin(); it != map.end(); it++)
    v.push_back(it->second);
对于更精细的解决方案，您可以通过使用reserve来优化一点，以便在此之前在向量中准备足够的空间。此外，如果你打算在此之后扔掉地图，你可以尽量避免复制这些项目，而是将它们移进去: 
v.reserve(map.size());
for ( auto it = map.begin(); it!= map.end(); it++)
    v.emplace_back(std::move(it->second));

我的方法是:[警告未经测试]

template <typename Map>
std::vector<typename Map::mapped_type> extract_values(Map const& m) {
    std::vector<typename Map::mapped_type> v;
    v.reserve(m.size());
    std::for_each(std::begin(m), std::end(m), [&](typename Map::const_reference p)
        { v.push_back(p.second); }
    );
    return v;
}

更简单:

template <typename Map>
std::vector<typename Map::mapped_type> extract_values(Map const& m) {
    std::vector<typename Map::mapped_type> v;
    v.reserve(m.size());
    for(auto& p : m)
        v.push_back(p.second);
    return v;
}

我最近一直在尝试使用c++ 11。这是我想到的一些东西

#include <iostream>
#include <iterator>
#include <vector>
#include <unordered_map>
#include <algorithm>
int main() {
    std::vector<int> v;
    typedef std::unordered_multimap<int, int> MapType;
    MapType m { { 1, 1 }, { 1, 2 }, { 2, 1 }, { 2, 2 }, { 3, 1 } };
    std::for_each(begin(m), end(m), [&](MapType::value_type i){v.push_back(i.second); });
    std::copy(begin(v), end(v), std::ostream_iterator<int>(std::cout, " "));
    return 0;
}

在线运行代码

不可否认，这种使用STL算法的方法对于这个问题来说有点过头了。

相关文章：