Question

我正在编写一个使用具有堆栈结构的链表节点的程序，但是即使没有编译错误，它也会随机崩溃。在这里，我试图简化我的问题。如果我只想n->s->datas[i]=i;，那不是崩溃。显示所有数字并在控制台上测试后程序崩溃。我在做什么错了？

#include <iostream>

using namespace std;

struct stack {
    int *datas = new int;
    int top = -1;
};

struct node {
    node *next;
    node *prev;
    stack *s = new stack;
};

int main()
{
    node *n = new node;
    node *n1 = new node;
    for (int i = 0; i < 300; i++) {
        n->s->datas[i] = i;
        n1->s->datas[i] = n->s->datas[i];
        cout << n1->s->datas[i] << endl;
    }
    cout << "test";
}

Answer 1

 #include<iostream>

    class stack {
     public:
     stack(int size) {
           datas = new int[size];
           top = -1;
           this->size = size;
     }
     ~stack(){
        if(datas) 
            delete[] datas; //use array delete so you don't leak!!
     }
     int *datas ;
     int top;
     int size;
 };

 class node {
      public:
     node(int size){
          s = new stack(size);
      }
      ~node()
      {
         if(s)
             delete s; 
      }
      node *next;
      node *prev;
      stack *s; 
  };

 using namespace std;
 int main()
 {
     node *n = new node(300);
      node *n1 = new node(300);
      for (int i = 0; i < 300; i++) {
          n->s->datas[i] = i;
          n1->s->datas[i] = n->s->datas[i];
          cout << n1->s->datas[i] << endl;
      }
     cout << "test";
      if(n)
         delete n; //clean up n
       if(n1)
         delete n1; //clean up n1
 }

实际上，没有人专门编写这样的代码，因为它容易出错，并且缺乏任何类型的异常安全性。我希望这是针对一个班级，而不是任何产品。将来，对于动态数组，请考虑使用std :: vector；对于固定大小的数组，请考虑使用std :: array，并且在堆栈上保留一些变量没有什么错。在您的用例中，根本不需要n或n1是指针。最后，由于我不在PC上，因此我赞成代码格式。这是RAII。这是一种简单的设计模式，可防止您泄漏数据。在构造函数中分配，在析构函数中分配。但是，此代码远非异常安全。对new的任何调用都可能引发内存不足异常。

Answer 2

您应该创建一个特定的功能来为您创建节点。动态分配内存。

类似

static node* create_node(int stack_size)
{
    node* n = new node;
    n->s = new stack;
    n->s->datas = new int[stack_size];
    return n;
}

您的主要问题是堆栈结构中int *缓冲区的内存分配错误。

离开主范围（动态分配）后程序崩溃

2 个答案: