Thread: Segmentation Fault before faulty code is ever reached?

Here I have a segmentation fault caused by my function insert. It's not like one I've seen before though. Run insert once and it works fine. Run it twice and a segmentation fault occurs before insert even gets a chance to run. Could someone explain this?

Code:

#include <stdio.h>
#include <stdlib.h>

struct listnode {
	int num;
	struct listnode *nextPtr;
};

typedef struct listnode ListNode;

void insert( ListNode **sPtr, int number );
void display( ListNode **sPtr );



int main()
{
	ListNode *ptr = NULL;

	insert( &ptr, 2 );	
	insert( &ptr, 3 );
//	insert( &ptr, 111 );
	display( &ptr );
	return 0;
}




void display( ListNode **sPtr )
{
	ListNode *currentPtr = NULL;
	currentPtr = *sPtr;

	while ( currentPtr != NULL ) {
		printf( "%10d", currentPtr->num );
		currentPtr = currentPtr->nextPtr;
	}
}



void insert( ListNode **sPtr, int number )
{
	ListNode *newPtr = NULL;
	ListNode *currentPtr = NULL;
	ListNode *previousPtr = NULL;
// -------------This Test Statement is Never Reached when there are two inserts --------
printf( "test" );

	newPtr = malloc( sizeof( ListNode ) );
	newPtr->num = number;
	newPtr->nextPtr = *sPtr;

	if ( newPtr != NULL ) {
		printf( "hello" );
		if ( *sPtr == NULL ) {
			*sPtr = newPtr;
		}
		else {
			currentPtr = *sPtr;

			while ( currentPtr->nextPtr != NULL && currentPtr->num < number ) {
				previousPtr = currentPtr;
				currentPtr = currentPtr->nextPtr;
			}
			previousPtr->nextPtr = newPtr;
			newPtr->nextPtr = currentPtr;
		}
	}
}

any luck with gdb in pinpointing the source of the problem?

The problem is in your while loop. On the second call of your function (which is the first time the while loop is executed) currentPtr->nextPtr will be NULL, so the value of previousPtr will be NULL on completion of the loop. The first line after that loop is dereferencing previousPtr (i.e. dereferencing a NULL pointer).

It is also a good idea to check that newPtr (returned from malloc()) is non-NULL before setting newPtr->num and newPtr->nextPtr.

>>itCbitC
No, I haven't figured GDB out yet. It's on my todo list

>>Grumpy
That makes some sense. Why am I getting a segmentation fault before the first instance gets a chance to run? printf( "test" ) should run at least once. It does run when my main body has only one insert. But not even once when it has two or more inserts.

Your belief that "test" appears on your screen instantaneously is mistaken. If you want to see what's written to the screen, you should use fflush(stdout) [although usually putting a \n in the printed string is enough to force a flush as well].

Hey, Elysia...have you ever received a "segmentation fault" in Windows? If not, can you point me to a version of Visual Studio that runs on an OS that reports segmentation faults?

I know you're a Microsoft partisan, but a little context tells you this person is running this program in the Linux/Unix/BSD world. If this person said they got an Access Violation, I would have pointed them to the Visual Studio debugger.

Just get over it... a segfault is a UNIX/Linux/BSD thing, and GDB is the debugger that has >99% userbase on those systems.

It's like saying we can't assume a person saying he is using IE 7 is on Windows.

Yeah, but it's only in popular use on the *nix side. People call it different names on different platforms ("Access Violation" on Windows according to rags_to_riches), but only the *nix people call it "segfault" (it's an affectionate name).