二维数组动态分配中的分割错误

Question

这段代码在n=10,000上运行良好，但在内存为2 2GB的机器上运行在n=100,000上。在内存为1 1GB的机器上为n=10,000调用了kswap0，但立即显示了n=100,000的分段故障。

#include <stdio.h>
#include <time.h>
#include <stdlib.h>
int **createMatrix(int n)
{
    int **mat=(int**)malloc(n*sizeof(int*));
    int i;
    for(i=0;i<n;i++)
    {
        mat[i]=(int*)malloc(n*sizeof(int));
    }
    return mat;
}
void display(int **mat, int n)
{
    int i,j;
    for(i=0;i<n;i++)
    {
        for(j=0;j<n;j++)
        {
            printf("%d\t",mat[i][j]);
        }
        printf("\n");
    }
}
int main()
{
    int n=100000;
    int **matrixOne=createMatrix(n);
    int **matrixTwo=createMatrix(n);
    int **resultantMatrix=createMatrix(n);
    srand(time(NULL));
    int i,j;
    for(i=0;i<n;i++)
    {
        for(j=0;j<n;j++)
        {
            matrixOne[i][j]=rand()%10;
            matrixTwo[i][j]=rand()%10;
        }
    }
    display(matrixOne,n);
    display(matrixTwo,n);
    int k;
    for(i=0;i<n;i++)
    {
        for(j=0;j<n;j++)
        {
            for(k=0;k<n;k++)
            {
                resultantMatrix[i][j]+=matrixOne[i][k]*matrixTwo[k][j];
            }
        }
    }
    display(resultantMatrix,n);
    for(i=0;i<n;i++)
    {
        free(matrixOne[i]);
        free(matrixTwo[i]);
        free(resultantMatrix[i]);
    }

提前谢谢你！

Answer 1

int是4个字节。在createMatrix中，忽略第一个malloc，分配的是n*n* sizeof(int)字节。对于n=100,000，这是40,000,000,000字节，或大约40 GB。因为你这样做了3次，你需要大约120 GB的内存，而你没有。对于n= 10,000，您只需要大约1.2 GB (包括交换空间)。

正如前面提到的注释，您应该检查malloc的结果，以获得更清晰的错误信息，并避免seg错误。

Answer 2

我不能分配内存，因为矩阵对我的RAM来说太大了。每次检查malloc的结果

int **createMatrix(int n) {
    int **mat = NULL;
    int i;

    mat = malloc(n*sizeof(int*));
    if (mat == NULL) {
        exit(1);
    }
    for (i = 0; i<n; i++) {
        mat[i] = malloc(n*sizeof(int));
        if (mat[i] == NULL) {
            exit(2);
        }
    }
    return mat;
}

Answer 3

这种方法对于内存使用来说并不是最优的，因为您使用的RAM比所需的要多。您将创建一个矩阵作为数组的数组，因此对于您分配的每一行，您都有一个内存开销：

• 您分配的第一个一维数组不包含数据，而是包含指针。
• C运行时库将创建堆元数据

虽然这是一种很好的做法，因为您可以像编写静态2D数组一样编写Mi，但与传统的行主索引或列主索引的一维数组相比，您的分配(和分离)速度也要慢得多：

//allocation:
int * M = malloc(nCol * nRow * sizeof(int));

//access:
M[i + nRow*j] = data; // Column major
M[i*nCol + j] = data; // Row major

//deallocation:
free(M);

http://en.wikipedia.org/wiki/Row-major_order

最后，数据访问意味着双重引用，这可能比行主要索引或列主要索引慢。