У яких випадках я використовую malloc та / або new?

Я бачу, що в C ++ є кілька способів розподілу та вільних даних, і я розумію, що коли ви телефонуєте, mallocвам слід зателефонувати, freeі коли ви використовуєте newоператора, ви повинні з'єднатися з ними, deleteі це помилка змішати два (наприклад, дзвінок free()на щось створене з newоператором), але мені не зрозуміло, коли я повинен використовувати malloc/ freeі коли я повинен new/ deleteв своїх реальних програмах.

Якщо ви експерт з питань C ++, будь ласка, повідомте мене про будь-які основні правила чи умови, яких ви дотримуєтесь у цьому плані.

Якщо ви не змушені використовувати 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для 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до відсутності ПОД, тоді очевидна помилка не з’явиться під час компіляції, як ви сподівалися, наприклад:

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

   зробить mallocз f2також стати погано, без яких - або очевидних діагностики. Приклад тут тривіальний, але можна випадково ввести не-PODness набагато далі (наприклад, в базовий клас, додавши член, який не є 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для початку!

Від C ++ FQA Lite :

[16.4] Чому я повинен використовувати новий замість надійного старого malloc ()?

FAQ: новий / видалити виклик конструктора / деструктора; new - безпечний тип, malloc - ні; новий може бути замінений класом.

FQA: Чесноти, про які йдеться у FAQ, не є чеснотами, оскільки конструктори, деструктори та перевантаження оператора - сміття (дивіться, що відбувається, коли у вас немає сміття?), А питання безпеки типу тут справді крихітний (зазвичай у вас є передати порожнечу *, повернуту malloc, на правий тип вказівника, щоб призначити її введеній змінній вказівника, яка може бути прикрою, але далеко не "небезпечною").

О, а використання надійного старого malloc дає змогу використовувати однаково надійний та старий realloc. Шкода, що у нас немає блискучого нового оновлення оператора чи чогось іншого.

І все-таки нове не є достатньо поганим, щоб виправдати відхилення від загального стилю, що використовується в мові, навіть коли мова є C ++. Зокрема, класи з нетривіальними конструкторами будуть погано поводитись фатально, якщо ви просто зловживаєте об'єктами. То чому б не використати новий у всьому коді? Люди рідко перевантажують нового оператора, тому він, мабуть, не заважає вам занадто сильно. І якщо вони перевантажують нові, ви завжди можете попросити їх зупинитися.

Вибачте, я просто не втримався. :)

Завжди використовуйте нове в C ++. Якщо вам потрібен блок нетипізованої пам'яті, ви можете використовувати оператор new безпосередньо:

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

Використовуйте mallocі лише для розподілу пам'яті, якою керуватимуть c-центричні бібліотеки та API. Використовуйте та (і варіанти) для всього, що ви контролюєте.free newdelete[]

новий vs malloc ()

1) newє оператором , а malloc()є функцією .

2) newвикликає конструктори , поки malloc()не робить.

3) newповертає точний тип даних , тоді як malloc()повертає недійсні * .

4) newніколи не повертає NULL (викине з ладу), тоді як malloc()повертає NULL

5) Перерозподіл пам'яті, не обробляється newпоки malloc()може

Щоб відповісти на ваше запитання, ви повинні знати різницю між mallocіnew . Різниця проста:

malloc виділяє пам'ять , при цьому new виділяє пам'ять І викликає конструктор об'єкта, для якого ви виділяєте пам'ять.

Отже, якщо ви не обмежені на C, ви ніколи не повинні використовувати malloc, особливо при роботі з об'єктами C ++. Це був би рецепт порушення вашої програми.

Також різниця між freeі deleteзовсім однакова. Різниця полягає в тому, що deleteвикличе деструктор вашого об'єкта, крім звільнення пам'яті.

Є одна велика різниця між 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

Динамічний розподіл потрібен лише тоді, коли час життя об'єкта повинен відрізнятися від обсягу, який він створює (Це справедливо і для того, щоб зменшити обсяг як більший), і у вас є конкретна причина, коли зберігання його за значенням не означає робота.

Наприклад:

 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::make_unique<Class>(new Class(/*args*/)); // C++11
auto instance = std::make_unique<Class[]>(42); // C++14
auto instance = std::make_unique<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 ++? Єдиною вагомою причиною було б виділити пам'ять та ініціалізувати її пізніше, розміщуючи нову.

 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

Незважаючи на те, що вищезазначене є дійсним, це можна зробити і через нового оператора. std::vectorє хорошим прикладом для цього.

Нарешті, у нас ще є слон в кімнаті: C. Якщо вам доведеться працювати з бібліотекою С, де пам'ять отримується в коді C ++ і звільняється в коді С (або навпаки), ви змушені використовувати malloc / free.

Якщо ви в цьому випадку, забудьте про віртуальні функції, функції членів, класи ... Дозволені лише структури з POD-адресами в ньому.

Деякі винятки з правил:

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

Є кілька речей, що newне mallocробить:

1. new будує об'єкт, викликаючи конструктор цього об'єкта
2. new не вимагає набору даних виділеної пам'яті.
3. Для цього не потрібно виділяти об'єм пам'яті, швидше потрібно побудувати ряд об'єктів.

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

Якщо ви працюєте з даними, які не потребують побудови / знищення та потребують перерозподілу (наприклад, великий масив ints), то я вважаю, що malloc / free є хорошим вибором, оскільки він дає вам reallock, що швидше, ніж new-memcpy -delete (він знаходиться в моєму вікні Linux, але я думаю, це може залежати від платформи). Якщо ви працюєте з об'єктами C ++, які не є POD і не потребують побудови / знищення, тоді ви повинні використовувати нові та видалити оператори.

У будь-якому випадку, я не бачу, чому ви не повинні використовувати обидва (за умови звільнення пам’яті, що виділяється, та видалення об'єктів, виділених новими), якщо ви можете скористатися збільшенням швидкості (іноді важливою, якщо ви перерозподіляєте великі масиви від POD), який може вам надати realloc.

Якщо вам це не потрібно, вам слід дотримуватися нового / видалити в C ++.

Якщо у вас є код C, який ви хочете передати на C ++, ви можете залишити в ньому будь-які дзвінки malloc (). Для будь-якого нового коду C ++ я рекомендую замість цього використовувати новий.

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

new буде ініціалізувати значення за замовчуванням структури та правильно пов'язувати посилання в ньому до себе.

Напр

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

Таким чином new struct test_s, поверне ініціалізовану структуру з робочим посиланням, тоді як у malloc'ed версії немає значень за замовчуванням, а посилання інтерна не ініціалізуються.

З нижчої точки зору, новий ініціалізує всю пам'ять перед тим, як віддавати пам'ять, тоді як malloc збереже оригінальний вміст пам'яті.

У наступному сценарії ми не можемо використовувати новий, оскільки він викликає конструктор.

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

Ці newта deleteоператори можуть працювати на класи і структури, в той час , mallocі freeпрацюють тільки з блоками пам'яті , які повинні бути литий.

Використання new/deleteдопоможе покращити ваш код, оскільки вам не потрібно буде передавати виділену пам’ять необхідній структурі даних.

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

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