C++ 用预分配的嵌套向量快速构造无序_图std:：无序_图<；int，向量<；事物*>>；？

我想创建int到事物向量的映射*。我知道，

事情

将不再是1-50。我如何在开始时分配50以加快地图的构建

我尝试了三种方法，但仍然不确定是否足够快。你能建议更好的优化吗？ 10年前我用C++，我不确定我是否正确。你能帮忙吗？ 欢迎所有优化建议。代码从实际问题简化而来

#include <iostream>
#include <vector>
#include <unordered_map>

#include <time.h>

class Thing {
};

int main()
{
    clock_t start;
    start = clock();
    auto int_to_thing = std::unordered_map<int, std::vector<Thing *>>();
    for (int i = 0; i < 1000; i++) {
        for (int j = 0; j < 25; j++) {
            int_to_thing[i].push_back(new Thing());
        }
    }
    for (int i = 0; i < 1000; i++) {
        for (int j = 0; j < 25; j++) {
            int_to_thing[i].push_back(new Thing());
        }
    }
    std::cout << (clock() - start) << std::endl;

    start = clock();
    int_to_thing = std::unordered_map<int, std::vector<Thing *>>();
    for (int i = 0; i < 1000; i++) {
        int_to_thing[i].reserve(50);
        for (int j = 0; j < 25; j++) {
            int_to_thing[i].push_back(new Thing());
        }
    }
    for (int i = 0; i < 1000; i++) {
        for (int j = 0; j < 25; j++) {
            int_to_thing[i].push_back(new Thing());
        }
    }
    std::cout << (clock() - start) << std::endl;

    start = clock();
    int_to_thing = std::unordered_map<int, std::vector<Thing *>>();
    for (int i = 0; i < 1000; i++) {
        auto it = int_to_thing.find(i);
        if (it != int_to_thing.end()) {
            auto v = std::vector<Thing *>(50);
            auto pair = std::pair<int, std::vector<Thing *>>(i, v);
            int_to_thing.insert(pair);
        }
    }
    for (int i = 0; i < 1000; i++) {
        for (int j = 0; j < 25; j++) {
            int_to_thing[i].push_back(new Thing());
        }
    }
    std::cout << (clock() - start) << std::endl;
    
    return 0;
}

#包括
#包括
#包括
#包括
阶级事务{
};
int main（）
{
时钟没有启动；
开始=时钟（）；
auto int_to_thing=std:：无序映射（）；
对于（int i=0；i<1000；i++）{
对于（int j=0；j<25；j++）{
int_to_thing[i]。推回（新事物（））；
}
}
对于（int i=0；i<1000；i++）{
对于（int j=0；j<25；j++）{
int_to_thing[i]。推回（新事物（））；
}
}
std：：cout你关心的是
地图的构造（然后看@ShadowRanger的评论）还是向量的构造

我假设向量中有1..50
个东西，而不是地图中的1..50个向量

您的代码：

int_to_thing = std::unordered_map<int, std::vector<Thing *>>();
for (int i = 0; i < 1000; i++) {
    int_to_thing[i].reserve(50);

实际上，在向量中创建50个元素，并使用默认值对其进行初始化。这可能会也可能不会额外花费您的成本。具体来说，当前使用指针会很便宜，如果您切换到存储
对象本身，则会很贵。
如果您不确定某个对象是否足够快，那么您就没有进行测量这是你一点也不在乎的初步证据。如果你不测量它，你就不能对它提出任何要求。在你做任何事情之前先测量它。否则你会浪费每个人的时间。你工作的前提是这样的预分配会有帮助。我有一点暗示，它们根本不会有帮助ce你做的太少了，你只是在浪费时间。再说一次：如果你对性能很认真，你现在就停下来，进行测量，然后带着一些数字回来讨论。不要测量调试版本-只发布启用了完全优化的版本，包括链接时代码生成（LTCG）。如果你不优化，你也不关心性能。句号。句号。这些是规则

是的，你有计算时间的代码，但这不是度量的目的。它们需要在你使用数据的环境中发生，这样你才能看到你有多少相对开销。如果任务需要一个小时，而你花一秒钟来“非理想地”做这件事，那么首先优化就没有意义了——你首先要做的是更大的事情。此外，在大多数情况下，代码是缓存驱动的，ie数据访问模式决定性能，所以我认为你目前根本没有做任何有用的事。这样的微优化完全没有意义。这段代码不是在真空中存在的。如果是这样的话，你可以删除它，把它全部忘掉，对吗？
对于你的定时运行，你是用优化的方法编译的吗？而且，除非<代码>东西>代码>是多态的类型，你应该使用一个<代码>向量< /代码>。如果它是多态的，考虑使用<代码>矢量< /代码>，这样它就可以为你管理内存清理。ps pre-最小化重新灰化？不太可能会有很大的不同，但确实是这样。评测代码并不是那么简单。要么你打开编译器优化，然后编译器会优化掉所有东西，因为你的代码唯一可以观察到的行为是计时的打印输出，要么你不打开优化，然后是测量的时间mes几乎没有意义如果您知道内存不会超过50个，并且愿意为所有50个预先分配内存，那么您可以使用
std:：array
，这样您就不必担心如何最好地预分配
auto v=std:：vector（50）
不好，因为我不知道它是否会是50。我知道它可能是50。我尝试了这个，我创建了异常（因为迭代了空元素）>这是个好主意第一个“int-to-thing[I]。reserve（50）；`看起来很轻！我测试过它不起作用。
insert（）
比
int-to-thing[I]更好。reserve（50）
。看起来我的代码速度更快：）@Chameleon-你用
插入
的代码做了一些不同的事情；
对
s有什么作用？它不会把25个
东西
s推到向量中。@Chameleon-你的上一个案例仍然缺少24个
推回
s！你判断并教人们如何快速。这对一个测试没有帮助d错。你无法理解这些限制。本例中的代码执行次数为1000000次或更多，优化它非常重要。这不仅是因为浪费能源，而且还因为它必须非常快。你对初学者的建议可能非常好，但不是这里。
auto v = std::vector<Thing *>(50);