Link List Help!

[elite zero]

This code is designed to tokenize names from an Input File from command line, insert them into a node, insert them into the list (in order by Last Name, First Name, or Age), and the last part (which I haven't started yet) will be to delete from this List a list of names from an Input file.

I have commented out the first name order, and age order to make it easier and get started. There are a few comments within as well that can be ignored. One is due to my Professor using a Mac and Vi[M] so things like (system("pause"), and strtok_s) don't work on his system so I have noted to myself to change them over.

My problem that I am having is getting the program to input into the next node after the head node. I tends to break when it gets to any "current-> next" due to it attempting to access a NULL value. Even if I try to set current = head, it will say it is NULL. Any help or advice is appreciated!

** NOTE **

Original - 12:00 AM [3/17/2014]

#include <iostream>
#include <fstream>
#include <cstdlib>
#include <stdlib.h>
#include <iomanip>
#include <sstream>
#include <stdio.h>
#include <windows.h>
#include <cstddef>
#include <string.h>

using namespace std;

const int buff_size = 81; // buffer size of 81 characters

ifstream input_File;
ifstream delete_File;

int i = 0;
char *buffer = new char[buff_size], // Tokenizing pointers
     *tokens[3],
	 *ptr,
	 *placeHolder;

string firstN; // Global variables
string lastN;
string ages;
int pause;

//-----------------------------------------------------------------------------

struct listNode // Structure named listNode
 {
  string age;       // Values within nodes
  string firstName;
  string lastName;
  listNode* next;
 };

listNode* newNode; // Node pointers
listNode* current;
listNode* head;
listNode* prev_Ptr;

//-----------------------------------------------------------------------------

void initializeList()
 {
  head = NULL;
  current = head;
  prev_Ptr = head;
 }

//-----------------------------------------------------------------------------

void reportDuplicate()
 {
  cout << "Duplicate Record: " << current-> lastName << " ";
  cout << current-> firstName << " ";
  cout << current-> age << endl;
 }

//-----------------------------------------------------------------------------

void incompleteRecord()
{
 cout << "Record incomplete: " << tokens[0] << " " << tokens[1] << " " << 
	  tokens[2] << endl;
}// end void incompleteRecord()

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

void insertName(string lastN, string firstN, string ages)
{

 // Initializes list on insertion
 // Creates new node and inserts tokenized values

 newNode = new listNode;
 newNode-> lastName = lastN;
 newNode-> firstName = firstN;
 newNode-> age = ages;
 newNode-> next = NULL;
 

 cout << newNode-> lastName << " " << newNode-> firstName << " " << newNode-> age << endl;

 if(head == NULL) // If no head node, create one
  {
   head = newNode;
   newNode-> next = NULL;
  }

 else
  {
   while(head) // Traverse the list
   {

    if(newNode-> lastName == current-> lastName)
	 {
/*	  if(current-> firstName == newNode-> firstName)
	   {
		if(current-> age == newNode-> age)
		 {
	      reportDuplicate();
	     }

		//-------------------------- age Order

		else if(current-> age < newNode-> age) 
		 {
		  newNode-> next = current;
		  prev_Ptr-> next = newNode;
		 }
		else //if(current-> age > newNode-> age)
		 {
		  newNode-> next = current-> next;
		  current-> next = newNode;
		 }
	   }

	  //-------------------------------- firstName Order

	  else if(current-> firstName < newNode-> firstName)
	   {
	    newNode-> next = current;
		prev_Ptr-> next = newNode;
	   }
	  else //if(current-> firstName > newNode-> firstName)
	   {
		newNode-> next = current-> next;
		current-> next = newNode;
	   }*/
	 }

	//------------------------------- lastName Order

	else if(newNode-> lastName < current-> lastName)
	 {
	  newNode-> next = current;
	  prev_Ptr-> next = newNode;
	 }
	else //if(newNode-> lastName > current-> lastName)
	 {
	  newNode-> next = current-> next;
	  current-> next = newNode;
	 }

  }//end While(loop) traversal
 }//end else(head)
}//end void insertName(...)

//-----------------------------------------------------------------------------

void tokenizingFunction()
 {
    while(input_File.getline(buffer, buff_size))
     {
      // If we found a blank line (newline char in column 1), ignore it and 
      // continue. 

      if(strlen(buffer) == 0)
	   continue;
      
      // Break the input string into white space separated tokens.
	  // 3rd parameter needs to be a char**_Context
      // Use char* (placeHolder) as a place holder within the string (used in strtok_s)

      ptr = (char *)strtok_s(buffer, " ", &placeHolder); // Remember to change this for Mac

      // If ptr == NULL, then other than whitespace, the input line is
      // empty.
    
      if(!ptr)
	   continue;
      
      // Store the tokens in tokens[]

      i = 0;

      tokens[i] = (char *)_strdup(ptr);

      do
	   {
        ptr = (char *)strtok_s('\0', " ", &placeHolder); // Remember to change this for Mac 

         if(ptr)
          {
           tokens[++i] = (char *)_strdup(ptr);
          }
		 
       }
      while(ptr); 

	  lastN = tokens[0];  // string lastN
	  firstN = tokens[1]; // string firstN
	  ages = tokens[2];   // string ages 

	   if(buffer && tokens[2]) // Not a blank line, and token[2] has token
	   {
        insertName(lastN, firstN, ages); // Insert
	   }
	  
	 }

  delete(buffer);
 } // end void tokenizingFunction()

//-----------------------------------------------------------------------------

  // Possible node activity //

  // newNode-> lastName;   -value of lastName
  // newNode-> firstName;  -value of firstName
  // newNode-> age;        -value of age
  // newNode-> next;       -pointer to next node

//-----------------------------------------------------------------------------

void displayList()
{
 cout << "\nDisplaying List" << endl << endl;

 current = head;

  while(current)
   {
    if(!current)
     {
	  cout << "\nEnd of list!" << endl;
     }
    else
     {
	  cout << current-> lastName << " ";
	  cout << current-> firstName << " ";
	  cout << current-> age << endl;

	  current = current-> next;
     }
   
  }// end while
}// end void displayList()

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

int main()//int argc, char *argv[])
{
   // Open input stream files for use without argc / argv ------ delete before turning in
   input_File.open("names.txt");
   // delete_File.open("deleteThese.in");


  
/*if(argc != 3)	// Usage statement of how to use program via command line
 {
  cout << "\nUsage: " << argv[0] << " 'Input File Name 1'" << " 'Input File Name 2'\n" <<  endl;
  return(0);
 }

//--------------------------- ifstreams

ifstream input_File(argv[1], ios::in);	// Open first input file to read from
 if(input_File.is_open())
  {
   cout << "\nInput File is open..." << endl;
  } 
 else
  {
   cout << "\nInput File did NOT open..." << endl;
   return (1);
  }

ifstream delete_File(argv[2], ios::in);	// Open second input file to delete from
 if(delete_File.is_open())
  {
   cout << "\nDelete File is open..." << endl;
  }
 else 
  {
   cout << "\nDelete File is NOT open..." << endl;
   return (1);
  }*/

//-----------------------------------------------------------------------------

// Functions

initializeList(); // Initializes head, current, and prev_Ptr

while(input_File.good())
 {
  while(!input_File.eof())
   {
    tokenizingFunction(); // tokenizes and inserts into list
   }
 }

displayList();

//-----------------------------------------------------------------------------
 
  cin >> pause; // Non Windows Pause similar to (system("pause");)
  return 0;
} 

[Volatile Pulse]

Ok, I'm going to start out by saying, WTF? This program is much more overly complicated than it needs to be. A lot of comments, that I am assuming, are going to be code first, but your primary concern should have been understanding the list before adding in all of these other features. I will point out two things that will aide you better.

1)

