Question

我有以下代码用于分配二维数组

#include <iostream>
using namespace std;
int **malloc2d(int r,int c){
    int **t=new int*[r];
     for (int i=0;i<r;i++)
         t[i]=new int[c];

      for (int i=0;i<r;i++){
           for (int j=0;j<c;j++){
                t[i][j]=i+j;
           }
      }
     return t;
     }

int main(){
    int m=10;
    int n=10;
    int **a=malloc2d(m,n);
     for (int i=0;i<m;i++){
          for (int j=0;j<n;j++){

              cout<<a[i][j]<< " ";
              cout<< " \n";
          }
          cout<< " \n";
     }


    return 0;


}

它有效但我的问题是：根据性能效率或代码速度，这段代码有多好？感谢

Answer 1

对于int **，你有很多指向微小（4字节）内存空间的指针，由于malloc开销而效率低下（每个malloc实现都有开销，最小通常是sizeof(void*) AFAIK，其中你的情况意味着所有“细胞”至少有100％的开销。）

作为替代方案，您可以使用一维数组并自行计算索引：index = (row * num_columns) + column。但是，你会丢失漂亮的a[row][column]符号。尽管如此，访问它应该更快，因为在你的（干净）解决方案中必须有两个指针解引用（内存操作），而我建议你只有一个。它看起来像这样：

#include <iostream>

using namespace std;

inline int a_index(int row, int column, int column_size) {
        return((row * column_size) + column);
}

int *malloc2d(int r,int c) {
        int *t=new int[r * c];
        for (int i=0;i<r;i++){
                for (int j=0;j<c;j++){
                        t[a_index(i,j,c)]=i+j;
                }
        }
        return t;
}


int main(){
        int m=10;
        int n=10;
        int *a=malloc2d(m, n);
        for (int i=0;i<m;i++){
                for (int j=0;j<n;j++){
                        cout<<a[a_index(i,j,n)]<< " ";
                        cout<< " \n";
                }
                cout<< " \n";
        }

        return 0;
}

Answer 2

我假设您计划添加delete[]，或者程序将在泄漏事件发生之前终止。

无论如何，效率不高。

首先，数组将由非连续的内存块组成。这使得机器的内存子系统难以处理。

其次，浪费了一些额外的空间来保存指针数组。

用老式的方式做吧：

int *a = new int[ r * c ];

或vector

std::vector<int> a( r * c );

并一如既往地计算索引：

cout << a[ i * c + j ] << ' ';

但是，由于您循环遍历整个数组，因此可以忽略格式化之外的二维性：

for ( int i = 0; i < r * c; ++ i ) {
    cout << a[ i ] << ' ';
    if ( i % c == c-1 ) cout << '\n';
}

Answer 3

如果不删除使用new分配的内存，则会泄漏内存。

二维数组分配

3 个答案: