В каких случаях использовать malloc и / или new?

Если вы не вынуждены использовать C, вам следует никогда не использоватьmalloc. Всегда используйте new.

Если вам нужен большой кусок данных, просто сделайте что-нибудь вроде:

char *pBuffer = new char[1024];

Будьте осторожны, хотя это неверно:

//This is incorrect - may delete only one element, may corrupt the heap, or worse...
delete pBuffer;

Вместо этого вы должны сделать это при удалении массива данных:

//This deletes all items in the array
delete[] pBuffer;

Ключевое слово new - это способ сделать это в C++, и оно гарантирует, что ваш тип будет иметь свой конструктор называется. Ключевое слово new также больше типобезопасный, тогда как malloc вообще не является типобезопасным.

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

Стоит отметить, что нельзя смешивать new / free и malloc / delete.

Примечание. Некоторые ответы на этот вопрос неверны.

int* p_scalar = new int(5);  // Does not create 5 elements, but initializes to 5
int* p_array  = new int[5];  // Creates 5 elements

Используйте malloc и freeТолько для выделения памяти, которая будет управляться c-ориентированными библиотеками и API. Используйте new и delete (и варианты []) для всего, что вы контролируете.

Если у вас есть код C, который вы хотите перенести на C++, вы можете оставить в нем любые вызовы malloc (). Для любого нового кода C++ я бы рекомендовал использовать вместо него new.

Всегда используйте новое в C++. Если вам нужен блок нетипизированной памяти, вы можете напрямую использовать оператор new:

void *p = operator new(size);
   ...
operator delete(p);

Из C++ FQA Lite:

[16.4] Why should I use new instead of trustworthy old malloc()?

FAQ: new/delete call the constructor/destructor; new is type safe, malloc is not; new can be overridden by a class.

FQA: The virtues of new mentioned by the FAQ are not virtues, because constructors, destructors, and operator overloading are garbage (see what happens when you have no garbage collection?), and the type safety issue is really tiny here (normally you have to cast the void* returned by malloc to the right pointer type to assign it to a typed pointer variable, which may be annoying, but far from "unsafe").

Oh, and using trustworthy old malloc makes it possible to use the equally trustworthy & old realloc. Too bad we don't have a shiny new operator renew or something.

Still, new is not bad enough to justify a deviation from the common style used throughout a language, even when the language is C++. In particular, classes with non-trivial constructors will misbehave in fatal ways if you simply malloc the objects. So why not use new throughout the code? People rarely overload operator new, so it probably won't get in your way too much. And if they do overload new, you can always ask them to stop.

Извини, я просто не удержался. :)

Операторы new и delete могут работать с классами и структурами, тогда как malloc и free работают только с блоками памяти, которые необходимо преобразовать.

Использование new/delete поможет улучшить ваш код, поскольку вам не нужно будет преобразовывать выделенную память в требуемую структуру данных.

С более низкой точки зрения, new инициализирует всю память перед передачей памяти, тогда как malloc сохранит исходное содержимое памяти.

Короткий ответ: не используйте malloc для C++ без действительно веской причины. malloc имеет ряд недостатков при использовании с C++, для устранения которых был определен new.

Недостатки, исправленные новым для кода C++

1. malloc не является типобезопасным в каком-либо смысле. В C++ требуется выполнить возврат от void*. Это потенциально создает множество проблем:

   #include <stdlib.h>
   
   struct foo {
     double d[5];
   }; 
   
   int main() {
     foo *f1 = malloc(1); // error, no cast
     foo *f2 = static_cast<foo*>(malloc(sizeof(foo)));
     foo *f3 = static_cast<foo*>(malloc(1)); // No error, bad
   }
   

