现在std有一个真正的哈希映射unordered_map,为什么(或何时)我还想在它实际存在的系统上使用旧的mapover unordered_map？是否有任何我无法立即看到的明显情况？
我们正在用C++开发一个高性能的关键软件.我们需要一个并发的哈希映射并实现一个.所以我们写了一个基准来弄清楚我们的并发哈希映射与之比较慢多少std::unordered_map.
但是,std::unordered_map似乎是非常慢......所以这是我们的微基准测试(对于并发映射,我们产生了一个新的线程,以确保锁定不会被优化掉,并注意我从来没有inser 0因为我也基准测试google::dense_hash_map,需要一个空值):
boost::random::mt19937 rng;
boost::random::uniform_int_distribution<> dist(std::numeric_limits<uint64_t>::min(), std::numeric_limits<uint64_t>::max());
std::vector<uint64_t> vec(SIZE);
for (int i = 0; i < SIZE; ++i) {
uint64_t val = 0;
while (val == 0) {
val = dist(rng);
}
vec[i] = val;
}
std::unordered_map<int, long double> map;
auto begin = std::chrono::high_resolution_clock::now();
for (int i = 0; i < SIZE; ++i) {
map[vec[i]] = 0.0;
}
auto end = std::chrono::high_resolution_clock::now();
auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(end - begin);
std::cout << "inserts: " << …我需要将原始键(int,可能很长)映射到高性能哈希映射数据结构中的struct值.
我的程序将有几百个这样的地图,每个地图通常最多只有几千个条目.但是,地图会不断地"刷新"或"翻腾"; 想象一下处理数百万add和delete消息.
C或C++中的哪些库具有适合此用例的数据结构？或者,您会如何建议自己建造？谢谢!
我浏览了虚幻引擎源代码，发现它们使用自己的容器类，例如内部动态数组。但是 C++ STL 提供了（几乎）所有必需的容器类。那么他们为什么要花时间再次开发相同的容器呢？对于开发人员来说，使用容器std::vector来编写他们的代码而不是试图弄清楚如何使用TArray引擎中的类来做事情不是更容易吗？
我写了一个小程序，用两个样本数据创建了两百万张地图的向量，然后查询一些值。
我知道我可以在此时使用数据库，但是我只是在四处探索以实现性能优化。
代码：
#include <iostream>
#include <vector>
#include <unordered_map>
#include <map>
#include <string>
#include <chrono>
using namespace std;
static int NUM_OF_MAPS = 2 * 1000 * 1000;
void buildVector(vector<unordered_map <string, int>> &maps);
void find(string key, int value, vector<unordered_map <string, int>> &maps);
int main() {
auto startPrg = chrono::steady_clock::now();
vector<unordered_map <string, int>> maps;
buildVector(maps);
for (int i = 0; i < 10; i++) {
string s(1, 'a'+ i);
find(s, i, maps);
}
auto endPrg = chrono::steady_clock::now();
cout << "program duration: " …我有一个unordered_map存储大对象：
std::unordered_map<uint64_t, LargeObject> map;
LargeObject 是一个 POD 数组/没有指针成员。
我收到了很多LargeObjects，所以我只想在它们不存在的情况下将它们插入到地图中（很多时候它们确实存在，因为我正在收听多个来源）。
性能很重要，因为我收到了数百万美元。
似乎有几种方法可以做到这一点：
map[key] = largeObject;
或者：
map.insert(std::make_pair<uint64_t, LargeObject>(key, largeObject);
或者：
if(map.count(key) == 0)
{
map[key] = largeObject;
}
或者：
auto iter = map.find(key);
if(iter == map.end())
{
map[key] = largeObject;
}
也许还有更多我没有包括在内。
当地图的值是一个大对象时，哪种插入技术最有效？
我有一个 (C++ 14) 地图
using MyTuple = tuple<A, B, C>;
map<MyTuple, MyData>
其中MyTuple有明显的情况operator<()，首先比较 A，然后比较 B，然后比较 C。
我想搜索O(ln N)与某个常量匹配的键(a, b)。显然，如果有的话，它们将是连续的。所以基本上我想要
map<MyTuple, MyData> my_map = GetMyData();
tuple<A, B> my_key = make_tuple(a, b);
auto iter = my_map.lower_bound_if([my_key](const MyTuple& key) {
if (get<0>(my_key) == get<0>(key) &&
get<1>(my_key) == get<1>(key)) {
return true;
}
return false;
});
while( /* iter.first is still an (a,b) */) {
// Do something with iter.
// Increment iter.
}
map::lower_bound_if但还没有任何功能， …
我有一个值列表，有一些重复，例如：{1,2,2,3,3,3,3,7,8,1}
我想将此列表中的唯一值及其计数存储在数据结构中。
--------------
|value |count|
--------------
| 1 | 2 |
--------------
| 2 | 2 |
--------------
| 3 | 4 |
--------------
| 7 | 1 |
--------------
| 8 | 1 |
--------------
哪种 C++ 标准库数据结构最有效？
编辑：我不会以任何方式修改结构，我只想知道计数，因为计数将帮助我确定编程问题的输出。
我正在尝试将两个std::map容器（例如std::map<int, int> foo, bar）合并到第三个容器std::map（例如std::map<int, int> foobar）中。
我知道我可以使用迭代器来实现这一点，如下所示：
std::map<int, int>::iterator itr1 = foo.begin();
std::map<int, int>::iterator itr2 = bar.begin();
for (; itr1 != foo.end() && itr2 != bar.end(); ++itr1, ++itr2)
{
foobar[itr1->first] += itr1->second;
foobar[itr2->first] += itr2->second;
}
但是我如何使用基于范围的 for 循环（也许与结构化绑定声明结合使用）来实现相同的目的？
或者有没有更好的方法来组合这两个关联容器？
编辑：这个问题的预期答案应该采用两个容器（std::map此处）并将它们组合成一个联合/联合映射，其中键来自各自的关联容器，并且添加重复键的值。
示例：
如果给定std::map容器foo和bar是：
std::map<int, int> foo = {{1, 10}, {2, 20}, {3, 30}};
std::map<int, int> bar = {{3, 50}, {4, 60}};
那么“foobar”应该是：
std::map<int, int> …