C function 内部struct下的数组动态分配

Question

我有一个包含一些动态分配数组的结构。

我写了下面的代码，它可以工作，但我不明白为什么它可以工作。

#include <stdio.h>
#include <stdlib.h>

struct Tray {
  int *parr;
};

int allocateTray(int n, struct Tray *tray) {
  tray->parr = calloc(n, sizeof(*tray->parr));

  for (int i = 0; i<n; i++) {
    tray->parr[i] = i+1;
  }
}

int main() {
  struct Tray tray = {NULL}, *ptray;
  int         n;

  n = 5;

  ptray = &tray;

  allocateTray(n, ptray);

  for (int i = 0; i<n; i++) {
    printf("ptray->parr[%d] = %d \n", i, ptray->parr[i]);
  }

  return 0;
}

使用数组（不在结构内），即使我在 function 内分配arr参数int *arr ，它也不会给main分配的数组，它强制一个人在那里使用双指针。

但在这种情况下，我只是使用了一个指向结构的指针，而且它起作用了。 我在想我应该使用类似双指针的结构。

为什么在这种情况下它只适用于单个指针？

Answer 1

“即使我在 function 中分配 arr，参数为 int *arr，它也不会给 main 分配的数组”

一般来说，无论 object 还是 function 在通过它的参数列表传递时都需要修改，需要传递对象的地址，而不是 object 本身。 为了说明，对于任何类型 T：

对于T s s要改变 s，function 原型的参数应该是； void func(T *s);
调用示例是

T s = 0;
func(&s);

对于T *s如果要改变*s ，function 原型的参数应该是； void func(T **s);
调用示例是

T *s = 0;
func(&s);

对于T **s ，如果要改变**s ，参数function原型应该是； void func(T ***s);
调用示例是

T **s = 0;
func(&s);  

依此类推......（请注意每个调用约定的明显相似性。）

示例 - 以下代码将无法更改其参数的值：

int main(void)
{
    int x = 0;//object to be changed
    change_x(x);//passing object directly via argument
                //x is returned unchanged
    return 0;
}

void change_x(int x)
{
    x = 10;//within this function only will x now contain 10
}

但是这个例子传递了地址并且能够改变值：

int main(void)
{
    int x = 0;//object to be changed
    change_x(&x);//passing the address of the object to be changed
    return 0;
}

void change_x(int *x)
{
    *x = 10;//access to the object via its address allows change to occur 
}

“我在想我应该使用类似双指针的结构。”

是的，作为 function 原型中的参数，当需要更改指针 object 指向的 memory 的内容时，它会起作用。
用一个function中需要修改的指针（指向任何对象），同样如此，必须传递它的地址，而不是指针本身。 然后，这将需要该 function 的参数来容纳指向指针的指针。 使用具有int成员和int *成员的struct的简单示例：

typedef struct {
    int a;
    int b;
    int *parr;
}val_s;    

void change_val(val_s **v, size_t num_parr);

int main(void)
{
    val_s *val = NULL;
    int num = 10;
    change_val(&val, num);//passing address to a pointer
    val->a = 10;
    val->b = 20;
    for(int i = 0;i < num; i++) val->parr[i] = i;
    //once finished using memory, 
    //free it in the reverse order in which it was allocated
    free(val->parr);
    free(val);
    return 0;
}

void change_val(val_s **v, size_t num)//note only top level pointer address needs be send
{                                     //member pointers, whether allocated or not are 
    (*v) = malloc(sizeof(val_s));     //relative to memory of top level object
    if(*v)
    {
        (*v)->parr = malloc(num*sizeof (*v)->parr);//allocate memory to member pointer
    }
}

   

Answer 2

您不需要“双指针”； 您需要指向要修改的 object 的指针。 如果你想让function修改一个指针object，你需要传递一个指向那个object的指针。如果你想让function修改一个结构，你需要传递一个指向那个object的指针。

这正是您的代码所做的。 您想要修改main的tray ，因此您将指针传递给main的tray 。 所以你的代码有效。

下面证明了这一点。

---

首先，让我们看看不起作用的代码。

void fac( int *ac ) {
   ac = malloc( sizeof( int ) );
}

int main( void ) {
   int *a = NULL;
   fac( a );
   printf( "%p\n", (void *)a );   // XXX `a` isn't modified.
}

此代码修改ac ，但不修改a 。 它没有实现我们想要它实现的目标。 要修改a ，我们需要传递a的地址。

void fap( int **ap ) {
   *ap = malloc( sizeof( int ) );
}

int main( void ) {
   int *a = NULL;
   fap( &a );
   printf( "%p\n", (void *)a );   // XXX `s` isn't modified.
}

在这里，我们不修改参数，而是修改*ap ，它是a . 这段代码确实实现了我们想要它实现的目标。

---

现在，让我们介绍结构。

typedef struct { int *a } S;

void fsc( S sc ) {
   sc.a = malloc( sizeof( int ) );
}