2. Хотя все еще хуже. Если рассматриваемый тип - POD (простые старые данные), тогда вы можете разумно использовать malloc для выделения для него памяти, как это делает f2 в первом примере.

   Однако это не так очевидно, если тип - POD. Тот факт, что данный тип может измениться с POD на не-POD без результирующей ошибки компилятора и потенциально очень трудных для отладки проблем, является важным фактором. Например, если кто-то (возможно, другой программист, во время обслуживания, намного позже, внесет изменение, из-за которого foo больше не будет POD, то во время компиляции не появится очевидная ошибка, как вы надеетесь, например:

   struct foo {
     double d[5];
     virtual ~foo() { }
   };
   

   приведет к тому, что malloc из f2 также станет плохим, без какой-либо очевидной диагностики. Пример здесь тривиален, но можно случайно ввести не-POD-качество намного дальше (например, в базовый класс, добавив не-POD-член). Если у вас есть C++ 11 / boost, вы можете использовать is_pod, чтобы проверить правильность этого предположения и выдать ошибку, если это не так:

   #include <type_traits>
   #include <stdlib.h>
   
   foo *safe_foo_malloc() {
     static_assert(std::is_pod<foo>::value, "foo must be POD");
     return static_cast<foo*>(malloc(sizeof(foo)));
   }
   

   Хотя boost - это невозможно определить, является ли тип POD без C++ 11 или некоторых других расширений компилятора.

3. malloc возвращает NULL в случае сбоя выделения. new выбрасывает std::bad_alloc. Поведение при последующем использовании указателя NULL не определено. Исключение имеет чистую семантику, когда оно выбрасывается из источника ошибки. Добавление malloc к соответствующему тесту при каждом вызове кажется утомительным и подверженным ошибкам. (Вам нужно только один раз забыть, чтобы отменить всю эту хорошую работу). Исключению можно разрешить распространиться на уровень, на котором вызывающий может разумно его обработать, тогда как NULL гораздо сложнее передать обратно осмысленно. Мы могли бы расширить нашу функцию safe_foo_malloc, чтобы генерировать исключение, или выйти из программы, или вызвать некоторый обработчик:

   #include <type_traits>
   #include <stdlib.h>
   
   void my_malloc_failed_handler();
   
   foo *safe_foo_malloc() {
     static_assert(std::is_pod<foo>::value, "foo must be POD");
     foo *mem = static_cast<foo*>(malloc(sizeof(foo)));
     if (!mem) {
        my_malloc_failed_handler();
        // or throw ...
     }
     return mem;
   }
   

4. По сути, malloc - это функция C, а new - функция C++. В результате malloc не очень хорошо работает с конструкторами, он смотрит только на выделение части байтов. Мы могли бы расширить наш safe_foo_malloc, чтобы использовать размещение new:

   #include <stdlib.h>
   #include <new>
   
   void my_malloc_failed_handler();
   
   foo *safe_foo_malloc() {
     void *mem = malloc(sizeof(foo));
     if (!mem) {
        my_malloc_failed_handler();
        // or throw ...
     }
     return new (mem)foo();
   }
   

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

   #include <functional>
   #include <new>
   #include <stdlib.h>
   
   void my_malloc_failed_handler();
   
   template <typename T>
   struct alloc {
     template <typename ...Args>
     static T *safe_malloc(Args&&... args) {
       void *mem = malloc(sizeof(T));
       if (!mem) {
          my_malloc_failed_handler();
          // or throw ...
       }
       return new (mem)T(std::forward(args)...);
     }
   };
   

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

Есть одно большое различие между malloc и new. malloc выделяет память. Это нормально для C, потому что в C кусок памяти является объектом.

В C++, если вы не имеете дело с типами POD (которые похожи на типы C), вы должны вызвать конструктор в области памяти, чтобы действительно иметь там объект. Типы, не относящиеся к POD, очень распространены в C++, поскольку многие функции C++ автоматически делают объект не-POD.

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

Если вы сделаете что-то вроде этого:

non_pod_type* p = (non_pod_type*) malloc(sizeof *p);

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

Если, с другой стороны, вы делаете:

non_pod_type* p = new non_pod_type();

Вы получаете указатель, который всегда действителен, потому что new создал объект.

Даже для типов POD между ними есть существенная разница:

pod_type* p = (pod_type*) malloc(sizeof *p);
std::cout << p->foo;

Этот фрагмент кода будет печатать неопределенное значение, потому что объекты POD, созданные malloc, не инициализируются.

С new вы можете указать конструктор для вызова и, таким образом, получить четко определенное значение.

pod_type* p = new pod_type();
std::cout << p->foo; // prints 0

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

Еще одно отличие - поведение при неудаче. Когда не удается выделить память, malloc возвращает нулевой указатель, а new выдает исключение.

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

По этим причинам в коде C++ следует использовать new, а не malloc. Но даже в этом случае вам не следует использовать new «открыто», потому что он привлекает ресурсы, которые вам нужно выпустить позже. Когда вы используете new, вы должны немедленно передать его результат в класс управления ресурсами:

std::unique_ptr<T> p = std::unique_ptr<T>(new T()); // this won't leak

malloc () используется для динамического выделения памяти в C в то время как та же работа выполняется new () в C++. Таким образом, вы не можете смешивать соглашения о кодировании двух языков. Было бы хорошо, если бы вы спросили разницу между calloc и malloc ()

В следующем сценарии мы не можем использовать new, поскольку он вызывает конструктор.

class  B  {
private:
    B *ptr;
    int x;
public:
    B(int n)  {
        cout<<"B: ctr"<<endl;
        //ptr = new B;  //keep calling ctr, result is segmentation fault
        ptr = (B *)malloc(sizeof(B));
        x = n;
        ptr->x = n + 10;
    }
    ~B()  {
        //delete ptr;
        free(ptr);
        cout<<"B: dtr"<<endl;
    }
};

Если вы работаете с данными, которые не нуждаются в построении / уничтожении и требуют перераспределения (например, большой массив целых чисел), то я считаю, что malloc / free - хороший выбор, поскольку он дает вам перераспределение, что намного быстрее, чем new-memcpy -delete (это на моем компьютере с Linux, но я предполагаю, что это может зависеть от платформы). Если вы работаете с объектами C++, которые не являются POD и требуют построения / уничтожения, вы должны использовать операторы new и delete.

В любом случае, я не понимаю, почему вы не должны использовать оба (при условии, что вы освобождаете свою malloced память и удаляете объекты, выделенные с помощью new), если можете воспользоваться преимуществом повышения скорости (иногда значительного, если вы повторно блокируете большие массивы POD), который может дать вам realloc.

Если вам это не нужно, вы должны придерживаться new / delete в C++.

Есть несколько вещей, которые new делает, но не malloc:

1. new создает объект, вызывая конструктор этого объекта.
2. new не требует приведения типа выделенной памяти.
3. Для этого не требуется выделять объем памяти, а требуется несколько объекты для строительства.

Итак, если вы используете malloc, вам нужно делать указанные выше вещи явно, что не всегда практично. Кроме того, new может быть перегружен, а malloc - нет.

Если вы используете C++, попробуйте использовать new / delete вместо malloc / calloc, поскольку они являются операторами. Для malloc / calloc вам нужно включить другой заголовок. Не смешивайте два разных языка в одном коде. Их работа во всех отношениях схожа, оба динамически распределяют память из сегмента кучи в хеш-таблице.

новый против malloc ()

1) new - это оператор, а malloc() - это функция.

