C++ 填充整数列表比填充整数向量快100倍

我比较了填充整数列表和整数向量所需的时间

每个vector&list都填充了1000万个随机整数，这个实验重复100次以找到平均值

令我惊讶的是，填充列表比填充整数向量快100倍左右。我希望填充整型向量的速度要快得多，因为向量在内存中是连续的，插入要快得多

填充列表怎么可能比填充向量快100倍而不是10倍呢。我确信我遗漏了导致这种情况的一些概念或想法

这是我用来生成结果的代码

#include <iostream>
#include <sstream>
#include <list>
#include <vector>
#include <ctime>
#include <time.h>

using namespace std;



int main()
{
   list<int> mylist;
   vector<int> myvector;
   srand(time(NULL));
   int num;

   clock_t list_start;
   clock_t list_end;
   clock_t list_totaltime;

   for (int i=0;i<100;i++)
   {

    list_start = clock();

        for (int i = 0 ; i < 10000000 ; i++ ) // 10 million
        {    
            num = rand() % 10000000 ; 

            mylist.push_back(num);
         }

    list_end = clock();

    list_totaltime += difftime(list_end,list_start);

    mylist.clear();

   }

   cout << list_totaltime/CLOCKS_PER_SEC/100;

   cout <<" List is done ";

   cout << endl
        << endl;

   clock_t vector_start;  
   clock_t vector_end;
   clock_t vector_totaltime;

   for (int i=0;i<100;i++)
   {

    vector_start = clock();

        for (int i = 0 ; i < 10000000 ; i++ ) // 10 million times
        {    
            num = rand() % 10000000 ; 

            myvector.push_back(num);
        }

    vector_end = clock();

    vector_totaltime += difftime(vector_end,vector_start);

    myvector.clear();

    }

   cout << vector_totaltime/CLOCKS_PER_SEC/100;

   cout << " Vector is done " ;


}

