Apakah 'baru' dan 'hapus' sudah tidak digunakan lagi di C ++?

Saya menemukan sebuah kuis yang melibatkan deklarasi array dengan ukuran berbeda. Hal pertama yang terlintas di pikiran saya adalah bahwa saya perlu menggunakan alokasi dinamis dengan newperintah, seperti ini:

while(T--) {
   int N;
   cin >> N;
   int *array = new int[N];
   // Do something with 'array'
   delete[] array;
}

Namun, saya melihat bahwa salah satu solusi memungkinkan kasus berikut:

while(T--) {
    int N;
    cin >> N;
    int array[N];
    // Do something with 'array'
}

Setelah sedikit riset, saya membaca bahwa g ++ memungkinkan ini, tetapi membuat saya berpikir, dalam hal apa kemudian diperlukan untuk menggunakan alokasi dinamis? Atau apakah kompiler menerjemahkan ini sebagai alokasi dinamis?

Fungsi hapus disertakan. Perhatikan, bagaimanapun, bahwa pertanyaan di sini bukan tentang kebocoran memori.

Cuplikan yang Anda tampilkan tidak idiomatis, kode C ++ modern.

newdan delete(dan new[]dan delete[]) tidak ditinggalkan dalam C ++ dan tidak akan pernah. Mereka masih merupakan cara untuk instantiate objek yang dialokasikan secara dinamis. Namun, karena Anda harus selalu mencocokkan a newdengan delete(dan a new[]dengan delete[]), mereka paling baik disimpan dalam kelas (perpustakaan) yang memastikan ini untuk Anda. Lihat Mengapa pemrogram C ++ meminimalkan penggunaan 'baru'? .

Cuplikan pertama Anda menggunakan "telanjang" new[]dan kemudian tidak pernah delete[]menciptakan array. Itu masalah. std::vectormelakukan semua yang Anda butuhkan di sini dengan baik. Ini akan menggunakan beberapa bentuk di newbelakang layar (saya tidak akan membahas rincian implementasi), tetapi untuk semua yang Anda harus peduli, itu adalah array yang dinamis tetapi lebih baik dan lebih aman.

Cuplikan kedua Anda menggunakan "array panjang variabel" (VLA), fitur C yang juga diizinkan oleh beberapa kompiler di C ++ sebagai ekstensi. Tidak seperti new, VLA pada dasarnya dialokasikan pada stack (sumber daya yang sangat terbatas). Tetapi yang lebih penting, mereka bukan fitur C ++ standar dan harus dihindari karena mereka tidak portabel. Mereka tentu tidak menggantikan alokasi dinamis (yaitu tumpukan).

Baiklah, sebagai permulaan, new/delete tidak mendapatkan usang.

Dalam kasus spesifik Anda, mereka bukan satu-satunya solusi. Apa yang Anda pilih tergantung pada apa yang disembunyikan di bawah komentar "lakukan sesuatu dengan array" Anda.

Contoh ke-2 Anda menggunakan ekstensi VLA non-standar yang mencoba menyesuaikan array pada stack. Ini memiliki keterbatasan tertentu - yaitu ukuran terbatas dan ketidakmampuan untuk menggunakan memori ini setelah array keluar dari ruang lingkup. Anda tidak dapat memindahkannya, itu akan "menghilang" setelah tumpukan dibuka.

Jadi, jika satu-satunya tujuan Anda adalah melakukan perhitungan lokal dan kemudian membuang data, itu mungkin benar-benar berfungsi dengan baik. Namun, pendekatan yang lebih kuat adalah mengalokasikan memori secara dinamis, lebih disukai dengan std::vector. Dengan begitu Anda mendapatkan kemampuan untuk membuat ruang untuk elemen yang persis sama banyaknya seperti yang Anda butuhkan berdasarkan nilai runtime (yang akan kita lakukan selama ini), tetapi juga akan membersihkan dirinya dengan baik, dan Anda dapat memindahkannya ruang lingkup ini jika Anda ingin menyimpan memori digunakan untuk nanti.

