C++ 基于BFS算法的SIGSEGV误差

我有一个BFS算法错误。 我尝试过用

gdb

进行调试，但我不明白为什么会出现这种情况

谁能告诉我为什么下面的代码出现

SIGSEGV

错误。它是否取决于您使用的编译器对指针的寻址方式？因为代码中存在无效指针错误

#include<iostream>
#include<stdlib.h>

#define TRUE 1
#define FALSE 0

using namespace std;

const int MAX = 8;

struct Node
{
  int data;
  Node *next;
};

class Graph
{
  private:

    int visited[MAX];
    int q[8];
    int front, rear;

public:

    Graph();
    void BFS(int v, Node **p);
    Node *getNode_Write(int val);
    static void addQueue(int *a, int vertex, int *f, int *r);
    static int deleteQueue(int *q, int *f, int *r);
    static int isEmpty(int *f);
    void del(Node *n);
};

// initialize data memeber
Graph::Graph()
{
   for(int i = 0; i < MAX; i++)
        visited[i] = FALSE;

   front = rear = -1;
}

// function that implements breadth first search (BFS) algorithm
void Graph::BFS(int v, Node **p)
{
    Node *u;

    visited[v-1] = TRUE;

    cout<<v<<"\t";

   addQueue(q, v, &front, &rear);

   while(isEmpty(&front) == FALSE)
   {
       v = deleteQueue(q, &front, &rear);
       u = *(p+v-1);

       while(u != NULL)
       {
          if(visited[u->data-1] == FALSE)
          {
            addQueue(q, u->data, &front, & rear);
            visited[u->data-1] == TRUE;
            cout<<u->data<<"\t";
          }

          u = u->next;
       }            

     }
  }

 // Creates a node
 Node *Graph::getNode_Write(int val)
 {
     Node *newNode = new Node;
     newNode->data = val;
     return newNode;
 }

 //Adds node to the queue
 void Graph::addQueue(int *a, int vertex, int *f, int *r)
 {
    if(*r == MAX -1)
    {
       cout<<"\nQueue Overflow.";
       exit(0);
    }

    (*r)++;

    a[*r] = vertex;

    if(*f == -1)
       *r = 0;
   }

   // Deletes a node from the queue
   int Graph::deleteQueue(int *a, int *f, int *r)
   {
       int data;

       if(*f == -1)
       {
         cout<<"\nQueue Underflow";
         exit(0);
       }

       data = a[*f];

       if(*f == *r)
          *f = *r = -1;
       else
         (*f)++;

      return data;      
    }

    // checks if queque is empty
  int Graph::isEmpty(int *f)
  {
     if(*f == -1)
        return TRUE;
    return FALSE;
  }


  // deallocate the memory
  void Graph::del(Node *n) 
  {
       Node *temp;

      while(n != NULL)
      {
           temp = n->next;
           delete n;
           n = temp;
      }
   }

  int main()
  {
      Node *arr[MAX];
      Node *v1,*v2,*v3,*v4;

      Graph g;

      v1 = g.getNode_Write(2);  
      arr[0] = v1;  
      v1->next = v2 = g.getNode_Write(3);
      v2->next = NULL;

      v1 = g.getNode_Write(1);
      arr[1] = v1;
      v1->next = v2 = g.getNode_Write(4);
      v2->next = v3 = g.getNode_Write(5);
      v3->next = NULL;  

      cout<<endl;

      g.BFS(1,arr);

      for(int i = 0; i<MAX; i++)
          g.del(arr[i]);    


    }

#包括
#包括
#定义真1
#定义FALSE 0
使用名称空间std；
常数int MAX=8；
结构体类型
{
int数据；
节点*下一步；
};
类图
{
私人：
int访问量[MAX]；
int q[8]；
前，后；
公众：
图（）；
无效BFS（内部v，节点**p）；
Node*getNode_写入（int-val）；
静态void addQueue（int*a，int-vertex，int*f，int*r）；
静态int-deleteQueue（int*q，int*f，int*r）；
静态int为空（int*f）；
void del（节点*n）；
};
//初始化数据存储器
Graph:：Graph（）
{
对于（int i=0；i
不，它主要不依赖于编译器。正如约阿希姆在他的文章中指出的：

要查看错误的真正来源，您只需加快堆栈跟踪，并检查所有变量和参数的实际设置情况

很可能是由于缺少或错误的变量初始化，您调用了一些未定义的行为。
在
main
的堆栈框架中有一个未初始化的数组
arr
。仅
arr[0]
和
arr[1]
初始化。在main的末尾，它将在整个数组中迭代，并在垃圾值上的
Graph:：del（Node*n）
中调用
delete。
在调试器中运行程序，调试器将在崩溃位置停止。向上遍历函数调用堆栈，找到代码（如果还没有）“编辑你的问题，只包括代码的相关部分，加上相关变量的值，当然，除非你自己能弄清楚。@SouravGhosh”试图用gdb进行调试，但我不明白为什么我会得到这个…“@πάνταῥεῖ 哎呀，我错过了“医生”部分。@SouravGhosh没问题。很可能OP只是错误地使用了调试器，类似于；-）…感谢各位的建议，我正在研究它。但是，我不理解我的问题的负计数。我知道在线上有很多BFS算法，但这似乎使用了更多的指针，我更喜欢它继续研究当然。