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

这篇具有很好参考价值的文章主要介绍了C++中vector和数组之间的转换及其效率问题。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

因为一些原因,本人遇到需要频繁把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);

C++中vector和数组之间的转换及其效率问题
如上图所示,array是指向指针的指针,其内容为array[0]的地址,而array[0]的内容为array[0][0]的地址,array[0][0]的内容即为每个元素的值。

第一种方法的解释

我们首先声明一个指向指针的指针,其长度为array_size,也就是说,有array_size个指针。
然后每个指针将其内容改为每行vector的首地址,这样就可以访问每个元素了。文章来源地址https://www.toymoban.com/news/detail-407881.html

到了这里,关于C++中vector和数组之间的转换及其效率问题的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • OpenCV - cv::Mat与unsigned char*数组或者float*数组相互转换,cv::Mat与std::vector的相互转换

    通常情况下,在同一个opencv项目传递cv::Mat可直接通过const cv::Mat img这种方式传递,但是如果需要进行跨语言传递,比如C++传递到C#或者C#传递到C++,那么通常这种情况下需要将cv::Mat转换为内存指针比如unsigned char指针或者float指针进行传递。 1.1 cv::Mat转换为unsigned char 数组、un

    2024年02月13日
    浏览(54)
  • C++——数组、多维数组、简单排序、模板类vector

    个人简介 👀 个人主页: 前端杂货铺 🙋‍♂️ 学习方向: 主攻前端方向,正逐渐往全干发展 📃 个人状态: 研发工程师,现效力于中国工业软件事业 🚀 人生格言: 积跬步至千里,积小流成江海 🥇 推荐学习:🍍前端面试宝典 🍉Vue2 🍋Vue3 🍓Vue2/3项目实战 🥝Node.js🍒

    2024年01月22日
    浏览(44)
  • C++ vector计算数组之和

        在C++ vector是一个动态数组,支持按下标索引访问、顺序访问、动态扩容等。计算vector里的元素之和,既可以通过for循环遍历每一个元素,然后相加得到数组之和;也可以通过调用accumulate()库函数,输入vector的起点、终点、参考原点(默认是0或者0.000),来得到数组之和;

    2024年01月22日
    浏览(34)
  • 正规文法、正规表达式、有限自动机及其之间的转换(笔记)

    The Equivalent Transforming among RG, RE and FA A Grammar G is a quadruple (四元组):G = (V N , V T , S, P ) Where, V N is a finite set of nonterminals. V T is a finite set of terminals. S is the start symbol, S ∈ in ∈ V N . P is a finite set of productions (产生式). Regular Grammar (RG) (正规文法): α∈V N and β ∈V T ∪V T V N Regular Exp

    2024年02月08日
    浏览(39)
  • java byte数组与int之间相互转换

    运算符 含义 说明 与 对应位都是1,结果为1,否则为0 | 或 对应位都是0,结果为0,否则为1 ~ 取反 每一位变相反位,即0变成1,1变成0 ^ 异或 对应位值相同,结果为0,否则为1 左移位 低位补0 右移位 保留符号位,0为正,1为负 无符号右移位 高位补0 位逻辑运算示例 A B AB A|B

    2024年04月14日
    浏览(57)
  • Java中List与数组之间的相互转换

    List列表中存储对象,如 ListInteger 、 ListString 、 ListPerson ,对象数组中同样存储相应的对象,如Integer[]、String[]、Person[],对象数组与对象List的转换可通过如下方式实现: (一)对象List转对象数组 1、toArray()方法 直接调用对象List的toArray()方法转换为对象数组,该方法的参数是

    2024年02月16日
    浏览(47)
  • 动态数组和C++ std::vector详解

    std::vector 是C++的默认动态数组,其与array最大的区别在于vector的数组是动态的,即其大小可以在运行时更改。 std::vector 是封装动态数组的顺序容器,且该容器中元素的存取是连续的。 vector的存储是自动管理,不需要人为操作自动实现按需扩张收缩。但实现自动管理的代价就是

    2024年02月13日
    浏览(66)
  • Java中字符串与byte数组之间的转换方法

    在Java编程中,我们常常需要对字符串和byte数组进行转换。字符串一般是用来表示文本信息,而byte数组则是用来表示二进制数据,如图片、音频等。本文将详细介绍Java中字符串和byte数组之间的转换方法,包括将字符串转换为byte数组和将byte数组转换为字符串。 Java中字符串与

    2024年02月09日
    浏览(47)
  • 【C++】学习C++STL中的数组——vector

            好久不见大家!今天的这篇博客是关于我对于STL(C++标准模板库)中的容器vector的学习和理解,希望大家能够喜欢。          vector是STL中的一种序列容器,对应着数据结构中的顺序表,也可以说是数组。在我们正式学习了解vector之前,我们先看看C++官网对其的文档介

    2024年02月10日
    浏览(38)
  • 每日一道面试题之如何实现数组和 List 之间的转换?

    要实现数组和List之间的转换,可以使用Java中的 Arrays类 和 Collections类 提供的方法。 数组转换为List: 使用 Arrays类 的 asList()方法 可以 将数组转换为List 。这个方法接受一个数组作为参数,并返回一个包含数组元素固定大小的List。 举例: 输出如下所示: List转换为数组: 使

    2024年02月16日
    浏览(31)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包