Berputar kembali ke awal, mungkin vector akan menggunakan newbeberapa lapisan lebih dalam, tetapi Anda tidak perlu khawatir dengan itu, karena antarmuka yang dihadirkannya jauh lebih unggul. Dalam hal itu, menggunakan newdan deletedapat dianggap tidak dianjurkan.

Contoh kedua Anda menggunakan array panjang variabel (VLA), yang sebenarnya merupakan fitur C99 ( bukan C ++!), Namun demikian didukung oleh g ++ .

Lihat juga jawaban ini .

Perhatikan bahwa array panjang variabel berbeda dari new/ deletedan jangan "mencabut" mereka dengan cara apa pun.

Perlu diketahui juga bahwa VLA bukan ISO C ++.

C ++ modern menyediakan cara yang lebih mudah untuk bekerja dengan alokasi dinamis. Pointer pintar dapat menangani pembersihan setelah pengecualian (yang mungkin terjadi di mana saja jika diizinkan) dan pengembalian awal, segera setelah struktur data yang direferensikan keluar dari ruang lingkup, jadi mungkin masuk akal untuk menggunakan ini sebagai gantinya:

  int size=100;

  // This construct requires the matching delete statement.
  auto buffer_old = new int[size];

  // These versions do not require `delete`:
  std::unique_ptr<int[]> buffer_new (new int[size]);
  std::shared_ptr<int[]> buffer_new (new int[size]); 
  std::vector<int> buffer_new (size);  int* raw_access = buffer_new.data();

Dari C ++ 14 Anda juga dapat menulis

auto buffer_new = std::make_unique<int[]>(size);

ini terlihat lebih bagus dan akan mencegah kebocoran memori jika alokasi gagal. Dari C ++ 20 Anda harus dapat melakukan sebanyak mungkin

auto a = std::make_shared<int[]>(size);

ini bagi saya masih belum dikompilasi pada saat penulisan dengan gcc 7.4.0. Dalam dua contoh ini kami juga menggunakan autobukan tipe deklarasi di sebelah kiri. Dalam semua kasus, gunakan array seperti biasa:

buffer_old[0] = buffer_new[0] = 17;

Memori bocor dari new dan crash dari dua kali lipat deleteadalah sesuatu C ++ telah dihancurkan selama bertahun-tahun, menjadi "titik sentral" dari argumentasi untuk beralih ke bahasa lain. Mungkin lebih baik dihindari.

baru dan hapus tidak ditinggalkan.

Objek yang dibuat oleh operator baru dapat dilewatkan dengan referensi. Objek dapat dihapus menggunakan delete.

baru dan hapus adalah aspek dasar bahasa. Kegigihan suatu objek dapat dikelola menggunakan yang baru dan menghapus. Ini pasti tidak akan ditinggalkan.

Statement - int array [N] adalah cara mendefinisikan sebuah array. Array dapat digunakan dalam lingkup blok kode terlampir. Itu tidak bisa dilewati seperti bagaimana suatu objek dilewatkan ke fungsi lain.

Contoh pertama membutuhkan delete[]di akhir, atau Anda akan memiliki kebocoran memori.

Contoh kedua menggunakan panjang array variabel yang tidak didukung oleh C ++; itu hanya memungkinkan konstan ekspresi untuk panjang array .

Dalam hal ini berguna untuk digunakan std::vector<>sebagai solusi; yang membungkus semua tindakan yang dapat Anda lakukan pada array ke dalam kelas templat.

Sintaksnya terlihat seperti C ++, tetapi idiomnya mirip dengan Algol60 tua biasa. Itu umum untuk memiliki blok kode seperti ini:

read n;
begin
    integer array x[1:n];
    ... 
end;

Contohnya dapat ditulis sebagai:

while(T--) {
    int N;
    cin >> N;
    {
        int array[N];
        // Do something with 'array'
    }
}

Saya terkadang melewatkan ini dalam bahasa saat ini;)