C++中vector和数组之间的转换及其效率问题详解

更新时间：2023年03月30日 11:29:30 作者：renshy5

c++ vector转数组是一种将vector容器的元素转换为数组的方法,主要能帮助提高程序的性能和效率,下面这篇文章主要给大家介绍了关于C++中vector和数组之间的转换及其效率问题的相关资料,需要的朋友可以参考下

数组转换为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

// 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

// 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];
}

method3

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的思路基本一致，因为一维的数组的存储也是连续随机存储的。

先创造一个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;
        }
    }

method1

double **array1 = (double **)malloc(sizeof(double *) * array_size);
// method1 因为vector存储是顺序且连续的，所以可以直接把指向数组每行首地址的地址指向vector每行的首地址
// 上面那句话有点绕，解释在最后
for (int i = 0; i < array_size; i++)
{
    array1[i] = &v[i][0];
}

method2

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];
    }
}

method3

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和数组之间的转换及其效率问题的文章就介绍到这了,更多相关C++中vector和数组转换内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

C++ vector与数组转换写入/读出文件方式

C++实现CreatThread函数主线程与工作线程交互的方法
这篇文章主要介绍了C++实现CreatThread函数主线程与工作线程交互的方法,是Windows应用程序设计中非常实用的方法,需要的朋友可以参考下
2014-10-10
$快速入门的一些C\C++书籍$
快速入门的一些C\C++书籍
这篇文章为大家精心推荐了一些快速入门的一些C\C++书籍，希望大家可以喜欢，对这门语言可以产生兴趣，需要的朋友可以参考下
2015-12-12
C/C++ Qt TableDelegate 自定义代理组件使用详解
TableDelegate自定义代理组件的主要作用是对原有表格进行调整，本文主要介绍了QT中TableDelegate 自定义代理组件的使用教程，感兴趣的朋友可以了解一下
2021-12-12
C++实现LeetCode(138.拷贝带有随机指针的链表)
这篇文章主要介绍了C++实现LeetCode(138.拷贝带有随机指针的链表),本篇文章通过简要的案例,讲解了该项技术的了解与使用,以下就是详细内容,需要的朋友可以参考下
2021-07-07
详解C++的反调试技术与绕过手法
反调试技术，恶意代码会用它识别自身是否被调试，或者让调试器失效，给反病毒工程师们制造麻烦，拉长提取特征码的时间线，本章将具体总结常见的反调试基础的实现原理以及如何过掉这些反调试手段，从而让我们能够继续分析恶意代码
2021-06-06
C++中VTK9.3.0刻度标签重叠的问题记录
这篇文章主要介绍了C++中VTK9.3.0刻度标签重叠的问题,本文采用VTK9.3.0版本,其他版本如VKT8.0亦有同样的问题,需要的朋友可以参考下
2024-06-06
VC小技巧汇总之对话框技巧
这篇文章主要介绍了VC小技巧汇总之对话框技巧,非常实用！对于进行VC开发有一定的参考借鉴价值,需要的朋友可以参考下
2014-07-07
VSCode插件开发全攻略之package.json详解
这篇文章主要介绍了VSCode插件开发全攻略之package.json的相关知识，本文给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
2020-05-05
QTimer与QTime实现电子时钟
这篇文章主要为大家详细介绍了QTimer与QTime实现电子时钟，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
2019-07-07
深入分析C++中deque的使用
本篇文章介绍了，深入分析C++中deque的使用。需要的朋友参考下
2013-05-05