Dalam kasus apa saya menggunakan malloc dan / atau baru?

Saya melihat di C ++ ada beberapa cara untuk mengalokasikan dan membebaskan data dan saya mengerti bahwa ketika Anda menelepon mallocAnda harus menelepon freedan ketika Anda menggunakan newoperator Anda harus memasangkan dengan deletedan itu adalah kesalahan untuk mencampur keduanya (misalnya Memanggil free()sesuatu yang telah dibuat dengan newoperator), tapi saya tidak jelas kapan saya harus menggunakan malloc/ freedan kapan saya harus menggunakan new/ deletedalam program dunia nyata saya.

Jika Anda seorang pakar C ++, beri tahu saya aturan apa pun yang Anda ikuti dalam hal ini.

Kecuali Anda dipaksa untuk menggunakan C, Anda seharusnya tidak pernah menggunakan malloc . Selalu gunakan new.

Jika Anda membutuhkan banyak data, lakukan saja seperti:

char *pBuffer = new char[1024];

Hati-hati meskipun ini tidak benar:

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

Alih-alih, Anda harus melakukan ini saat menghapus array data:

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

Itu new kunci adalah cara C ++ untuk melakukannya, dan itu akan memastikan bahwa tipe Anda akan memanggil konstruktornya . Kata newkunci juga lebih aman-tipe sedangkan malloctidak-aman sama sekali.

Satu-satunya cara saya bisa berpikir itu akan bermanfaat untuk digunakan malloc adalah jika Anda perlu mengubah ukuran buffer data Anda. Kata newkunci tidak memiliki cara analog seperti realloc. The reallocFungsi mungkin bisa memperpanjang ukuran sepotong memori untuk Anda lebih efisien.

Perlu disebutkan bahwa Anda tidak dapat mencampur new/ freedan malloc/ delete.

Catatan: Beberapa jawaban dalam pertanyaan ini tidak valid.

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

Jawaban singkatnya adalah: jangan gunakan mallocuntuk C ++ tanpa alasan yang bagus untuk melakukannya. mallocmemiliki sejumlah kekurangan saat digunakan dengan C ++, yangnew didefinisikan untuk diatasi.

Kekurangan diperbaiki oleh baru untuk kode C ++

1. mallocbukan typesafe dengan cara apa pun yang berarti. Di C ++ Anda diminta untuk mengembalikan dari void*. Ini berpotensi menimbulkan banyak masalah:

   #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. Ini lebih buruk dari itu. Jika jenis yang dimaksud adalah POD (data lama biasa) maka Anda dapat menggunakan secara semi-bijaksana mallocuntuk mengalokasikan memori untuknya, sepertif2 halnya dalam contoh pertama.

   Namun tidak begitu jelas apakah suatu tipe POD. Fakta bahwa dimungkinkan untuk tipe tertentu untuk berubah dari POD ke non-POD tanpa menghasilkan kesalahan kompiler dan berpotensi sangat sulit untuk men-debug masalah adalah faktor yang signifikan. Sebagai contoh jika seseorang (mungkin programmer lain, selama pemeliharaan, jauh kemudian adalah untuk membuat perubahan yang menyebabkan footidak lagi menjadi POD maka tidak ada kesalahan yang jelas akan muncul pada waktu kompilasi seperti yang Anda harapkan, misalnya:

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

   akan membuat mallocdari f2juga menjadi buruk, tanpa diagnosa yang jelas. Contoh di sini sepele, tetapi mungkin untuk secara tidak sengaja memperkenalkan non-PODness lebih jauh (misalnya dalam kelas dasar, dengan menambahkan anggota non-POD). Jika Anda memiliki C ++ 11 / boost, Anda dapat menggunakanis_pod untuk memeriksa bahwa asumsi ini benar dan menghasilkan kesalahan jika tidak:

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

   Meskipun dorongan tidak dapat menentukan apakah suatu tipe POD tanpa C ++ 11 atau ekstensi kompiler lainnya.

3. mallockembali NULLjika alokasi gagal. newakan melempar std::bad_alloc. Perilaku nanti menggunakan NULLpointer tidak ditentukan. Pengecualian memiliki semantik bersih saat dilempar dan dilempar dari sumber kesalahan. Membungkus mallocdengan tes yang sesuai pada setiap panggilan tampaknya membosankan dan rawan kesalahan. (Anda hanya perlu lupa sekali untuk membatalkan semua pekerjaan bagus itu). Pengecualian dapat diizinkan untuk menyebar ke tingkat di mana penelepon dapat memprosesnya dengan masuk akal, di mana NULLjauh lebih sulit untuk lulus kembali secara bermakna. Kami dapat memperluas safe_foo_mallocfungsi kami untuk melempar pengecualian atau keluar dari program atau memanggil beberapa penangan:

   #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. Pada dasarnya mallocadalah fitur C dan newmerupakan fitur C ++. Akibatnya malloctidak bermain bagus dengan konstruktor, itu hanya terlihat mengalokasikan sejumlah byte. Kami dapat memperluas safe_foo_malloclebih lanjut untuk menggunakan penempatan 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_mallocFungsi kami tidak terlalu umum - idealnya kami menginginkan sesuatu yang dapat menangani semua jenis, bukan hanya foo. Kita dapat mencapai ini dengan templat dan templat variadic untuk konstruktor non-default:

   #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)...);
     }
   };

   Namun sekarang dalam memperbaiki semua masalah yang kami identifikasi sejauh ini, kami praktis telah menemukan kembali newoperator default . Jika Anda akan menggunakan mallocdan penempatan newmaka Anda mungkin juga hanya newperlu mulai dengan!

