是否有一种简洁的语法来分配和填充结构指针的值（当 function 结束时不会被破坏）？

Question

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

#define ALLOC3(t, n, a, b, c) t* n = malloc(sizeof(t));\
memcpy(n, &((t){a, b, c}), sizeof(t));

int wickCount = 3;
char* color = "green";
char* scent = "Fresh Balsam";

typedef struct Candle_ {
  int wickCount;
  char* color;
  char* scent;
} Candle;

Candle* maker1 () {
  /* Imagine some code here that generates data,
  but for now, I will use hard-coded values */
  
  /* Create candle */
  Candle* candle = malloc(sizeof(Candle));
  candle->wickCount = wickCount;
  candle->color = color;
  candle->scent = scent;
  return candle;
}

Candle* maker2 () {
  Candle* candle = malloc(sizeof(Candle));
  memcpy(candle, &((Candle){wickCount, color, scent}), sizeof(Candle));
  return candle;
}

Candle* maker3 () {
  Candle* candle = malloc(sizeof(Candle));
  *candle = (Candle){wickCount, color, scent};
  return candle;
}

Candle* maker4 () {
  ALLOC3(Candle, candle, wickCount, color, scent);
  return candle;
}

int main () {
  Candle* candle = maker4();
  /* Do some random things to check for memory leaks.
  Let me know if there is a better way to do this. */
  int temp = 5;
  char* tempstr = "Some filler text...";
  printf("Filler text...\n");
  printf("%s\n", tempstr);
  printf("Filler text...\n");
  printf("==============\n");
  printf("Values:\n");
  /* Finally, print the values */
  printf("%d\n", candle->wickCount);
  printf("%s\n", candle->color);
  printf("%s\n", candle->scent);
  return 0;
}

Maker1 有效，但您必须按名称一一设置每个成员。

Maker2 工作，但仍需要 2 行和额外的语法。

Maker3 似乎在这里工作并且字数较少，但它似乎有时会导致 memory 泄漏。

Maker4 也可以，但我必须为所有数量的成员制作宏，例如 ALLOC1、ALLOC2、ALLOC3、ALLOC4 等。 当然，还有一种比宏更少被破解的方式。

全局 scope 有一个很好的语法：

Candle candle = {wickCount, color, scent};

有没有办法从 function 内部以简短的语法分配和设置所有成员，而不会在 function 结束时破坏值？

更新我想出了一个适用于任意数量成员的宏：

#define ALLOC(s, v, p) s* p = malloc(sizeof(s));\
memcpy(p, &v, sizeof(s));

/* Then you can call it with this: */
ALLOC(Candle, ((Candle){wickCount, color, scent}), candle);

但它仍然不是最干净的，如果有更好的内置标准方式，我仍然不想使用宏。

Answer 1

您可以将整个代码放在一个宏中，然后将其称为“短”。 您可能想了解__VA_ARGS__和可变参数宏。 您的代码不处理分配错误。

#define ALLOCRET(TYPE, ...) \
   TYPE *_tmp = malloc(sizeof(TYPE)); \
   if (_tmp) \
       *_tmp = (TYPE){ __VA_ARGS__ }; \
   return _tmp;

Candle *maker5(void) {
   ALLOCRET(Candle, wickCount, color, scent);
}

主观：总的来说， maker3是最易读的，因此是首选。 隐藏宏后面的东西可能会使您的代码难以维护和不可读。 混合大写和小写相似的名称是令人困惑的 - Candle和candle 。 考虑使用视觉上明显不同的名称来减少错误。 考虑在使用结构时编写struct关键字。

Answer 2

就我个人而言，我会 go mark3但如果你真的喜欢单线，你可以试试下面的宏：

#define DYNINIT(T, ...) ((T*)memcpy(malloc(sizeof(T)), &(T){ __VA_ARGS__ }, sizeof (T)))
...

Candle *maker5(void) {
   return DYNINIT(Candle, wickCount, color, scent);
}

或者直接在main()中使用，例如

Candle* candle = DYNINIT(Candle, .wick = 2, .color="brown");

该宏执行以下步骤：

1. 使用malloc(sizeof(T))为类型T分配 memory
2. 使用可变参数宏的初始化器创建复合文字

(T){ __VA_ARGS__)

将宏参数作为初始化程序传递可以解决为每种类型制作专用的类似ALLOC的宏的问题。

3. 将复合文字复制到目标 memory

memcpy(malloc(...), &(T){ ... }, sizeof (T))

注意memcpy()返回目标地址

4. 将从memcpy返回的void*转换为指向T的指针，以确保某种类型安全。