在另一個結構內重新分配結構數組

Question

我正在一個目標是創建自動機的項目中。

自動機由struct定義：

typedef struct {
    int num_states;
    int initial_state;
    State * states;
} Automaton;

狀態是定義狀態之間弧線的另一種結構：

typedef struct {
    int num_arcs;
    bool is_final;
    Arc * arcs;
} State;

typedef struct {
    int symbol;
    int destination;
} Arc;

我用malloc這樣創建一個自動機：

Automaton* create_automaton(void) {
    Automaton * a = (Automaton *)malloc(sizeof(Automaton));
    assert(a != NULL);
    a->initial_state = UNDEFINED;
    a->num_states = 0;
    a->states = NULL;
    return a;
}

因此，我想使用兩個由這些函數創建的狀態和弧構成的自動機：

int add_state(Automaton* a) {
    State* state = (State *)realloc(a->states, (a->num_states + 1) * sizeof(State));
    if(state == NULL)
        exit(EXIT_FAILURE);
    a->states = state;
    a->states[a->num_states].num_arcs = 0;
    a->states[a->num_states].is_final = FALSE;
    a->states[a->num_states].arcs = NULL;

    return a->num_states++;
}

void add_arc(Automaton* a, int from, int to, int symbol) {
    if(from >= a->num_states || to >= a->num_states)
        exit(EXIT_FAILURE);
    Arc * arc = (Arc *)realloc(a->states[from].arcs, (a->states[from].num_arcs + 1) * sizeof(Arc));
    if(arc == NULL)
        exit(EXIT_FAILURE);
    a->states[from].arcs = arc;
    a->states[from].arcs[a->states[from].num_arcs].destination = to;
    a->states[from].arcs[a->states[from].num_arcs].symbol = symbol;
    a->states[from].num_arcs++;
}

我想將這兩個自動機結合在一起，所以我寫了這個函數：

Automaton* append_automaton(Automaton * a1, Automaton * a2)
{
    Automaton * a = copy_automaton(a1);
    int i = 0;
    for(i = 0; i < a2->num_states; i++)
    {
        add_state(a);
        a->states[a1->num_states + i] = a2->states[i];
        for(j = 0;j<a->states->num_arcs;j++)
        {
            a->states[i].arcs[j].destination =+ a2->num_states;
        }
    }
    a->initial_state = a1->initial_state;

    return a;
}

但是，我可以創建自動機，向其添加狀態和弧線而沒有任何問題，當我嘗試將它們與append_automaton合並在一起時，當在add_state（）中重新分配狀態以在新的自動機中容納一個以上的狀態時，會遇到分段錯誤。

因此，我的問題如下：為什么在此函數（append_automaton）中重新分配給我一個分段錯誤，盡管它可以在外部完美運行？

PS：copy_Automaton（）確實覆蓋了create_Automaton（），因此我刪除了這一行： Automaton * a = create_automaton()在append_automaton（）中，這是copy_automaton（）：

Automaton* copy_automaton(Automaton* a) {
    int i = 0;
    Automaton * cp_a = malloc(sizeof(Automaton));
    cp_a->states = malloc(sizeof(a->states));
    for(i = 0; i < a->num_states; i++)
    {
        cp_a->states[i].arcs = malloc(sizeof(a->states[i].arcs));
        cp_a->states[i] = a->states[i];
    }
    cp_a->num_states = a->num_states;
    cp_a->initial_state = a->num_states;
    //memcpy(a, cp_a, sizeof(Automaton));
    return cp_a;
}

Answer 1

我看到的問題是您在for循環后正在更新a->num_states 。 但是a->num_states會在循環內的add_state(a);函數中add_state(a); 您需要將（a-> num_states）++放入循環中。