vector效率低于c数组好几倍，为什么

[gunnardeng]

我这段代码运行，NEH_EvaluateP7函数中使用c数组 int Depart[500][21]程序运行只要4s多时间，可如果使用vector的话，需要18s多CPU时间，为什么二者相差这么大？有没有高人解释下。另怎么用vector定义Depart，使得程序也只需要数秒钟实现。
#include <vector>
#include <ctime>
#include <iomanip>
#include <iostream>
using namespace std;

struct individual//实际编码结构
{
vector <int> permutation;
int value;
};

const int product=500;
const int machine=20;

vector< vector<int> > Time(500,vector<int> (20));

int NEH_EvaluateP7(vector<int>& A, int size);
void NEH(individual& ind);

int main()
{
int i;
individual temp_individual;
vector <int> CC(product);
for(i=0;i<product;++i)
CC[i]=i+1;
temp_individual.permutation=CC;
clock_t start,finish;//计算程序开始结束时间
double totaltime;
start=clock();
NEH(temp_individual);
finish=clock();
totaltime=static_cast <double>(finish-start)/CLOCKS_PER_SEC;
cout<<showpoint<<fixed<<setprecision(6)<<totaltime<<" sec"<<endl;
return 0;
}
int NEH_EvaluateP7(vector<int>& A, int size)
{
int i,j;
int cmax;
int Depart[500][21];
//vector< vector<int> > Depart(500,vector<int> (21));
Depart[0][0]=0;
for(i=1;i<=machine;i++)
Depart[0][i]=Depart[0][i-1]+Time.at(A[0]-1).at(i-1);
for(i=1;i<size;i++)
{
Depart[i][0]=Depart[i-1][1];
for(j=1;j<machine;j++)
Depart[i][j]=max(Depart[i][j-1]+Time.at(A[i]-1).at(j-1),Depart[i-1][j+1]);
Depart[i][machine]=Depart[i][machine-1]+Time.at(A[i]-1).at(machine-1);
}
cmax=Depart[size-1][machine];
for(i=0;i<size-1;i++)
cmax+=Depart[i][machine];
return cmax;
}

void NEH(individual& ind)
{
int i,j,k;
int cmax,cmax2;
vector<int> B(product),C(product),D(product);
B[0]=ind.permutation.at(0);
B[1]=ind.permutation.at(1);
C[0]=ind.permutation.at(1);
C[1]=ind.permutation.at(0);
if( NEH_EvaluateP7(B,2)>NEH_EvaluateP7(C,2) )
{
B=C;
}
for(i=2;i<product;i++)
{
D=B;
cmax=100000000;
for(j=0;j<=i;j++)
{
C=D;
for(k=i;k>j;k--)
C[k]=C[k-1];
C[j]=ind.permutation.at(i);
cmax2=NEH_EvaluateP7(C,i+1);
if( cmax>=cmax2 )
{
B=C;
cmax=cmax2;
}
}
}
ind.permutation=B;
ind.value=cmax;
}

[RLib]

大量的构造和虚构是难以避免的

[庄鱼]

如果图方便，你就用vector，避免许多指针操作。
如果图效率，那就用指针，那样也灵活。
用指针，数学基础要好，否则，你会在指针、数组对应之间犯错误，但是熟悉了，你会更喜欢用指针而不是用模板，毕竟临时起意的东西太多，合适的模板去记忆、查找起来太麻烦。于是，你会发现C++虽然为你提供了大量的方便工具，但最后用到项目上的总是很少一部分，相反，有关界面的对象控件倒是经常浸淫的重点。

[gl378591432]

二维数组跟一维好像没什么区别吧！为什么不能认为二维数组就是特殊的一维呢
[Quote=引用 5 楼 gunnardeng 的回复:]
引用 3 楼 nice_cxf 的回复:

首先要用reverse先分配，
然后不要用vector嵌套
谢谢指点，不使用vector嵌套的话，我怎么实现二维的数组呢，其实这个二维数组的大小应该是动态变化的，C数组不太方便啊，再给我指点指点
[/Quote]

[zhyuzhyu]

一般vector慢的原因都是因为存在自增长时的拷贝，预先reverse足够大的空间就可以了，函数开销影响不大。

[前行]

好用必然牺牲效率

[Tim_Chase]

先reverse会增加效率

[elegant87]

vector是连续分配的
嵌套调用效率低
看看vector的源代码

[「已注销」]

效率不是问题！
维护才是问题。

[mosal]

