另一个函数内的 Malloc

Question

我必须从另一个函数中分配一个结构，显然是使用指针。 我已经盯着这个问题好几个小时了，并尝试了一百万种不同的方法来解决它。

这是一些示例代码（非常简化）：

...
some_struct s;
printf("Before: %d\n", &s);
allocate(&s);
printf("After: %d\n", &s);
...

/* The allocation function */
int allocate(some_struct *arg) {

arg = malloc(sizeof(some_struct));
printf("In function: %d\n", &arg);

return 0;
}

这确实在分配调用之前和之后给了我相同的地址：

Before: -1079752900
In function: -1079752928
After: -1079752900

我知道这可能是因为它在函数中进行了复制，但我不知道如何实际处理我作为参数给出的指针。我尝试定义 some_struct *s 而不是 some_struct s，但没有运气。我尝试过：

int allocate(some_struct **arg)

效果很好（分配函数也需要更改），但是根据分配，我可能不会更改声明，并且它必须是 *arg.. 如果我这样做，那将是最正确的只需声明 some_struct s..而不是 some_struct *s 。 分配函数的目的是初始化一个结构体（a some_struct），其中还包括分配它。

还有一件事我忘了提。 allocate 函数中的 return 0 是为某些状态消息保留的，因此我无法使用它返回地址。

Answer 1

通常，我会从 allocate 返回指针：

void * allocate()
{
    void * retval = malloc(sizeof(some_struct));
    /* initialize *retval */
    return retval;
}

如果您想在参数中返回它，则必须将指针传递给该参数。由于这是指向 some_struct 的指针，因此您必须将指针传递给指针：

void allocate (some_struct ** ret)
{
    *ret = malloc(sizeof(some_struct));
    /* initialization of **ret */
    return;
}

才能调用为

some_struct *s;
allocate(&s);

Answer 2

我非常怀疑这就是你的老师的想法，但你可以使用一系列合法的类型转换来作弊。

   int allocate(some_struct *arg) 
   /* we're actually going to pass in a some_struct ** instead. 
      Our caller knows this, and allocate knows this.  */
   { 
      void *intermediate = arg;  /* strip away type information */
      some_struct **real_deal = intermediate;  /* the real type */
      *real_deal = malloc(sizeof *real_deal); /* store malloc's return in the 
                                                 object pointed to by real_deal */
      return *real_deal != 0;  /* return something more useful than always 0 */
   }

然后你的调用者做同样的事情：

   {
      some_struct *s; 
      void *address_of_s = &s; 
      int success = allocate(address_of_s); 
      /* what malloc returned should now be what s points to */
      /* check whether success is non-zero before trying to use it */
   }

这依赖于 C 中的一个规则，即任何指向对象的指针都可以隐式转换为 void 指针，反之亦然，不会丢失。

请注意，形式上这是未定义的，但它几乎肯定可以工作。虽然任何对象指针值都需要能够无损地转换为 void* 并返回，但该语言中没有任何内容可以保证 some_struct* 可以存储some_struct** 无损失。但它很有可能工作得很好。

你的老师让你别无选择，只能编写正式非法的代码。我看你除了这样“作弊”之外，没有其他选择。

Answer 3

int func(some_struct *arg) {
    arg = malloc(sizeof(some_struct));
    ... 
}

在这里，您只需将 malloc 的结果分配给本地 arg 变量即可。在 C 中，指针按值传递，指针的副本传递给函数。您无法通过这种方式更改调用者的指针。请记住指针和它指向的内容的区别。

您有多种选择：

从函数返回指针：

 some_struct *func(void) {
    arg = malloc(sizeof(some_struct));
    ...
    return arg;
}
...
some_struct *a = func();

在调用者中分配结构：

 int func(some_struct *arg) {
    ...
    arg->something = foo;

}
... 
some_struct a;
func(&a);

或动态分配它

some_struct *a = malloc(sizeof *a);
func(a);

使用指向调用者指针的指针：

 int func(some_struct **arg) {
    *arg = malloc(sizeof **arg);

}
... 
some_struct *a;
func(&a);

使用全局变量（丑陋..）

 some_struct *global;
 int func(void) {
    global = malloc(sizeof *global);

}
 ... 
some_struct *a;
func();
a = global;

Answer 4

你不能这样做。您不能按值声明结构，然后按地址更改它。

Answer 5

some_struct *s;
printf("Before: %d\n", s");
allocate(&s);
printf("After: %d\n", s");
...

/* The allocation function */
int allocate(some_struct **arg) {

*arg = malloc(sizeof(some_struct));
printf("In function: %d\n", *arg");

return 0;
}

您需要修改结构体的指向值。所以你需要另一层间接，因此你必须发送一个指向结构指针的指针。

Answer 6

嗯，C 使用值传递，这意味着函数获取其参数的副本，并且对这些副本所做的任何更改都不会影响调用者中的原始副本。

/* The allocation function */
int allocate(some_struct *arg) {

arg = malloc(sizeof(some_struct));
printf("In function: %d\n", &arg");

return 0;
}

在这里您传入 some_struct 的地址。然后丢弃该地址，并将其替换为 malloc 返回的任何内容。然后你返回，malloc的返回值就永远丢失了，你就泄漏了内存。并且您的 some_struct 尚未更改。它仍然具有您打印出来的初始化时的随机数。

如果您不能更改分配函数的签名，那么它永远不会有用。它必须要么获取指针的地址，以便它可以修改该指针的值，要么必须返回调用者可以隐藏的指针。