alloc大小错误或free方法使用错误？

我有结构并为其分配内存：

TRANSITION *transitions = malloc(sizeof(TRANSITION *));

我在程序的另一部分中添加了转换，因此我重新分配内存：

TRANSITION *transitions = source->transitions;
transitions = realloc(transitions, (numberTransitions + 1) * sizeof(TRANSITION *));

我有一个方法想释放内存：

free(transitions);

当我调用free方法时，我得到：

"Aborted (core dumped)"

怎么了

整个代码：

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

typedef struct STATE STATE;
typedef struct TRANSITION TRANSITION;

struct STATE
{
    char name[4];
    bool initial_state;
    bool final_state;
    TRANSITION *transitions;
    int numberTransitions;
};

struct TRANSITION
{
    char c;
    STATE *destination;
};

STATE *create_state(char *name, bool is_initial, bool is_final);
void add_transition(STATE *source, char sign, STATE *dest);
void destroy_state(STATE **pp_state);

int main(void)
{
  STATE *state0 = create_state("S'0", true, false);
STATE *state1 = create_state("S'1", false, false);
STATE *state2 = create_state("S'2", false, true);
STATE *zero_state = create_state("0", false, false);

add_transition(state0, 'a', state1);
add_transition(state0, 'b', zero_state);

add_transition(zero_state, 'a', zero_state);
add_transition(zero_state, 'b', zero_state);

add_transition(state1, 'a', state1);
add_transition(state1, 'b', state2);

add_transition(state2, 'a', state1);
add_transition(state2, 'b', state2);
destroy_state(&state0);
}

STATE *create_state(char *name, bool is_initial, bool is_final)
{
    STATE *state = malloc(sizeof(STATE *));
    strcpy(state->name, name);
    state->initial_state = is_initial;
    state->final_state = is_final;
    state->transitions = NULL;
    state->numberTransitions = 0;
    return state;
}

void add_transition(STATE *source, char sign, STATE *dest)
{
    if (source->transitions == NULL)
    {

        TRANSITION *transitions = malloc(sizeof(TRANSITION *));
        transitions->c = sign;
        transitions->destination = malloc(sizeof(STATE *));
        transitions->destination = dest;
        source->transitions = transitions;
        source->numberTransitions = 1;
    }
    else
    {
        TRANSITION *transitions = source->transitions;
        int numberTransitions = source->numberTransitions;
        transitions = realloc(transitions, (numberTransitions + 1) * sizeof(TRANSITION *));
        transitions[numberTransitions].c = sign;
        transitions[numberTransitions].destination = dest;
        (source->numberTransitions)++; 
    }
}

void destroy_state(STATE **pp_state)
{
    TRANSITION *transitions = (*pp_state)->transitions;
    // free(transitions->destination);
    // transitions->destination = NULL;
    free(transitions);
    // transitions = NULL;
    // free(pp_state);
    // pp_state = NULL;

}

