Question

我试图让我的shell终止，如果用户进入＆＃34;关闭＆＃34;或者＆＃34;重启＆＃34;在shell命令行中。一切都很好。我使用C（strtok，cstring）和C ++来编写代码。当我使用valgrind时，它表示仍然可以访问1个块。我知道这不是泄漏，但我很想知道造成它的原因以及解决方法。花了2天的时间试图找到它是不可能的。请查看我的代码和valgrind报告。

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

您通过调用ShutdownAndRestart()的{{1}}退出该计划。

exit()没有解开堆栈，它会中止＆＃34;该程序只需要很少的清理工作。具体来说，exit(0)中的tokens变量不会被销毁，并且所包含的蜇的内存不会被解除分配。

如果从main返回退出程序，则问题应该消失。例如，main()可以返回一个标志，指示主循环是否应该停止，而不是在内部调用ProcessCommand()。

std :: string中的内存泄漏

1 个答案: