對vector與deque插值與遍歷的性能數據

std::vector<int> vecint;
std::deque<int> queint;
clock_t t0, t1;

int size = 1000000;

t0 = clock();
for (int i = 0; i < size; ++i)
{
    vecint.push_back(i);
}
t1 = clock();
//vector的push_back速度，共350ms，畢竟有realloc和copy的過程
std::wcout<<t1 - t0<<std::endl;

t0 = clock();
for (int i = 0; i < size; ++i)
{
    queint.push_back(i);
}
t1 = clock();
//而deque因為沒有realloc和copy的過程，只用了340ms，其實也沒快多少
//不過要是push_front，就會快非常多了
std::wcout<<t1 - t0<<std::endl;

int i;

t0 = clock();
for (auto it = vecint.begin(); it != vecint.end(); ++it)
{
    i = *it;
}
t1 = clock();
//用iterator遍歷vector，花費882ms，不推薦這么遍歷
std::wcout<<t1 - t0<<std::endl;

t0 = clock();
for (auto it = queint.begin(); it != queint.end(); ++it)
{
    i = *it;
}
t1 = clock();
//用iterator遍歷deque，花費768ms，對於deque這已經是最快的方法了
std::wcout<<t1 - t0<<std::endl;

t0 = clock();
for (int i = 0; i < size; ++i)
{
    i = vecint[i];
}
t1 = clock();
//用下標遍歷vector，花費55ms，推薦的方式
std::wcout<<t1 - t0<<std::endl;

t0 = clock();
for (int i = 0; i < size; ++i)
{
    i = queint[i];
}
t1 = clock();
//用下標遍歷deque，花費1548ms，比iterator方式慢了一倍
std::wcout<<t1 - t0<<std::endl;

t0 = clock();
for (unsigned int i = 0; i < vecint.size(); ++i)
{
    i = vecint[i];
}
t1 = clock();
//一個小細節，即便使用下標遍歷，最好把size提前取出來，
//每次訪問一下還是要犧牲性能的，花費了82ms。
std::wcout<<t1 - t0<<std::endl;

而list的push_back性能和遍歷性能跟它們就更沒有可比性了。

 

以上數據引自 http://gfdice.iteye.com/blog/1313520 ，為在VS2010中，使用Dinkumware STL測試的數據。

 

我的自測數據（1000000條）：

#include <vector>
#include <deque>
#include <sys/time.h>
#include <iostream>

using std::vector;
using std::deque;
using std::cout;
using std::endl;

//struct timeval {
//    long    tv_sec;         /* seconds */
//    long    tv_usec;        /* and microseconds 微秒 */
//};

void tv_sub(struct timeval *out, struct timeval *in)
{
    if ((out->tv_usec -= in->tv_usec) < 0) {
        --out->tv_sec;
        out->tv_usec += 1000000;
    }
    out->tv_sec -= in->tv_sec;
}

int main()
{
    static timeval tv_start, tv_stop;
    int MAXSIZE = 1000000;
    vector<int*> vec(MAXSIZE, new int(0));


    int tt = 0;
    gettimeofday(&tv_start, NULL);
    for(vector<int*>::iterator it = vec.begin(); it != vec.end(); ++it)
        tt = **it;
    gettimeofday(&tv_stop, NULL);
    tv_sub(&tv_stop, &tv_start);
    cout << "iteratror: " << tv_stop.tv_sec * 1000000.0 + tv_stop.tv_usec << endl;

    gettimeofday(&tv_start, NULL);
    for (int i = 0; i < MAXSIZE; ++i)
        tt = *vec[i];
    gettimeofday(&tv_stop, NULL);
    tv_sub(&tv_stop, &tv_start);
    cout << "operator[]: " << tv_stop.tv_sec * 1000000.0 + tv_stop.tv_usec << endl;

    deque<int*> deq(MAXSIZE, new int(0));
    gettimeofday(&tv_start, NULL);
    for(deque<int*>::iterator it = deq.begin(); it != deq.end(); ++it)
        tt = **it;
    gettimeofday(&tv_stop, NULL);
    tv_sub(&tv_stop, &tv_start);
    cout << "deq iteratror: " << tv_stop.tv_sec * 1000000.0 + tv_stop.tv_usec << endl;

    gettimeofday(&tv_start, NULL);
    for (int i = 0; i < MAXSIZE; ++i)
        tt = *deq[i];
    gettimeofday(&tv_stop, NULL);
    tv_sub(&tv_stop, &tv_start);
    cout << "deq operator[]: " << tv_stop.tv_sec * 1000000.0 + tv_stop.tv_usec << endl;
}

vector iterator:  31,718 μs

vector [ ]:            9,515 μs

deque iterator:  37,956 μs

deque [ ]:        132,348 μs

對vector遍歷最佳是用operator[]，deque則是用iterator更好。

 

 

另，關於多線程網上有人這樣說，覺得在概念上更清晰了：

標准C++里沒有線程這個概念，也不支持多線程

鎖會導致性能低下，實際工作中線程很少需要讀寫同一套數據，線程是用來解決io等待的；多線程能不能提高程序的性能很難說，如果問題本身就具有原子性，不能分割，多線程就沒有意義。

盡量減少線程的使用，盡量減小鎖的粒度。