Dari C ++ FQA Lite :

[16.4] Mengapa saya harus menggunakan malloc () lama yang baru dan bukan yang dapat dipercaya?

FAQ: baru / hapus panggilan konstruktor / destruktor; baru adalah tipe aman, malloc tidak; baru dapat diganti oleh suatu kelas.

FQA: Keutamaan baru yang disebutkan oleh FAQ bukanlah kebajikan, karena konstruktor, destruktor, dan kelebihan beban operator adalah sampah (lihat apa yang terjadi ketika Anda tidak memiliki pengumpulan sampah?), Dan masalah keamanan jenis sangat kecil di sini (biasanya Anda memiliki untuk membuang void * dikembalikan oleh malloc ke tipe pointer kanan untuk menetapkannya ke variabel pointer yang diketik, yang mungkin mengganggu, tetapi jauh dari "tidak aman").

Oh, dan menggunakan malloc lama yang dapat dipercaya memungkinkan untuk menggunakan realall yang sama-sama dapat dipercaya & lama. Sayang sekali kami tidak memiliki perpanjangan operator baru yang mengkilap atau sesuatu.

Namun, yang baru tidak cukup buruk untuk membenarkan penyimpangan dari gaya umum yang digunakan di seluruh bahasa, bahkan ketika bahasa C ++. Secara khusus, kelas dengan konstruktor non-sepele akan bertingkah fatal dengan cara jika Anda hanya malloc objek. Jadi mengapa tidak menggunakan yang baru di seluruh kode? Orang-orang jarang membebani operator baru, jadi mungkin tidak akan menghalangi Anda terlalu banyak. Dan jika mereka melakukan overload baru, Anda selalu dapat meminta mereka untuk berhenti.

Maaf, saya tidak bisa menolak. :)

Selalu gunakan yang baru di C ++. Jika Anda membutuhkan blok memori yang tidak diketik, Anda dapat menggunakan operator baru secara langsung:

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

Gunakan mallocdan hanya untuk mengalokasikan memori yang akan dikelola oleh perpustakaan c-centric dan API. Gunakan dan (dan variannya) untuk semua yang Anda kontrol.free newdelete[]

baru vs malloc ()

1) newadalah operator yang , sementara malloc()adalah fungsi .

2) newmemanggil konstruktor , sementaramalloc() tidak.

3) newmengembalikan tipe data yang tepat , sementara malloc()mengembalikan batal * .

4) newtidak pernah mengembalikan NULL (akan gagal) sementaramalloc() mengembalikan NULL

5) Realokasi memori tidak ditangani oleh new selagi malloc()bisa

Untuk menjawab pertanyaan Anda, Anda harus tahu perbedaan antara mallocdannew . Perbedaannya sederhana:

malloc mengalokasikan memori , sementara new mengalokasikan memori DAN memanggil konstruktor dari objek Anda mengalokasikan memori untuk.

Jadi, kecuali Anda dibatasi untuk C, Anda tidak boleh menggunakan malloc, terutama ketika berhadapan dengan objek C ++. Itu akan menjadi resep untuk merusak program Anda.

Juga perbedaan antara freedan deletecukup sama. Perbedaannya adalah bahwa deleteakan memanggil destruktor objek Anda selain membebaskan memori.

Ada satu perbedaan besar antara mallocdan new.mallocmengalokasikan memori. Ini bagus untuk C, karena di C, benjolan memori adalah objek.

