Что лучше new или malloc

Чем new отличается от malloc?

В чем разница между malloc() и (char *)malloc()
Прошу помочь разобраться: не могу понять в чем разница междуs=malloc(sizeof(char)); иs=(char.

В чем разница между malloc и new?
в чем разница? что лучше использовать?

В чем разница malloc и calloc?
подскажите пожалуйста,в чем разница malloc и calloc? эмалок выделение динамической памяти а сиалок.

Malloc + reinterept_cast и new. В чем разница?
Уважаемые форумчане, скажите пожалуйста, в чем разница между этим: int* arr_i; arr_i =.

Тогда malloc честно выделит область памяти размера типа another_type и передаст указатель на нее. Но мы-то присваиваем адрес этой области памяти указателю some_type. И теперь компилятор будет работать с ней как с областью памяти, выделенной под совсем другое.

В то же время new мало того, что возвращает указатель именно на тот тип, который мы ему указали, так он еще и вызывает конструктор для этого типа. Так что на выходе мы имеем не сырую память подходящего размера, а полноценно сконструированный объект нужного типа (при условии, что подходящий конструктор работает как надо), и нам не нужно прямо здесь же вручную инициализировать эту область памяти нужными значениями. Кроме того, в случае неудачи new вызовет исключение bad_alloc, а не вернет указатель черт знает на что.

Возможно, что-то еще.

Добавлено через 9 минут

Комментарий модератора

Темы объединены.

Чем отличаются ф-ии GlobalAllocPtr() и malloc()?
Здрасьте! Чем отличаются ф-ии GlobalAllocPtr() и malloc()? Спасибо!

Чем отличается if от (?:)
Здравствуйте. Почитываю С++, сам программирую в Делфи. Вот немного запутался. В делфи есть условный.

Источник

Что быстрее/эффективнее malloc/realloc или new/delete?

В чем преимущества new и delete и могут ли они действительно заменить функции calloc, malloc, free, realloc?
Язык программирования C поддерживает функции динамического управления пямятью: calloc, malloc.

Можно ли выделять память под объект класса с помощью функций calloc, malloc или realloc?
Интересует данный вопрос. Можно ли и имеет ли вобще смысл например выделять память под объект.

Malloc realloc и C++
Подскажите, в C++ 11 выделение памяти по прежнему «нормально» выделять с помощью malloc и изменять.

malloc, realloc
У меня задан одномерный динамический массив таким образом: int *m1=new int; //n-количество.

Решение

Добавлено через 44 минуты
Люди, так что всё-таки шустрее realloc или new/delete? Сами что используете? =)

malloc/realloc/free более низкоуровневые вещи, поэтому многие рекоммендуют в С++ использовать new/delete. Тем более что их можно перегружать, применяя таким образом другие стратегии работы с памятью.

Во-первых, malloc/free это функции из библиотеки Си.
Во-вторых, malloc просто выделяет кусок сырой памяти, что же касается new, то тут всё немного сложнее. Я так понял, в рассчет берется new-expression, а не operator new, а значит помимо выделения памяти (чуть ниже об этом) мы имеем всякие new handler функции, обвяз для исключений, инициализацию объектов, и на выходе имеем уже не сырую память. Как по мне, так это сравнение теплого с мягким.
Если же взять за основу вместо new-expression именно operator new, то получим на выходе такую же сырую память как и от malloc. operator new может быть перегружен, сможете перегрузить его так, чтобы он работал с максимальной эффективностью? Если да, то прекрасно, со всеми вытекающими. Получаем более эффективное, гибкое и универсальное решение.

Источник

В чем разница между new и malloc()?

Начал читать книгу Пахомов Б. «C/C++ и MS Visual C++ 2008 для начинающих»

До этого прочитал С++ за 21 день.

В книге Похомова встретил такую функцию как malloc() и free()

В чем разница между malloc и new?
в чем разница? что лучше использовать?

