首页 > 软件编程 > C语言 > C++中vector和数组之间的转换及其效率问题详解

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

福牛 3月 30, 2023 41 0

因为一些原因，本人遇到需要频繁把vector与数组之间转换的情况，于是就分析了一下两个之间转换的实施以及相关的效率问题。

数组转换为vector

众所周知，一维vector中的元素存储是顺序连续的，所以我们可以通过访问第一个元素的地址以及元素的数量来访问一系列的元素。因此，我们可以采取如下操作来对vector进行访问和转换：

先创造一个数组

  1. int array_size = 1000;
  2. double **array = (double **)malloc(sizeof(double *) * array_size);
  3. for (int i = 0; i < array_size; i++)
  4.      array[i] = (double *)malloc(sizeof(double) * array_size);
  5.  
  6. for (int i = 0; i < array_size; i++)
  7.      for (int j = 0; j < array_size; j++)
  8.          array[i][j] = i * array_size + j;

method1

  1. // method1
  2. vector<vector<double>> t(array_size, vector<double>(array_size));
  3. for (int i = 0; i < array_size; i++)
  4. {
  5.      // 直接定义一个一维的vector，其首地址为数组的起始地址，末尾地址为最后的地址。
  6.      t[i] = vector<double>(array[i], array[i] + array_size);
  7. }

method2

  1. // method2
  2. vector<vector<double>> tt(array_size, vector<double>(array_size));
  3. for (int i = 0; i < array_size; i++)
  4. {
  5.      // 直接复制每一个值
  6.      for (int j = 0; j < array_size; j++)
  7.          tt[i][j] = array[i][j];
  8. }

method3

  1. vector<vector<double>> ttt(array_size, vector<double>(array_size));
  2. for (int i = 0; i < array_size; i++)
  3. {
  4.      // 直接使用memcpy进行复制
  5.      memcpy(&ttt[i][0], &array[i][0], array_size * sizeof(double));
  6. }

对于上述的三种方法，我简单的对其进行了效率测试，测试思路是每个都循环执行100遍，看每个方法所需要的时间，测试代码如下：

  1. clock_t begin, end;
  2. double cost;
  3. begin = clock();
  4. for (int x = 0; x < 100; x++)
  5. {
  6.      vector<vector<double>> t(array_size, vector<double>(array_size));
  7.      for (int i = 0; i < array_size; i++)
  8.      {
  9.          t[i] = vector<double>(array[i], array[i] + array_size);
  10.      }
  11. }
  12. end = clock();
  13. cost = (double)(end – begin) / CLOCKS_PER_SEC;
  14. printf(“method 1 cost: %lf secs\n”, cost);
  15.  
  16. // method2
  17. begin = clock();
  18. for (int x = 0; x < 100; x++)
  19. {
  20.      vector<vector<double>> tt(array_size, vector<double>(array_size));
  21.      for (int i = 0; i < array_size; i++)
  22.      {
  23.          for (int j = 0; j < array_size; j++)
  24.              tt[i][j] = array[i][j];
  25.      }
  26. }
  27. end = clock();
  28. cost = (double)(end – begin) / CLOCKS_PER_SEC;
  29. printf(“method 2 cost: %lf secs\n”, cost);
  30.  
  31. // method3
  32. begin = clock();
  33. for (int x = 0; x < 100; x++)
  34. {
  35.      vector<vector<double>> ttt(array_size, vector<double>(array_size));
  36.      for (int i = 0; i < array_size; i++)
  37.      {
  38.          memcpy(&ttt[i][0], &array[i][0], array_size * sizeof(double));
  39.      }
  40. }
  41. end = clock();
  42. cost = (double)(end – begin) / CLOCKS_PER_SEC;
  43. 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：

  1.      int array_size = 1000;
  2.      vector<vector<double>> v(array_size, vector<double>(array_size, 0));
  3.      for (int i = 0; i < array_size; i++)
  4.      {
  5.          for (int j = 0; j < array_size; j++)
  6.          {
  7.              v[i][j] = i * array_size + j;
  8.          }
  9.      }

