用c分配整数矩阵

我有一个整数2d矩阵NUMI和一个叫做

PROB

的3d双矩阵

以下是2个分配：

   int main ( int argc, char* argv[]){
        double  ***PROB;
        int  **NUMI;    
        NUMI = (int **)malloc((dim)*sizeof(int *));
        PROB = (double ***)malloc((dim)*sizeof(double**));
        ...    
        for( i = 0; i < n ; i++){
            PROB[ACT][ACTSTART][i] = value;
            NUMI[i][i]= value2;
        }


}

intmain（intargc，char*argv[]）{
双***问题；
国际**努米；
NUMI=（int**）malloc（（dim）*sizeof（int*）；
PROB=（双***）malloc（（dim）*sizeof（双***））；
...    
对于（i=0；i

• 有多少行和列具有

  NUMI

  ？是否为

  尺寸x尺寸矩阵

• PROB

  是一个3d矩阵……这里的分配是

  dim x dim x dim

NUMI

“是指向

int

的指针数组。

PROB

“是指向

double

的指针的

l+1

指针数组

这更接近您想要的：

#include <cstdlib>

int main( int argc, char* argv[] )
{
    size_t dim = 100;

    int **NUMI = (int **)malloc( dim * sizeof(int*) );
    for( size_t i = 0; i < dim; ++i )
        NUMI[i] = (int*)malloc( dim * sizeof(int) );

    double*** PROB = (double ***)malloc( dim * sizeof(double**) );
    for( size_t i = 0; i < dim; ++i )
    {
        PROB[i] = (double**)malloc( dim * sizeof(double*) );
        for( size_t j = 0; j < dim; ++j )
            PROB[i][j] = (double*)malloc( dim * sizeof(double) );
    }
    /// ...
    size_t ACT = 0, ACTSTART = 0;
    for( size_t i = 0 ; i < dim; i++ )
    {
        PROB[ACT][ACTSTART][i] = 1;
        NUMI[i][i] = 2;
    }
}

#包括
int main（int argc，char*argv[]）
{
尺寸尺寸=100；
int**NUMI=（int**）malloc（dim*sizeof（int*）；
用于（尺寸i=0；i

int main（）{
int**p；
int m=4，n=4，i；
/*分配内存*/
p=（int*）malloc（sizeof（int*）*m）；/*行指针*/
对于（i=0；i

---

这将动态分配大小为[4][4]的数组。同样，也可以为三维数组分配内存。

您应该为每个维度分配内存：

NUMI = (int **)malloc((dim)*sizeof(int *));
for (i = 0; i < dim; i++)
    NUMI[i] = (int*)malloc(dim * sizeof(int));

PROB = (double ***)malloc((dim)*sizeof(double**));
for (i = 0; i < dim; i++)
{
    int j;
    PROB[i] = (double**)malloc(dim* sizeof(double*));
    for (j = 0; j < dim; j++)
    {
        PROB[i][j] = (double*)malloc(dim * sizeof(double));
    }
}

NUMI=（int**）malloc（（dim）*sizeof（int*）；
对于（i=0；i

NUMI没有行和列，它是指向int的指针，恰好指向一个分配的内存，该内存有空间容纳指向int的

dim

指针，而不是

dim*dim

int。这相当于将其视为已声明的

int*NUMI[dim]

电话

int* NUMI;
NUMI= malloc( dim*dim*sizeof(int) );

将通过

dim

整数矩阵分配

dim

但是，请注意，对于多维数组，例如

int-example[a][b]

，分配区域的大小相当于

int*example\uuu=malloc（a*b*sizeof（int））

，编译器完成从多维索引到一维索引的转换，即

example[c][d]

->

示例_[c*a+d]

所以当你这么做的时候

int* NUMI;
NUMI= malloc( dim*dim*sizeof(int) );
//...
NUMI[i][i]= value2;

编译器没有从多维转换为等效的一维所需的信息

PROB与此类似，指向一个内存区域，该区域有空间容纳

dim

指针，指向指向double的指针，而不是

dim*dim*dim

double。 要获得一个

dim

立方矩阵，您需要

double  *PROB;
PROB = (double *)malloc( dim*dim*dim*sizeof(double) );

在多维索引中也会遇到同样的问题

如果dim是编译时常量，则可以直接声明多维数组，而无需malloc

double PROB[dim][dim][dim];
int    NUMI[dim][dim];

main（）末尾的循环现在应该按预期工作

如果必须使用malloc，请按照上述说明使用malloc：

NUMI= (int *)    malloc( dim*dim*sizeof(int) );
PROB = (double *)malloc( dim*dim*dim*sizeof(double) );

并将循环体修改为

PROB[(ACT * dim * dim) + (ACTSTART * dim ) + i] = value;
NUMI[i + dim * i]= value2;

或者，如Alexey和Paolo所述，在多个循环中调用malloc。

---

在我的解决方案中，每个变量有一个

malloc（）

调用，因此每个变量都引用一个连续的内存区域在循环中调用时，您有多个分配的内存区域，这些区域不太可能是连续的。

而且所有大写名称通常都是用于宏的。并且在C中不会强制转换

malloc

等的返回值。我知道，但这不是我的代码什么是

n

？在

部分有什么？您的代码不完整。不要使用2D或者C中的3D矩阵。使用1D数组和一些访问器（例如
#定义ELEM_2D（Mat，Width，I，J）（Mat）[（I）*（Width）+（J）]
…）是的，除非您需要“参差不齐”的行（不同的长度），否则使用成堆的指针分配多维数组会导致极度混乱和更大的内存泄漏可能性。
PROB[(ACT * dim * dim) + (ACTSTART * dim ) + i] = value;
NUMI[i + dim * i]= value2;