C编程：SIGABRT 134错误；我是否正确释放了此内存？

我有一个嵌套的数据结构（这些是初始化）：

数据的结构方式：多个区间结构指针存储在每个信号结构的“区间”数组中。每个信号结构指针都存储在堆栈结构的“信号”数组中（始终只有一个）

我如何尝试访问和释放数据：我有两个函数可以从结构中打印数据，并尝试释放使用malloc（和realloc）分配的内存。然而，我似乎得到了一个信号（错误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]));
    }
}

void pop（信号*s，整数n）{
如果（ntop）{
printf（“[%d，%d）@%d”，s->interval[n].b，s->interval[n].e，s->interval[n].m）；
pop（s，n+1）；
}
否则{
自由时间->间隔时间；
}
}
空打印间隔（堆栈*st）{
for（inti=0；itop；i++）{
pop（&（st->signals[i]），0；
printf（“\n”）；
自由（&（st->信号[i]）；
}
}

1。printInterval调用一次，然后为每个信号调用pop函数

2.pop函数递归打印出每个区间结构，直到包含区间的数组为空，此时I 尝试从信号中释放间隔数组

3。此时，pop结束，流返回到PrintInterval。在这里，我尝试释放信号数组，因为 没有留下要打印的内容，循环将继续打印下一个信号 从堆栈中删除

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

如果你

free（）

多个

堆栈
指针-以一个为例-你总是释放同一个指针

当您在函数范围中将结构声明为
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*
的函数根本不会释放任何内容，事实上，您应该避免释放在不同上下文中分配的给定上下文中的内存。
如果您
free（）
多个
堆栈
指针-以其中一个为例-您实际上总是在释放同一个指针

当您在函数范围中将结构声明为
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*

的函数不会释放任何内容，事实上，您应该避免释放在不同上下文中分配的给定上下文中的内存。

static Stack st；

后跟

st.signals=malloc（）

非常糟糕，并且很容易发生内存泄漏。请准备好并在您使用它的上下文中理解

static

的含义。似乎您希望避免

malloc（）

调用，因此您做了一些非常错误的事情。

static Stack st；

后跟

st.signals=malloc（）

非常糟糕，并且很容易发生内存泄漏。请准备好并在您使用它的上下文中理解

static

的含义。似乎您希望避免

malloc（）

调用，因此您做了一些非常错误的事情例如，在一个实际是计算运算符的&address的结果的指针上：

char*p=malloc（10）；free（&p[0]）；

可以正常工作。重要的不是地址，而是它是否生成正确的指针例如，在实际是运算符的&address求值结果的指针上。：

char*p=malloc（10）；free（&p[0]）；

可以正常工作。重要的不是的地址，而是它是否生成正确的指针。

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;
}