Why is this causing a segmentation fault?

Question

I've been coding this in project in C++, normally I wouldn't have too much trouble with a segmentation fault, but I'm new to C++. Basically I'm making a pointer to an IntList and calling prepend() to make a IntList from the pointer. The problem is when prepend is called it is getting stuck somewhere in the header file an justd exits out. I can't tell what is causing this and gdb tells me it just gets stuck at the header. Help would be really appreciated, like a hint or clue to what I'm doing wrong. Thank you.

IntList.h:

#ifndef _INTLIST_H
#define _INTLIST_H

#include <string>
#include <cstring>
using namespace std;

class EmptyIntList;

class IntList
{
public:
     static IntList *emptyList();
     //static IntList *fromString(string s);                                                                                                                                                         

     virtual bool     isEmpty();
     IntList *prepend(int n);
     virtual int      head();
     virtual IntList *tail();
     string   toString();

     //     virtual int      length();                                                                                                                                                               
     //     virtual IntList *append(IntList *lst);                                                                                                                                                   

     //     virtual int      operator[](int n);                                                                                                                                                      

     //     virtual ~IntList();                                                                                                                                                                      

protected:
     IntList();
     IntList(IntList &);
     //     const IntList &operator=(const IntList &);                                                                                                                                               
private:
     int      data;
     IntList *rest;
};


IntList *operator+(IntList &lst1, IntList &lst2);
ostream &operator<<(ostream &outStream, IntList *lst);
ostream &operator<<(ostream &outStream, IntList &lst);

#endif

IntList.cpp:

#include "IntList.h"
#include "EmptyIntList.h"
#include <sstream>

IntList::IntList(){}

IntList *IntList::emptyList(){

  return ( (IntList*)EmptyIntList::emptyList() );

}

bool IntList::isEmpty(){

  return false;

}

IntList *IntList::prepend(int n){

  IntList *x;

  IntList y;

  *x = y;

  y.data = n ;

  y.rest = x ;

  return x;

}

int IntList::head(){

  return data;

}

IntList *IntList::tail(){

  return rest;

}

testIntList.cpp:

int main()
{
  int n;
  IntList *x;
  n=6;

  x->prepend(n);
  //  cout << x->toString();                                                                                                                                                                         
  return 0;

}

gdb step by step:

8   int main()
(gdb) step
12    n=6;
(gdb) 
14    x->prepend(n);
(gdb) 
IntList::prepend (this=0x0, n=6) at IntList.cpp:30
30    IntList y;
(gdb) 
IntList (this=0x7fff93ecb3c0) at IntList.cpp:12
12  IntList::IntList(){}
(gdb) 
IntList::prepend (this=0x0, n=6) at IntList.cpp:32
32    *x = y;
(gdb) 
IntList::operator= (this=0x401650) at IntList.h:18
18  {
(gdb) 

Program received signal SIGSEGV, Segmentation fault.
0x0000000000401361 in IntList::operator= (this=0x401650) at IntList.h:18
18  {

You say you're new to C++? I'll recommend [a good introductory C++ book](http://stackoverflow.com/q/388242/46642). Yes, I say that to every neophyte :) — R. Martinho Fernandes, Oct 05 '11 at 23:20

score 1 · Answer 1 · answered Oct 05 '11 at 23:13

1

IntList *x;

This is uninitialized, and so is the value that it points to.

answered Oct 05 '11 at 23:13

Pubby

51,882
13
139
180

score 0 · Answer 2 · answered Oct 05 '11 at 23:12

0

Below line just defined a pointer, not malloc memory, so it's pointed to a random address in memory : IntList *x;

When you try to assign the value "y" to it, program crashes.

answered Oct 05 '11 at 23:12

shaowei_zhang

27
4

score 0 · Answer 3 · answered Oct 05 '11 at 23:13

I see two things right off the bat.

1) In main, you are not allocating an IntList, just an IntList* that points to garbage. When you call x->prepend, you are using uninitialized memory. You need a concrete object before you can call methods on it.

2) Your prepend method creates a locaion IntList, and returns it, which is a no-no. You're returning an object that had been on the stack and is now no longer valid (though it might work, sometimes. Funny thing, that undefined behavior.)

The return from `prepend` is fine. The UB in `prepend` is the same as main: `x` is not initialized. — R. Martinho Fernandes, Oct 05 '11 at 23:18

score 0 · Accepted Answer · answered Oct 06 '11 at 00:08

Any pointer that has not been initialized has an undefined value, e.g. it probably points to random garbage in the unallocated regions of the heap. Any dereference into an area of the heap which is not allocated is a segmentation fault.

You need to use the new operator to allocate some heap memory and get the address of that memory. In main:

IntList *x; // IntList
x = new IntList();

In prepend:

IntList *x;
x = new IntList(); // We now have no need for the local variable y
x->data = n;

It looks like you wanted to use the address-of operator to point x at y, i.e. x=&y but this will return a pointer to garbage. Any local variable is allocated on the stack and deallocated as soon as the function returns. Never retain a pointer to stack memory after the value pointed to leaves scope, as that memory is likely to be quickly re-allocated to something else, preventing a crash & causing mysterious behavior.

Look up the delete operator as well.

Why is this causing a segmentation fault?

4 Answers4

Linked

Related