二維數組動態分配中的分割錯誤

Question

此代碼在n = 10,000的情況下可以正常工作，但在具有2GB內存的計算機上可以達到n = 100,000。 在內存為1GB的計算機上，調用kswap0的n = 10,000，但立即顯示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的RAM，而您沒有。 對於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。 您將矩陣創建為數組數組，因此，為您分配的每一行都有內存開銷：

• 您分配的第一個1D數組不包含數據，而是包含指針。
• C運行時庫將創建堆元數據

雖然這很不錯，因為您可以像靜態2D數組一樣編寫M [i] [j]，但與具有行主索引或列主索引的傳統1D數組相比，分配（和取消分配）的速度也要慢得多：

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

最后，數據訪問意味着雙重取消引用，這可能比主要行索引或主要列索引的速度慢。