Утечка памяти в этой ситуации? Использование нового ключевого слова снова и снова

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 создавать 20 отдельных новых ints в отдельной памяти на время heapeach?

Кроме того, еще один вопрос: если бы не деструктор, освободилась бы динамически выделенная память? Видя, как будто продолжительность жизни в классе - это продолжительность программы, будет ли она очищать всю «новую» память?

Редактировать: Спасибо за ответы. Причина, по которой я прошу об этом, заключается в том, что я пытаюсь обойти вызов new и delete каждый раз, когда WndProc вызывается для Raw Input в основном, а именно, как MSDN говорит вам об этом. Кажется очень неэффективным.

Answer 1

Как только вы переназначить указатель без использования delete[] де-выделить эту выделенную память в куче, вы создаете память протечь. Это произойдет, если вы зациклируете свой aFunction(), поскольку он повторно назначает указатель каждый раз, когда он вызывается.

Что касается вашего второго вопроса, ваш деструктор будет только delete[] последним массивом, назначенным указателю.

Answer 2

Только delete[] освобождает выделение памяти, которое было выделено new. И каждый раз, когда вы используете new, вам нужен a 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]; 
} 

без deallocating старых Интс первых, как

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

будет делать.

Вызов aFunction() приведет к «бесконечным» выделениям памяти. И ваш деструктор, который только освобождает последние выделенные ints, даже никогда не называется.

Почему ваш обработчик не управляет собственной памятью?

Очень плохая практика распределять память за пределами вашего объекта и освобождать ее внутри или наоборот.

Почему бы не реализовать класс обработчика таким образом:

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(); 
    } 
}