method1

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

method2

  1. double **array2 = (double **)malloc(sizeof(double *) * array_size);
  2. // method2 直接复制每一个值
  3. for (int i = 0; i < array_size; i++)
  4. {
  5.      array2[i] = (double *)malloc(sizeof(double) * array_size);
  6.      for (int j = 0; j < array_size; j++)
  7.      {
  8.          array2[i][j] = v[i][j];
  9.      }
  10. }

method3

  1. double **array = (double **)malloc(sizeof(double *) * array_size);
  2. for (int i = 0; i < array_size; i++)
  3. {
  4.      // method3 使用memcpy来拷贝数组的元素
  5.      array[i] = (double *)malloc(sizeof(double) * array_size);
  6.      memcpy(array[i], &v[i][0], sizeof(double) * array_size);
  7. }

效率测试：因为每个方法的执行都是动态申请内存，而作为程序员一定要关注内存，所以每次malloc使用完之后需要free，但是如果按照最开始的方法，在同一个程序内每个执行100遍来测试时间的话，可能会导致因为程序执行到最后因为内存使用快满了而导致速度遍慢，于是，我们每个方法只是执行1遍（因为1遍的内存比较小），然后比较时间。

测试代码（注意，这里没有free，在正式使用的时候要记得free）：

  1. clock_t begin, end;
  2. double cost;
  3.  
  4. // method1
  5. begin = clock();
  6. double **array1 = (double **)malloc(sizeof(double *) * array_size);
  7. for (int i = 0; i < array_size; i++)
  8. {
  9.      array1[i] = &v[i][0];
  10. }
  11. end = clock();
  12. cost += (double)(end – begin) / CLOCKS_PER_SEC;
  13. printf(“method 1 cost: %lf secs\n”, cost);
  14.  
  15. // method2
  16. begin = clock();
  17. double **array2 = (double **)malloc(sizeof(double *) * array_size);
  18. for (int i = 0; i < array_size; i++)
  19. {
  20.      array2[i] = (double *)malloc(sizeof(double) * array_size);
  21.      for (int j = 0; j < array_size; j++)
  22.      {
  23.          array2[i][j] = v[i][j];
  24.      }
  25. }
  26. end = clock();
  27. cost = (double)(end – begin) / CLOCKS_PER_SEC;
  28. printf(“method 2 cost: %lf secs\n”, cost);
  29.  
  30. // method3
  31. begin = clock();
  32. double **array3 = (double **)malloc(sizeof(double *) * array_size);
  33. for (int i = 0; i < array_size; i++)
  34. {
  35.      array3[i] = (double *)malloc(sizeof(double) * array_size);
  36.      memcpy(array3[i], &v[i][0], sizeof(double) * array_size);
  37. }
  38. end = clock();
  39. cost = (double)(end – begin) / CLOCKS_PER_SEC;
  40. 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转化为数组的中，第一种方法比其他快很多，其具体是怎么实现的呢，解释如下：

二维数组的声明

二维数组的声明有几种方法，下面介绍其中的一种方法：

  1. // 声明一个指向指针的指针，有array_size个这样的指针。
  2. double **array = (double **)malloc(sizeof(double *) * array_size);
  3. // 每个指向指针的指针指向一个一维数组的首地址，其一维数组的长度为array_size。
  4. for (int i = 0; i < array_size; i++)
  5.      array[i] = (double *)malloc(sizeof(double) * array_size);

-1

如上图所示，array是指向指针的指针，其内容为array[0]的地址，而array[0]的内容为array[0][0]的地址，array[0][0]的内容即为每个元素的值。

第一种方法的解释

我们首先声明一个指向指针的指针，其长度为array_size，也就是说，有array_size个指针。

然后每个指针将其内容改为每行vector的首地址，这样就可以访问每个元素了。

总结

到此这篇关于C++中vector和数组之间的转换及其效率问题的文章就介绍到这了,更多相关C++中vector和数组转换内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！

标签

相关推荐

发表评论