#包括
#包括
#包括
#包括
类型定义结构状态；
typedef结构转换；
结构状态
{
字符名[4]；
布尔初始状态；
布尔州；
过渡*过渡；
整数转换；
};
结构转换
{
字符c；
国家*目的地；
};
状态*创建状态（字符*名称，bool为初始值，bool为最终值）；
void add_转换（STATE*source、char-sign、STATE*dest）；
无效销毁状态（状态**pp\U状态）；
内部主（空）
{
STATE*state0=创建_状态（“S'0”，真，假）；
STATE*state1=创建_状态（“S'1”，false，false）；
STATE*state2=创建状态（“S'2”，false，true）；
STATE*zero_STATE=创建_状态（“0”，false，false）；
添加_转换（state0，'a'，state1）；
添加_转换（state0，'b'，zero_状态）；
添加_转换（零_状态，'a'，零_状态）；
添加_转换（零_状态，'b'，零_状态）；
添加_转换（state1，'a'，state1）；
添加_转换（状态1，'b'，状态2）；
添加转换（状态2，'a'，状态1）；
添加_转换（state2，'b'，state2）；
销毁状态（&state0）；
}
状态*创建状态（字符*名称，布尔是首字母，布尔是最终字母）
{
STATE*STATE=malloc（sizeof（STATE*））；
strcpy（状态->名称，名称）；
状态->初始状态=初始状态；
状态->最终状态=是最终状态；
状态->转换=NULL；
状态->数字转换=0；
返回状态；
}
无效添加转换（状态*源、字符符号、状态*目的）
{
如果（源->转换==NULL）
{
TRANSITION*transitions=malloc（sizeof（TRANSITION*））；
转换->c=符号；
转换->目的地=malloc（sizeof（STATE*））；
转换->目的地=目的地；
源->转换=转换；
来源->数字转换=1；
}
其他的
{
转换*转换=源->转换；
int numberTransitions=源->numberTransitions；
transitions=realloc（transitions，（numberTransitions+1）*sizeof（TRANSITION*）；
转换[NumbertTransitions].c=符号；
转换[NumbertTransitions]。目的地=目的地；
（来源->数字转换）+；
}
}
无效销毁状态（状态**pp\U状态）
{
过渡*过渡=（*pp_状态）->过渡；
//免费（转换->目的地）；
//转换->目的地=NULL；
自由（过渡）；
//转换=空；
//免费（pp_州）；
//pp_state=NULL；
}

我认为您希望malloc sizeof（TRANSITION）而不是sizeof（TRANSITION*）。第一个是分配转换结构的大小，第二个只是malloc指针的大小，它可能小于结构的大小。

我认为您希望malloc sizeof（转换）而不是sizeof（转换*）。第一个是分配转换结构的大小，第二个只是malloc指针的大小，它可能小于结构的大小。

我更喜欢这样调用

malloc

：

T *t = malloc(sizeof(*t));

这样，您的分配始终是指针指向的对象的大小

这当然相当于：

T *t = malloc(sizeof(T));

---

但是避免了在

t

类型发生变化时出现错误。

我更喜欢这样调用

malloc

：

T *t = malloc(sizeof(*t));

这样，您的分配始终是指针指向的对象的大小

这当然相当于：

T *t = malloc(sizeof(T));

---

但是避免了在

t

类型发生变化时出现错误。

修复分配后，需要将

realloc

的返回值存储在

源中。您还需要检查分配是否成功

当前，您将旧指针保留在
源中
，因此当您尝试释放内存时，该块已被释放，实际分配的内存因未存储在任何位置而泄漏
 修复分配后，需要将
realloc
的返回值存储在
source
中。您还需要检查分配是否成功

当前，您将旧指针保留在
源中
，因此当您尝试释放内存时，该块已被释放，实际分配的内存因未存储在任何位置而泄漏
 我确信您想要分配
sizeof（TRANSITION）
，因为现在您只分配足够的指针，而不是指针实际指向的对象。我希望您存储
realloc
的值，不要试图释放原始文件。很难说，因为你没有显示实际的代码。@AlexD我以前有过这个，但后来一切都搞砸了。我的手镯看起来像这样▒. 显然有些内存错误当您使用
realloc
时，您的指针可能指向一个新的位置，并且您还可能收到
NULL
的返回值-您确定释放了正确的指针（而不是旧地址）吗？此外，您没有在代码中执行任何错误处理，您忽略了可能的意外情况，并且您显然忽略了编译器警告。。。使用编译器警告，它们可以提供帮助！C不支持方法，只支持函数！除宏或枚举常量外，不要将所有大写字母用于任何其他内容。@SamiKuhmonen我添加了所有字符。我确定您要分配
sizeof（TRANSITION）
，因为现在您只为指针分配了足够的字符，而不是指针实际指向的字符。我希望您存储
realloc
的值，不要试图释放原始文件。很难说，因为你没有显示实际的代码。@AlexD我以前有过这个，但后来一切都搞砸了。我的手镯看起来像这样▒. 显然有些内存错误当您使用
realloc
时，您的指针可能指向一个新的位置，并且您可能会收到一个返回值
NULL
-您确定是fre吗