So the program compiled but as soon as you enter a number for the length of the word it comes up with a segmentation error.
Here is my code

.h
#ifndef GUESSER_H
#define GUESSER_H

#include <string>


class Game;

class Guesser {
public:
  // Initialize the guesser for a game with the indicated wordlength,
  // using words from an indicated file.
  Guesser (int wordLength, const char* wordListFilename);


  /**
   * Scan the words that are possible solutions so far, counting, for
   * each letter not already tried, the number of words with that letter.
   * Guess the letter that occurs in the most words.
   */
  char guessACharacter();


  /**
   * Following a successful guess of a letter in the word, make a pass through
   * the possibleSolutions, removing all words that do not contain the
   * guess character in the positions indicated in wordSoFar.
   */
  void characterIsInWord (char guess, const std::string& wordSoFar);


  /**
   * Following a mistaken guess of a letter in the word, make a pass through
   * the possibleSolutions, removing all words that contain the
   * guess character.
   */
  void characterIsNotInWord (char guess);


  /**
   * Guesser has lost the game. Look at the provider's actual word
   * and gripe a bit about losing.
   */
  void admitToLoss (std::string actualWord, const std::string& wordSoFar);
private:

  struct ListNode {
    std::string data;
    ListNode* next;

    ListNode (std::string str, ListNode* nxt)
      :data(str), next(nxt)
    {}
  };

  // A collection of words that match all guesses made so far
  ListNode* possibleSolutions;

  // Tracks characters already guessed.
  //  charactersTried[c-'a'] is true if the character c
  //    has been guessed previously
  bool charactersTried[26];

  static const std::string alphabet;


  // For grading purposes - Ignore this (but don't remove it)
  friend void instructorCheck (const Guesser& g);

};



.cpp

#include "guesser.h"
#include "game.h"

#include <iostream>
#include <fstream>

using namespace std;

const std::string Guesser::alphabet = "abcdefghijklmnopqrstuvwxyz";

// Initialize the guesser for a game wit hthe indicated wordlength,
// using words from an indicated file.
Guesser::Guesser (int wordLength, const char* wordListFilename)
{

    for (int i = 0; i < 26; ++i)
        charactersTried[i] = false;

    string word;
    ifstream in (wordListFilename);
    while (in >> word)
    {
        if (word.size() == wordLength)
    {
      // word is of desired length
        if (word.find_first_not_of(alphabet) == string::npos)
        {
            possibleSolutions->data = word;
            possibleSolutions = possibleSolutions->next;
        }
    }
    in.close();
    }
}
/**
 * Scan the words that are possible solutions so far, counting, for
 * each letter not already tried, the number of words with that letter.
 * Guess the letter that occurs in the most words.
 */
char Guesser::guessACharacter()
{
    int counts[26];
    for (int i = 0; i < 26; ++i)
        counts[i] = 0;

  // Count the number of words in which each letter can be found
    for (ListNode* current = possibleSolutions; current != NULL; current = current->next)
    {
    std::string word = current->data;

        for (char c = 'a'; c <= 'z'; ++c)
        {
            if (!charactersTried[c- 'a'])
            {
          // Character c has not been tried yet
                if (word.find(c) != string::npos)
        // c is in this word
                    ++counts[c - 'a'];
            }
        }
    }

  // Find the character that occurs in the most words
    char guess = ' ';
    int maxSoFar = -1;
    for (char c = 'a'; c <= 'z'; ++c)
    {
        if (counts[c - 'a'] > maxSoFar)
        {
            guess = c;
            maxSoFar = counts[c - 'a'];
        }
    }


    if (maxSoFar <= 0)
    {
        guess = 'a';
        while (charactersTried[guess-'a'])
        ++guess;
    }

    charactersTried[guess-'a'] = true;
    return guess;
}


/**
 * Following a successful guess of a letter in the word, make a pass through
 * the possibleSolutions, removing all words that do not contain the
 * guess character in the positions indicated in wordSoFar.
 */
void Guesser::characterIsInWord (char guess, const string& wordSoFar)
{
  ListNode* remainingSolutions = 0;

  for (ListNode* current = possibleSolutions; current != NULL; current = current->next)
    {
      string wd = current->data;
      bool OK = true;
      for (int k = 0; OK && k < wordSoFar.size(); ++k)
    {
      if (wordSoFar[k] == guess)
        {
          if (wd[k] != guess)
        {
            OK = false;
        }
        }
    }
      if (OK)
    {
      //cerr << "Keeping " << wd << endl;
        remainingSolutions->data=wd;
    }
    }

    possibleSolutions = remainingSolutions;

}


/**
 * Following a mistaken guess of a letter in the word, make a pass through
 * the possibleSolutions, removing all words that contain the
 * guess character.
 */
void Guesser::characterIsNotInWord (char guess)
{
    ListNode* remainingSolutions;
    for (ListNode* current = possibleSolutions; current != NULL; current = current->next)
    {
      string wd = current->data;
      if (wd.find(guess) == string::npos)
    {
      remainingSolutions = new ListNode(wd, remainingSolutions);
    }
}

  possibleSolutions = remainingSolutions;
}


/**
 * Guesser has lost the game. Look at the provider's actual word
 * and gripe a bit about losing.
 */
void Guesser::admitToLoss (std::string actualWord, const string& wordSoFar)
{
  bool match = actualWord.size() == wordSoFar.size();
  for (int i = 0; match && i < actualWord.size(); ++i)
    {
      match = wordSoFar[i] == Game::FILL_CHARACTER ||
    wordSoFar[i] == actualWord[i];
    }
  if (!match)
    {
      cout << "Ummm...your word '" << actualWord
       << "' does not match the patterh '"
       << wordSoFar <<"'.\nDid you make a mistake somewhere?"
       << endl;
    }
  else
    {
      for (int i = 0; match && i < actualWord.size(); ++i)
    {
      if (wordSoFar[i] == Game::FILL_CHARACTER
          && charactersTried[actualWord[i]-'a'])
        {
          cout << "Did you forget to mention the '"
           << actualWord[i]
           << "' in position " << i+1 << "?"
           << endl;
          return;
        }
    }

      for (ListNode* current = possibleSolutions; (!match) && current != NULL; current = current->next)
    {
        match = (actualWord == current->data);
        current = current->next;
        match = match && (current != 0);
    }
      if (match)
    {
      cout << "OK, I might have guessed that eventually." << endl;
    }
      else
    {
      cout << "Interesting, I don't know that word. Are you sure you\n"
           << "spelled it correctly?." << endl;
    }

    }

}


#endif

My error appears in the .cpp file " string wd = current->data;"

Could someone please just point me in the right direction on how to go about fixing this?
Thank you.

Maybe it would be easier to debug if you wrote a small program with main() that tests that class. That way you can test it without trying to debug your entire game at the same time.