0

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

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

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

我并没有真正从 SIGABRT 的 wiki 页面中学到很多东西，而且我认为十六进制数字对我没有任何意义。这是我的代码，分为两个类和主要的：

标题：

#include <cstdio>
#include <cstdlib>

类堆栈：

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

};

类宇宙：

/*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());
            }
        }       
};

主要功能：

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 ()
4

4 回答 4

5

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

stack = realloc(stack, (size+diff));
于 2011-08-21T11:33:30.680 回答
1

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

另一个问题是您使用realloc不正确。真的应该是：

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

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

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

于 2011-08-21T12:06:58.003 回答
1

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

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

于 2011-08-21T11:35:16.963 回答
0

在您的程序中的某个地方，您尝试使用无效指针。内存损坏很难找到，尤其是对于初学者。引用 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<T>或std::vector<T>。除非必须，否则不要乱用指针。
  • 不要使用mallocand free，如果需要，使用newand 。delete
  • 尝试将 x、y、质量、速度等数据放入数据结构中，以减少重复代码。
于 2011-08-21T12:17:19.627 回答