我知道已经有很多类似的问题和答案存在，但我无法解决我的问题。

在我的大型应用程序中，堆在某处损坏，我无法找到它。我也使用了像 gflags 这样的工具，但没有运气。

我在以下样本上尝试了 gflags，它故意破坏了堆:

char* pBuffer = new char[256];
memset(pBuffer, 0, 256 + 1);
delete[] pBuffer;

在第 2 行，堆被覆盖，但如何通过 gflags、windbg 等工具找到它。可能是我没有正确使用 gflags。

最佳答案

如果自动化工具(如 electric fence 或 valgrind)无法解决问题，那么专注地盯着您的代码试图找出可能出错的地方并没有帮助，并且禁用/启用各种操作(直到你得到堆损坏的存在与事先执行或未执行的操作之间的相关性)缩小它似乎不起作用，你总是可以尝试这种技术，它试图尽快找到损坏，而不是稍后，以便更容易追查来源:

创建您自己的自定义 new 和 delete 运算符，在分配的内存区域周围放置明显损坏的保护区，如下所示:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <new>

// make this however big you feel is "big enough" so that corrupted bytes will be seen in the guard bands
static int GUARD_BAND_SIZE_BYTES = 64;

static void * MyCustomAlloc(size_t userNumBytes)
{
    // We'll allocate space for a guard-band, then space to store the user's allocation-size-value,
    // then space for the user's actual data bytes, then finally space for a second guard-band at the end.
    char * buf = (char *) malloc(GUARD_BAND_SIZE_BYTES+sizeof(userNumBytes)+userNumBytes+GUARD_BAND_SIZE_BYTES);
    if (buf)
    {
       char * w = buf;
       memset(w, 'B', GUARD_BAND_SIZE_BYTES);          w += GUARD_BAND_SIZE_BYTES;
       memcpy(w, &userNumBytes, sizeof(userNumBytes)); w += sizeof(userNumBytes);
       char * userRetVal = w;                          w += userNumBytes;
       memset(w, 'E', GUARD_BAND_SIZE_BYTES);          w += GUARD_BAND_SIZE_BYTES;
       return userRetVal;
    }
    else throw std::bad_alloc();
}

static void MyCustomDelete(void * p)
{
    if (p == NULL) return;   // since delete NULL is a safe no-op

    // Convert the user's pointer back to a pointer to the top of our header bytes
    char * internalCP = ((char *) p)-(GUARD_BAND_SIZE_BYTES+sizeof(size_t));

    char * cp = internalCP;
    for (int i=0; i<GUARD_BAND_SIZE_BYTES; i++)
    {
        if (*cp++ != 'B')
        {
            printf("CORRUPTION DETECTED at BEGIN GUARD BAND POSITION %i of allocation %p\n", i, p);
            abort();
        }
    }

    // At this point, (cp) should be pointing to the stored (userNumBytes) field
    size_t userNumBytes = *((const size_t *)cp);
    cp += sizeof(userNumBytes);  // skip past the user's data
    cp += userNumBytes;

    // At this point, (cp) should be pointing to the second guard band
    for (int i=0; i<GUARD_BAND_SIZE_BYTES; i++)
    {
        if (*cp++ != 'E')
        {
            printf("CORRUPTION DETECTED at END GUARD BAND POSITION %i of allocation %p\n", i, p);
            abort();
        }
    }

    // If we got here, no corruption was detected, so free the memory and carry on
    free(internalCP);
}

// override the global C++ new/delete operators to call our
// instrumented functions rather than their normal behavior
void * operator new(size_t s)    throw(std::bad_alloc)   {return MyCustomAlloc(s);}
void * operator new[](size_t s)  throw(std::bad_alloc)   {return MyCustomAlloc(s);}
void operator delete(void * p)   throw()                 {MyCustomDelete(p);}
void operator delete[](void * p) throw()                 {MyCustomDelete(p);}

...以上内容足以让您获得 Electric-Fence 风格的功能，因为如果有任何内容写入任何新/删除内存分配的开头或结尾的两个 64 字节“保护带”中的任何一个，然后当分配被删除时，MyCustomDelete() 将注意到损坏并使程序崩溃。

如果这还不够好(例如，因为在删除发生时，自损坏以来发生了太多事情，以至于很难说出是什么导致了损坏)，您可以更进一步，让 MyCustomAlloc() 添加分配的缓冲区进入单例/全局双链分配列表，并让 MyCustomDelete() 从同一个列表中删除它(如果您的程序是多线程的，请确保序列化这些操作!)。这样做的好处是您可以添加另一个函数，例如CheckForHeapCorruption() 将迭代该链表并检查链表中每个分配的保护带，并报告它们是否已损坏。然后，您可以在整个代码中散布对 CheckForHeapCorruption() 的调用，这样当发生堆损坏时，将在下一次调用 CheckForHeapCorruption() 时检测到它，而不是在稍后的某个时间。最终您会发现对 CheckForHeapCorruption() 的一次调用以出色的效果通过，然后在几行之后对 CheckForHeapCorruption() 的下一次调用检测到损坏，此时您知道损坏是由在两者之间执行的任何代码引起的对 CheckForHeapCorruption() 的两次调用，然后您可以研究该特定代码以找出它做错了什么，和/或根据需要在该代码中添加更多对 CheckForHeapCorruption() 的调用。

重复直到错误变得明显。祝你好运!

关于c++ - 找出堆内存损坏的地方，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/33891513/