C ++ 'ta yeni operatör ile bellek nasıl başlatılır?

C ++ 'a girmeye başladım ve bazı iyi alışkanlıklar kazanmak istiyorum. Ben sadece operatör intile tür bir dizi newayırdıysanız, hepsini kendim döngü olmadan hepsini 0 olarak nasıl başlatabilirim? Sadece kullanmalı mıyım memset? Bunu yapmanın bir “C ++” yolu var mı?

C ++'ın şaşırtıcı derecede az bilinen bir özelliği (hiç kimsenin bunu henüz bir cevap olarak vermediği kanıtlandığı gibi), ancak aslında bir diziyi değerlendirmek için özel bir sözdizimine sahiptir:

new int[10]();

Boş parantezleri kullanmanız gerektiğini unutmayın; örneğin,(0) başka bir şey (bu nedenle bu yalnızca değer başlatma için yararlıdır).

Buna ISO C ++ 03 5.3.4 [expr.new] / 15 tarafından açıkça izin verilmektedir:

Tür nesnesi oluşturan yeni ifade T bu nesneyi aşağıdaki gibi başlatır:

...

• Yeni başlatıcı formdaysa, ()öğe değerle başlatılır (8.5);

ve buna izin verilen türleri kısıtlamaz, (expression-list)form aynı bölümdeki diğer kurallar tarafından dizi türlerine izin vermeyecek şekilde açıkça kısıtlanır.

Gerçekten std :: vector değil bir dizi istediğinizi varsayarsak, "C ++ yolu"

#include <algorithm> 

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

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

Ancak, kaputun altında bunun aslında her öğeyi 0'a atayan bir döngü olduğunu unutmayın (bunu yapmanın gerçekten başka bir yolu yoktur, donanım düzeyinde desteğe sahip özel bir mimariyi engeller).

İçsel tip bir dizi tahsis etmek için birkaç yöntem vardır ve bu yöntemlerin hepsi doğru olsa da, hangisini seçmek için bağlıdır ...

Döngüdeki tüm elemanların manuel olarak başlatılması

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

Kullanımı std::memsetgelen işlevi<cstring>

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

std::fill_nAlgoritmasını kullanma<algorithm>

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

std::vectorKonteyner kullanma

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

Eğer C ++ 0x mevcut kullanarak başlatıcı listesi özellikleri

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

Ayırdığınız bellek, yararlı bir şey yapan bir kurucuya sahip bir sınıfsa, yeni işleç bu kurucuyu çağırır ve nesnenizi başlatılmış olarak bırakır.

Ancak , nesnenin durumunu başlatan bir yapıcıya sahip olmayan bir POD veya bir şey ayırıyorsanız , bellek ayıramaz ve bu belleği bir işlemde yeni operatörle başlatamazsınız. Ancak, birkaç seçeneğiniz vardır:

1) Bunun yerine bir yığın değişkeni kullanın. Tek bir adımda aşağıdaki gibi tahsis edebilir ve varsayılan olarak başlatabilirsiniz :

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

2) kullanın memset(). Tahsis ettiğiniz nesne bir POD değilse, , taklit etmenin kötü bir fikir olduğunu unutmayın. Bunun özel bir örneği, sanal işlevleri olan bir sınıfı takarsanız, vtable'ı uçuracak ve nesnenizi kullanılamaz bir durumda bırakacaksınız.

3) Birçok işletim sistemi, istediğinizi yapan çağrılara sahiptir - bir yığına ayırın ve verileri bir şeye başlatın. Windows örneğiVirtualAlloc()

4) Bu genellikle en iyi seçenektir. Belleği kendiniz yönetmek zorunda kalmayın. Ham bellekle yapacağınız hemen hemen her şeyi yapmak için STL kaplarını kullanabilirsiniz, hepsi bir arada bırakma ve başlatma dahil olmak üzere:

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

Evet var:

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

Dinamik olarak ayrılmış bir dizi yerine bir vektör kullanın. Faydaları arasında, diziyi açıkça silmeyle uğraşmak zorunda kalmamak (vektör kapsam dışına çıktığında silinir) ve ayrıca bir istisna olsa bile belleğin otomatik olarak silinmesi yer alır.

Düzenleme: Aşağıdaki yorumları okumak için uğraşmayan kişilerden daha fazla sürmek downvotes önlemek için, bu cevabın vektör her zaman doğru cevap olduğunu söylemediğini daha açık hale getirmek gerekir . Ancak bir diziyi sildiğinizden emin olmak için "manuel" olandan daha fazla C ++ yoludur.

Şimdi C ++ 11 ile, sabit boyutlu bir diziyi modelleyen std :: dizisi de var (büyüyebilen vektöre karşı). Dinamik olarak ayrılmış bir diziyi yöneten std :: unique_ptr de vardır (bu sorunun diğer yanıtlarında yanıtlandığı gibi başlatma ile birleştirilebilir). Bunlardan herhangi biri, işaretçiyi IMHO dizisine elle işlemekten daha C ++ yoludur.

std::fillbir yoludur. İki yineleyici ve bölgeyi doldurmak için bir değer alır. Bu ya da for döngüsü, (sanırım) daha fazla C ++ yolu olurdu.

Bir dizi ilkel tamsayı türünü özel olarak 0 olarak ayarlamak için memsetiyidir, ancak kaşları artırabilir. Ayrıca düşününcalloc , çünkü döküm nedeniyle C ++ 'dan kullanmak biraz rahatsız edici.

Kendi adıma, hemen hemen her zaman bir döngü kullanıyorum.

(İnsanların niyetlerini ikinci olarak tahmin etmekten hoşlanmıyorum, ancak std::vectorher şeyin eşit olduğu, kullanılmaya tercih edildiği doğrudur new[].)

her zaman memset kullanabilirsiniz:

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

Genellikle dinamik öğe listeleri için a kullanırsınız std::vector.

Genel olarak, değişkenin gelecekte kod alanının ne kadar olacağını tahmin ettiğime bağlı olarak ham bellek dinamik ayırma için memset veya bir döngü kullanıyorum.