Каким образом соединение new [] с delete могло привести только к утечке памяти?

Предположим, я компилятор C ++ и реализую управление памятью следующим образом: я добавляю каждому блоку зарезервированной памяти размер памяти в байтах. Что-то вроде этого;

| size | data ... |
         ^
         pointer returned by new and new[]

Обратите внимание, что с точки зрения распределения памяти нет разницы между new и new[]: оба просто выделяют блок памяти определенного размера.

Как теперь delete[] узнать размер массива, чтобы вызвать нужное количество деструкторов? Просто разделите size блока памяти на sizeof(T), где T - это тип элементов массива.

Теперь предположим, что я реализую delete как просто один вызов деструктора с последующим освобождением size байтов, тогда деструкторы последующих элементов никогда не будут вызываться. Это приводит к утечке ресурсов, выделяемых последующими элементами. Тем не менее, поскольку я освобождаю size байтов (а не sizeof(T) байтов), никакого повреждения кучи не происходит.

Сказка о смешении new[] и delete, якобы вызывающих утечку памяти, - это просто сказка. На самом деле это абсолютно беспочвенно. Я не знаю, откуда он взялся, но к настоящему времени он обрел собственную жизнь и выживает как вирус, передаваясь из уст в уста от одного новичка к другому.

Наиболее вероятное объяснение этой чуши об "утечке памяти" состоит в том, что с невинно наивной точки зрения разница между delete и delete[] состоит в том, что delete используется для уничтожения только одного объекта, а delete[] уничтожает массив объектов ("множество" объектов) . Наивный вывод, который обычно делается из этого, состоит в том, что первый элемент массива будет уничтожен delete, а остальные останутся, таким образом создавая предполагаемую «утечку памяти». Конечно, любой программист, обладающий хотя бы базовым пониманием типичных реализаций кучи, сразу поймет, что наиболее вероятным последствием этого является повреждение кучи, а не «утечка памяти».

Другое популярное объяснение наивной теории «утечки памяти» состоит в том, что, поскольку вызывается неправильное количество деструкторов, вторичная память, принадлежащая объектам в массиве, не освобождается. Это может быть правдой, но очевидно, что это очень вынужденное объяснение, которое не имеет большого значения перед лицом гораздо более серьезной проблемы с повреждением кучи.

Короче говоря, смешивание различных функций распределения - одна из тех ошибок, которые приводят к надежному, непредсказуемому и очень практичному неопределенному поведению. Любые попытки наложить какие-то конкретные ограничения на проявления этого неопределенного поведения - просто пустая трата времени и верный признак отсутствия базового понимания.

Излишне добавлять, что new/delete и new[]/delete[] на самом деле являются двумя независимыми механизмами управления памятью, которые можно настраивать независимо. После того, как они будут настроены (путем замены необработанных функций управления памятью), нет абсолютно никакого способа даже начать предсказывать, что может случиться, если они смешаются.

Похоже, действительно ваш вопрос: «Почему не бывает разрушения кучи?». Ответ на этот вопрос - «потому что диспетчер кучи отслеживает размеры выделенных блоков». Вернемся на минутку к C: если вы хотите выделить один int в C, вы должны сделать int* p = malloc(sizeof(int)), если вы хотите выделить массив размером n, вы можете написать int* p = malloc(n*sizeof(int)) или int* p = calloc(n, sizeof(int)). Но в любом случае вы освободите его до free(p), как бы вы его не распределили. Вы никогда не передаете размер в free (), free () просто «знает», сколько нужно освободить, потому что размер блока malloc () - ed сохраняется где-то «перед» блоком. Возвращаясь к C ++, new / delete и new [] / delete [] обычно реализуются в терминах malloc (хотя они и не должны быть таковыми, вам не следует полагаться на это). Вот почему комбинация new [] / delete не повреждает кучу - удаление освобождает нужный объем памяти, но, как объясняли все до меня, вы можете получить утечки, не вызывая нужное количество деструкторов.

Тем не менее, рассуждения о неопределенном поведении в C ++ всегда бессмысленны. Почему это важно, если комбинация new [] / delete работает, "только" утекает или вызывает повреждение кучи? Вы не должны так кодить, точка! И на практике я бы по возможности избегал ручного управления памятью - STL и ускорение существуют не просто так.

Если нетривиальный деструктор, который вызывается не для всех, кроме первого элемента в массиве, должен освободить некоторую память, вы получите утечку памяти, поскольку эти объекты не очищаются должным образом.

Это приведет к утечке во ВСЕХ реализациях C ++ в любом случае, когда деструктор освобождает память, потому что деструктор никогда не вызывается.

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

утечка памяти может произойти, если оператор new () переопределен, а new [] - нет. то же самое и с оператором delete / delete []

Помимо неопределенного поведения, наиболее очевидная причина утечек заключается в том, что реализация не вызывает деструктор для всех, кроме первого объекта в массиве. Это, очевидно, приведет к утечкам, если объектам выделены ресурсы.

Это самый простой из возможных классов, который, как мне кажется, приводит к такому поведению:

 struct A { 
       char* ch;
       A(): ch( new char ){}
       ~A(){ delete ch; }
    };

A* as = new A[10]; // ten times the A::ch pointer is allocated

delete as; // only one of the A::ch pointers is freed.

PS: обратите внимание, что конструкторы не могут быть вызваны и при многих других ошибках программирования: невиртуальные деструкторы базового класса, ложная зависимость от интеллектуальных указателей, ...

Поздно для ответа, но ...

Если ваш механизм удаления состоит в том, чтобы просто вызвать деструктор и поместить освобожденный указатель вместе с размером, подразумеваемым sizeof, в свободный стек, то вызов delete для фрагмента памяти, выделенного с помощью new [], будет результат теряется память - но не повреждение. Более сложные структуры malloc могут повредить или обнаружить такое поведение.

Почему не может быть ответа, что он вызывает и то, и другое?

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

Или, скорее, поскольку я могу повторно реализовать новое и удалить… Разве это не может вообще ничего не вызвать. Технически я могу заставить new и delete выполнять new [] и delete [].

Отсюда: неопределенное поведение.

Я отвечал на вопрос, который был помечен как дубликат, поэтому я просто скопирую его сюда, если он найдет нужный. До меня было сказано, как работает распределение памяти, я просто объясню причину и следствия.

Немного сразу с Google: http://en.cppreference.com/w/cpp/memory/new/operator_delete

Как бы то ни было, delete - это функция для одного объекта. Он освобождает экземпляр от указателя и уходит;

delete [] - это функция, используемая для освобождения массивов. Это означает, что он не просто освобождает указатель; Он объявляет весь блок памяти этого массива мусором.

На практике это все круто, но вы мне скажете, что ваше приложение работает. Вам, наверное, интересно ... почему?

Решение состоит в том, что C ++ не устраняет утечки памяти. Если вы используете delete без скобок, он удалит только массив как объект - процесс, который может вызвать утечку памяти.

классная история, утечка памяти, почему меня это должно волновать?

Утечка памяти происходит, когда выделенная память не удаляется. Затем этой памяти требуется ненужное дисковое пространство, что приведет к потере полезной памяти практически без причины. Это плохое программирование, и вам, вероятно, следует исправить это в своих системах.