使用数组指针的动态内存分配

Question

如何为数组指针动态分配内存？(*p)[4]

int main()
{
    int (*p)[4];
    int i;
    for (i=0;i<4;i++)
       (p)[i]=(int*)malloc(4);
    printf("a");
    return 0;
} 

在code::blocks上，它说：

error: incompatible types when assigning to type 'int[4]' from type 'int *'|

Answer 1

你混合了一个指向整数数组的指针(你的声明)和一个整数指针数组(赋值)。您可以将声明更改为：

int *p[4];

在这种情况下，你的任务将会起作用。或者，您可以简单地删除malloc，因为您的声明已经分配了四个整数。但是，如果您希望将整数作为自动变量，则如果声明为：

int p[4];

因为这基本上是一回事。如果以后想要一个指向整数数组的指针，只需传入&p即可。

Answer 2

在您的声明int (*p)[4];中，p是一个指向int类型和4长度数组的指针，但p只是一个指针，它不指向任何数组。所以你可以赋值给(*p)[i]。

请注意，由于precedence of []运算符高于*差异运算符，因此需要用括号将*p括起来。所以(p)[i]是非常错误的。

首先了解如何使用指针进行数组检查，如下所示：

#include<stdio.h>
int main(){
  int b[4] = {1, 2, 3, 4}; 
  int  i;
  int (*p)[4] = &b;
  for(i = 0; i < 4; i++){
     printf(" b[%d] = (*p)[%d] = %d\n", i, i, (*p)[i]);
  }
  return 1;
}

输出：

 b[0] = (*p)[0] = 1
 b[1] = (*p)[1] = 2
 b[2] = (*p)[2] = 3
 b[3] = (*p)[3] = 4

检查工作代码@codepad。

现在，如何为p指针使用动态内存分配呢？检查以下示例：

#include<stdio.h>
#include<stdlib.h>
int main(){
  int  i;
  int (*p)[4];
  p = malloc(4 * sizeof(int)); // allocation 
  // assignments 
  for(i = 0; i < 4; i++){
    (*p)[i] = i * i;
  }
  for(i = 0; i < 4; i++){
     printf(" (*p)[%d] = %d\n", i, (*p)[i]);
  }
  return 1;
}   

将其编译为: working @codepad的gcc -Wall -pedantic xx.c校验代码。

关于这个读取Do I cast the result of malloc?，我建议你避免使用C从malloc和calloc函数中转换返回的地址。

Answer 3

如果您只是分配一个包含4个元素的int数组，您应该这样写

int (*p)[4] = malloc( sizeof *p );

或

int (*p)[4];
...
p = malloc( sizeof *p );

因为p的类型是“指向int的4元素数组的指针”，所以表达式*p的类型是“int的4元素数组”，所以sizeof *p为我们提供了正确的字节数来分配(sizeof (int [4]))。

您可以像这样访问每个元素

(*p)[i] = x; 

括号是必要的。请记住，表达式数组的类型是“int的4元素数组”，因此我们希望对该表达式的结果应用[]运算符。由于[]比一元*具有更高的优先级，因此我们需要使用括号显式地将*运算符分组为p。

您还可以编写p[0][i] = x，因为p[0]与*p是同义词。这消除了显式的解引用，但它将p视为2D数组，这可能会令人困惑。

由于这种混乱，这不是通常的分配一维数组的方式；通常的做法是编写

int *p = malloc( n * sizeof *p );
...
p[i] = x;

因为p的类型是“指向int的指针”，所以表达式*p的类型只是int，所以我们需要在malloc调用中指定我们想要的int的数量。因为p是一个指向int的简单指针，所以我们可以直接对它应用下标操作符，而不必首先取消对它的引用。

如果要分配int的nx4元素数组，则应编写

int (*p)[4] = malloc ( N * sizeof *p );

访问每个元素，如下所示

p[i][j] = x;

因为表达式p的类型是“指向int的4元素数组的指针”，所以表达式p[i]的类型是“int的4元素数组”，因此我们不需要显式地取消对p的引用。

所以，总结一下：

• 分配和使用T类型的单个元素:t *p = malloc( sizeof *p )；*p = ...；(P );

• 分配和使用T的一维数组:t *p = malloc( N* sizeof *p )；pi = ...；(P );

• 分配和使用T的二维数组:t ( *p )N = malloc (M* sizeof *p )；pi = ...；(P );

• 分配和使用T的3D数组:t ( *p )M = malloc (K * sizeof *p )；pik = ...；(P );

更高维数组的模式应该是清晰的。