int main( void ) {
   S s = { .a = NULL };
   fsc( s );
   printf( "%p\n", (void *)(s.a) );   // Ok. `s` is modified.
}

此代码修改sc ，但不修改s 。 它没有实现我们想要它实现的目标。 要修改s ，我们需要传递s的地址。

typedef struct { int *a } S;

void fsp( S *sp ) {
   sp->a = malloc( sizeof( int ) );   // `sp->a` means `(*sp).a`
}

int main( void ) {
   S s = { .a = NULL };
   fsp( &s );
   printf( "%p\n", (void *)(s.a) );   // Ok. `s` is modified.
}

在这里，我们没有修改参数，而是修改了*sp即s 。 这段代码确实实现了我们想要它实现的目标。

---

完整演示：

#include <stdbool.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>

typedef struct { int *a; } S;

void fac( int *ac ) {
   ac = malloc( sizeof( int ) );
}

void fap( int **ap ) {
   *ap = malloc( sizeof( int ) );
}

void fsc( S sc ) {
   sc.a = malloc( sizeof( int ) );
}

void fsp( S *sp ) {
   sp->a = malloc( sizeof( int ) );   // `sp->a` means `(*sp).a`
}

int main( void ) {
   int *a = NULL;
   fac( a );
   printf( "%p\n", (void *)a );       // XXX `a` isn't modified.

   fap( &a );
   printf( "%p\n", (void *)a );       // Ok. `a` is modified.

   S s = { .a = NULL };
   fsc( s );
   printf( "%p\n", (void *)(s.a) );   // XXX `a` isn't modified.

   fsp( &s );
   printf( "%p\n", (void *)(s.a) );   // Ok. `s` is modified.
}

警告：

<source>: In function 'fac':
<source>:10:16: warning: parameter 'ac' set but not used [-Wunused-but-set-parameter]
   10 | void fac( int *ac ) {
      |           ~~~~~^~
<source>: In function 'fsc':
<source>:18:13: warning: parameter 'sc' set but not used [-Wunused-but-set-parameter]
   18 | void fsc( S sc ) {
      |           ~~^~

Output：

(nil)
0x158a2d0
(nil)
0x158a310

Answer 3

要在 function 中更改 object，您需要通过引用传递它而不是通过值传递。

在 C 中，通过引用传递意味着通过指向它的指针间接传递 object。 因此取消引用传递的指针，您将可以直接访问指针指向的 object 并可以更改它。

使用数组（不在结构内），即使我在 function 内分配 arr，参数为 int *arr，它也不会给 main 分配的数组，它强制一个人在那里使用双指针。

这意味着指针按值传递给了 function。 即 function 处理由传递的指针值初始化的局部变量（参数）。 更改局部变量不会更改用作 function 参数的原始指针。

考虑一个简单的程序

#include <stdio.h>
#include <stdlib.h>

void f( int *p )
{
    p = malloc( sizeof( int ) );
}

int main( void )
{
    int *a = NULL;

    f( a );

    printf( "a == NULL is %s\n", a == NULL ? "true" : "false" );
}

您可以想象 function 的定义及其调用方式如下

f( a );

//...

void f( /* int *p */ )
{
    int *p = a;
    p = malloc( sizeof( int ) );
}

如您所见，function 更改了其局部变量p ，该变量由传递给 function 的指针a的值初始化。原始指针a保持不变。

如果要更改 function 中 main 中声明的指针a ，则需要通过引用传递它。 那就是程序看起来像下面这样

#include <stdio.h>
#include <stdlib.h>

void f( int **p )
{
    *p = malloc( sizeof( int ) );
}

int main( void )
{
    int *a = NULL;

    f( &a );

    printf( "a == NULL is %s\n", a == NULL ? "true" : "false" );

    free( a );
}

现在取消引用 function 中的指针p

*p = malloc( sizeof( int ) );

您可以直接访问原始指针a并因此可以更改它。

至于你的第一个程序，然后是在结构Tray中声明的指针parr

struct Tray {
  int *parr;
};

通过指向结构类型 object 的指针通过引用传递给 function。

  struct Tray tray = {NULL}, *ptray;
  //...
  ptray = &tray;

  allocateTray(n, ptray);

那就是取消引用 function 中的指针ptray ，您可以直接访问结构类型的原始 object 并可以更改（任何）它的数据成员。

Answer 4

Gerhardh 的评论是正确的：您使用的是双指针。

考虑：

#include <stdio.h>
#include <stdlib.h>

struct Tray {
  int *parr;
};

void allocateTray(int n, struct Tray *tray) {
  tray->parr = calloc(n, sizeof(*tray->parr));

  for (int i = 0; i<n; i++) {
    tray->parr[i] = i+1;
  }
}

int main() {
  int *tray = NULL, **ptray;
  int         n;

  n = 5;

  ptray = &tray;

  allocateTray(n, (struct Tray*)ptray);

  for (int i = 0; i<n; i++) {
    printf("ptray[%d] = %d \n", i, (*ptray)[i]);
  }

  return 0;
}