Question

I was developing a generic linked list. Although the compiler doesn’t give any error but on running the program, it just crashes. I haven’t been able to figure out what’s wrong but since I am trying insert method of the list in main, the problem is somewhere there itself. Here’s the code in List.h

#include<cstdlib>

enum Error_code
{
    success,
    overflow,
    underflow,
    range_error
};

template<class Node_entry>
struct Node
{
    Node_entry entry;
    Node<Node_entry> *next;

    Node()
    {
        next=NULL;
    }

    Node(Node_entry item, Node<Node_entry> *add_on=NULL)
    {
        entry=item;
        next=add_on;
    }
};

template<class List_entry>
class List
{
  public:
    List()
    {
        count=0;
        head=NULL;
    }

    Error_code insert(int position, const List_entry &x)
    {
        if(position<0 || position>count)
            return range_error;
        Node<List_entry> *previous, *following, *new_node;
        if(position>0) {
            previous=set_position(position-1);
            following=previous->next;
        } else {
            following=head;
        }
        new_node = new Node<List_entry>(x, following);
        if(new_node==NULL)
            return overflow;
        if(position==0)
            head=new_node;
        else
            previous->next=new_node;
        count++;
        return success;
    }

    Error_code remove(int position, List_entry &x)
    {
        if(position<0 || position>count)
            return overflow;
        Node<List_entry> *old_node, *previous;
        if(position==0)
            old_node=head;
        else {
            previous=set_position(position-1);
            old_node=previous->next;
        }
        if(old_node==NULL)
            return underflow;
        if(position==0) {
            head=old_node->next;
            delete old_node;
        } else {
            previous->next=old_node->next;
            delete old_node;
        }
        count--;
        return success;
    }

    bool empty() const
    {
        return count==0;
    }

    ~List()
    {
        Node<List_entry> *temp_node=head->next;
        while(!empty()) {
            delete head;
            head=temp_node;
            temp_node=head->next;
        }
    }

  protected:
    int count;
    Node<List_entry> *head;

    Node<List_entry> *set_position(int position)const
    {
        Node<List_entry> *q=head;
        for(int i=0;i<count;i++)
            q=q->next;
        return q;
    }
};

main.cpp

#include <iostream>
#include"List.h"
using namespace std;
int main()
{
    int i;
    List<int> the_list;
    the_list.insert(1, 2);
}

P.S I am just into learning the basics for now and not working on large scale design modules and practices. At this point, this only needs to work.

Answer 1

What happens in your main function is:

1. Construct list; success.
2. Try to insert at position 1, which fails with range_error because position>count. If you choose to return error codes, you should always check for them.
3. Destroy list. This segfaults because head is NULL when you try to dereference it with Node<List_entry> *temp_node=head->next;