title: Segmentation Fault when trying to push a string to the back of a list
body: <p>I am trying to write a logger class for my C++ calculator, but I'm experiencing a problem while trying to push a string into a list.</p>
  
  <p>I have tried researching this issue and have found some information on this, but nothing that seems to help with my problem. I am using a rather basic C++ compiler, with little debugging utilities and I've not used C++ in quite some time (even then it was only a small amount).</p>
  
  <p>My code:</p>
  
  <pre><code>#ifndef _LOGGER_H_
  #define _LOGGER_H_
  
  #include &lt;iostream&gt;
  #include &lt;list&gt;
  #include &lt;string&gt;
  
  using std::cout;
  using std::cin;
  using std::endl;
  using std::list;
  using std::string;
  
  class Logger
  {
  private:
   list&lt;string&gt; mEntries;
  
  public:
   Logger() {}
   ~Logger() {}
  
   // Public Methods
   void WriteEntry(const string&amp; entry)
   {
    mEntries.push_back(entry);
   }
  
   void DisplayEntries()
   {
    cout &lt;&lt; endl &lt;&lt; "**********************" &lt;&lt; endl
              &lt;&lt; "*   Logger Entries   *" &lt;&lt; endl
        &lt;&lt; "**********************" &lt;&lt; endl
      &lt;&lt; endl;
  
    for(list&lt;string&gt;::iterator it = mEntries.begin();
     it != mEntries.end(); it++)
    {
    // *** BELOW LINE IS MARKED WITH THE ERROR ***
     cout &lt;&lt; *it &lt;&lt; endl;
    }
   }
  };
  
  #endif
  </code></pre>
  
  <p>I am calling the WriteEntry method by simply passing in a string, like so:</p>
  
  <pre><code>mLogger-&gt;WriteEntry("Testing");
  </code></pre>
  
  <p>Any advice on this would be greatly appreciated.</p>
  
  <p><strong>* CODE ABOVE HAS BEEN ALTERED TO HOW IT IS NOW *</strong></p>
  
  <p>Now, the line:</p>
  
  <pre><code>cout &lt;&lt; *it &lt;&lt; endl;
  </code></pre>
  
  <p>causes the same error. I'm assuming this has something to do with how I am trying to get the string value from the iterator.</p>
  
  <p>The code I am using to call it is in my main.cpp file:</p>
  
  <pre><code>#include &lt;iostream&gt;
  #include &lt;string&gt;
  #include &lt;sstream&gt;
  #include "CommandParser.h"
  #include "CommandManager.h"
  #include "Exceptions.h"
  #include "Logger.h"
  
  using std::string;
  using std::stringstream;
  using std::cout;
  using std::cin;
  using std::endl;
  
  #define MSG_QUIT    2384321
  #define SHOW_LOGGER true
  
  void RegisterCommands(void);
  void UnregisterCommands(void);
  int ApplicationLoop(void);
  void CheckForLoggingOutput(void);
  void ShowDebugLog(void);
  
  // Operations
  double Operation_Add(double* params);
  double Operation_Subtract(double* params);
  double Operation_Multiply(double* params);
  double Operation_Divide(double* params);
  
  // Variable
  CommandManager  *mCommandManager;
  CommandParser   *mCommandParser;
  Logger          *mLogger;
  
  int main(int argc, const char **argv)
  {
      mLogger-&gt;WriteEntry("Registering commands...\0");   
  
      // Make sure we register all commands first
      RegisterCommands();
  
      mLogger-&gt;WriteEntry("Command registration complete.\0");
  
      // Check the input to see if we're using the program standalone,
      // or not
      if(argc == 0)
      {
          mLogger-&gt;WriteEntry("Starting application message pump...\0");
  
          // Full version
          int result;
          do
          {
              result = ApplicationLoop();
          } while(result != MSG_QUIT);
      }
      else
      {
          mLogger-&gt;WriteEntry("Starting standalone application...\0");
  
          // Standalone - single use
          // Join the args into a string
          stringstream joinedStrings(argv[0]);
          for(int i = 1; i &lt; argc; i++)
          {
              joinedStrings &lt;&lt; argv[i];
          }
  
          mLogger-&gt;WriteEntry("Parsing argument '" + joinedStrings.str() + "'...\0");
  
          // Parse the string
          mCommandParser-&gt;Parse(joinedStrings.str());
  
          // Get the command names from the parser
          list&lt;string&gt; commandNames = mCommandParser-&gt;GetCommandNames();
  
          // Check that all of the commands have been registered
          for(list&lt;string&gt;::iterator it = commandNames.begin();
              it != commandNames.end(); it++)
          {
              mLogger-&gt;WriteEntry("Checking command '" + *it + "' is registered...\0");
  
              if(!mCommandManager-&gt;IsCommandRegistered(*it))
              {
                  // TODO: Throw exception
                  mLogger-&gt;WriteEntry("Command '" + *it + "' has not been registered.\0");
              }
          }
  
          // Get each command from the parser and use it's values
          // to invoke the relevant command from the manager
          double results[commandNames.size()];
          int currentResultIndex = 0;
          for(list&lt;string&gt;::iterator name_iterator = commandNames.begin();
              name_iterator != commandNames.end(); name_iterator++)
          {
              string paramString = mCommandParser-&gt;GetCommandValue(*name_iterator);
              list&lt;string&gt; paramStringArray = StringHelper::Split(paramString, ' ');
  
              double params[paramStringArray.size()];
              int index = 0;
              for(list&lt;string&gt;::iterator param_iterator = paramStringArray.begin();
                  param_iterator != paramStringArray.end(); param_iterator++)
              {
                  // Parse the current string to a double value
                  params[index++] = atof(param_iterator-&gt;c_str());
              }
  
              mLogger-&gt;WriteEntry("Invoking command '" + *name_iterator + "'...\0");
  
              results[currentResultIndex++] =
                  mCommandManager-&gt;InvokeCommand(*name_iterator, params);
          }
  
          // Output all results
          for(int i = 0; i &lt; commandNames.size(); i++)
          {
              cout &lt;&lt; "Result[" &lt;&lt; i &lt;&lt; "]: " &lt;&lt; results[i] &lt;&lt; endl;
          }
      }
  
      mLogger-&gt;WriteEntry("Unregistering commands...\0");
  
      // Make sure we clear up our resources
      UnregisterCommands();
  
      mLogger-&gt;WriteEntry("Command unregistration complete.\0");
  
      if(SHOW_LOGGER)
      {
          CheckForLoggingOutput();
      }
  
      system("PAUSE");
  
      return 0;
  }
  
  void RegisterCommands()
  {
      mCommandManager = new CommandManager();
      mCommandParser = new CommandParser();
      mLogger = new Logger();
  
      // Known commands
      mCommandManager-&gt;RegisterCommand("add", &amp;Operation_Add);
      mCommandManager-&gt;RegisterCommand("sub", &amp;Operation_Subtract);
      mCommandManager-&gt;RegisterCommand("mul", &amp;Operation_Multiply);
      mCommandManager-&gt;RegisterCommand("div", &amp;Operation_Divide);
  }
  
  void UnregisterCommands()
  {
      // Unregister each command
      mCommandManager-&gt;UnregisterCommand("add");
      mCommandManager-&gt;UnregisterCommand("sub");
      mCommandManager-&gt;UnregisterCommand("mul");
      mCommandManager-&gt;UnregisterCommand("div");
  
      // Delete the logger pointer
      delete mLogger;
  
      // Delete the command manager pointer
      delete mCommandManager;
  
      // Delete the command parser pointer
      delete mCommandParser;
  }
  
  int ApplicationLoop()
  {
      return MSG_QUIT;
  }
  
  void CheckForLoggingOutput()
  {
      char answer = 'n';
  
      cout &lt;&lt; endl &lt;&lt; "Do you wish to view the debug log? [y/n]: ";
      cin &gt;&gt; answer;
  
      switch(answer)
      {
          case 'y':
              ShowDebugLog();
              break;
      }
  }
  
  void ShowDebugLog()
  {
      mLogger-&gt;DisplayEntries();
  }
  
  // Operation Definitions
  double Operation_Add(double* values)
  {
      double accumulator = 0.0;
  
      // Iterate over all values and accumulate them
      for(int i = 0; i &lt; (sizeof values) - 1; i++)
      {
          accumulator += values[i];
      }
  
      // Return the result of the calculation
      return accumulator;
  }
  
  double Operation_Subtract(double* values)
  {
      double accumulator = 0.0;
  
      // Iterate over all values and negativel accumulate them
      for(int i = 0; i &lt; (sizeof values) - 1; i++)
      {
          accumulator -= values[i];
      }
  
      // Return the result of the calculation
      return accumulator;
  }
  
  double Operation_Multiply(double* values)
  {
      double accumulator = 0.0;
  
      for(int i = 0; i &lt; (sizeof values) - 1; i++)
      {
          accumulator *= values[i];
      }
  
      // Return the value of the calculation
      return accumulator;
  }
  
  double Operation_Divide(double* values)
  {
      double accumulator = 0.0;
  
      for(int i = 0; i &lt; (sizeof values) - 1; i++)
      {
          accumulator /= values[i];
      }
  
      // Return the result of the calculation
      return accumulator;
  }
  </code></pre>
  
  <hr>