C 二维阵列动态分配中的分段错误

该代码在n=10000时运行良好，但在具有2GB ram的机器上，n=100000时运行良好。 在内存为1GB的机器上，调用kswap0表示n=10000，但立即显示n=100000的分段错误

#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]);
    }

#包括
#包括
#包括
int**createMatrix（int n）
{
int**mat=（int**）malloc（n*sizeof（int*）；
int i；
对于（i=0；i而言，int是4个字节。在createMatrix中，忽略第一个malloc，您将分配n*n*sizeof（int）字节。对于n=100000，这是40000000000字节，或大约40 GB。由于您执行了3次，您将需要大约120 GB的RAM，而您没有。对于n=10000，您只需要大约1.2 GB，而您确实有（包括交换空间）

正如前面提到的注释，您应该检查malloc的结果，以获得更清晰的错误消息，并避免seg故障。
我无法分配内存，因为矩阵对于我的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;
}

int**createMatrix（int n）{
int**mat=NULL；
int i；
mat=malloc（n*sizeof（int*）；
如果（mat==NULL）{
出口（1）；
}
对于（i=0；i来说，这种方法对于内存的使用不是最佳的，因为您使用的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);


最后，数据访问意味着双重取消引用，这可能比行主索引或列主索引慢。
提示：您需要检查
malloc
的结果。一旦内存用完，
malloc
开始返回
NULL
。顺便说一句，需要初始化，例如
resultantMatrix[i][j]=0；
如果您的装备可以（a）分配这么多的内存，然后（b）在一段时间内完成一个PRNG（我想他的周期要短得多），这段时间不允许你转动轮胎和油漆房子，我想要你的硬件。