Question

我有一个整数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;
        }


}

NUMI有多少行和列？是dim x dim matrix ???
PROB是一个3d矩阵......这里的分配是dim x dim x dim？

Answer 1

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

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

Answer 2

NUMI没有行和列，它是指针指向int的指针，恰好指向一个分配的内存，它有dim指针到int的空间，而不是{ {1}}整数。这相当于将其视为已声明为dim * dim

致电

int* NUMI[dim]

将按int* NUMI; NUMI= malloc( dim*dim*sizeof(int) );整数矩阵分配dim。

但是，请注意，对于多维数组，比如说dim，分配区域的大小等于int example[a][b]，并且编译器计算出从多维索引转换为单个 - 维度索引，即int* example_ = malloc(a*b*sizeof(int)) - ＆gt; example[c][d]

所以当你这样做时

example_[c*a+d]

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

PROB类似，指向一个内存区域，int* NUMI; NUMI= malloc( dim*dim*sizeof(int) ); //... NUMI[i][i]= value2;指针指向双倍，而不是dim双倍。要获得dim * dim * dim立方矩阵，您需要

dim

并遇到与多维索引相同的问题。

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

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

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

如果必须使用malloc，请使用malloc，如上所述：

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

并将循环体修改为

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

或者，如Alexey和Paolo所述，在多个循环中调用malloc。使用我的解决方案，每个变量有一个PROB[(ACT * dim * dim) + (ACTSTART * dim ) + i] = value; NUMI[i + dim * i]= value2;调用，因此每个变量都指向一个连续的内存区域。在循环中有多个malloc()调用，您有多个分配的内存区域，这些区域不太可能是连续的。

Answer 3

NUMI“是l+1指向int的指针数组。 PROB“是l+1指向double的指针数组。

这更接近您的期望：

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

Answer 4

int main() {
int **p;
int m=4,n=4,i;

/* Allocate memory */
p = (int *) malloc(sizeof(int *) * m); /* Row pointers */
for(i = 0; i < m; i++) 
 {
      p[i] = (int) malloc(sizeof(int) * n); /* Rows */
 }

这将动态分配大小为[4] [4]的数组。类似地，可以为3-D阵列分配。

用c分配整数矩阵

4 个答案: