Come inizializzare la memoria con il nuovo operatore in C ++?

Sto appena iniziando a entrare in C ++ e voglio prendere alcune buone abitudini. Se ho appena assegnato una matrice di tipo intcon l' newoperatore, come posso inizializzarli tutti su 0 senza eseguirli tutti? Dovrei solo usare memset? Esiste un modo "C ++" per farlo?

È una funzionalità sorprendentemente poco nota di C ++ (come dimostra il fatto che nessuno ha ancora fornito questa risposta), ma in realtà ha una sintassi speciale per l'inizializzazione del valore di un array:

new int[10]();

Si noti che è necessario utilizzare le parentesi vuote, ad esempio non è possibile utilizzare (0)o altro (motivo per cui ciò è utile solo per l'inizializzazione del valore).

Ciò è esplicitamente consentito dalla ISO C ++ 03 5.3.4 [expr.new] / 15, che dice:

Una nuova espressione che crea un oggetto di tipo Tinizializza l'oggetto nel modo seguente:

...

• Se il nuovo inizializzatore è nel modulo (), l'elemento viene inizializzato in base al valore (8.5);

e non limita i tipi per i quali ciò è consentito, mentre il (expression-list)modulo è esplicitamente limitato da ulteriori regole nella stessa sezione in modo tale da non consentire tipi di array.

Supponendo che tu voglia davvero un array e non uno std :: vector, il "modo C ++" sarebbe questo

#include <algorithm> 

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

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

Tuttavia, tieni presente che questo è in realtà solo un ciclo che assegna ogni elemento a 0 (non c'è davvero un altro modo per farlo, escludendo un'architettura speciale con supporto a livello hardware).

Esiste un numero di metodi per allocare un array di tipo intrinseco e tutti questi metodi sono corretti, sebbene quale scegliere, dipende ...

Inizializzazione manuale di tutti gli elementi in loop

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

Utilizzando la std::memsetfunzione da<cstring>

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

Utilizzando l' std::fill_nalgoritmo di<algorithm>

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

Usando il std::vectorcontenitore

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

Se C ++ 0x disponibile, utilizza le funzionalità dell'elenco di inizializzatori

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

Se la memoria che stai allocando è una classe con un costruttore che fa qualcosa di utile, l'operatore new chiamerà quel costruttore e lascerà il tuo oggetto inizializzato.

Ma se stai allocando un POD o qualcosa che non ha un costruttore che inizializza lo stato dell'oggetto, allora non puoi allocare memoria e inizializzare quella memoria con l'operatore nuovo in una sola operazione. Tuttavia, hai diverse opzioni:

1) Utilizzare invece una variabile di stack. È possibile allocare e inizializzare per impostazione predefinita in un solo passaggio, in questo modo:

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

2) uso memset(). Nota che se l'oggetto che stai allocando non è un POD , memorizzarlo è una cattiva idea. Un esempio specifico è se memorizzi una classe con funzioni virtuali, spazzerai via la vtable e lascerai il tuo oggetto in uno stato inutilizzabile.

3) Molti sistemi operativi hanno chiamate che fanno quello che vuoi: allocare su un heap e inizializzare i dati su qualcosa. Un esempio di Windows sarebbeVirtualAlloc()

4) Questa è di solito l'opzione migliore. Evita di dover gestire la memoria da solo. Puoi usare i contenitori STL per fare praticamente tutto ciò che faresti con la memoria grezza, inclusa l'allocazione e l'inizializzazione in un colpo solo:

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

Si C'è:

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

Utilizzare un vettore anziché un array allocato dinamicamente. I vantaggi includono la necessità di non doversi preoccupare di eliminare esplicitamente l'array (viene eliminato quando il vettore esce dall'ambito) e anche che la memoria viene automaticamente eliminata anche se viene generata un'eccezione.

Modifica: per evitare ulteriori riduzioni del drive-by da parte di persone che non si preoccupano di leggere i commenti qui sotto, dovrei chiarire che questa risposta non dice che il vettore è sempre la risposta giusta. Ma è sicuramente un modo più C ++ che "manualmente" assicurandosi di eliminare un array.

Ora con C ++ 11, c'è anche std :: array che modella un array di dimensioni costanti (rispetto al vettore che è in grado di crescere). C'è anche std :: unique_ptr che gestisce un array allocato dinamicamente (che può essere combinato con l'inizializzazione come risposta in altre risposte a questa domanda). Ognuno di questi è un modo più C ++ rispetto alla gestione manuale del puntatore alla matrice, IMHO.

std::fillè un modo. Richiede due iteratori e un valore per riempire la regione. Quello, o il ciclo for, sarebbe (suppongo) il modo più C ++.

Per impostare una matrice di tipi interi primitivi su 0 in modo specifico, memsetva bene, anche se può sollevare le sopracciglia. Considera anche calloc, sebbene sia un po 'scomodo usare da C ++ a causa del cast.

Da parte mia, uso quasi sempre un loop.

(Non mi piace indovinare le intenzioni delle persone, ma è vero che std::vector, a parità di condizioni, è preferibile usarle new[].)

puoi sempre usare memset:

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

In genere per gli elenchi dinamici di elementi, si utilizza a std::vector.

In genere utilizzo memset o un ciclo per l'allocazione dinamica della memoria non elaborata, a seconda della variabile che prevedo in futuro per quell'area di codice.