c++ - 无法解释的内存泄漏 C++

Question

我正在尝试在下面的代码中实现类名为 SharedPtr 的共享指针。但是我遇到了奇怪的内存泄漏问题。如果我像这样创建新对象:

SharedPtr* P = new SharedPtr(new double(30));

然后删除它

delete P;

一切顺利。但是如果我这样创建它:

SharedPtr P1(new double(10));

我遇到内存泄漏。

我做错了什么？

我已经检查过是否调用了析构函数并且内存正在释放，但我仍然遇到内存泄漏

#include <iostream>
#include <cstddef> // int
#include <cstring> // strlen, strcpy

#define _CRTDBG_MAP_ALLOC
#include <crtdbg.h>

#ifdef _DEBUG
#define DBG_NEW new ( _NORMAL_BLOCK , __FILE__ , __LINE__ )
// Replace _NORMAL_BLOCK with _CLIENT_BLOCK if you want the
// allocations to be of _CLIENT_BLOCK type
#else
#define DBG_NEW new
#endif

using namespace std;

struct SharedPtr
{
  double* ptr;
  int* counter;

  explicit SharedPtr(double* ptr = 0) : ptr(ptr)
  {
    counter = ptr ? DBG_NEW int(1) : 0;
  }
  ~SharedPtr()
  {
    if (!ptr)
      return;
    (*counter)--;
    if (!(*counter))
    {
      delete ptr;
      delete counter;
    }
  }
  SharedPtr(const SharedPtr& P) : counter(P.counter), ptr(P.ptr)
  {
    if (ptr)
      (*counter)++;
  }
  SharedPtr& operator=(const SharedPtr& P)
  {
    if (this != &P)
    {
      if (ptr)
      {
        (*counter) -= 1;
        if ((*counter) == 0)
        {
          delete ptr;
          delete counter;

          ptr = 0;
          counter = 0;
        }

      }
      if (P.ptr)
      {
        (*P.counter)++;
        ptr = P.ptr;
        counter = P.counter;
      }
    }

    return *this;
  }
};
int main()
{
  SharedPtr P1(DBG_NEW double(10)); //Leak
  SharedPtr P2(DBG_NEW double(20)); //Leak
 // SharedPtr P3 = P1, P4 = P1, P5 = P1;


  SharedPtr* P = DBG_NEW SharedPtr(DBG_NEW double(30)); 
  delete P; //No leak

  _CrtDumpMemoryLeaks();
  return 0;
}

我希望程序在任何情况下都没有任何泄漏，但是如果我在不分配内存的情况下创建指针对象，我会得到一些

Z:\T00TEST\T00TEST\T00TEST.cpp(26) : {159} normal block at 0x00BB6110, 4 bytes long.
 Data: <    > 01 00 00 00 
Z:\T00TEST\T00TEST\T00TEST.cpp(101) : {158} normal block at 0x00BBEA18, 8 bytes long.
 Data: <      4@> 00 00 00 00 00 00 34 40 
Z:\T00TEST\T00TEST\T00TEST.cpp(26) : {157} normal block at 0x00BBD898, 4 bytes long.
 Data: <    > 01 00 00 00 
Z:\T00TEST\T00TEST\T00TEST.cpp(100) : {156} normal block at 0x00BBEB30, 8 bytes long.
 Data: <      $@> 00 00 00 00 00 00 24 40 

Answer 1

   _CrtDumpMemoryLeaks();

此时，您的P1 和P2 共享指针仍然存在并在范围内，并保持引用计数。它们不会被销毁(但您的动态分配指针被deleted 销毁)。因此，您不必对调试库仍然找到一些分配的内存感到惊讶。您在 P1 和 P2 main() 返回时销毁 之前调用了此调试函数。

先摧毁 P1 和 P2，然后再试一次。最简单的方法是将它们简单地放在内部范围内。

{
  SharedPtr P1(DBG_NEW double(10)); //Leak
  SharedPtr P2(DBG_NEW double(20)); //Leak

// The rest of your code

}
_CrtDumpMemoryLeaks();