Question

我对内存泄漏非常谨慎，所以我认为我已经验证了这一点。在下面的例子中会出现内存泄漏吗？我的直觉是肯定的。

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会在heapeach时间在单独的内存中创建20个单独的新int？

另外，另一个问题是，如果它不是析构函数，是否会释放动态分配的内存？看到课程的生命周期是程序的持续时间，它是否会清除所有＆＃34; new＆＃34;存储器？

编辑：谢谢你的回答。我之所以这么说的原因是因为我每次都试图绕过调用new并删除每次WadProc基本上都是Raw Input，这就是MSDN告诉你这样做的原因。似乎非常低效。

Answer 1

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

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

Answer 2

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

对于另一个问题，基于Documentation：

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

Answer 3

是的，当您多次调用该函数时，如果没有在每次调用后明确取消分配handler.ptrToInts，则会发生内存泄漏;

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

//-----somewhere we see the caller

while(!quit)
    {
      aFunction(); 
    }

但是，这是一个检测泄漏的简单案例......您应该学会使用Leak detectors和static analyzers。

请参阅How do you detect/avoid Memory leaks in your (Unmanaged) code?

Answer 4

当然有内存泄漏。您在

中分配了整数

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

首先没有释放旧的int，比如

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

会做的。

致电aFunction()将导致无限的＆＃34;内存分配。而且你的析构函数，只释放最后分配的整数，甚至永远不会被调用。

为什么你的处理程序没有管理它自己的记忆？

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

为什么不这样实现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(); 
  }
}

在这种情况下内存泄漏？一遍又一遍地使用新关键字

4 个答案: