损坏的双链表：0x0804d0c0 (C++)？

Question

注意：我以前从未遇到过这种规模的问题，并且真的不知道如何布局，如果我布局错误，请解释我应该如何布局。如果您不能或不愿意帮助该程序，我很高兴了解该问题。

我一直在编写一段代码来练习面向对象编程，但是我遇到了一个我以前从未见过的错误（我只花了几个月的时间，并且没有太多时间来学习，因为我的时间都浪费在义务教育上）。内核本身（显然）在我的代码中产生了这个错误。但是运行 gdb（带有调试符号）并没有让我知道行号。放入 printf 语句后发现，即使不再满足条件，它也会围绕 while 循环进行循环？这对我来说似乎很奇怪，因为似乎条件不满足，但它一直循环。当发生这种情况时，它会出现错误（我认为）的原因是因为在“Stack”类中的某个地方，它为整数数组重新分配了负大小的内存 - 不过，当我向 Stack::reloc 添加一个 if 语句以便防止它重新分配负数组大小，它仍然会导致错误。往下看，它显示了其他几条信息，（引用 gdb）：

程序收到信号 SIGABRT，已中止。 0x0012d422 in __kernel_vsyscall ()

我并没有从 SIGABRT 的 wiki 页面中学到太多东西，而且我认为十六进制数字对我来说没有任何意义。这是我的代码，分为两个类和 main:

headers:

#include <cstdio>
#include <cstdlib>

class Stack:

class Stack {
private:
    int *stack;
    int size;
    void init(int *top) {
        *top = 0;
    }

    void push2(int *s,int* top, int element) {
        s[(*top)++] = element;
    }

    int pop2(int *s,int *top) {
        return s[--(*top)];
    }
    void reloc(int diff) {
        if ((top+diff)>1) {
            realloc(stack, (size+diff));
            size = size+diff;
        }
    }

public:
    int top;
    Stack() {
        init(&top);
        size = 100;
        stack = (int *)malloc(100 * sizeof(int));
    }
    void push(int element) {
        if (top>=(size-1)) reloc(100);
        push2(stack, &top, element);
    }
    int pop() {
        if ((top<(size-120)) && (top>100)) reloc(-100);
        return (pop2(stack, &top));
    }
    int sth() {
        return size;
    }

};

class Universe:

/*Universe is the casual layout for the universe*/
class Universe {
    private:
        int y_cog; //y axis center of gravity
        int x_cog; //x axis "
        int force; //weight of universe
        int fps; //frames per second
        int g; //acceleration under gravity
        int G; //gravitational constant

        //NB: velocity in d/s
        //all stacks defined
        Stack y_pos; //y axis position
        Stack x_pos; //x axis "
        Stack mass; //mass of object
        Stack y_vel; //velocity on y axis
        Stack x_vel; //velocity on x axis
        Stack y_pos2; //stacks for repeating
        Stack x_pos2;
        Stack mass2;
        Stack y_vel2;
        Stack x_vel2;

        //function 'increments' the center of gravity
        void cog(int y, int x, int m) {
            //ratio is offset of universe cog
            //where 100 is exectly half way
            int ratio = ((m*100)/(force))/2;
            //set the center of gravity the ratio beween the objects
            y_cog = y_cog-(((y_cog-y)/100)*ratio);
            x_cog = x_cog-(((x_cog-x)/100)*ratio);
            force = m+force;
        }

        /*moves the object at the top of the stack and alters velocity
        according to previouse velocity and force towards the universe
        center of gravity*/
        void move() {
            int yp, xp, m, yv, xv, vi, yvi, xvi, rm;
            yp = y_pos2.pop();
            xp = x_pos2.pop();
            m = mass2.pop();
            yv = y_vel2.pop();
            xv = x_vel2.pop();
            //important part
            //set the position according to velocity and frame rate
            yp = yp+(yv/fps);
            xp = xp+(xv/fps);
            //find the ratio share of velocity
            vi = ((g*100)/fps); //velocity increase
            rm = ((y_cog-yp)+(x_cog-xp)); //ratio maximum
            if (rm==0) rm = 1;
            yvi = ((vi/rm)*(y_cog-yp))/100;
            xvi = ((vi/rm)*(x_cog-xp))/100;
            yv = yvi;
            xv = xvi;
            //push everything back
            y_pos.push(yp);
            x_pos.push(xp);
            mass.push(m);
            y_vel.push(yv);
            x_vel.push(xv);
        }

