本文小编为大家详细介绍“C++中vector和数组之间的转换及其效率问题怎么解决”，内容详细，步骤清晰，细节处理妥当，希望这篇“C++中vector和数组之间的转换及其效率问题怎么解决”文章能帮助大家解决疑惑，下面跟着小编的思路慢慢深入，一起来学习新知识吧。
众所周知，一维vector中的元素存储是顺序连续的，所以我们可以通过访问第一个元素的地址以及元素的数量来访问一系列的元素。因此，我们可以采取如下操作来对vector进行访问和转换：
先创造一个数组
int array_size = 1000; double **array = (double **)malloc(sizeof(double *) * array_size); for (int i = 0; i < array_size; i++) array[i] = (double *)malloc(sizeof(double) * array_size); for (int i = 0; i < array_size; i++) for (int j = 0; j < array_size; j++) array[i][j] = i * array_size + j;
// method1
vector<vector<double>> t(array_size, vector<double>(array_size));
for (int i = 0; i < array_size; i++)
{
// 直接定义一个一维的vector，其首地址为数组的起始地址，末尾地址为最后的地址。
t[i] = vector<double>(array[i], array[i] + array_size);
}// method2
vector<vector<double>> tt(array_size, vector<double>(array_size));
for (int i = 0; i < array_size; i++)
{
// 直接复制每一个值
for (int j = 0; j < array_size; j++)
tt[i][j] = array[i][j];
}vector<vector<double>> ttt(array_size, vector<double>(array_size));
for (int i = 0; i < array_size; i++)
{
// 直接使用memcpy进行复制
memcpy(&ttt[i][0], &array[i][0], array_size * sizeof(double));
}对于上述的三种方法，我简单的对其进行了效率测试，测试思路是每个都循环执行100遍，看每个方法所需要的时间，测试代码如下：
clock_t begin, end;
double cost;
begin = clock();
for (int x = 0; x < 100; x++)
{
vector<vector<double>> t(array_size, vector<double>(array_size));
for (int i = 0; i < array_size; i++)
{
t[i] = vector<double>(array[i], array[i] + array_size);
}
}
end = clock();
cost = (double)(end - begin) / CLOCKS_PER_SEC;
printf("method 1 cost: %lf secs\n", cost);
// method2
begin = clock();
for (int x = 0; x < 100; x++)
{
vector<vector<double>> tt(array_size, vector<double>(array_size));
for (int i = 0; i < array_size; i++)
{
for (int j = 0; j < array_size; j++)
tt[i][j] = array[i][j];
}
}
end = clock();
cost = (double)(end - begin) / CLOCKS_PER_SEC;
printf("method 2 cost: %lf secs\n", cost);
// method3
begin = clock();
for (int x = 0; x < 100; x++)
{
vector<vector<double>> ttt(array_size, vector<double>(array_size));
for (int i = 0; i < array_size; i++)
{
memcpy(&ttt[i][0], &array[i][0], array_size * sizeof(double));
}
}
end = clock();
cost = (double)(end - begin) / CLOCKS_PER_SEC;
printf("method 3 cost: %lf secs\n", cost);多次测试结果基本情况如下：
method 1 cost: 0.388440 secs
method 2 cost: 0.726254 secs
method 3 cost: 0.371002 secs
由此可见，第三种方法是最快的，不过和第一种方法差距不大，第二种方法是最差的，所需时间基本是其他两种方法的两倍。
和数组转换为vector的思路基本一致，因为一维的数组的存储也是连续随机存储的。
先创造一个vector：
int array_size = 1000;
vector<vector<double>> v(array_size, vector<double>(array_size, 0));
for (int i = 0; i < array_size; i++)
{
for (int j = 0; j < array_size; j++)
{
v[i][j] = i * array_size + j;
}
}double **array1 = (double **)malloc(sizeof(double *) * array_size);
// method1 因为vector存储是顺序且连续的，所以可以直接把指向数组每行首地址的地址指向vector每行的首地址
// 上面那句话有点绕，解释在最后
for (int i = 0; i < array_size; i++)
{
array1[i] = &v[i][0];
}double **array2 = (double **)malloc(sizeof(double *) * array_size);
// method2 直接复制每一个值
for (int i = 0; i < array_size; i++)
{
array2[i] = (double *)malloc(sizeof(double) * array_size);
for (int j = 0; j < array_size; j++)
{
array2[i][j] = v[i][j];
}
}double **array = (double **)malloc(sizeof(double *) * array_size);
for (int i = 0; i < array_size; i++)
{
// method3 使用memcpy来拷贝数组的元素
array[i] = (double *)malloc(sizeof(double) * array_size);
memcpy(array[i], &v[i][0], sizeof(double) * array_size);
}效率测试：因为每个方法的执行都是动态申请内存，而作为程序员一定要关注内存，所以每次malloc使用完之后需要free，但是如果按照最开始的方法，在同一个程序内每个执行100遍来测试时间的话，可能会导致因为程序执行到最后因为内存使用快满了而导致速度遍慢，于是，我们每个方法只是执行1遍（因为1遍的内存比较小），然后比较时间。
测试代码（注意，这里没有free，在正式使用的时候要记得free）：
clock_t begin, end;
double cost;
// method1
begin = clock();
double **array1 = (double **)malloc(sizeof(double *) * array_size);
for (int i = 0; i < array_size; i++)
{
array1[i] = &v[i][0];
}
end = clock();
cost += (double)(end - begin) / CLOCKS_PER_SEC;
printf("method 1 cost: %lf secs\n", cost);
// method2
begin = clock();
double **array2 = (double **)malloc(sizeof(double *) * array_size);
for (int i = 0; i < array_size; i++)
{
array2[i] = (double *)malloc(sizeof(double) * array_size);
for (int j = 0; j < array_size; j++)
{
array2[i][j] = v[i][j];
}
}
end = clock();
cost = (double)(end - begin) / CLOCKS_PER_SEC;
printf("method 2 cost: %lf secs\n", cost);
// method3
begin = clock();
double **array3 = (double **)malloc(sizeof(double *) * array_size);
for (int i = 0; i < array_size; i++)
{
array3[i] = (double *)malloc(sizeof(double) * array_size);
memcpy(array3[i], &v[i][0], sizeof(double) * array_size);
}
end = clock();
cost = (double)(end - begin) / CLOCKS_PER_SEC;
printf("method 3 cost: %lf secs\n", cost);多次测试结果大致如下：
method 1 cost: 0.000006 secs
method 2 cost: 0.007973 secs
method 3 cost: 0.003540 secs
由此可见第一种方法的速度最快，而且远远块于其他两种方法，第二种方法是第三种方法时间的两倍。
结论，直接赋值指针速度>使用memcpy>挨个赋值。
我们可以看到在上面vector转化为数组的中，第一种方法比其他快很多，其具体是怎么实现的呢，解释如下：
二维数组的声明有几种方法，下面介绍其中的一种方法：
// 声明一个指向指针的指针，有array_size个这样的指针。 double **array = (double **)malloc(sizeof(double *) * array_size); // 每个指向指针的指针指向一个一维数组的首地址，其一维数组的长度为array_size。 for (int i = 0; i < array_size; i++) array[i] = (double *)malloc(sizeof(double) * array_size);
如上图所示，array是指向指针的指针，其内容为array[0]的地址，而array[0]的内容为array[0][0]的地址，array[0][0]的内容即为每个元素的值。
第一种方法的解释
我们首先声明一个指向指针的指针，其长度为array_size，也就是说，有array_size个指针。
然后每个指针将其内容改为每行vector的首地址，这样就可以访问每个元素了。
读到这里，这篇“C++中vector和数组之间的转换及其效率问题怎么解决”文章已经介绍完毕，想要掌握这篇文章的知识点还需要大家自己动手实践使用过才能领会，如果想了解更多相关内容的文章，欢迎关注亿速云行业资讯频道。
免责声明：本站发布的内容（图片、视频和文字）以原创、转载和分享为主，文章观点不代表本网站立场，如果涉及侵权请联系站长邮箱：is@yisu.com进行举报，并提供相关证据，一经查实，将立刻删除涉嫌侵权内容。
