具有未知大小的结构体数组的结构体

Question

我一整天都在试图解决这个问题......

，我有一个名为 State 的结构，它有一个名称，另一个名为 StateMachine 的结构，有一个名称、一组状态和添加的状态总数：

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

typedef struct State {
  const char * name;

} State;

typedef struct StateMachine {
  const char * name;

  int total_states;
  State ** states;

} StateMachine;

StateMachine * create_state_machine(const char* name) {
  StateMachine * temp;

  temp = malloc(sizeof(struct StateMachine));

  if (temp == NULL) {
    exit(127);
  }

  temp->name = name;
  temp->total_states = 0;

  temp->states = malloc(sizeof(struct State));
  return temp;
}

void destroy_state_machine(StateMachine* state_machine) {
  free(state_machine);
}

State * add_state(StateMachine* state_machine, const char* name) {
  State * temp;

  temp = malloc(sizeof(struct State));

  if (temp == NULL) {
    exit(127);
  }

  temp->name = name;

  state_machine->states[state_machine->total_states]= temp;
  state_machine->total_states++;

  return temp;
}

int main(int argc, char **argv) {

  StateMachine * state_machine;

  State * init;
  State * foo;
  State * bar;

  state_machine = create_state_machine("My State Machine");

  init = add_state(state_machine, "Init");
  foo  = add_state(state_machine, "Foo");
  bar  = add_state(state_machine, "Bar");

  int i = 0;

  for(i; i< state_machine->total_states; i++) {
    printf("--> [%d] state: %s\n", i, state_machine->states[i]->name);
  }

}

基本上 出于某种原因（阅读低 C-fu / 多年的 ruby​​/python/php）我无法表达 states 是一个状态数组的事实。上面的代码打印：

--> [0] state: ~
--> [1] state: Foo
--> [2] state: Bar

添加的第一个状态发生了什么？

如果我在添加的第一个状态上 malloc 状态数组（例如 state_machine = malloc(sizeof(temp)); 那么我得到第一个值，但不是第二个值。

有什么建议吗？

这是一个 C 问题。我正在使用 gcc 4.2。 1 编译示例。

Answer 1

看起来您没有为机器中第一个状态之后的状态分配空间。

StateMachine * create_state_machine(const char* name) {
  StateMachine * temp;

  temp = malloc(sizeof(struct StateMachine));

  if (temp == NULL) {
    exit(127);
  }

  temp->name = name;
  temp->total_states = 0;

  temp->states = malloc(sizeof(struct State)); // This bit here only allocates space for 1.
  return temp;
}

您最好将固定大小的状态数组放入状态机结构中。如果这不行，您将必须重新分配并移动整个集合，或者分配块并跟踪当前长度，或者创建一个链接列表。

顺便说一下，init、foo 和 bar 从来没有被使用过。

编辑：我的建议看起来像这样：

#define MAX_STATES 128 // Pick something sensible.
typedef struct StateMachine {
  const char * name;
  int total_states;
  State *states[MAX_STATES];
} StateMachine;

Answer 2

看起来您希望在每个状态机中拥有可变数量的状态，但您分配的内存不正确。在 create_state_machine 中，这一行：

temp->states = malloc(sizeof(struct State));

分配单个 State 对象，而不是指针数组（这就是您使用它的方式）。

有两种方法可以改变这种情况。

1. 将 states 声明为 State states[]; 但这样你就不能拥有超过固定数量的状态。
2. 添加另一个成员来指示已为 states 分配了多少存储空间，以便您可以跟踪该存储空间以及使用了多少存储空间（即正在使用的 total_states为了）。

后者看起来像这样：

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

typedef struct 
{
    const char *name;
} State;

typedef struct 
{
    const char *name;
    int total_states;
    int states_capacity;
    State *states;
} StateMachine;

StateMachine *create_state_machine(const char *name)
{
    StateMachine *temp = malloc(sizeof(StateMachine));
    memset(temp, 0, sizeof(*temp));

    temp->name = name;
    temp->states_capacity = 10;
    temp->states = malloc(sizeof(State) * temp->states_capacity);

    return temp;
}

State *add_state(StateMachine *machine, const char *name)
{
    if (machine->total_states == machine->states_capacity)
    {
        // could grow in any fashion.  here i double the size, could leave
        // half the memory wasted though.
        machine->states_capacity *= 2;

        machine->states = realloc(
            machine->states, 
            sizeof(State) * machine->states_capacity);
    }

    State *state = (machine->states + machine->total_states);
    state->name = name;

    machine->total_states++;

    return state;
}

Answer 3

在你的 add_state 函数内部：

temp = malloc(sizeof(struct StateMachine)); 

应该是

temp = malloc(sizeof(struct State));

但是，即使改变了，我仍然得到正确的输出：

--> [0] state: Init
--> [1] state: Foo
--> [2] state: Bar

也许你的代码没有任何问题。我正在使用 gcc 版本 4.4.3

Answer 4

State ** states;

将创建一个状态数组的数组。

我还没有如实阅读整个解决方案（必须运行），但您提到想要一组状态 - 您是否可能想做：

State* states

或者

State states[size];

相反？只是供大家思考，很可能这不是你的问题，因为我没有完全阅读它：p

Answer 5

您犯了一个概念错误：

State ** states;

确实，您可以将状态视为指向 State 对象的指针数组，但您只为一种状态分配空间。
当你这样做时：

state_machine->states[state_machine->total_states]= temp;

如果total_states大于零，你就做错了，因为你指向未分配的内存段（我想知道为什么你没有得到SEGFAULT）。要以这种方式存储动态数量的状态，您需要一个链接列表，或者调用 realloc 您添加的每个状态（但这不是一个好主意）。使用不同的 malloc 调用分配的内存不是连续的。