2) new вызывает конструкторы, а malloc() - нет.

3) new возвращает точный тип данных, а malloc() возвращает пустота *.

4) new никогда не возвращает НУЛЕВОЙ (выдает при сбое), в то время как malloc() возвращает NULL

5) Перераспределение памяти не обрабатывается new, в то время как malloc() может

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

Например.

struct test_s {
    int some_strange_name = 1;
    int &easy = some_strange_name;
}

Таким образом, new struct test_s вернет инициализированную структуру с рабочей ссылкой, в то время как версия с измененной локализацией не имеет значений по умолчанию, а внутренние ссылки не инициализируются.

Редкий случай использования malloc / free вместо new / delete - это когда вы выделяете, а затем перераспределяете (простые типы модулей, а не объекты) с помощью realloc, поскольку в C++ нет аналогичной функции для realloc (хотя это можно сделать с помощью больше подход C++).

Чтобы ответить на ваш вопрос, вы должны знать разница между malloc и new. Отличие простое:

mallocвыделяет память, а newвыделяет память и вызывает конструктор объекта, для которого вы выделяете память.

Итак, если вы не ограничены C, вам никогда не следует использовать malloc, особенно при работе с объектами C++. Это был бы рецепт нарушения вашей программы.

Также разница между free и delete такая же. Разница в том, что delete вызовет деструктор вашего объекта в дополнение к освобождению памяти.

