在C中为结构指针数组成员分配地址

Question

在一些指针算术上遇到了相当大的麻烦。我认为我得到了概念（指针变量指向内存地址，普通变量指向数据）但我相信我的问题在于语法（*, &, (*), *(), 等）

我想要做的是构建自定义结构的动态数组（即指向堆结构的指针数组），我的接口提供了两种方法，“ad_to_obj_array”（它需要添加对象和可以为空的数组为空）和“obj_array_dustbin”（它只需要处理数组，也处理内容，堆对象）。前者如下图。

对象的细节并不重要（并且结构已经被重命名），但我对一般问题的解决方案如下，如果您能发现错误，我将不胜感激。编译器抱怨左值无效，我尝试将 RHS 指针中的地址分配给指向堆结构的指针数组中的指针值：

#define NUM_ELEM(x) (sizeof (x) / sizeof (*(x)))

obj* add_to_obj_array(obj* new_obj, obj* array)
{
  int number_of_elements = 0;
  if (array != NULL)
  {
    number_of_elements = NUM_ELEM(array);
  }

  obj* new_array = NULL;

  /* note: I am expecting sizeof(new_obj) to return the size of an obj* 
     to go into the array of pointers. */
  if ( NULL ==
       (new_array = (obj*)malloc((number_of_elements + 1)* sizeof(new_obj))) )
  {
    /* memory request refused :( */
    return NULL;
  }

  /* copy the old array pointers into the new array's pointer slots: */
  int i;
  for (i = 0; i < number_of_elements; i++)
  {
    &(new_array[i]) = &(array[i]);
  }

  /* add the new item to the end (assign pointer value directly): */
  new_array[number_of_elements] = new_obj;

  if (number_of_elements > 0)
  {
    free(&array);
  }

  return new_array;
}

现在，我尝试了以下违规行的排列：

  &(new_array[i]) = &(array[i]);
  *(new_array[i]) = &(array[i]);
  new_array[i] = &(array[i]);

并且都给出了一种或另一种编译器错误。我相当确定右侧是旧数组的第 i 个元素的地址，但是当数组的元素是指向结构的指针时，如何分配给新的第 i 个元素？

编辑 - 请注意，上面的宏 NUM_ELEM 不起作用；它总是会返回 1。请参阅下面的@Merlyn Morgan-Graham 的回答了解原因。

Answer 1

根据您的描述，您一开始就错了，所以当您开始复制内容时，您无能为力。

现在，您已将new_array（可能还有array）定义为指向obj 的指针。结果如下所示：

在这种情况下，您有一个指向动态分配的对象数组的指针。当/如果你扩大分配，你需要自己复制所有的对象。

根据您的描述：“（即指向堆结构的指针数组）”，您想要的是一个指针数组。如果您想自动分配该指针数组，您的定义将如下所示：

obj *array[NUMBER];

我的猜测是这不是你想要的。据推测，您也想动态分配该数组。看起来像这样：

在这种情况下，new_array 和array 都需要定义为指向obj 的指针。然后，您将分配一个指针数组（即，指向任意数量的 objs 的指针）并让每个点指向 obj：

obj **new_array;

// allocate an array of pointers with space to point at more items:    
new_array = malloc(sizeof(obj *) * new_elements);

// copy the pointers to the current items to the new array:
for (i=0; i<current_elements; i++)
    new_array[i] = array[i];

这样做的好处是，当您进行复制时，您只复制指针，而不是对象本身。特别是对于大型对象，这可以节省大量工作量。权衡是使用一个元素要经过两个间接级别而不是一个，因此引用可能会更慢（尽管很少非常慢，尤其是在相对高性能的处理器上）。

正如@rerun 已经指出的那样，无论哪种情况，您都可能希望使用realloc。特别是，这可能能够“就地”扩展分配，并避免经常复制数据。当然，这并不能保证，但至少你给了它一个机会；如果你malloc 并且每次都复制，你甚至消除了优化的可能性。

Answer 2

你有两个数组 new_array[i] = array[i] 不能满足你的需要。

• 您是否将realloc 视为可能的解决方案。

Answer 3

只需分配值。 new_array[i] = array[i].

您可能遇到的问题是，obj* 实际上是一个指针 数组，obj 本身必须是一个指针类型：

typedef struct
{
  int value1;
} obj_pool;

typedef obj_pool* obj;

int main(int argc, char* argv[])
{
  obj_pool pool1;
  pool1.value1 = 5;
  obj array[] = { &pool1 };
  array[0]->value1 = 16;
  return 0;
}

编译后会遇到的另一个问题是sizeof(array) == sizeof(obj*)。 NUM_ELEM(array) 将总是返回相同的值。这意味着您必须将 size_t array_size 参数传递给您的函数。

Answer 4

在您的代码中，数组元素不是结构上的指针，它们是结构对象。 this 数组 obj** 数组的元素是结构 obj 上的指针。

#define NUM_ELEM(x) (sizeof (x) / sizeof (*(x)))

void add_to_obj_array(obj* new_obj, obj** array)
{
  int number_of_elements = 0;
  if (array != NULL)
  {
    number_of_elements = NUM_ELEM(array);
  }

  // expand array with one more item
  array = (obj**)realloc(array, (number_of_elements + 1) * sizeof(new_obj));

  if (array == NULL )
  {
    /* memory request refused :( */
    return;
  }

  // Put new item at the last place on the array
  array[number_of_elements] = new_obj;
}

所以这里我们使用了矩阵（obj 结构指针上的指针）。当我们添加新元素时，我们只需将现有数组扩展为一个位置，然后在该位置放置新的结构对象。不需要返回值，因为我们对对象的指针进行操作，所有的更改都是在实际对象上完成的，而不是在它们的副本上。