用 c 分配整数矩阵

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 "is" 指向 int 的 l+1 指针数组。 PROB "is" 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 2

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 数组分配。

Answer 3

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

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 4

NUMI 没有行和列，它是一个指向整数的指针，恰好指向一个分配的内存，该内存有空间容纳 dim 个指向整数的指针，不是 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))，并且编译器计算出从多维索引到单维索引，即 example[c][d] -> example_[c*a+d]

所以当你这样做时

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

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

PROB 类似，指向一个内存区域，该内存区域有 dim 个指向双精度指针的空间，而不是 dim * dim * dim 个双精度空间。要获得 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() 调用，因此每个变量都引用一个连续的内存区域。在循环中有多个 malloc() 调用，你有多个分配的内存区域不太可能是连续的。

用 c 分配整数矩阵

Allocate matrix of integer with c

c

malloc

matrix