Segmentation violation signal in unidirectional list - c++

Question

I'm trying to make a unidirectional list with nodes containing a value and a pointer to the next node (the pointer in the final node is supposed to be a nullptr).
Howerver, things are not going as planed. It's compiling without any problems, but when I try to run it i get this fatal error condition:
SIGSEGV - Segmentation violation signal.
It think it's trying to reach memory which it doesn't have permission to use, or something? Another common cause is an accidental "=" instead of "==", but that doesn't seem to be the problem here.
It seems that the error occurs when I try to construct a Sorted_List without any nodes in my test file, like this:
Sorted_List empty_list{};
Here is the code I imagine can be relevant to the error:
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) == "");
}
Any clues?

Answer 1

If you use a debugger you will see that the crash happens when the empty_list object is destructed. More precisely in the check_empty function called from the destructor.
This is because the default constructor sets head to a null pointer, and then in the check_empty you dereference this null pointer.
Your check_empty function should check if head is a null pointer.