    public:
        Universe() {
            y_cog = 0;
            x_cog = 0;
            force = 0;
            fps = 10;
            g = 10;
            //all stacks initialised
            y_pos = Stack();
            x_pos = Stack();
            mass = Stack();
            y_vel = Stack();
            x_vel = Stack();
        }

        void add(int yp, int xp, int m, int yv, int xv) { //adds object to stack
            y_pos.push(yp);
            x_pos.push(xp);
            mass.push(m);
            y_vel.push(yv);
            x_vel.push(xv);
        }

        void run() {
            int yp, xp, m, yv, xv;
            while (y_pos.top<=0) { //reposition center of gravity
                //mainly pushing things around
                yp = y_pos.pop();
                xp = x_pos.pop();
                m = mass.pop();
                yv = y_vel.pop();
                xv = x_vel.pop();
                cog(yp, xp, m); //the important part
                y_pos2.push(yp);
                x_pos2.push(xp);
                mass2.push(m);
                y_vel2.push(yv);
                x_vel2.push(xv);
            }
            while (y_pos2.top<1) {
                move();
            }
        }

        void outh() { //human output
            int yp, xp, m, yv, xv;
            while (y_pos.top<=0) {
                yp = y_pos.pop();
                xp = x_pos.pop();
                m = mass.pop();
                yv = y_vel.pop();
                xv = x_vel.pop();
                y_pos2.push(yp);
                x_pos2.push(xp);
                mass2.push(m);
                y_vel2.push(yv);
                x_vel2.push(xv);
                printf("%d, %d\t%d\t%d\n", yp, xp, m, yv+xv);
            }
            while (y_pos2.top<=0) {
                y_pos.push(y_pos2.pop());
                x_pos.push(x_pos2.pop());
                mass.push(mass.pop());
                y_vel.push(y_vel.pop());
                x_vel.push(x_vel.pop());
            }
        }       
};

function main:

int main() {
    Universe main = Universe();
    main.add(10, 10, 10, 0, 0);
    main.add(5, 5, 5, 0, 0);
    int i;
    for (i = 1; i<100; i++) {
        main.run();
        main.outh();
        printf("\n");
    }
    return 0;
}

GDB运行结果（带有调试符号）：

Starting program: /home/james/Desktop/coding/Universe/debug 
*** glibc detected *** /home/james/Desktop/coding/Universe/debug: corrupted double-linked list: 0x0804d0c0 ***
======= Backtrace: =========
/lib/tls/i686/cmov/libc.so.6(+0x6b591)[0x2d4591]
/lib/tls/i686/cmov/libc.so.6(+0x70ce3)[0x2d9ce3]
/lib/tls/i686/cmov/libc.so.6(realloc+0xdd)[0x2d9f9d]
/home/james/Desktop/coding/Universe/debug[0x80486b2]
/home/james/Desktop/coding/Universe/debug[0x804872c]
/home/james/Desktop/coding/Universe/debug[0x80489b0]
/home/james/Desktop/coding/Universe/debug[0x8048cec]
/home/james/Desktop/coding/Universe/debug[0x80485fd]
/lib/tls/i686/cmov/libc.so.6(__libc_start_main+0xe6)[0x27fbd6]
/home/james/Desktop/coding/Universe/debug[0x80484d1]
======= Memory map: ========
00110000-0012b000 r-xp 00000000 08:01 393241     /lib/ld-2.11.1.so
0012b000-0012c000 r--p 0001a000 08:01 393241     /lib/ld-2.11.1.so
0012c000-0012d000 rw-p 0001b000 08:01 393241     /lib/ld-2.11.1.so
0012d000-0012e000 r-xp 00000000 00:00 0          [vdso]
0012e000-00217000 r-xp 00000000 08:01 2625203    /usr/lib/libstdc++.so.6.0.13
00217000-00218000 ---p 000e9000 08:01 2625203    /usr/lib/libstdc++.so.6.0.13
00218000-0021c000 r--p 000e9000 08:01 2625203    /usr/lib/libstdc++.so.6.0.13
0021c000-0021d000 rw-p 000ed000 08:01 2625203    /usr/lib/libstdc++.so.6.0.13
0021d000-00224000 rw-p 00000000 00:00 0 
00224000-00248000 r-xp 00000000 08:01 525255     /lib/tls/i686/cmov/libm-2.11.1.so
00248000-00249000 r--p 00023000 08:01 525255     /lib/tls/i686/cmov/libm-2.11.1.so
00249000-0024a000 rw-p 00024000 08:01 525255     /lib/tls/i686/cmov/libm-2.11.1.so
0024a000-00267000 r-xp 00000000 08:01 393299     /lib/libgcc_s.so.1
00267000-00268000 r--p 0001c000 08:01 393299     /lib/libgcc_s.so.1
00268000-00269000 rw-p 0001d000 08:01 393299     /lib/libgcc_s.so.1
00269000-003bc000 r-xp 00000000 08:01 525247     /lib/tls/i686/cmov/libc-2.11.1.so
003bc000-003bd000 ---p 00153000 08:01 525247     /lib/tls/i686/cmov/libc-2.11.1.so
003bd000-003bf000 r--p 00153000 08:01 525247     /lib/tls/i686/cmov/libc-2.11.1.so
003bf000-003c0000 rw-p 00155000 08:01 525247     /lib/tls/i686/cmov/libc-2.11.1.so
003c0000-003c3000 rw-p 00000000 00:00 0 
08048000-0804a000 r-xp 00000000 08:01 132105     /home/james/Desktop/coding/Universe/debug
0804a000-0804b000 r--p 00001000 08:01 132105     /home/james/Desktop/coding/Universe/debug
0804b000-0804c000 rw-p 00002000 08:01 132105     /home/james/Desktop/coding/Universe/debug
0804c000-0806d000 rw-p 00000000 00:00 0          [heap]
b7e00000-b7e21000 rw-p 00000000 00:00 0 
b7e21000-b7f00000 ---p 00000000 00:00 0 
b7fed000-b7fef000 rw-p 00000000 00:00 0 
b7ffe000-b8000000 rw-p 00000000 00:00 0 
bffeb000-c0000000 rw-p 00000000 00:00 0          [stack]