#包括
#包括
#包括
#包括
#包括
#包括
使用名称空间std；
int main（）
{
列出我的清单；
向量myvector；
srand（时间（空））；
int-num；
时钟列表开始；
时钟列表结束；
时钟列表总时间；
对于（int i=0；i向量中的元素按顺序存储在连续的内存位置。最初，一些内存分配给向量，当您不断向向量添加更多元素时，必须进行大量的内存操作才能保留向量的此属性。这些内存操作需要考虑可操作时间

而在列表的情况下，头存储第二个元素的地址，第三个元素的地址存储在第三个元素中，依此类推。这里不需要任何内存重新分配

但与向量相比，列表占用了更多的存储内存。
向量中的元素按顺序存储在连续的内存位置。最初，一些内存分配给向量，随着不断向向量添加更多元素，必须进行大量的内存操作才能保留此属性向量的属性。这些内存操作需要相当长的时间

而在列表的情况下，头存储第二个元素的地址，第三个元素的地址存储在第三个元素中，依此类推。这里不需要任何内存重新分配

但与向量相比，列表占用了更多的存储内存。
向量中的元素按顺序存储在连续的内存位置。最初，一些内存分配给向量，随着不断向向量添加更多元素，必须进行大量的内存操作才能保留此属性向量的属性。这些内存操作需要相当长的时间

而在列表的情况下，头存储第二个元素的地址，第三个元素的地址存储在第三个元素中，依此类推。这里不需要任何内存重新分配

但与向量相比，列表占用了更多的存储内存。
向量中的元素按顺序存储在连续的内存位置。最初，一些内存分配给向量，随着不断向向量添加更多元素，必须进行大量的内存操作才能保留此属性向量的属性。这些内存操作需要相当长的时间

而在列表的情况下，头存储第二个元素的地址，第三个元素的地址存储在第三个元素中，依此类推。这里不需要任何内存重新分配

但是与向量相比，列表占用了更多的存储内存。
如果向量的大小超过其容量，则需要重新分配向量。在这种情况下，必须将以前的所有值复制到新的存储器中。
尝试使用
vector:：reserve
增加容量，以减少所需的重新分配。
如果向量的大小超过其容量，则需要重新分配向量。在这种情况下，必须将以前的所有值复制到新存储中。
尝试使用
vector:：reserve
增加容量，以减少所需的重新分配。
如果向量的大小超过其容量，则需要重新分配向量。在这种情况下，必须将以前的所有值复制到新存储中。
尝试使用
vector:：reserve
增加容量，以减少所需的重新分配。
如果向量的大小超过其容量，则需要重新分配向量。在这种情况下，必须将以前的所有值复制到新存储中。
尝试用<代码>向量来增加容量：：保留< /代码>以减少所需的重新分配。
 < P>我尝试用VS2013 C++编译器，并且<强> >代码> STD:：向量 >比STD:：列表>（如我所料）。

我得到了以下结果：

我使用Windows高分辨率性能计数器来测量时间。

当然，我在优化的发布版本中做了测试

我还重构了push-back循环中的随机数生成，并使用了一个

您使用
clock（）
的方法是否适合测量执行时间

<>你使用了什么C++编译器？你测试了优化的构建吗？< /P>
可编译的测试代码如下所示：

// Testing push_back performance: std::vector vs. std::list

#include <algorithm>
#include <exception>
#include <iostream>
#include <list>
#include <random>
#include <vector>
#include <Windows.h>
using namespace std;

long long Counter() {
    LARGE_INTEGER li;
    QueryPerformanceCounter(&li);
    return li.QuadPart;
}

long long Frequency() {
    LARGE_INTEGER li;
    QueryPerformanceFrequency(&li);
    return li.QuadPart;
}

void PrintTime(const long long start, const long long finish, 
               const char * const s) {
    cout << s << ": " << (finish - start) * 1000.0 / Frequency() << " ms" << endl;
}

int main() {
    try {
        cout << endl
            << "Testing STL vector vs. list push_back() time\n"
            << "--------------------------------------------\n"
            << endl;

        const auto shuffled = []() -> vector<int> {
            static const int kCount = 10 * 1000 * 1000;

            vector<int> v;
            v.reserve(kCount);

            for (int i = 1; i <= kCount; ++i) {
                v.push_back((i % 100));
            }

            mt19937 prng(1995);
            shuffle(v.begin(), v.end(), prng);

            return v;
        }();

        long long start = 0;
        long long finish = 0;

        cout << "Testing std::vector...";
        start = Counter();
        vector<int> v;
        for (size_t i = 0; i < shuffled.size(); ++i) {
            v.push_back(shuffled[i]);
        }
        finish = Counter();
        cout << "done.\n";
        PrintTime(start, finish, "std::vector::push_back()");

        cout << endl;

        cout << "Testing std::list...";
        start = Counter();
        list<int> l;
        for (size_t i = 0; i < shuffled.size(); ++i) {
            l.push_back(shuffled[i]);
        }
        finish = Counter();
        cout << "done.\n";
        PrintTime(start, finish, "std::list::push_back()");
    } catch (const exception& ex) {
        cout << "\n*** ERROR: " << ex.what() << endl;
    }
}

测试回推性能：std:：vector与std:：list
#包括
#包括
#包括
#包括
#包括
#包括
#包括
使用名称空间std；
长计数器（）{
大整数李；
QueryPerformanceCounter（&li）；
返回li.QuadPart；
}
长频率{
大整数李；
查询性能频率（&li）；
返回li.QuadPart；
}
无效打印时间（恒长开始、恒长结束、，
常量字符*常量s）{
CUT< P>我尝试了VS2013 C++编译器，并且<强> >代码> STD:：向量 >比 STD:：列表>（如我所料）。

我得到了以下结果：

我用的是Windows高分辨率pe
// Testing push_back performance: std::vector vs. std::list

#include <algorithm>
#include <exception>
#include <iostream>
#include <list>
#include <random>
#include <vector>
#include <Windows.h>
using namespace std;

long long Counter() {
    LARGE_INTEGER li;
    QueryPerformanceCounter(&li);
    return li.QuadPart;
}

long long Frequency() {
    LARGE_INTEGER li;
    QueryPerformanceFrequency(&li);
    return li.QuadPart;
}

void PrintTime(const long long start, const long long finish, 
               const char * const s) {
    cout << s << ": " << (finish - start) * 1000.0 / Frequency() << " ms" << endl;
}

int main() {
    try {
        cout << endl
            << "Testing STL vector vs. list push_back() time\n"
            << "--------------------------------------------\n"
            << endl;

        const auto shuffled = []() -> vector<int> {
            static const int kCount = 10 * 1000 * 1000;

            vector<int> v;
            v.reserve(kCount);

            for (int i = 1; i <= kCount; ++i) {
                v.push_back((i % 100));
            }

            mt19937 prng(1995);
            shuffle(v.begin(), v.end(), prng);

            return v;
        }();

        long long start = 0;
        long long finish = 0;

        cout << "Testing std::vector...";
        start = Counter();
        vector<int> v;
        for (size_t i = 0; i < shuffled.size(); ++i) {
            v.push_back(shuffled[i]);
        }
        finish = Counter();
        cout << "done.\n";
        PrintTime(start, finish, "std::vector::push_back()");

        cout << endl;

        cout << "Testing std::list...";
        start = Counter();
        list<int> l;
        for (size_t i = 0; i < shuffled.size(); ++i) {
            l.push_back(shuffled[i]);
        }
        finish = Counter();
        cout << "done.\n";
        PrintTime(start, finish, "std::list::push_back()");
    } catch (const exception& ex) {
        cout << "\n*** ERROR: " << ex.what() << endl;
    }
}

0.2 List is done 
0.07 Vector is done