Bagaimana cara menginisialisasi memori dengan operator baru di C ++?

Saya baru mulai masuk ke C ++ dan saya ingin mengambil beberapa kebiasaan baik. Jika saya baru saja mengalokasikan array tipe intdengannew operator, bagaimana saya bisa menginisialisasinya menjadi 0 tanpa melalui semuanya sendiri? Haruskah saya gunakan memset? Apakah ada cara "C ++" untuk melakukannya?

Ini adalah fitur yang sangat sedikit diketahui dari C ++ (sebagaimana dibuktikan oleh fakta bahwa belum ada yang memberikan ini sebagai jawaban), tetapi sebenarnya memiliki sintaks khusus untuk menginisialisasi nilai array:

new int[10]();

Perhatikan bahwa Anda harus menggunakan tanda kurung kosong - Anda tidak dapat, misalnya, menggunakan(0) atau apa pun lainnya (itulah sebabnya ini hanya berguna untuk inisialisasi nilai).

Ini secara eksplisit diizinkan oleh ISO C ++ 03 5.3.4 [expr.new] / 15, yang mengatakan:

Ekspresi baru yang menciptakan objek tipe T menginisialisasi objek tersebut sebagai berikut:

...

• Jika inisialisasi-baru dari bentuk (), item diinisialisasi-nilai (8,5);

dan tidak membatasi jenis yang diizinkan ini, sedangkan (expression-list)formulir secara eksplisit dibatasi oleh aturan lebih lanjut di bagian yang sama sehingga tidak mengizinkan jenis array.

Dengan asumsi bahwa Anda benar-benar menginginkan array dan bukan std :: vector, "C ++ way" adalah ini

#include <algorithm> 

int* array = new int[n]; // Assuming "n" is a pre-existing variable

std::fill_n(array, n, 0); 

Tetapi perlu diketahui bahwa di bawah tenda ini sebenarnya masih hanya sebuah loop yang menetapkan setiap elemen ke 0 (benar-benar tidak ada cara lain untuk melakukannya, kecuali arsitektur khusus dengan dukungan tingkat perangkat keras).

Ada sejumlah metode untuk mengalokasikan array tipe intrinsik dan semua metode ini benar, meskipun yang mana untuk dipilih, tergantung ...

Inisialisasi manual semua elemen dalam lingkaran

int* p = new int[10];
for (int i = 0; i < 10; i++)
{
    p[i] = 0;
}

Menggunakan std::memsetfungsi dari<cstring>

int* p = new int[10];
std::memset(p, 0, sizeof(int) * 10);

Menggunakan std::fill_nalgoritma dari<algorithm>

int* p = new int[10];
std::fill_n(p, 10, 0);

Menggunakan std::vectorwadah

std::vector<int> v(10); // elements zero'ed

Jika C ++ 0x tersedia, gunakan fitur daftar penginisialisasi

int a[] = { 1, 2, 3 }; // 3-element static size array
vector<int> v = { 1, 2, 3 }; // 3-element array but vector is resizeable in runtime

Jika memori yang Anda alokasikan adalah kelas dengan konstruktor yang melakukan sesuatu yang bermanfaat, operator yang baru akan memanggil konstruktor itu dan membiarkan objek Anda diinisialisasi.

Tetapi jika Anda mengalokasikan POD atau sesuatu yang tidak memiliki konstruktor yang menginisialisasi keadaan objek, maka Anda tidak dapat mengalokasikan memori dan menginisialisasi memori itu dengan operator yang baru dalam satu operasi. Namun, Anda memiliki beberapa opsi:

1) Gunakan variabel tumpukan sebagai gantinya. Anda dapat mengalokasikan dan menginisialisasi default dalam satu langkah, seperti ini:

int vals[100] = {0};  // first element is a matter of style

2) gunakan memset(). Perhatikan bahwa jika objek yang Anda alokasikan bukan POD alokasikan , memsetting itu adalah ide yang buruk. Salah satu contoh spesifik adalah jika Anda memset kelas yang memiliki fungsi virtual, Anda akan menerbangkan vtable dan meninggalkan objek Anda dalam keadaan tidak dapat digunakan.

3) Banyak sistem operasi memiliki panggilan yang melakukan apa yang Anda inginkan - mengalokasikan pada tumpukan dan menginisialisasi data untuk sesuatu. Contoh Windows akan menjadiVirtualAlloc()

4) Ini biasanya merupakan pilihan terbaik. Hindari mengatur memori sendiri. Anda dapat menggunakan wadah STL untuk melakukan apa saja yang Anda lakukan dengan memori mentah, termasuk mengalokasikan dan menginisialisasi semua dalam satu gerakan:

std::vector<int> myInts(100, 0);  // creates a vector of 100 ints, all set to zero

Ya ada:

std::vector<int> vec(SIZE, 0);

Gunakan vektor alih-alih array yang dialokasikan secara dinamis. Manfaatnya termasuk tidak perlu repot menghapus array secara eksplisit (itu dihapus ketika vektor keluar dari ruang lingkup) dan juga bahwa memori secara otomatis dihapus bahkan jika ada pengecualian yang dilemparkan.

Sunting: Untuk menghindari downvotes drive-by lebih lanjut dari orang-orang yang tidak repot-repot membaca komentar di bawah, saya harus membuatnya lebih jelas bahwa jawaban ini tidak mengatakan bahwa vektor selalu merupakan jawaban yang tepat. Tapi itu jelas merupakan cara yang lebih C ++ daripada "secara manual" memastikan untuk menghapus array.

Sekarang dengan C ++ 11, ada juga std :: array yang memodelkan array ukuran konstan (vs vektor yang dapat tumbuh). Ada juga std :: unique_ptr yang mengelola array yang dialokasikan secara dinamis (yang dapat dikombinasikan dengan inisialisasi seperti dijawab dalam jawaban lain untuk pertanyaan ini). Semua itu adalah cara yang lebih C ++ daripada secara manual menangani pointer ke array, IMHO.

std::filladalah satu arah. Mengambil dua iterator dan nilai untuk mengisi wilayah. Itu, atau untuk loop, akan (saya kira) menjadi lebih banyak cara C ++.

Untuk mengatur larik tipe integer primitif ke 0 secara khusus, memsettidak masalah, meskipun dapat menaikkan alis. Pertimbangkan juga calloc, meskipun agak tidak nyaman untuk digunakan dari C ++ karena para pemain.

Bagi saya, saya cukup sering menggunakan loop.

(Saya tidak suka menebak-nebak niat orang, tetapi memang benar bahwa std::vector, semua hal dianggap sama, lebih baik daripada menggunakan new[].)

Anda selalu dapat menggunakan memset:

int myArray[10];
memset( myArray, 0, 10 * sizeof( int ));

Biasanya untuk daftar item yang dinamis, Anda menggunakan a std::vector.

Secara umum saya menggunakan memset atau loop untuk alokasi dinamis memori mentah, tergantung pada bagaimana variabel saya mengantisipasi area kode di masa depan.