在这种情况下内存泄漏?反复使用新关键字

Memory leak in this situation? Using new keyword over and over

本文关键字：关键字 这种情况下 内存 泄漏      更新时间：2023-10-16

我对内存泄漏非常谨慎，所以我想我应该对此进行验证。在以下示例中，是否存在内存泄漏？我的直觉是肯定的。

class Handler        // Class definition
{public:
  ~Handler();
  int* ptrToInts;    
};
Handler::~Handler()  // Class destructor
{
  delete[] ptrToInts; 
}
Handler handler;     // Global object

void aFunction()
{
    handler.ptrToInts = new int[20];
}

int main()
{
  bool quit = false;
  while(!quit)
    {
      aFunction(); 
    }
  return 0;
}

ptrToInts每次都会在堆上的单独内存中创建20个单独的新int吗？

另外，另一个问题是，如果没有析构函数，动态分配的内存会被释放吗？就好像类的生存期就是程序的持续时间一样，它会清理所有"新"内存吗？

编辑：谢谢你的回答。我之所以问这个问题，是因为每次为Raw Input调用WndProc时，我都会尝试绕过调用new和delete，基本上，MSDN告诉你这样做。看起来效率很低。

在不使用delete[]取消分配堆上已分配内存的情况下重新分配指针后，就会产生内存泄漏。如果每次调用aFunction()时它都会重新分配指针，则会发生这种情况。

至于第二个问题，析构函数将只delete[]分配给指针的最后一个数组。

只有delete[]释放由new分配的内存。每次使用new时，都需要delete。

对于另一个问题，基于文档：

MyClass * p1 = new MyClass[5]; // allocates and constructs five objects

是的，当您多次调用该函数时，如果每次调用后都没有显式释放handler.ptrToInts，则会出现内存泄漏；

void aFunction()
{
    handler.ptrToInts = new int[20];
}
//-----somewhere we see the caller
while(!quit)
    {
      aFunction(); 
    }

然而，这是一个检测泄漏的琐碎案例。。。您应该学会使用泄漏检测器和静态分析仪。

请参阅如何检测/避免（非托管）代码中的内存泄漏？

当然存在内存泄漏。您在中分配int

void aFunction()
{
    handler.ptrToInts = new int[20];
}

而不首先释放旧的int，如

void aFunction()
{
    delete [] handler.ptrToInts;
    handler.ptrToInts = new int[20];
}

调用aFunction()将导致"无限"内存分配。而您的析构函数，只释放最后分配的int，甚至从未被调用。

为什么您的处理程序不管理它自己的内存？

在对象外部分配内存并在对象内部释放内存是非常糟糕的做法，反之亦然。

为什么不以这种方式实现Handler类：

class Handler
{
public:
  Handler();
  ~Handler();
  void aMethod();
private:
  int* ptrToInts;    
};
Handler::Handler() {
  handler.ptrToInts = new int[20];
}
Handler::~Handler() {
  delete[] ptrToInts; 
}
void Handler::aMethod() {
  delete[] ptrToInts; 
  handler.ptrToInts = new int[20];
}
int main() {
  bool quit = false;
  Handler handler;
  while(!quit) {
    handler.aMethod(); 
  }
}
相关文章：