Comment initialiser la mémoire avec l'opérateur new en C++ ?

Question

Je commence tout juste à m'intéresser au C++ et je souhaite prendre quelques bonnes habitudes. Si je viens d'allouer un tableau de type int avec le new opérateur, comment puis-je les initialiser tous à 0 sans les passer en boucle moi-même ? Devrais-je simplement utiliser memset ? Existe-t-il une méthode "C++" pour le faire ?

Answer 1

C'est une caractéristique étonnamment peu connue du C++ (comme le prouve le fait que personne n'a encore donné cette réponse), mais il dispose d'une syntaxe spéciale pour initialiser un tableau par une valeur :

new int[10]();

Notez que vous debe 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 des valeurs).

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

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

...

• Si le nouvel initialisateur est de la forme () l'élément est initialisé en valeur (8.5) ;

et ne limite pas les types pour lesquels cela est autorisé, alors que la méthode (expression-list) est explicitement limitée par d'autres règles dans la même section, de sorte qu'elle n'autorise pas les types de tableaux.

Answer 2

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

Initialisation manuelle de tous les éléments de la boucle

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

Utilisation std::memset de la fonction <cstring>

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

Utilisation std::fill_n algorithme de <algorithm>

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

Utilisation std::vector conteneur

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

Si C++11 est disponible, en utilisant liste des initiateurs caractéristiques

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

Answer 3

En supposant que vous vouliez vraiment un tableau et non un std::vector, la "méthode 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 attention, sous le capot, il s'agit toujours d'une boucle qui affecte chaque élément à 0 (il n'y a pas vraiment d'autre moyen de le faire, à moins d'une architecture spéciale avec un support matériel).

Answer 4

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, alors vous ne pouvez pas allouer de la mémoire et initialiser cette mémoire avec l'opérateur new en une seule opération. Cependant, plusieurs options s'offrent à vous :

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

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

2. utiliser memset() . Notez que si l'objet que vous allouez n'est pas un POD, le memsetting est une mauvaise idée. Par exemple, si vous mémorisez une classe qui possède des fonctions virtuelles, vous ferez disparaître la table virtuelle et laisserez 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 sous Windows serait VirtualAlloc() .

4. C'est généralement la meilleure option. Vous éviterez ainsi de devoir gérer vous-même la mémoire. 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 en une seule fois :

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

Answer 5

Oui, c'est le cas :

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

Utiliser un vecteur au lieu d'un tableau alloué dynamiquement. L'avantage est qu'il n'est pas nécessaire de supprimer explicitement le tableau (il est supprimé lorsque le vecteur sort de son champ d'application) et que la mémoire est automatiquement supprimée même en cas d'exception.

Edit : Pour éviter de nouveaux downvotes de la part 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 une méthode plus C++ que de s'assurer "manuellement" de la suppression d'un tableau.

Maintenant, avec C++11, il y a aussi std::array qui modélise un tableau de taille constante (par opposition à un vecteur qui peut croître). Il y a aussi std::unique_ptr qui gère un tableau alloué dynamiquement (qui peut être combiné avec l'initialisation comme indiqué dans d'autres réponses à cette question). Toutes ces méthodes sont plus C++ que la gestion manuelle du pointeur sur le tableau, IMHO.