Comment initialiser la mémoire avec un nouvel opérateur en C ++?

Je commence tout juste à entrer dans le C ++ et je veux prendre de bonnes habitudes. Si je viens d'allouer un tableau de type intavec l' newopérateur, comment puis-je les initialiser tous à 0 sans les parcourir tous moi-même? Dois-je simplement utiliser memset? Existe-t-il une manière «C ++» de le faire?

C'est une fonctionnalité étonnamment peu connue de C ++ (comme en témoigne le fait que personne n'a encore donné cette réponse), mais elle a en fait une syntaxe spéciale pour l'initialisation de la valeur d'un tableau:

new int[10]();

Notez que vous devez utiliser les parenthèses vides - vous ne pouvez pas, par exemple, utiliser (0)ou quoi que ce soit d'autre (c'est pourquoi cela n'est utile que pour l'initialisation de la valeur).

Ceci est explicitement autorisé par ISO C ++ 03 5.3.4 [expr.new] / 15, qui dit:

Une nouvelle expression qui crée un objet de type Tinitialise cet objet comme suit:

...

• Si le nouvel initialiseur est de la forme (), l'élément est initialisé par la valeur (8.5);

et ne restreint pas les types pour lesquels cela est autorisé, alors que le (expression-list)formulaire est explicitement restreint par d'autres règles dans la même section de sorte qu'il n'autorise pas les types de tableau.

En supposant que vous vouliez vraiment un tableau et non un std :: vector, la "manière C ++" serait la suivante

#include <algorithm> 

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

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

Mais sachez que sous le capot, il ne s'agit en fait que d'une boucle qui attribue à chaque élément la valeur 0 (il n'y a vraiment pas d'autre moyen de le faire, à l'exception d'une architecture spéciale avec un support au niveau matériel).

Il existe un certain nombre de méthodes pour allouer un tableau de type intrinsèque et toutes ces méthodes sont correctes, mais celle à choisir dépend ...

Initialisation manuelle de tous les éléments en boucle

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

Utilisation de la std::memsetfonction de<cstring>

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

Utilisation de l' std::fill_nalgorithme de<algorithm>

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

Utilisation du std::vectorconteneur

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

Si C ++ 0x est disponible, en utilisant les fonctionnalités de la liste d'initialisation

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

Si la mémoire que vous allouez est une classe avec un constructeur qui fait quelque chose d'utile, l'opérateur new appellera ce constructeur et laissera votre objet initialisé.

Mais si vous allouez un POD ou quelque chose qui n'a pas de constructeur qui initialise l'état de l'objet, vous ne pouvez pas allouer de mémoire et initialiser cette mémoire avec l'opérateur new en une seule opération. Cependant, vous avez plusieurs options:

1) Utilisez plutôt une variable de pile. Vous pouvez allouer et initialiser par défaut en une seule étape, comme ceci:

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

2) utilisation memset(). Notez que si l'objet que vous allouez n'est pas un POD , le paramétrer est une mauvaise idée. Un exemple spécifique est que si vous memset une classe qui a des fonctions virtuelles, vous allez faire sauter la vtable et laisser votre objet dans un état inutilisable.

3) De nombreux systèmes d'exploitation ont des appels qui font ce que vous voulez - allouer sur un tas et initialiser les données à quelque chose. Un exemple Windows seraitVirtualAlloc()

4) C'est généralement la meilleure option. Évitez du tout d'avoir à gérer la mémoire vous-même. Vous pouvez utiliser les conteneurs STL pour faire à peu près tout ce que vous feriez avec de la mémoire brute, y compris l'allocation et l'initialisation d'un seul coup:

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

Oui il y a:

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

Utilisez un vecteur au lieu d'un tableau alloué dynamiquement. Les avantages incluent ne pas avoir à se soucier de supprimer explicitement le tableau (il est supprimé lorsque le vecteur sort de la portée) et aussi que la mémoire est automatiquement supprimée même s'il y a une exception levée.

Edit: Pour éviter d'autres votes négatifs au volant de personnes qui ne prennent pas la peine de lire les commentaires ci-dessous, je dois préciser que cette réponse ne dit pas que le vecteur est toujours la bonne réponse. Mais c'est certainement une manière plus C ++ que "manuellement" de s'assurer de supprimer un tableau.

Désormais, avec C ++ 11, il existe également std :: array qui modélise un tableau de taille constante (vs un vecteur capable de croître). Il existe également std :: unique_ptr qui gère un tableau alloué dynamiquement (qui peut être combiné avec l'initialisation comme répondu dans d'autres réponses à cette question). N'importe lequel de ceux-ci est un moyen plus C ++ que la gestion manuelle du pointeur vers le tableau, à mon humble avis.

std::fillest un moyen. Prend deux itérateurs et une valeur pour remplir la région. Cela, ou la boucle for, serait (je suppose) la manière la plus C ++.

Pour définir un tableau de types entiers primitifs à 0 spécifiquement, memsetc'est bien, même si cela peut soulever des sourcils. Considérez également calloc, bien qu'il soit un peu gênant à utiliser à partir de C ++ en raison de la distribution.

Pour ma part, j'utilise presque toujours une boucle.

(Je n'aime pas remettre en question les intentions des gens, mais il est vrai que std::vector , toutes choses étant égales par ailleurs, préférable à l'utilisation new[].)

vous pouvez toujours utiliser memset:

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

En règle générale, pour les listes d'éléments dynamiques, vous utilisez un fichier std::vector.

En général, j'utilise memset ou une boucle pour l'allocation dynamique de la mémoire brute, en fonction de la façon dont je prévois que cette zone de code sera à l'avenir.