Di C ++, jika Anda tidak berurusan dengan tipe POD (yang mirip dengan tipe C) Anda harus memanggil konstruktor pada lokasi memori untuk benar-benar memiliki objek di sana. Jenis non-POD sangat umum di C ++, karena banyak fitur C ++ membuat objek secara otomatis non-POD.

newmengalokasikan memori dan membuat objek di lokasi memori itu. Untuk jenis non-POD ini berarti memanggil konstruktor.

Jika Anda melakukan sesuatu seperti ini:

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

Pointer yang Anda peroleh tidak dapat direferensikan karena tidak menunjuk ke objek. Anda harus memanggil konstruktor sebelum dapat menggunakannya (dan ini dilakukan dengan menggunakan penempatannew ).

Sebaliknya, jika Anda melakukannya:

non_pod_type* p = new non_pod_type();

Anda mendapatkan pointer yang selalu valid, karena new membuat objek.

Bahkan untuk tipe POD, ada perbedaan yang signifikan antara keduanya:

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

Sepotong kode ini akan mencetak nilai yang tidak ditentukan, karena objek POD yang dibuat oleh malloctidak diinisialisasi.

Dengan new, Anda bisa menentukan konstruktor yang akan dipanggil, dan dengan demikian mendapatkan nilai yang terdefinisi dengan baik.

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

Jika Anda benar-benar menginginkannya, Anda dapat menggunakan gunakan newuntuk mendapatkan objek POD yang tidak diinisialisasi. Lihat jawaban lain ini untuk informasi lebih lanjut tentang itu.

Perbedaan lainnya adalah perilaku pada kegagalan. Ketika gagal mengalokasikan memori, mallocmengembalikan pointer nol, sementaranew melempar pengecualian.

Yang pertama mengharuskan Anda untuk menguji setiap pointer yang dikembalikan sebelum menggunakannya, sementara yang berikutnya akan selalu menghasilkan pointer yang valid.

Untuk alasan ini, dalam kode C ++ Anda harus menggunakan new, dan tidak malloc. Tetapi meskipun demikian, Anda tidak boleh menggunakan new"di tempat terbuka", karena ia memperoleh sumber daya yang perlu Anda rilis nanti. Ketika Anda menggunakan, newAnda harus segera menyerahkan hasilnya ke kelas pengelola sumber daya:

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

Alokasi dinamis hanya diperlukan ketika masa hidup objek harus berbeda dari ruang lingkup yang dibuatnya (Ini berlaku juga untuk membuat ruang lingkup lebih kecil sebagai lebih besar) dan Anda memiliki alasan khusus di mana menyimpannya dengan nilai tidak kerja.

Sebagai contoh:

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

Dari C ++ 11 dan seterusnya, kita harus std::unique_ptrberurusan dengan memori yang dialokasikan, yang berisi kepemilikan memori yang dialokasikan.std::shared_ptrdibuat ketika Anda harus berbagi kepemilikan. (Anda akan membutuhkan ini kurang dari yang Anda harapkan dalam program yang bagus)

Membuat instance menjadi sangat mudah:

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 juga menambahkan std::optionalyang dapat mencegah Anda dari membutuhkan alokasi memori

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

Segera setelah 'instans' keluar dari ruang lingkup, memori dibersihkan. Mentransfer kepemilikan juga mudah:

 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)

Jadi kapan Anda masih membutuhkannya new? Hampir tidak pernah dari C ++ 11 on. Sebagian besar yang Anda gunakan std::make_uniquesampai Anda mencapai titik di mana Anda menekan API yang mentransfer kepemilikan melalui pointer mentah.

 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

Dalam C ++ 98/03, Anda harus melakukan manajemen memori manual. Jika Anda berada dalam kasus ini, cobalah memutakhirkan ke versi standar yang lebih baru. Jika Anda macet:

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

Pastikan Anda melacak kepemilikan dengan benar agar tidak ada kebocoran memori! Pindah semantik juga belum berfungsi.

Jadi, kapan kita perlu malloc di C ++? Satu-satunya alasan yang valid adalah untuk mengalokasikan memori dan menginisialisasi nanti melalui penempatan baru.

 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

Meskipun, di atas valid, ini dapat dilakukan melalui operator baru juga. std::vectoradalah contoh yang bagus untuk ini.

Akhirnya, kita masih memiliki gajah di dalam ruangan: C. Jika Anda harus bekerja dengan C-library di mana memori dialokasikan dalam kode C ++ dan dibebaskan dalam kode C (atau sebaliknya), Anda dipaksa untuk menggunakan malloc / gratis.

