Question

我正在尝试创建一个单向列表，其中包含一个包含值的节点和一个指向下一个节点的指针（最终节点中的指针应该是一个nullptr）。

但是，事情并没有像计划那样进行。它正在编译没有任何问题，但是当我尝试运行它时，我得到了这个致命的错误条件： SIGSEGV - 分段违规信号。

它认为它试图获得它没有使用许可的内存，或者什么？另一个常见原因是偶然的“=”而不是“==”，但这似乎不是问题。

当我尝试在我的测试文件中构建没有任何节点的Sorted_List时，似乎发生了错误，如下所示：

Sorted_List empty_list{};

以下是我想象的与错误相关的代码：

Sorted_List.cc

#include "Sorted_list.h"
#include <iostream>
#include <string>
#include <sstream>
using namespace std;

Sorted_List::Sorted_List() : head{nullptr} {}

Sorted_List::Sorted_List(initializer_list<int> i)
  :Sorted_List()
{
  for (auto ii : i)
    {
      add_val(ii);
    }
}

Sorted_List::~Sorted_List()
{
  if (!check_empty())
    {
      Node* del = head;
      while(del != nullptr)
    {
      Node* next = del->next;
      delete del;
      del = next;
    }
    }
}

bool Sorted_List::check_empty() const
{
  return (head->value == 0 && head->next == nullptr);
}


void Sorted_List::del_val(int num)
{
  Node* del = head;
  if (num == 1)
  {
    head = del->next;
    delete del;
  }
  for (int i = 1; i < num - 1; i++)
    {
      del = del->next;
    }
}

void Sorted_List::add_val(int num)
{
  Node* temp = new Node;
  temp->value = num;
  if (head == nullptr || head->value >= temp->value)
    {
      temp->next = head;
      head = temp;
    }    
  else
    {
      Node* current = head;
      while(current->next != nullptr && current->next->value <temp->value)
    {
      current = current->next;
    }
      temp->next = current->next;
      current->next = temp;
    }
}
string Sorted_List::print( Sorted_List& list)
{
  Sorted_List::Node* temp;
  stringstream list_stream;
  for(temp = list.head; temp != nullptr; temp = temp->next) 
    {
      list_stream << temp->value;
      if(temp->next != nullptr)
    list_stream << ", ";
    }
  return list_stream.str();
}

Sorted_List.h

#ifndef SORTED_LIST_H
#define SORTED_LIST_H

#include <string>
#include <iostream>
#include <initializer_list>
#include <string>

class Sorted_List
{
private:
    class Node
    {
    public:
        int value{};
        Node* next{};
    };
Node* head{};

public:
    Sorted_List();
    Sorted_List(std::initializer_list<int>);
    ~Sorted_List();

    std::string print(Sorted_List&);
    void add_val(int num);
    bool check_empty() const;
    void del_val(int num);
};

#endif

Sorted_List_test.cc

#define CATCH_CONFIG_MAIN
#include "Sorted_list.h"
#include "catch.hpp"
#include <iostream>
#include <string>
using namespace std;

TEST_CASE(" EMPTY ")
{  
  Sorted_List empty_list{}; // this is where the error occurs
  //REQUIRE(empty_list.check_empty() == true);
  //REQUIRE(empty_list.print(empty_list) == "");
}

任何线索？

Answer 1

如果使用调试器，您将看到empty_list对象被销毁时发生崩溃。更确切地说，在析构函数调用的check_empty函数中。

这是因为默认构造函数将head设置为空指针，然后在check_empty中取消引用此空指针。

您的check_empty函数应检查head是否为空指针。

单向列表中的分段违规信号

1 个答案: