C++ 在Windows上使用Google测试时内存泄漏

当我运行以下代码时：

#include "gmock/gmock.h"
#include "gtest/gtest.h"

#define _CRTDBG_MAP_ALLOC
#include <crtdbg.h>

int main(int argc, char **argv) 
{
    ::testing::InitGoogleTest(&argc, argv);
    _CrtDumpMemoryLeaks();
    return 0;
}

#包括“gmock/gmock.h”
#包括“gtest/gtest.h”
#定义\u CRTDBG\u映射\u ALLOC
#包括
int main（int argc，字符**argv）
{
：：测试：：InitGoogleTest（&argc，argv）；
_CrtDumpMemoryLeaks（）；
返回0；
}

我得到以下输出：

Detected memory leaks!
Dumping objects ->
{652} normal block at 0x00074CE0, 4 bytes long.
 Data: < L  > 98 4C 07 00 
{651} normal block at 0x00074C98, 12 bytes long.
 Data: <,           > 2C 03 1B 01 00 00 00 00 00 00 00 00 
{650} normal block at 0x00074C50, 8 bytes long.
 Data: <hI      > 68 49 07 00 00 00 00 00 
{649} normal block at 0x00074C10, 4 bytes long.
 Data: <t   > 74 03 1B 01 
{648} normal block at 0x00074BC8, 8 bytes long.
 Data: <xK      > 78 4B 07 00 00 00 00 00 
{647} normal block at 0x00074B70, 28 bytes long.
 Data: <         K   L  > BC 01 1B 01 01 CD CD CD C8 4B 07 00 E0 4C 07 00 
{646} normal block at 0x00074B28, 8 bytes long.
 Data: < I      > 18 49 07 00 00 00 00 00 
{645} normal block at 0x00074AE0, 8 bytes long.
 Data: < I      > 04 49 07 00 00 00 00 00 
{644} normal block at 0x00074A98, 8 bytes long.
 Data: < H      > DC 48 07 00 00 00 00 00 
{643} normal block at 0x00074A50, 8 bytes long.
 Data: < H      > C8 48 07 00 00 00 00 00 
{642} normal block at 0x00074A08, 8 bytes long.
 Data: < H      > B4 48 07 00 00 00 00 00 
{641} normal block at 0x000749C0, 8 bytes long.
 Data: < H      > A0 48 07 00 00 00 00 00 
{640} normal block at 0x00074E90, 1 bytes long.
 Data: < > 00 
{639} normal block at 0x00074870, 272 bytes long.
 Data: <        t    N  > 20 03 1B 01 CD CD CD CD 74 FA 1B 01 90 4E 07 00 
{638} normal block at 0x00074F68, 72 bytes long.
 Data: <C:\Users\Baz> 43 3A 5C 55 73 65 72 73 5C 45 42 41 52 47 52 49 
{637} normal block at 0x00074E48, 8 bytes long.
 Data: <hO  G   > 68 4F 07 00 47 00 00 00 
{616} normal block at 0x00074EE0, 72 bytes long.
 Data: <C:\Users\Baz> 43 3A 5C 55 73 65 72 73 5C 45 42 41 52 47 52 49 
{595} normal block at 0x00074828, 8 bytes long.
 Data: <        > F0 F9 1B 01 00 00 00 00 
{594} normal block at 0x000747E8, 1 bytes long.
 Data: < > 00 
{561} normal block at 0x000747A0, 5 bytes long.
 Data: <fast > 66 61 73 74 00 
{496} normal block at 0x00074760, 1 bytes long.
 Data: < > 00 
{311} normal block at 0x00074720, 1 bytes long.
 Data: < > 00 
{282} normal block at 0x000746E0, 2 bytes long.
 Data: <* > 2A 00 
{253} normal block at 0x00074698, 5 bytes long.
 Data: <auto > 61 75 74 6F 00 
Object dump complete.

检测到内存泄漏！
转储对象->
0x00074CE0处的{652}正常块，4字节长。
数据：98 4C 07 00
0x00074C98处的{651}正常块，12字节长。
数据：2C 03 1B 01 00
0x00074C50处的{650}正常块，8字节长。
资料：68490700
0x00074C10处的{649}正常块，4字节长。
数据：74 03 1B 01
0x00074BC8处的{648}正常块，8字节长。
数据：784B0700
0x00074B70处的{647}正常块，28字节长。
数据：BC 01 1B 01 CD CD C8 4B 07 00 E0 4C 07 00
0x00074B28处的{646}正常块，8字节长。
数据：18490700
0x00074AE0处的{645}正常块，8字节长。
数据：04490700
0x00074A98处的{644}正常块，8字节长。
数据：DC 48 07 00
0x00074A50处的{643}正常块，8字节长。
数据：C8 48 07 00
0x00074A08处的{642}正常块，8字节长。
数据：B4 48 07 00
0x000749C0处的{641}正常块，8字节长。
数据：A0 48 07 00
0x00074E90处的{640}正常块，1字节长。
数据：<>00
0x00074870272字节长的{639}正常块。
数据：20 03 1B 01 CD 74 FA 1B 01 90 4E 07 00
0x00074F68处的{638}正常块，72字节长。
资料：433a5c55736572735c454241524749
0x00074E48处的{637}正常块，8字节长。
资料：68 4F 07 00 47 00
0x00074EE0处的{616}正常块，72字节长。
资料：433a5c55736572735c454241524749
0x00074828处的{595}正常块，8字节长。
数据：<>F0F9 1B 01 00
0x000747E8处的{594}正常块，1字节长。
数据：<>00
0x000747A0处的{561}正常块，5字节长。
数据：6661737400
0x00074760处的{496}正常块，1字节长。
数据：<>00
0x00074720处的{311}正常块，1字节长。
数据：<>00
0x000746E0处的{282}正常块，2字节长。
数据：2A 00
0x00074698处的{253}正常块，5字节长。
资料：6175746F00
对象转储完成。

---

我做错了什么？

你没有做错什么。“内存泄漏”来自静态初始化的GoogleTestSingleton类的堆分配

---

以下是谷歌测试常见问题解答的答案：

除了公认的答案，谷歌声明：

由于静态初始化谷歌测试单需要在堆上分配，VisualC++内存泄漏检测器将在程序运行结束时报告内存泄漏。避免这种情况的最简单方法是使用_CrtMemCheckpoint和_CrtMemDumpAllObjectsSince调用不报告任何静态初始化的堆对象。有关更多详细信息和其他堆检查/调试例程，请参见MSDN

这包括在

：testing:：InitGoogleTest

之后调用，然后在

RUN\u ALL\u TESTS（）之后调用。主要功能如下所示：

::testing::InitGoogleTest(&argc, &argv);
// Get a checkpoint of the memory after Google Test has been initialized.
_CrtMemState memoryState = {0};
_CrtMemCheckpoint( &memoryState );
int retval = RUN_ALL_TESTS();

// Check for leaks after tests have run
_CrtMemDumpAllObjectsSince( &memoryState );
return retval;

不幸的是，如果测试失败，Google测试会导致内存泄漏，这意味着这不是一个完美的解决方案。
不幸的是，这还不够，在gtest-1.7.0上，gtest中有在RUN_ALL_测试中进行的分配，这些测试没有释放，请检查
UnitTestImpl:：os_stack_trace_getter
，例如@kerim提到的，由于在
UnitTestImpl:：os\u stack\u trace\u getter
中执行静态分配，仅使用_CrtMemCheckpoint方法是不够的。我的变通方法是总是在内存检查点之前执行一个虚拟测试。这增加了一个额外的前导测试，但至少我可以检查泄漏。提示：您可以使用
：：testing:：GTEST_标志（filter）=“DummyTestName*”
仅执行虚拟测试，然后在运行其余测试时使用
：testing:：GTEST_标志（filter）=“-DummyTestName*”
将其排除。