Динамическое распределение требуется только тогда, когда время жизни объекта должно отличаться от области, в которой он создается (это также справедливо для уменьшения области действия), и у вас есть конкретная причина, по которой его сохранение по значению не Работа.

Например:

 std::vector<int> *createVector(); // Bad
 std::vector<int> createVector();  // Good

 auto v = new std::vector<int>(); // Bad
 auto result = calculate(/*optional output = */ v);
 auto v = std::vector<int>(); // Good
 auto result = calculate(/*optional output = */ &v);

Начиная с C++ 11, у нас есть std::unique_ptr для работы с выделенной памятью, которая содержит владение выделенной памятью. std::shared_ptr был создан для случаев, когда вам нужно разделить владение. (вам понадобится меньше, чем вы ожидаете от хорошей программы)

Создание экземпляра становится действительно простым:

auto instance = std::make_unique<Class>(/*args*/); // C++14
auto instance = std::unique_ptr<Class>(new Class(/*args*/)); // C++11
auto instance = std::make_unique<Class[]>(42); // C++14
auto instance = std::unique_ptr<Class[]>(new Class[](42)); // C++11

C++ 17 также добавляет std::optional, который может помешать вам требовать выделения памяти.

auto optInstance = std::optional<Class>{};
if (condition)
    optInstance = Class{};

Как только «экземпляр» выходит из области видимости, память очищается. Передать право собственности также просто:

 auto vector = std::vector<std::unique_ptr<Interface>>{};
 auto instance = std::make_unique<Class>();
 vector.push_back(std::move(instance)); // std::move -> transfer (most of the time)

Итак, когда вам все еще нужен new? Практически никогда с C++ 11. В большинстве случаев вы используете std::make_unique, пока не дойдете до точки, в которой вы попадете в API, который передает право собственности через необработанные указатели.

 auto instance = std::make_unique<Class>();
 legacyFunction(instance.release()); // Ownership being transferred

 auto instance = std::unique_ptr<Class>{legacyFunction()}; // Ownership being captured in unique_ptr

В C++ 98/03 вам придется вручную управлять памятью. В этом случае попробуйте выполнить обновление до более новой версии стандарта. Если вы застряли:

 auto instance = new Class(); // Allocate memory
 delete instance;             // Deallocate
 auto instances = new Class[42](); // Allocate memory
 delete[] instances;               // Deallocate

Убедитесь, что вы правильно отслеживаете право собственности, чтобы не было утечек памяти! Семантика перемещения тоже пока не работает.

Итак, когда нам нужен malloc в C++? Единственная веская причина - выделить память и инициализировать ее позже путем размещения new.

 auto instanceBlob = std::malloc(sizeof(Class)); // Allocate memory
 auto instance = new(instanceBlob)Class{}; // Initialize via constructor
 instance.~Class(); // Destroy via destructor
 std::free(instanceBlob); // Deallocate the memory

Несмотря на то, что вышеизложенное верно, это также можно сделать с помощью оператора new. std::vector - хороший тому пример.

Наконец, у нас все еще есть слон в комнате: C. Если вам нужно работать с C-библиотекой, где память выделяется в коде C++ и освобождается в коде C (или наоборот), вы вынуждены использовать malloc / free.

Если вы в этом случае, забудьте о виртуальных функциях, функциях-членах, классах ... Разрешены только структуры с POD.

Некоторые исключения из правил:

• Вы пишете стандартную библиотеку с расширенными структурами данных, где подходит malloc
• Вам нужно выделить большой объем памяти (в памяти копия файла размером 10 ГБ?)
• У вас есть инструменты, которые не позволяют использовать определенные конструкции.
• Вам нужно хранить неполный тип