Memory leak in a std::string

Question

I am trying to make my shell terminate if user enter's "shutdown" or "restart" in the shell command line. Everything is working fine. I used C (strtok, cstring) and C++ to write the code. When I use valgrind it says that 1 block is still reachable. I know that it's not a leak but I will love to know what's causing it and how to solve it. Spent 2 days on trying to find it an couldn't. Please have a look at my code and the valgrind report.

CODE

#include <iostream>
#include <fstream>
#include <sstream>
#include <stdlib.h>
#include <string.h>
#include <signal.h>

using namespace std;

const int MAX_COMMAND_LINE_ARGUMENTS = 8;
const int SLEEP_DELAY = 100000;

int GetCommand (string tokens []);
int TokenizeCommandLine (string tokens [], string commandLine);
bool CheckForCommand ();
void ProcessCommand (string tokens [], int tokenCount);
void ShutdownAndRestart (string tokens [], int tokenCount);

static volatile sig_atomic_t cullProcess = 0;

int main()
{
    string tokens [MAX_COMMAND_LINE_ARGUMENTS];
    int tokenCount;

    do
    {
        tokenCount = GetCommand (tokens);
        ProcessCommand (tokens, tokenCount);
    } while (1);

    return 0;
}
int GetCommand (string tokens [])
{
    string commandLine;
    bool commandEntered;
    int tokenCount;

    do
    {
         cout << "shell> ";
        while (1)
        {
            getline (cin, commandLine);
            commandEntered = CheckForCommand ();            if (commandEntered)
            {
                break;
            }
        }


      } while (commandLine.length () == 0);

      tokenCount = TokenizeCommandLine (tokens, commandLine);
      commandLine.clear();
      return tokenCount;
}

int TokenizeCommandLine (string tokens [], string commandLine)
{
    char *token [MAX_COMMAND_LINE_ARGUMENTS];
    char *workCommandLine = new char [commandLine.length () + 1];
    int i;
    int tokenCount;

    for (i = 0; i < MAX_COMMAND_LINE_ARGUMENTS; i ++)
    {
        tokens [i] = "";
    }

    strcpy (workCommandLine, commandLine.c_str ());
    i = 0;
    if ((token [i] = strtok (workCommandLine, " ")) != NULL)
    {
        i ++;
 while ((token [i] = strtok (NULL, " ")) != NULL)
        {
            i ++;
        }
    }
    tokenCount = i;

    for (i = 0; i < tokenCount; i ++)
    {
        tokens [i] = (string) token [i];
    }

    delete [] workCommandLine;
    return 0;
}

bool CheckForCommand ()
{
    if (cullProcess)
    {
        cullProcess = 0;
        cin.clear ();
        cout << "\b\b  \b\b";
        return false;
    }

    return true;
}



void ProcessCommand (string tokens [], int tokenCount)
{
    if (tokens [0] == "shutdown" || tokens [0] == "restart")
    {
        ShutdownAndRestart (tokens, tokenCount);
        return;
    }
}
void ShutdownAndRestart (string tokens [], int tokenCount)
{
    if (tokenCount > 1)
    {
        cout << "shell: " << tokens [0] << " does not require any arguments" << endl;
        return;
    }

    cout << endl;
    cout << "shell: terminating ..." << endl;
    exit(0);
}

VALGRIND

valgrind --leak-check=full --show-leak-kinds=all --show-reachable=yes tryThis

==20257== Memcheck, a memory error detector
==20257== Copyright (C) 2002-2015, and GNU GPL'd, by Julian Seward et al.
==20257== Using Valgrind-3.12.0 and LibVEX; rerun with -h for copyright info
==20257== Command: tryThis
==20257==
shell> shutdown

shell: terminating ...
==20257==
==20257== HEAP SUMMARY:
==20257==     in use at exit: 33 bytes in 1 blocks
==20257==   total heap usage: 6 allocs, 5 frees, 157 bytes allocated
==20257==
==20257== 33 bytes in 1 blocks are still reachable in loss record 1 of 1
==20257==    at 0x4C2A203: operator new(unsigned long) (vg_replace_malloc.c:334)
==20257==    by 0x4EF3CF8: allocate (new_allocator.h:104)
==20257==    by 0x4EF3CF8: std::string::_Rep::_S_create(unsigned long, unsigned long, std::allocator<char> const&) (basic_string.tcc:607)
==20257==    by 0x4EF5580: char* std::string::_S_construct<char const*>(char const*, char const*, std::allocator<char> const&, std::forward_iterator_tag) (basic_string.tcc:138)
==20257==    by 0x4EF59B7: _S_construct_aux<char const*> (basic_string.h:1725)
==20257==    by 0x4EF59B7: _S_construct<char const*> (basic_string.h:1746)
==20257==    by 0x4EF59B7: std::basic_string<char, std::char_traits<char>, std::allocator<char> >::basic_string(char const*, std::allocator<char> const&) (basic_string.tcc:215)
==20257==    by 0x40134D: TokenizeCommandLine(std::string*, std::string) (in xxx/tryThis)
==20257==    by 0x4011C7: GetCommand(std::string*) (in xxx/tryThis)
==20257==    by 0x4010CA: main (in xxx/tryThis)
==20257==
==20257== LEAK SUMMARY:
==20257==    definitely lost: 0 bytes in 0 blocks
==20257==    indirectly lost: 0 bytes in 0 blocks
==20257==      possibly lost: 0 bytes in 0 blocks
==20257==    still reachable: 33 bytes in 1 blocks
==20257==                       of which reachable via heuristic:
==20257==                         stdstring          : 33 bytes in 1 blocks
==20257==         suppressed: 0 bytes in 0 blocks
==20257==
==20257== For counts of detected and suppressed errors, rerun with: -v
==20257== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)

Answer 1

You exit the program through ShutdownAndRestart() which calls exit(0).

exit() doesn't unwind the stack, it "aborts" the program with only minimal cleanup. Specifically, the tokens variable in main() doesn't get destroyed and the memory of the contained stings will not be deallocated.

If you exit the program by returning from main instead, the problem should go away. For example ProcessCommand() could return a flag that indicates if the main loop should stop, instead of calling exit() internally.