blocks|key|1009194|text|这是一个运行时容器，对吗？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1009195|您是在末尾(如在push_back中)还是在前面或中间添加？您是在随机位置删除，还是其他什么？|offset|length|style|CODE|1009196|你是如何在其中引用信息的？随机的，或者从前面或者后面，或者别的什么？|1009197|如果你需要随机访问，基于数组或散列的东西是最好的。|1009198|如果重新分配是一个大问题，你想要更像树或列表的东西。|1009199|即便如此，如果您经常对放入容器中的对象执行new-ing+(和delete-ing)，那么仅此一项就可能消耗大量时间，在这种情况下，您可能会发现将使用过的对象保存在垃圾列表中是有意义的，这样您就可以回收它们。|1009200|我的建议是，与其为容器的选择而烦恼，不如选择一个，编写程序，然后。无论您选择什么，您都可能想要更改它，可能不止一次。我在这个例子中发现，任何预先存在的容器类都是通过简化编程来证明其存在的合理性，而不是通过最快的速度。|1009201|我知道这是违反直觉的，但除非你的程序中的其他活动最终成为主要的成本，而且你不能缩小它，否则你最终的速度爆发将需要手工编码数据结构。|1009202|entityMap^0|0|8|9|0|0|0|0|L|3|V|6|0|0|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|W|8|@$D|X|E|Y|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|Z|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|10|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|11|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|12|8|@$D|13|E|14|F|G]|$D|15|E|16|F|G]]|9|@]|A|$]]|$1|P|3|Q|5|6|7|17|8|@]|9|@]|A|$]]|$1|R|3|S|5|6|7|18|8|@]|9|@]|A|$]]|$1|T|3|-4|5|6|7|19|8|@]|9|@]|A|$]]]|U|$]]

This is a run-time container, right?

Are you adding at the end (as in <code>push_back</code>) or in the front or the middle?
Are you removing at random locations, or what?

How are you referencing information in it?
Randomly, or from the front or back, or what?

If you need random access, something based on array or hash is preferred.

If reallocation is a big problem, you want something more like a tree or list.

Even so, if you are constantly <code>new</code>-ing (and <code>delete</code>-ing) the objects that you're putting in the container, that alone is likely to consume a large fraction of time,
in which case you might find it makes sense to save used objects in junk lists, so you can recycle them.

My suggestion is, rather than agonize over the choice of container, just pick one, write the program, and then <a href="https://sourceforge.net/projects/randompausedemo/" rel="nofollow">tune it, as in this example</a>.
No matter what you choose, you will probably want to change it, maybe more than once.
What I found in that example was that any pre-existing container class is justifying its existence by ease of programming, not by fastest-possible speed.

I know it's counter-intuitive, but 
unless some other activity in your program ends up being the dominant cost, and you can't shrink it, your final burst of speed will require hand-coding the data structure.

blocks|key|4903277|text|您需要什么样的访问权限？顺序访问、随机访问、按键查找？此外，您可以手动重新散列无序映射(rehash方法)，并设置其负载因子。在任何情况下，当链变得太长时(即，当超过负载因子时)，散列将自我重建。此外，哈希表的减速点是在它满的时候~80%25，而不是50%25。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4903278|您真的应该已经阅读了文档，例如here。|4903279|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/bb982522.aspx^0|18|6|0|F|4|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@$9|Q|A|R|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|S|8|@]|D|@$9|T|A|U|1|V]]|E|$]]|$1|H|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|I|$J|$5|K|L|M|E|$N|O]]]]

What kind of access do you need? Sequential, random access, lookup by key? Plus, you can rehash unordered map either manually (<code>rehash</code> method), and set its load factor. In any case the hash will rebuild itself when chains get too long (i.e., when the load factor is exceeded). Additionally, the slow-down point of a hash table is when it is full ~80%, not 50%.

You should really have read the documentation, for example <a href="http://msdn.microsoft.com/en-us/library/bb982522.aspx" rel="nofollow">here</a>.

I am looking a container to support frequent adds/removals. I have not idea how large the container may grow but I don't want to get stalls due to huge reallocations. I need a good balance between performance and consistent behavior.

Initially, I considered std::tr1::unordered_map but since I don't know the upper bound of the data set, collisions could really slow down the unordered_map's performance. It's not a matter of a good hashing function because no matter how good it is, if the occupancy of the map is more than half the bucket count, collisions will likely be a problem.

Now I'm considering std::map because it doesn't suffer from the issue of collisions but it only has log(n) performance.

Is there a way to intelligently handle collisions when you don't know the target size of an unordered_map? Any other ideas for handling this situation, which I imagine is not uncommon?

Thanks

Fast container for consistent performance

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我正在寻找一个支持频繁添加/删除的容器。我不知道容器可能会增长到多大，但我不想因为巨大的重新分配而停滞不前。我需要在性能和一致的行为之间取得良好的平衡。最初，我考虑使用std::tr1::unordered_map，但由于我不知道数据集的上限，冲突可能会降低unordered的性能。这不是一个好的散列函数的问题，因为无...

问Fast容器提供一致的性能
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Fast容器提供一致的性能EN