Jika Anda berada dalam kasus ini, lupakan fungsi virtual, fungsi anggota, kelas ... Hanya struct dengan POD di dalamnya yang diizinkan.

Beberapa pengecualian terhadap aturan:

• Anda sedang menulis perpustakaan standar dengan struktur data lanjutan di mana malloc sesuai
• Anda harus mengalokasikan sejumlah besar memori (Dalam salinan memori file 10GB?)
• Anda memiliki perkakas yang mencegah Anda menggunakan konstruksi tertentu
• Anda perlu menyimpan jenis yang tidak lengkap

Ada beberapa hal yang newtidak yang malloctidak:

1. new membangun objek dengan memanggil konstruktor objek itu
2. new tidak memerlukan typecasting memori yang dialokasikan.
3. Itu tidak memerlukan sejumlah memori untuk dialokasikan, melainkan membutuhkan sejumlah objek yang akan dibangun.

Jadi, jika Anda menggunakan malloc, maka Anda perlu melakukan hal-hal di atas secara eksplisit, yang tidak selalu praktis. Selain itu, newbisa kelebihan beban tetapi malloctidak bisa.

Jika Anda bekerja dengan data yang tidak memerlukan konstruksi / penghancuran dan membutuhkan realokasi (mis., Array int yang besar), maka saya percaya malloc / free adalah pilihan yang baik karena memberi Anda realall, yang jauh lebih cepat daripada memcpy baru -delete (ada di kotak Linux saya, tapi saya kira ini mungkin tergantung platform). Jika Anda bekerja dengan objek C ++ yang bukan POD dan membutuhkan konstruksi / penghancuran, maka Anda harus menggunakan operator baru dan menghapus.

Lagi pula, saya tidak mengerti mengapa Anda tidak harus menggunakan keduanya (asalkan Anda membebaskan memori malloced Anda dan menghapus objek yang dialokasikan dengan yang baru) jika dapat mengambil keuntungan dari peningkatan kecepatan (kadang-kadang yang signifikan, jika Anda realokasi array besar POD) yang realall dapat berikan kepada Anda.

Kecuali Anda membutuhkannya, Anda harus tetap menggunakan / menghapus yang baru di C ++.

Jika Anda memiliki kode C yang ingin Anda portingkan ke C ++, Anda dapat meninggalkan panggilan malloc () di dalamnya. Untuk kode C ++ baru, saya sarankan menggunakan yang baru.

Jika Anda menggunakan C ++, coba gunakan baru / hapus alih-alih malloc / calloc karena mereka adalah operator. Untuk malloc / calloc, Anda perlu memasukkan header lain. Jangan mencampur dua bahasa berbeda dalam kode yang sama. Pekerjaan mereka serupa dalam segala hal, keduanya mengalokasikan memori secara dinamis dari segmen heap di tabel hash.

new akan menginisialisasi nilai default struct dan dengan benar menghubungkan referensi ke dalamnya.

Misalnya

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

Jadi new struct test_sakan mengembalikan struktur yang diinisialisasi dengan referensi yang berfungsi, sedangkan versi malloc'ed tidak memiliki nilai default dan referensi intern tidak diinisialisasi.

Dari perspektif yang lebih rendah, baru akan menginisialisasi semua memori sebelum memberikan memori sedangkan malloc akan menyimpan konten asli memori.

Dalam skenario berikut, kami tidak dapat menggunakan yang baru karena memanggil konstruktor.

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

The newdan deleteoperator dapat beroperasi pada kelas dan struktur, sedangkan mallocdan freehanya bekerja dengan blok memori yang perlu menjadi pemain.

Menggunakan new/deleteakan membantu meningkatkan kode Anda karena Anda tidak perlu membuang memori yang dialokasikan ke struktur data yang diperlukan.

Rare case untuk dipertimbangkan menggunakan malloc / free daripada new / delete adalah ketika Anda mengalokasikan dan kemudian realokasi (tipe pod sederhana, bukan objek) menggunakan realloc karena tidak ada fungsi yang mirip dengan realall di C ++ (meskipun ini dapat dilakukan dengan menggunakan lebih banyak pendekatan C ++).

malloc () digunakan untuk secara dinamis menetapkan memori dalam C sementara pekerjaan yang sama dilakukan oleh new () dalam c ++. Jadi, Anda tidak dapat mencampur konvensi pengkodean 2 bahasa. Akan lebih baik jika Anda meminta perbedaan antara calloc dan malloc ()