Segmentation fault (core dumped) ? what is it and why is caused ??? ( doubly circular linked list program in c++)

Question

My program (its not complete but I would really like to know my error):

#include <iostream.h>
using namespace std;
class dcllnode
{
private:
    int data;
    dcllnode *next;
    dcllnode *prev;
public:
    dcllnode(int ele)
    {
        data = ele;
        prev = next;
        next = prev;
    }
    friend class dcll;
};

class dcll
{
private:
    dcllnode *head;
public:
    dcll()
    {
        head = NULL;

    }
    void create();
    void inserts(int ele);
    void inserte(int ele);
    void inserta(int ele, int pos);
    void insertb(int ele, int pos);
    void dels();
    void dele();
    void dela();
    void display();
};
void dcll::create()
{
    if (head == NULL)
    {
        head = new dcllnode(0);
        cout << "list is created";
    }
    else
    {
        cout << "list has already been created";
    }
}
void dcll::inserts(int ele)
{
    if (head == NULL)
        cout << "please create the list first ";
    else
    {
        dcllnode *x;
        x = new dcllnode(ele);
        x->prev = head;
        x->next = head->next;
        (head->next)->prev = x;
        head->next = x;
        cout << "list is modified";
    }
}

void dcll::inserte(int ele)
{
    if (head == NULL)

        cout << "please create the list first ";
    else
    {
        dcllnode *x;
        x = new dcllnode(ele);
        x->next = head;
        x->prev = head->prev;
        (head->prev)->next = x;
        head->prev = x;
        cout << "list is modified";
    }
}

void dcll::dels()
{
    if (head == NULL)
        cout << "please create the list first ";
    else
    {
        dcllnode *x;
        head->next = x;
        head->next = x->next;
        (x->next)->prev = head;
        x->next = NULL;
        x->prev = NULL;
        delete(x);
        cout << "list is modified";
    }
}

void dcll::dele()
{
    if (head == NULL)
        cout << "please create the list first ";
    else
    {
        dcllnode *x;
        head->prev = x;
        head->prev = x->prev;
        (x->prev)->next = head;
        x->prev = NULL;
        x->next = NULL;
        delete(x);
        cout << "list is modified";
    }
}
void dcll::display()
{
    if (head == NULL)
        cout << "please create the list first ";
    else
    {
        dcllnode *p = head->next;
        while (p != head)
        {
            cout << "\n" << p->data;
            p = p->next;
        }
    }
}

int main()
{
    dcll l1;
    l1.create();
    l1.inserte(10);
    l1.display();
    l1.inserts(20);
    return 0;
}

The segmentation problem is not occurring when I use only the create function. I would like to know how to solve such problems and how to avoid segmentation errors in future any information and/or help is appreciated.

`dcllnode`'s constructor makes sure that both `prev` and `next` have the same indeterminate value. You're not going to be able to use them. I would recommend that you start with a singly-linked list for pointer practice. — molbdnilo, Jun 26 '15 at 14:26
i have done singly linked list ... i was able to execute it without any glitch ......... — Tina Hakim, Jun 26 '15 at 15:34

score 1 · Answer 1 · answered Jun 26 '15 at 14:17

You typically get segmentation faults when using illegal pointers (null or uninitialized pointers, or pointers pointing to unallocated or otherwise illegal memory).

In your case it's easy to see what one of the problems are, it's in the dcllnode constructor where you do

prev = next;
next = prev;

When you do these assignments the pointers next and prev are uninitialized, and their values are indeterminate. Assigning them to each other like this will not initialize them, just make them both have the same indeterminate value. Later when you dereference these pointers you will have undefined behavior leading to your segmentation fault and the crash.

What you probably should to is to initialize both pointers to null:

prev = nullptr;  // or 0
next = nullptr;  // or 0

_{[Note: In C++ don't use NULL, use either nullptr (preferred) or if you don't have it then plain 0.]}

and if it is a circular list (head->next)->prev = x; (head->prev)->next = x; they wont be null right ? — Tina Hakim, Jun 26 '15 at 14:27

score 1 · Answer 2 · answered Jun 26 '15 at 14:21

1

To complete joachim's answer, in these two statements:

(head->next)->prev = x;
(head->prev)->next = x;

head->next and head->prev can be nullptr so you have to check it before dereferencing the pointer.

answered Jun 26 '15 at 14:21

Brahim

808
1
8
17

Segmentation fault (core dumped) ? what is it and why is caused ??? ( doubly circular linked list program in c++)

2 Answers2