C编程: SIGABRT 134 error; am I freeing this memory correctly?

Question

我有一个嵌套的数据结构(这些是初始化):

Interval *newInterval(int b, int e, int m){
    static Interval i;
    i.b = b;
    i.e = e;
    i.m = m;
    return &i;
}
Signal *newSignal(int size){
    static Signal s;
    s.intervals = malloc(size * sizeof(Interval));
    s.top = 0;
    s.size = size;
    return &s;
}

Stack *newStack(int size){
    static Stack st;
    st.signals = malloc(size * sizeof(Signal));
    st.top = 0;
    st.size = size;
    return &st;
}

数据的结构:多个间隔结构指针存储在每个信号结构的“间隔”数组中。每个 Signal 结构指针都存储在 Stack 结构的“信号”数组中(永远只有一个)。

        -> [Signal 0] -> [Interval 0][Interval 1][Interval 2]...
[Stack] -> [Signal 1] -> [Interval 0][Interval 1]
        -> [Signal 2] -> [Interval 0][Interval 1][Interval 2]...

我如何尝试访问和释放数据:我有两个函数从结构中打印出数据，并尝试释放使用 malloc(和 realloc)分配的内存。但是我似乎收到了 SIGABRT(错误 134)。我想这是因为我释放内存的方式；但我不知道该怎么办!

    void pop(Signal *s, int n){
    if(n < s->top) {
        printf("[%d,%d)@%d ", s->intervals[n].b, s->intervals[n].e, s->intervals[n].m);
        pop(s,n+1);
    }
    else {
        free(s->intervals);
    }
}

void printIntervals(Stack *st){
    for(int i=0; i<st->top; i++){
        pop(&(st->signals[i]), 0);
        printf("\n");
        free(&(st->signals[i]));
    }
}

1. printIntervals is called once, and in turn calls the pop function for each signal.

2. The pop function recursively prints out each interval struct, until the array containing intervals is empty, at which point I attempt to free the intervals array from the signal.

3. At this point pop finishes, and the flow goes back to printIntervals. Here, I attempt to free the signals array as there's nothing left to print, and the loop moves on to print the next signal from the Stack.

我释放内存的方式不正确吗？如何修复内存错误？谢谢。

Answer 1

如果您free() 多个Stack 指针——拿一个作为例子——你实际上总是在释放同一个指针。

当您在函数作用域中将结构声明为 static 时，它只初始化一次，后续调用将影响您最初返回的指针，因此使用 malloc()一个成员有效地使您的所有指针指向相同的 malloc()ed 区域。所以它指向的前一个指针现在丢失了，你不能释放它。

此外，您不能free() malloc() 未返回的内容。特别是在指针上调用 free() 是愚蠢的，而且可能是错误的，该指针实际上是评估运算符的 & 地址的结果。

您的代码可能应该按如下方式修复，

Interval *
newInterval(int b, int e, int m)
{
    Interval *interval;
    interval = malloc(sizeof(*interval));
    if (interval == NULL)
        return NULL;
    interval->b = b;
    interval->e = e;
    interval->m = m;
    return interval;
}

Signal *
newSignal(int size)
{
    Signal *signal;
    signal = malloc(sizeof(*signal));
    if (signal == NULL)
        return NULL;
    signal->intervals = malloc(size * sizeof(*signal->intervals));
    if (signal->intervals == NULL) {
        free(signal);
        return NULL;
    }
    signal->top = 0;
    signal->size = size;
    return signal;
}

Stack *
newStack(int size)
{
    Stack *stack;
    stack = malloc(sizeof(*stack));
    if (stack == NULL)
        return NULL;
    stack->signals = malloc(size * sizeof(*stack->signals));
    if (stack->signals == NULL) {
        free(stack);
        return NULL;
    }
    stack->top = 0;
    stack->size = size;
    return stack;
}

此外，良好的设计很重要，名为 print* 的函数根本不会释放任何东西，事实上，您应该避免在给定的上下文中释放内存，而该内存是在不同的上下文中分配的。