Program received signal SIGABRT, Aborted.
0x0012d422 in __kernel_vsyscall ()

Answer 1

一个大问题，realloc() 行应该是：

stack = realloc(stack, (size+diff));

Answer 2

由于内存损坏，您的程序行为异常并崩溃。

在您的情况下，这可能是由于通过无效指针进行写入引起的。由于代码中唯一直接使用指针的部分是 Stack 类，因此可能 Stack 有错误，或者 Universe 有错误导致Stack使用不正确的错误。

Answer 3

标准库已经提供了堆栈实现，所以我不明白你为什么要实现自己的。你的问题是你没有提供析构函数、复制构造函数或复制赋值运算符。当析构函数被调用时，它会释放指针，但不会释放它指向的对象。这会导致内存泄漏。同样，当调用复制构造函数或赋值运算符时，它将复制指针，而不是它指向的对象。如果您正确定义了析构函数，但没有定义复制函数，则如果对象已被复制（不正确），您可能会删除不存在的对象。

另一个问题是您错误地使用了realloc。实际上应该是：

stack = realloc(stack, (size + diff) * sizeof(int));

这是为了防止分配位置发生变化。编辑：由于另一个答案的评论，我注意到的另一件事是，您必须将大小乘以 sizeof(int)，因为它期望大小以字节为单位。

上述问题并不是程序无限循环的原因，但值得一提。真正的问题是循环。您期望当 top 小于或等于 0（或在一种情况下小于 1）时执行循环。实际上，应该是当 top 大于 0 时，因为 0 表示堆栈中没有更多元素。由于您允许堆栈访问索引小于 0 的元素，因此您会收到错误。无论如何，循环看起来只能满足其条件一次，因此您可以将其删除。

Answer 4

在程序中的某个地方您尝试使用无效的指针。内存损坏很难发现，特别是对于初学者来说。引用 Brian Kernighan 的话：“当你尽力编写代码时，你将如何调试它？” GDB 可以帮助你完成复杂的程序，但在这种情况下我会转向另一个方向。

幸运的是，Stack 似乎是程序中唯一处理内存的地方。
我的建议是在其方法中放入一些断言，如下所示：

// at the beginning of pop():
  assert(top > 1);

这将帮助您找到代码其他部分中滥用 Stack 类的错误：

while (y_pos.top<=0) {
  yp = y_pos.pop();

即使 Stack 是正确的。正如其他答案所指出的，realloc 没有设置指针。

还有其他一些点，我会反对您的代码：

• 使用标准库容器，例如 std::stack 或 std::vector。除非必要，否则不要乱用指针。
• 不要使用 malloc 和 free，如有必要，请使用 new 和 delete。
• 尝试将 x、y、质量、速度等数据放入数据结构中，以减少重复代码。