В чем разница между malloc() и (char *)malloc()
Прошу помочь разобраться: не могу понять в чем разница междуs=malloc(sizeof(char)); иs=(char.

В чем разница malloc и calloc?
подскажите пожалуйста,в чем разница malloc и calloc? эмалок выделение динамической памяти а сиалок.

Malloc + reinterept_cast и new. В чем разница?
Уважаемые форумчане, скажите пожалуйста, в чем разница между этим: int* arr_i; arr_i =.

Решение

Это не вместо. Это просто два разных способа выделить память.

Решение

это Си’шные функции.

Скорее выражения new и delete пришли им на замену, и они учитывают возможности и особенности C++.

Добавлено через 1 минуту
Скажите спасибо за этот вопрос книге

там этих функций сроду небыло.

как я понял для malloc надо включить

Решение

Решил выделить память в куче для массива указателей.

для обычного массива делал так

Croessmah, просто меня медленный интернет подводит 😎

Благодарю за помощь!

могу врать, но работает так тоже

Разница между malloc и new
Ниже представлен код: #include using namespace std; struct stand < int x.

В чем разница между ^p и ^13
Заменой сделал строку с ^p и строку с ^13 с Подстановочными знаками. Если поместить курсор на.

В чем разница между X x; и X x()?
Корректный ли этот ответ?

Источник

Альтернативные аллокаторы памяти

Написал Стивен Тови в 2:29 утра по программированию (шутка юмора Google Translate)
Вступление от себя: эта заметка, прорекламированная Алёной C++, предназначена в основном разработчикам игр для консолей, но будет, наверное, полезна и всем, кому приходится сталкиваться с экстремальным аллоцированием динамической памяти. Возможно, любители посравнивать управление памятью в C++ и Java тоже найдут над чем задуматься.

Обязательная вступительная басня

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

Заходит компания их трёх человек и просит показать им места. Довольный приходом посетителей, ты любезно их усаживаешь. Не успевают они присесть и положить себе немного вкусных Текка Маки, как дверь снова открывается, и заходят ещё четверо! Тебе сегодня везёт, как утопленнику, парень! Ресторан теперь выглядит так…

Так как время обеденное, ресторан быстро заполняется до отказа. Наконец, поглотив всё что смогла, и оплатив счёт, первая компашка (те которых трое) уходит, а взамен заходит парочка и ты предлагаешь новым посетителям вновь освободившиеся места. Так случается несколько раз и наконец ресторан выглядит так…

И тут приходят четыре человека и просят усадить их. Прагматичный по натуре, ты тщательно отслеживал, сколько осталось свободных мест, и смотри, сегодня твой день, четыре места есть! Есть одно «но»: эти четверо жутко социальные и ходят сидеть рядом. Ты отчаянно оглядываешься, но хоть у тебя и есть четыре свободных места, усадить эту компанию рядом ты не можешь! Просить уже имеющихся посетителей подвинуться посреди обеда было бы грубовато, поэтому, к сожалению, у тебя нет другого выбора, кроме как дать новым от ворот поворот, и они, возможно, никогда не вернутся. Всё это ужасно печально. Если вы там гадаете, как эта басня относится к разработке игр, читайте дальше. В наших программах мы должны управлять памятью. Память — это драгоценный ресурс, которым нужно тщательно управлять, как и местами в нашем метафорическом суши-ресторане. Каждый раз, когда мы динамически выделяем память, мы резервируем место в штуке, называемой «кучей». В C и C++, обычно это делается, соответственно, при помощи функции malloc и оператора new. Продолжая нашу тухловатую аналогию (больше не буду, обещаю!) это похоже на то, как наши бесстрашные компашки едоков просят показать им их места. Но вот что по-настоящему фигово, так это то, что наш гипотетический сценарий случается и при работе с памятью, и последствия его гораздо хуже, чем пара пустых животиков. Это называется фрагментацией, и это кошмар!

Что же не так с malloc и new?

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

Скромный линейный аллокатор

Название этого раздела как бы намекает, что этот аллокатор, безусловно, самый простой из всех тех, которые я собираюсь представить, хотя по правде говоря, все они простые (и это делает их прекрасными). Линейный аллокатор, по существу, предполагает отсутствие мелочного освобождения выделенных ресурсов памяти и линейным способом выделяет куски памяти один за другим из фиксированного пула. Смотрите на картинку.

Хороший пример, где линейный аллокатор оказывается чрезвычайно полезным, можно найти практически везде при программировании синергетического процессора. Постоянность локальных данных за рамками текущей выполняемой задачи не важна, и во многих случаях количество данных, приходящих в локальное хранилище (по крайней мере данных, несколько варьирующихся в размерах) является достаточно ограниченным. Однако, не обманывайтесь, это далеко единственное его применение. Вот пример того, как можно было бы реализовать простой линейный аллокатор в С.

Применяя битовые операции к значению смещения во время выделения памяти можно поддержать выровненное аллоцирование. Оно может быть очень полезным, но знайте, что в зависимости от размера данных, которые вы размещаете в вашем буфере (а в некоторых случаях от порядка, в котором сделаны размещения), вы можете заполучить неиспользуемое пространство между выделенной памятью в буфере. Для выравниваний разумного размера это, как правило, приемлемо, но может стать чрезмерно расточительным, если вы выделяете память, с гораздо большим выравниванием, например по 1 Мб. В таких ситуациях порядок размещения объектов в линейном аллокаторе может оказать радикальное влияние на количество неиспользуемой памяти. Всё, что нужно сделать для сброса аллокатора (возможно, в конце уровня), это установить значение смещения в ноль. Как и всегда при работе с динамической памятью, клиенты аллокатора должны быть уверены в том, что у них нет указателей на память, которую вы таким способом деаллоцируете, иначе вы рискуете аллокатор сломать. У всех C++ объектов, которые вы разместили в буфере, нужно будет вручную вызвать деструктор.

Несколько оговорок прежде чем начать рассказывать об этом аллокаторе. Когда я говорю о «стековом аллокаторе» в данном конкретном случае, я не говорю о стеке вызовов, однако, как мы увидим позже, тот стек играет важную роль в избавлении от динамического выделения памяти из кучи. Так о чем тогда я говорю? Описанный выше линейный аллокатор является отличным решением для многих задач выделения памяти, но что, если вы хотите немного больше контроля над тем, как вы освобождаете свои ресурсы? Его вам даст стековый аллокатор. Ближе к концу описания линейного аллокатора я отметил, что для его сброса вы можете просто установить смещение в ноль, что освободит все ресурсы аллокатора. Принцип установки конкретного значения смещения является базовым, используемым в реализации стекового аллокатора. Если вы не знакомы с понятием стека, как структуры данных, то, вероятно, сейчас самое время, чтобы это сделать, например здесь. Сделали? Прекрасно. С каждым куском памяти, выделенным нашим стековым аллокатором будет опционально проассоциирован указатель на состояние стекового аллокатора непосредственно перед аллоцированием. Это означает, что если мы восстановим это состояние аллокатора (путем изменения его смещения) мы фактически ‘освободим’ память, которую можно будет повторно использовать. Это показано на диаграмме ниже.

Это может быть очень полезно, если вы хотите временно выделить память для данных с ограниченным временем жизни. Например, ограниченным временем жизни конкретной функции или подсистемы. Эта стратегия может быть также полезна для таких вещей как ресурсы уровня, у которых чётко определен порядок освобождения (обратный порядку размещения). Вот небольшой пример на C, иллюстрирующий только что сказанное

Двусторонний стек

Если вы осилили описанную выше концепцию стека, то мы можем перейти к двустороннему стеку. Он похож на стековый аллокатор, за исключением того, что в нём два стека, из которых один растёт из нижней части буфера вверх, а другой растёт из верхней части буфера вниз. Смотрите картинку:

Где это можно использовать? Хорошим примером была бы любая ситуация, где у вас есть данные схожего типа, но с совершенно разным временем жизни, или если бы у вас были данные, которые были бы тесно связаны и должны быть размещены в одной и той же области памяти, но имеют разный размер. Следует отметить, что место, где встретятся смещения двух стеков, не фиксировано. В частности, стеки не должны обязательно занимать половину буфера каждый. Нижний стек может вырастать до очень больших размеров, а верхний быть меньше, и наоборот. Для того, чтоб использовать буфер памяти наилучшим образом, эта дополнительная гибкость может быть иногда необходима. Думаю, вы не нуждаетесь в советах Капитана О., и не буду приводить тут примеры кода для аллокатора с двусторонним стеком, так как он, естественно, похож на уже обсуждённый односторонний стековый аллокатор.

Мы сейчас немного сместим фокус с семьи описанных выше аллокаторов, основанных на линейных перемещениях указателей или смещений и перейдём к несколько иным вещам. Пуловый аллокатор, про который я сейчас буду рассказывать, предназначен для работы с данными одинакового типа или размера. Он делит подконтрольный ему буфер памяти на сегменты одинакового размера, а затем позволяет клиенту по его желанию выделять и освобождать эти куски (см. диаграмму ниже). Для этого он должен постоянно отслеживать свободные сегменты, и мне известны несколько способов реализации этого. Я лично избегаю реализаций, использующих стек индексов (или указателей) на свободные сегменты, из-за того что им нужно дополнительное место, что часто может быть непозволительно, но они вообще есть. Реализация, про которую я здесь расскажу, не требует дополнительного места для управления свободными сегментами в пуле. На самом деле, в служебной структуре данных этого аллокатора есть всего два поля, что делает его самым маленьким из всех аллокаторов, описанных в этой заметке.

Так как же это работает? Для управления свободными сегментами мы будем использовать структуру данных, известную как связанный список. Опять же, если вы с этой структурой данных не знакомы, то попробуйте прочитать это. Имея опыт с PlayStation3 и Xbox360, где доступ к памяти дорог я в общем считаю структуры данных, основанные на узлах (например, связанный список) довольно мрачными, но я думаю, что это, пожалуй, одно из тех их применений, которые я одобряю. По сути в служебной структуре аллокатора будет находиться указатель на связанный список. Сам же связанный список размазан по всему пулу, занимая то же пространство, что и свободные сегменты в буфере памяти. Когда мы инициализируем аллокатор, мы проходим через сегменты буфера и записываем в первых четырёх (или восьми) байтах каждого сегмента указатель с адресом следующего свободного сегмента. Заголовок же указывает на первый элемент в этом списке. Некоторым ограничением, накладываемым хранением указателей в свободных сегментах пула является то, что размер сегмента должен быть не меньше размера указателя на целевом железе. См. диаграмму ниже.

При выделении памяти из пула нужно просто передвинуть указатель на голову связанного списка в заголовке на второй элемент списка, а затем вернуть указатель на первый элемент. Это очень просто, при выделении памяти мы всегда возвращаем первый элемент в связанном списке. Аналогичным образом, когда мы освобождаем сегмент и возвращаем его в пул, мы просто вставляем его в голову связанного списка. Вставка освобождаемого сегмента в голову, а не в хвост, имеет несколько преимуществ: в первую очередь мы не должны проходить связанный список (или хранить дополнительный указатель на хвост в заголовке) и во-вторых (и это более важно), у узла, только что освобождённого, больше шансов остаться в кеше при последующих размещениях. После нескольких выделений и освобождений памяти ваш пул может стать похожим на такой:

Вот чуток кода на C для инициализации аллокатора и операций выделения и освобождения памяти.

Пара слов о стековых размещениях (alloca вам в помощь)

Если вы помните, ранее я сказал, что упомяну о стековых размещениях в контексте стека вызовов. Я уверен, что вы видели код, который концептуально выглядит примерно так:

Большинство компиляторов C поддерживает функцию, которая должна означать (в зависимости от размера выделяемой памяти), что вам не придется прибегать к выделениям памяти в куче на временные буферы такого рода. Эта функция alloca. Внутреннее устройство alloca зависит от архитектуры, но по сути она выполняет выделение памяти путем настройки стекового кадра вашей функции, что позволяет вам записывать данные в область стека вызовов. Это может быть просто перемещение указателя стека (совсем как в линейном аллокаторе, упомянутом в начале). Память, выделенная вам функцией alloca, освобождается при выходе из функции. Есть, однако, несколько подводных камней, о которых надо знать при использовании alloca. Не забывайте проверять размер запрашиваемой памяти, чтоб быть уверенным в том, что вы не просите стек сумасшедшего размера. Если ваш стек переполнится, последствия будут неприятными. По этой же причине, если вы думаете над тем, чтоб выделить большой кусок памяти при помощи alloca, лучше знать все места, откуда ваша функция будет вызываться в контексте общего потока программы. Использование alloca может повлиять на переносимость в некоторых ограниченных случаях (очевидно), но я еще не сталкивался с компилятором, который бы её не поддерживал.

Дальнейшие подробности вы можете найти в вашем любимом поисковике.

И напоследок.

Часто память, выделяемая в ходе выполнения задачи является временной и сохраняется только на время жизни одного кадра. Для борьбы с неприятными последствиями фрагментации в системах с ограниченной памятью важно использовать эту информацию и размещать память такого рода в отдельных буферах. Сработает любая из вышеперечисленных схем аллоцирования, но я бы, наверное, предложил попробовать одну из линейных, так как их гораздо легче сбрасывать, чем пул. Noel Llopis рассказал больше подробностей на эту тему в этой отличной заметке. То, какой аллокатор лучше всего подходит именно вам, зависит от многих факторов, и от того, что требует та задача, которую вы пытаетесь решить. Я бы посоветовал тщательно подумать о шаблонах выделения и освобождения памяти, которые вы планируете делать в вашей системе, подумать о размерах и времени жизни выделяемой памяти и попытаться управлять ею аллокаторами, имеющими смысл в заданном контексте. Иногда помогает нарисовать распределение памяти на бумаге (да, карандашом и всё такое) или набросать график того, какую зависимость использования памяти от времени вы ожидаете. Хотите верите, хотите нет, но это действительно может помочь вам понять, как система производит и получает данные. Если вы это сделаете, то вам будет легче понять, как разделить выделения памяти так, чтоб сделать управление памятью настолько легким, быстрым и нефрагментированным, насколько возможно.

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

Заканчивая, я считаю, что программисты должны учитывать последствия динамического выделения памяти, особенно в консольных играх и дважды обдумать использование функции malloc или оператора new. Легко убедить себя, что вы не делаете так уж много аллокаций, а значит большого значения это не имеет, но такой тип мышления распространяется лавиной по всей команде, и приводит к медленной мучительной смерти. Фрагментация и потери в производительности, связанные с использованием динамической памяти, не будучи пресечёнными в зародыше, могут иметь катастрофические трудноразрешаемые последствия в вашем дальнейшем цикле разработки. Проекты, где управление и распределение памяти не продумано надлежащим образом, часто страдают от случайных сбоев после длительной игровой сессии из-за нехватки памяти (которые, кстати, практически невозможно воспроизвести) и стоят сотни часов работы программистов, пытающихся освободить память и реорганизовать её выделение.

Помните: никогда не рано начать задумываться о памяти и когда бы вы ни начали это делать, вы будете жалеть о том что не сделали этого ещё раньше!

Дополнительная информация.

Вот несколько ссылок на схожие темы, или на темы, которые я не смог охватить:

Спасибо Саре, Джеймин, Ричарду и Дат за вычитку этой бредятины.

Ещё от переводчика: я не разработчик игр, поэтому переводы специфических терминов могут быть не очень правильными. Например, я понятия не имею, что такое синергетический процессор 🙂 Переводить игру английских слов тоже было непросто, но надеюсь, что получился не самый плохой вариант.

Источник

Русские Блоги

Разница между динамическим распределением памяти, malloc и new

Выделение памяти

Сначала посмотрите на распределение памяти

Динамическое распределение памяти

Метод динамического выделения или восстановления пространства хранения и выделения памяти во время выполнения программы.

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

Язык C
malloc、calloc、realloc、free

malloc:
void *malloc(unsigned int size)
Откройте непрерывное пространство памяти размера size и верните указатель типа void. При использовании malloc для открытия пробела преобразование void *, которое должно быть отображено, имеет требуемый тип, и если разработка завершается неудачей, она возвращает указатель NULL.

calloc
void* calloc (size_t num, size_t size);
Откройте num непрерывное пространство размера size и инициализируйте каждое пространство 0.

realloc
void *realloc(void *ptr,size_t size);
Настройте размер пространства с адресом памяти ptr в соответствии с размером.

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

free
void free (void* ptr);
Свободной функцией является освобождение динамически развивающейся памяти.
malloc и free должны использоваться вместе. Если их нет, это приведет к утечке памяти.

Где malloc () получает память?

Динамически развивается изстекЧтобы получить место. Это означает, что указатель, возвращаемый функцией malloc, указывает на часть памяти в куче. Операционная система имеет связанный список, который записывает адреса свободной памяти. Когда операционная система получает приложение от программы, она пересекает связанный список

C ++
new、delete

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

delete
delete
delete []

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

В чем разница между malloc и new?

Есть ли другое понимание?

2. Возвращение типа безопасности
malloc возвращает void * после успешного выделения памяти, а затем принудительно преобразует тип в требуемый тип, после того, как новый оператор успешно выделяет память, он возвращает тип указателя, соответствующий типу объекта, поэтому new является непротиворечивым Типобезопасные операторы.

3. Возвращаемое значение ошибки выделения памяти
malloc возвращает NULL после сбоя выделения памяти, new не может вызвать исключение памяти (bac_alloc).

try
<
int *a = new int();
>
catch (bad_alloc)
<
.
>

4. Расчет размера выделенной памяти
Когда вы используете оператор new для подачи заявки на выделение памяти, вам не нужно указывать размер блока памяти. Компилятор рассчитает его на основе информации о типе, а malloc должен явно указать необходимый объем памяти.

5. Вызывать ли конструктор / деструктор
Существует три шага при использовании оператора new для выделения памяти объекта:
-Первый шаг: вызовите функцию оператора new (оператор new [] для массивов), чтобы выделить достаточно большое, оригинальное, безымянное пространство памяти для хранения объектов определенных типов.
-Шаг 2: Компилятор запускает соответствующий конструктор для создания объекта и передает ему начальное значение.
-Шаг 3: После того, как объект построен, верните указатель на объект.

Существует два шага при использовании оператора удаления для освобождения памяти объекта:
-Первый шаг: вызов деструктора объекта.
— Шаг 2. Компилятор вызывает функцию оператора delete (или оператор delete []), чтобы освободить пространство памяти.

6. Обработка массивов
C ++ предоставляет new [] и delete [] для работы с типами массивов. Он вызовет конструктор для инициализации каждого элемента массива, а затем, когда освободит объект, он вызовет деструктор для каждого объекта, но оба должны использоваться вместе, как и для malloc, он не знает, хотите ли вы разместить массив в этом пространстве или Другие вещи, просто дайте часть оригинального пространства, а затем дайте адрес памяти для завершения, если вы хотите динамически открыть массив памяти, нам также нужно вручную настроить размер массива.
A * ptr = new A [10]; // Выделить 10 A объектов
delete [] ptr;
int * ptr = (int *) malloc (sizeof (int) * 10); // выделяем массив из 10 элементов int

7. Могут ли new и malloc вызывать друг друга
Реализация оператора new / оператора delete может быть основана на malloc, а реализация malloc не может вызвать new

8. Может ли он быть перегружен
opeartor new / operator delete можно перезагрузить. И malloc / free не может быть перегружен.

9. Недостаточно памяти при выделении памяти
После того, как malloc динамически выделяет память, если этого недостаточно, вы можете использовать функцию realloc для перераспределения, чтобы добиться расширения памяти, в то время как new не имеет такой операции;

подводить итоги
Организовать вышеуказанную разницу в 10 баллов в таблицу

удалить и удалить []

Зачем вам нужно новое / удалить с помощью malloc / free?

Вопросы, требующие внимания:

Источник