想用vector就预分配足够大的，这样会快不少！

[SuperLy]

vector本身效率还是很高的（前提是设置好相关编译参数，至少vs2005下的默认Release是不行的，会直接导致数倍甚至超过一个数量级的效率影响），当然，函数执行效率肯定受压栈等影响，不如直接赋值；
关键是vector未处理多线程，所以如果有多线程下的数据读写，要注意，在添加数据的时候，可能会导致整个vector空间重新分配而瞬间失效。

[mayjojo]

慢的原因是数据存储的局部性问题（data locality）:

1) 使用二位数组Depart[500][21]的时候，所有数据在内存中是连续存放的。访问内存时，内存访问的局部性较强，Cache命中的概率较大。L1 Cache访问延迟只有几个指令周期，而内存访问延迟则达到几百个指令周期。

2）Vector中的数据是连续存放的，但是Vector本身只保存指向数据块的指针。Vector建立在栈上，保存数据的数据块在堆上。因此二位动态数组Vector <Vector<int>>中，指向行的所有指针是连续存放的。每个行的数据是连续存放的，但是行与行之间是不连续存放的。因此跨行访问时局部性降低，Cache命中率下降。所以用时间更多。

改进方案。提升数据局部性：
typedef int line[21];
Vector<line> Depart;

参考书籍：《深入理解计算机系统》

[mayjojo]

[Quote=引用 6 楼 baichi4141 的回复:]

再简单不过的道理
因为vertor的功能比数组要强，所以它的效率比数组要低
[/Quote]

向量容器的中元素的引用都使用了内联函数，并且向量容器中数据的内存布局和数组是一样的。因此对向量容器的访问与对数组的访问从性能上来讲没有差别。

差别在于向量容器的的容量可以动态扩展，因此不正确使用可能导致性能问题。但只出现在向容器中插入数据时，使用reverse可以很好的克服。自己维护的动态数组同样存在这个问题。

C++编程时应避免使用数组，尽量使用向量替代。

[lanzhengpeng2]

我严重怀疑是用的Debug版本测试的.因为Release版的vector差别没有那么大,即便是嵌套的.
另外,楼主不会用一维模拟二维:
int a[100][200];
int b[100*200];
a[x][y] 等价于 b[x * 200 + y];
同理
vector c(100 * 200)
a[x][y] 等价于 c[x * 200 + y];

[tanwenhai123]

看不懂。。。。。。。。。。。

[asdss]

[Quote=引用 37 楼 的回复:]

慢的原因是数据存储的局部性问题（data locality）:

1) 使用二位数组Depart[500][21]的时候，所有数据在内存中是连续存放的。访问内存时，内存访问的局部性较强，Cache命中的概率较大。L1 Cache访问延迟只有几个指令周期，而内存访问延迟则达到几百个指令周期。

2）Vector中的数据是连续存放的，但是Vector本身只保存指向数据块的指针。Vector建……
[/Quote]

37楼38楼解释的很到位

[Saingel]

需要的时候才用vector，
但别太依赖，因为stl支持跨动态库能力比较差，动态库之间一般用数组

[赵4老师]

//在堆中开辟一个4×5的二维int数组
#include <stdio.h>
#include <malloc.h>
int **p;
int i,j;
void main() {
    p=(int **)malloc(4*sizeof(int *));
    if (NULL==p) return;
    for (i=0;i<4;i++) {
        p[i]=(int *)malloc(5*sizeof(int));
        if (NULL==p[i]) return;
    }
    for (i=0;i<4;i++) {
        for (j=0;j<5;j++) {
            p[i][j]=i*5+j;
        }
    }
    for (i=0;i<4;i++) {
        for (j=0;j<5;j++) {
            printf(" %2d",p[i][j]);
        }
        printf("\n");
    }
    for (i=0;i<4;i++) {
        free(p[i]);
    }
    free(p);
}
//  0  1  2  3  4
//  5  6  7  8  9
// 10 11 12 13 14
// 15 16 17 18 19

[darkread]

一个是静态的，一个是动态的，能不慢么。
vector你添加100个元素，他到5个，他会new一个10个元素的空间，然后copy原来元素过去，然后销毁原来元素。这能不慢么。

[MagiSu]

大哥们

是

RESERVE

不是
REVERSE

[lirunfa]

先查查vector的原理，明白reverse的好处
stl的容器是为了提高开发效率，功能强大运行效率上当然不如普通的数组，因为功能强大要附带很多预防出错的检测代码等等。