В чем разница между new / delete и malloc / free?
В чем разница между new / delete и malloc / free?
Связанные (повторяющиеся?): В каких случаях использовать malloc vs new?
Ответы 15
Наиболее существенное отличие состоит в том, что оператор new выделяет память, затем вызывает конструктор, а delete вызывает деструктор, а затем освобождает память.
Строго говоря, оператор new просто выделяет память. Это новое выражение, которое вызывает оператор new, а затем запускает конструктор в выделенной памяти.
Еще одно отличие заключается в том, где распределяется память. Я недавно где-то видел, что malloc / free работают с кучей, а new / delete работают в другой области памяти, имя которой сейчас ускользает от меня. (Однако достаточно сказать, что эту другую область, вероятно, можно рассматривать как еще одну кучу.)
RobH - вся память размещена в куче. Локальные переменные находятся в стеке. 'new' и malloc обычно являются одной и той же функцией, за исключением последующего вызова ctors.
@mgb: Да, вы правы, объекты размещаются либо в «куче приложения», либо в стеке. Но @RobH относится к тому, что стандарт называет разными частями «кучи приложения». Есть «Куча», из которой malloc выделяет память, и «Free Store», из которой new выделяет память. Хотя в реализациях немного эти области действительно перекрываются (это деталь реализации).
Ваше утверждение на 100% верно, но просто не отвечает на заданный вопрос, см. Ответ ниже, есть причина, по которой оно больше голосов, чем ваше.
Вот расширенная версия моего ответа, чтобы вы могли понять: «Наиболее существенное различие заключается в том, что оператор new выделяет память, затем вызывает конструктор, а удаление вызывает деструктор, а затем освобождает память, [в отличие от malloc / free, которые не вызывают ctors / dtors] "Я бы сказал, что один отрицательный голос (ваш), 30 положительных и 2 исправления по-прежнему считается хорошим ответом, а это означает, что большинство людей его понимают. И да, причина в том, что ответ Мартина лучше моего (он имеет 14 изменений) Кстати, я также поддержал его.
Все, что я пытался сказать, это должно быть хотя бы некоторое упоминание о malloc / free, чтобы его можно было квалифицировать как сравнение, которого не хватало в вашем ответе. Тем не менее, это актуальное и точное заявление, так что положительные голоса, надеюсь, вы понимаете мою точку зрения. В любом случае, если бы только ТАК позволил мне вернуть свой голос против, я бы искренне это сделал.
@волшебник. Ваш голос против принес мне золотой значок, так что я в порядке. В любом случае мне нравится, когда лаконичный ответ будет первым. Если людям нужна дополнительная информация, они могут прокрутить вниз.
@Trap ваш ответ не отвечает на вопрос, "расширенная" версия действительно расширена (и это отвечает на вопрос), однако мне очень нравится комментарий Дона Уэйкфилда
@DonWakefield: Различие между необработанным выделением и созданием объекта действительно существует, однако ваша терминология неверна. Когда вы сказали «новый оператор», вы имели в виду «(глобальную или членскую) функцию с именем operator new()». Везде, где появляется «новый оператор», это новое выражение и вызывает конструктор, нет значимого различия между двумя терминами, которые вы использовали в своем комментарии.
new вызывает ctor объекта, delete вызывает dtor.
malloc и free просто выделяют и освобождают необработанную память.
Что вы имеете в виду под сырой памятью?
Сырая память ничего не сделала. В нем еще не построен ни один объект, в него ничего не скопировано, и в большинстве случаев предыдущее содержимое не было перезаписано.
В C++ new / delete соответственно вызывают конструктор / деструктор.
malloc / free просто выделяют память из кучи. new / delete также выделяют память.
new / delete - это C++, malloc / free - это старый добрый C.
В C++ new вызывает конструктор объектов, а delete вызывает деструктор.
malloc и free, пришедшие из темных веков до OO, только выделяют и освобождают память, не выполняя никакого кода объекта.
«Исходя из темных веков до OO» звучит так, как будто вы подразумеваете, что new / delete - это лучше, чем malloc / free, когда на самом деле ни лучше, ни хуже, просто они имеют другое применение. Обратите внимание, что я не тот, кто проголосовал против вас, я просто предполагаю.
new и delete - это C++ примитивы, которые объявляют новый экземпляр класса или удаляют его (таким образом вызывая деструктор класса для этого экземпляра).
malloc и free - это C функции, и они выделяют и освобождают блоки памяти (по размеру).
Оба используют кучу для выделения памяти. malloc и free, тем не менее, являются более "низкоуровневыми", поскольку они просто резервируют часть пространства памяти, которая, вероятно, будет связана с указателем. Никаких структур вокруг этой памяти не создается (если вы не считаете массив C структурой).
new в C++ не объявляет экземпляр класса. Он (обычно) выделяет один из кучи и ничего не объявляет. Вы можете объявить экземпляр, просто объявив его, и в этом случае он будет в стеке или в глобальных объектах, в зависимости от продолжительности хранения объявления.
Что ж, он выделяет пространство памяти для класса, но вы не можете «объявить» класс в стеке, не в реальном смысле сохранения класса в стеке. Объявление включает только указатель на класс, который всегда выделяется в стеке, а фактическая память, содержащая класс, находится в куче.
Да, ты можешь. Согласно тегам вопросов, это C++, поэтому объекты могут попадать в стек. И новое - это не декларация, а выражение. Объявление чего-либо и распределение - это разные вещи.
Единственное сходство заключается в том, что оба malloc / new возвращают указатель, который адресует некоторую память в куче, и они оба гарантируют, что, как только такой блок памяти был возвращен, он не будет возвращен снова, если вы сначала не освободите / не удалите его. То есть они оба «выделяют» память.
Однако new / delete дополнительно выполняют произвольную другую работу, используя конструкторы, деструкторы и перегрузку операторов. malloc / free всегда выделяют и освобождают только память.
Фактически, new достаточно настраиваемый, поэтому он не обязательно возвращает память из кучи или даже выделяет память вообще. Однако new по умолчанию делает.
new / delete
- Выделить / освободить память
- Память выделена из «Бесплатного хранилища».
- Возвращает полностью типизированный указатель.
new(стандартная версия) никогда не возвращаетNULL(выдает ошибку при ошибке).- Вызываются с Type-ID (размер вычисляет компилятор).
- Имеет версию для явной обработки массивов.
- Перераспределение (чтобы получить больше места) не выполняется интуитивно (из-за конструктора копирования).
- Называют ли они
malloc/free, определяется реализацией. - Можно добавить новый распределитель памяти для работы с нехваткой памяти (
std::set_new_handler). operator new/operator deleteможно переопределить на законных основаниях.- Конструктор / деструктор, используемый для инициализации / уничтожения объекта.
malloc / free
- Выделить / освободить память
- Память выделена из «Кучи».
- Возвращает
void*. - В случае ошибки возвращает
NULL. - Необходимо указать требуемый размер в байтах.
- Выделение массива требует ручного расчета пространства.
- Простое перераспределение большей части памяти (конструктор копирования не о чем беспокоиться).
- Они будут НЕТ вызывать
new/delete. - Невозможно вставить пользовательский код в последовательность распределения, чтобы помочь с нехваткой памяти.
malloc/freeможет быть переопределен НЕТ юридически.
Таблица сравнения характеристик:
| Характерная черта | new / delete | malloc / free |
|---|---|---|
| Память выделена из | 'Бесплатный магазин' | 'Куча' |
| Возврат | Полностью типизированный указатель | void* |
| При неудаче | Броски (никогда не возвращает NULL) | Возвращает NULL |
| Требуемый размер | Рассчитывается компилятором | Должен быть указан в байтах |
| Обработка массивов | Имеет явную версию | Требуются ручные расчеты |
| Перераспределение | Не обрабатывается интуитивно | Простой (без конструктора копирования) |
| Зов обратного | Реализация определена | Нет |
| Случаи с низкой памятью | Можно добавить новый распределитель памяти | Не обрабатывается кодом пользователя |
| Переопределяемый | да | Нет |
| Использование конструктора / деструктора | да | Нет |
Технически память, выделенная new, поступает из «свободного хранилища», а память, выделенная malloc, поступает из «кучи». Являются ли эти две области одинаковыми - это деталь реализации, что является еще одной причиной того, что malloc и new нельзя смешивать.
Может ли кто-нибудь отредактировать, чтобы уточнить, что касается «бесплатного магазина», а не кучи? Куча процесса - это хорошо известная концепция уровня операционной системы, не зависящая от языка (?); откуда взялся "Free Store"?
@einpoklum: Это просто названия областей памяти. Ни то, ни другое не имеет ничего общего с концепцией языка, известной как «куча», или концепцией os «куча процессов». C++ намеренно определен как независимый от платформы / ОС / компилятора. Таким образом, использование конкретной концепции ОС, такой как «куча процессов», подорвет гибкость стандарта.
Для удаления проверка на нуль не требуется. OTOH, free ожидает ненулевой указатель.
@winterlight: Раньше это было правдой, но теперь нет. См .: linux.die.net/man/3/freeIf ptr is NULL, no operation is performed.
@LokiAstari Похоже, что «куча», «свободное хранилище» и «динамическая память / хранилище» являются синонимами: в Знакомство с C++ Бьярна Страуструпа он говорит: «Оператор new выделяет память из бесплатный магазин (также известного как динамическая память и куча). Стандарт C++ 14, раздел 3.7.4, посвященный Динамическое хранилище, говорит: «Объекты могут создаваться динамически во время выполнения программы (1.9) с использованием новых выражений (5.3.4) и уничтожаться с помощью выражений удаления».
@mheiber: в стандарте явно указано, что это могут быть отдельные области. n4567 20.7.13 C-Library параграф 5 (о malloc): It also allows malloc() to be implemented with a separate allocation arena,
@LokiAstari интересно, но я не уверен, что «разрешено находиться на отдельной арене распределения» подразумевает, что «бесплатное хранилище» - это другое понятие, чем «куча». Но тогда я не совсем понимаю, что означает «арена раздельного распределения». Вероятно, это специфично для семантики undeclare_unreachable, о которой идет речь в этом абзаце.
@mheiber: Значит, они могут быть одинаковыми. И несколько реализаций реализуют new путем вызова malloc (обратите внимание, что обратный способ явно не разрешен). Но в некоторых реализациях эти области памяти полностью разделены. Причина, по которой они были разделены, заключается в том, что это позволяет оптимизировать код управления памятью C++ иначе, чем управление памятью C. Дело в том, что они могут быть одинаковыми, но вы не можете предполагать, что это так.
@mheiber: Вы должны помнить, что new / delete являются неотъемлемой частью языка C++ и размещаются и выпускаются из 12.5 «Free Store». В то время как malloc и family предоставляются в виде библиотеки с совершенно другого языка, который ничего не знает о C++. В стандарте C malloc / free получает память из «Кучи». Теперь C++ внутренне разрешено использовать malloc под капотом, и в этом нет никаких требований.
@mheiber: Также "Обзор C++" предназначен для новичков, поэтому упрощение понимания вещей важнее фактических деталей реализации. Особенно, когда это мало что меняет на уровне приложений. Все, что вам нужно помнить, это то, что указатель, выделенный с помощью new, должен быть освобожден с помощью delete (не освобождается), а указатель, выделенный с помощью malloc, должен быть освобожден с помощью free (а не удаления).
Разница между «Free Store» и «Heap», продвигаемая этим ответом, не поддерживается стандартом, поскольку ни стандарты C, ни C++ не упоминают слово «куча» в этом контексте. (C вообще не упоминает об этом, а C++ говорит о кучах только в смысле структура данных.)
@ user4815162342: Термин «Free Store» определен стандартом C++. Термин «куча» (всегда в кавычках) используется здесь просто для того, чтобы различить две области распределения (без необходимости писать книгу о различиях).
Ответ цитирует как кучу, так и бесплатное хранилище. Почему бы просто не указать, что они разные, не вводя конкретный термин для одного из них? В конце концов, «куча» обычно используется для любой области динамической памяти, включая память, выделенную new. (И он также используется C++ для обозначения структуры данных, что может только усугубить путаницу.)
@ user4815162342: Который вы бы нашли, если бы прочитали только первые комментарии два.
Под «почему бы не уточнить» я имел в виду текст ответа. (Следует признать, что слово «указать» было легко неправильно понять в данном контексте.) Ваш комментарий касался формулировки стандарта.
Не уверен, что это важно для кого-то, но вы можете заставить ключевое слово 'new' возвращать нулевой указатель, а не 'bad_alloc', используя (notthrow) во время создания экземпляра указателя: foo = new (nothrow) int [5];
также,
глобальные new и delete можно переопределить, malloc / free не могут.
далее новые и удаляемые могут быть переопределены для каждого типа.
new делает несколько вещей, но не malloc:
newсоздает объект, вызывая конструктор этого объекта.newне требует приведения типа выделенной памяти.- Для этого не требуется выделять объем памяти, а требуется несколько объекты для строительства.
Итак, если вы используете malloc, вам нужно делать указанные выше вещи явно, что не всегда практично. Кроме того, new может быть перегружен, а malloc - нет.
Одним словом, если вы используете C++, постарайтесь максимально использовать new.
Основное различие между new и malloc заключается в том, что new вызывает конструктор объекта, а соответствующий вызов delete вызывает деструктор объекта.
Есть и другие отличия:
newявляется типобезопасным,mallocвозвращает объекты типаvoid*.newвыдает исключение при ошибке,mallocвозвращаетNULLи устанавливает errnonew- это оператор, который может быть перегружен,malloc- это функция и не может быть перегруженnew[], который выделяет массивы, более интуитивно понятен и типобезопасен, чемmallocРаспределения, производные от
malloc, могут быть изменены с помощьюrealloc, выделения, производные отnew, не могут быть измененыmallocможет выделить N-байтовый фрагмент памяти,newнеобходимо попросить выделить массив, скажем, типаchar
Глядя на различия, можно сказать, что malloc - это C-esque, new - C++ - esque. Используйте тот, который кажется наиболее подходящим для вашей кодовой базы.
Хотя допустимо, чтобы new и malloc были реализованы с использованием разных алгоритмов распределения памяти, в большинстве систем new внутренне реализуется с использованием malloc, что не приводит к разнице на системном уровне.
- Чтобы использовать
malloc(), нам нужно включают<stdlib.h>или<alloc.h>в программе, которая не требуется дляnew. newиdeleteмогут быть перегружены, аmalloc- нет.- Используя размещение
new, мы можем передать адрес, по которому мы хотим выделить память, но это невозможно в случаеmalloc.
alloc.h не является стандартным заголовком. <new> требуется для использования нового размещения.
new и delete - операторы в C++; который тоже может быть перегружен. malloc и free - функции в c;
malloc возвращает null ptr в случае сбоя, в то время как new выдает исключение.
адрес, возвращаемый malloc, должен быть приведен снова по типу, поскольку он возвращает (void *) malloc (size) New возвращает набранный указатель.
- new - это оператор, а malloc () - функция.
- new возвращает точный тип данных, а malloc () возвращает void * (указатель типа void).
- malloc (), память не инициализируется, а значение по умолчанию - мусор, тогда как в случае new память инициализируется значением по умолчанию, например, с 'ноль (0)' в случае с int.
- delete и free () могут использоваться для указателей NULL.
1. новый синтекс проще, чем malloc ()
2. new/delete - это оператор, где malloc () / free () это функция.
3. new/delete выполняется быстрее, чем malloc () / free (), потому что новый код сборки напрямую вставляется компилятором.
4. с помощью наложения оператора можно изменить значение в программе новое / удалить.
Этот код для использования ключевого слова delete или бесплатной функции. Но при создании объект-указатель с помощью 'malloc' или 'new' и освободить память объекта с помощью удалить даже этот указатель на объект может быть функцией вызова в классе. После которые используют бесплатно вместо удаления, тогда он также работает после бесплатного оператора, но при использовании обоих, только объект-указатель не может вызывать функцию в классе .. код выглядит следующим образом:
#include<iostream>
using namespace std;
class ABC{
public: ABC(){
cout<<"Hello"<<endl;
}
void disp(){
cout<<"Hi\n";
}
};
int main(){
ABC* b=(ABC*)malloc(sizeof(ABC));
int* q = new int[20];
ABC *a=new ABC();
b->disp();
cout<<b<<endl;
free(b);
delete b;
//a=NULL;
b->disp();
ABC();
cout<<b;
return 0;
}
output :
Hello Hi 0x2abfef37cc20
Смотрите также мой подробный ответ здесь.