listNode* newNode; // Node pointers
listNode* current;
listNode* head;
listNode* prev_Ptr;

Here, you have 4 global listNode pointers, none of which are really used except for head. The other ones should be local pointers in the functions they're needed in, not globals. To assist you, should should create a "tail" pointer that always points at the last, non-null, node. This will help you with 2.

2) Your issue is coming from the function insertName(). When you call it, you assign one of your global pointers with the data for the new node.

if(head == NULL) // If no head node, create one
  {
   head = newNode;
   newNode-> next = NULL;
  }

I don't believe this is ever needed. The node should always point to null, never anything else, not when you're just adding something anyways. if you're going to sort, sort with a separate function, not when adding. If you set tail up properly, you can have tail->next = newNode; and tail = newNode;. That alone should be the entire rest of that function. None of the other parts are really relevant.

Nevermind, you're using current as your tail, but here is something that isn't handled properly.

if(newNode-> lastName == current-> lastName)
	 {
/*	  if(current-> firstName == newNode-> firstName)
	   {
		if(current-> age == newNode-> age)
		 {
	      reportDuplicate();
	     }

		//-------------------------- age Order

		else if(current-> age < newNode-> age) 
		 {
		  newNode-> next = current;
		  prev_Ptr-> next = newNode;
		 }
		else //if(current-> age > newNode-> age)
		 {
		  newNode-> next = current-> next;
		  current-> next = newNode;
		 }
	   }

	  //-------------------------------- firstName Order

	  else if(current-> firstName < newNode-> firstName)
	   {
	    newNode-> next = current;
		prev_Ptr-> next = newNode;
	   }
	  else //if(current-> firstName > newNode-> firstName)
	   {
		newNode-> next = current-> next;
		current-> next = newNode;
	   }*/
	 }

That entire block is commented out, when that if statement is true, the node just disappears into digital nothingness.