C++ Comment définissez-vous un tableau de pointeurs à null dans un initialiser la liste comme façon de faire?

Je suis conscient que vous ne pouvez pas utiliser une initialiser la liste pour un tableau. Toutefois, j'ai entendu parler de façons que vous pouvez définir un tableau de pointeurs à NULL dans une manière qui est similaire à un initialiser la liste.

Je ne suis pas certain de la façon dont cela est fait. J'ai entendu dire qu'un pointeur est NULL par défaut, bien que je ne sais pas si cela est garanti/dans la norme C++. Je suis également pas sûr si l'initialisation par le nouvel opérateur par rapport à la normale de répartition peut aussi faire la différence.

Edit: je veux dire pour ce faire, dans un fichier d'en-tête ou le constructeur d'initialisation de la liste. Je ne veux pas le mettre dans le constructeur, et je ne veux pas utiliser un Vecteur.

InformationsquelleAutor user233320 | 2010-04-10

arrays c++null pointers

36

Afin de définir un tableau de pointeurs à null dans le constructeur de l'initialiseur de la liste, vous pouvez utiliser le () initialiseur
```
struct S {
  int *a[100];

  S() : a() {
    //`a` contains null pointers 
  }
};
```
Malheureusement, dans la version actuelle de la langue de la () initialiseur est le seul initialiseur que vous pouvez utiliser avec un membre du groupe dans le constructeur de l'initialiseur de la liste. Mais apparemment, c'est ce que vous avez besoin dans votre cas.

La () a le même effet sur les tableaux alloués avec new[]
```
int **a = new int*[100]();
//`a[i]` contain null pointers 
```
Dans d'autres contextes, vous pouvez utiliser le {} globale de l'initialiseur pour obtenir le même effet
```
int *a[100] = {};
//`a` contains null pointers 
```
Noter qu'il n'y a absolument pas besoin de presser un 0 ou un NULL entre les {}. Le vide paire de {} fera l'amende juste.
- Oui! C'est exactement ce que je voulais, merci 🙂
- +1, comme un de côté, C stipule qu'il doit y avoir au moins une valeur entre l'initialiseur de croisillons. C++ ajouté Le vide accolade de l'initialiseur ({ }) précisément parce qu'il n'y a aucune raison pour qu'un objet de valeur par défaut doit être quelque chose ressemblant à 0, et le code de demander de l'initialisation d'un objet ne peut avoir aucune idée de ce qu'une valeur par défaut raisonnable pourrait être (en particulier dans les modèles).
- J'ai pensé int *a = new int[100](); crée un pointeur vers un tableau d'entiers qui sont initialisé à zéro sens a[i] contiendrait le 0 et un pointeur déréférencé de la (i+1)ème entier dans ce tableau plutôt qu'un pointeur null.
- Bon spot. J'ai pris la liberté de fixation, car la Fourmi n'a pas au cours de l'année. 😉 Cela montre comment le pointeur et la syntaxe de tableau hérité de C est confus dans sa laideur, et combien une définition de type ou deux serait vraiment de l'aide ici - ou tout simplement pourquoi ne pas utiliser new. 😛
InformationsquelleAutor AnT
6

Vous pouvez passer de la matrice de std::vector et l'utilisation
```
std::vector<T*> v(SIZE);
```
Les valeurs seront initialisées par NULLs automatiquement. C'est le préféré C++ façon.

Mise à jour: Depuis C++11, il y a une façon de plus: à l'aide de
```
std::array<T*, SIZE> array = {};
```
Il se comporte plus comme une version corrigée de C-gamme de style (en particulier, évite les allocations dynamiques), porte autour de sa taille et de ne pas se désintègrent en un pointeur. La taille, cependant, doit être connue au moment de la compilation.
- À moins que l'OP ne veut pas dynamiquement un tableau de taille.
- Eh bien, l'OP peut ignorer la possibilité de redimensionnement dynamique. C++-style les tableaux sont généralement une Bonne Chose.
- Si la taille est connue à la compilation le temps, le groupe builtin les tableaux sont mieux. Il vaut mieux éviter d'allocation dynamique lorsque cela est possible. vectors doit être utilisé chaque fois que la taille de la constante n'est pas connu au moment de la compilation si.
- pas sûr à ce sujet. Avec vector on a au moins décent index-out-of-contrôle de la portée, ainsi que la copie des constructeurs etc. Ce qui conduit généralement à un moindre risque d'erreur de code. À mon humble avis, la nécessité pour le style C des tableaux n'est justifiée que par la nécessité d'une profonde manuel optimisations de code. Les compilateurs modernes sont généralement assez intelligent pour optimiser hors vector's, de frais généraux dans la plupart des cas.
- les vecteurs ont de nombreux, de nombreux avantages sur des tableaux qui n'ont rien à voir avec l'allocation dynamique. Par exemple, les vecteurs de porter autour de leur taille avec eux et ne pas se désintégrer en pointeurs. Et on doit éviter de l'allocation dynamique - mais dans son propre code, pas dans le code de bibliothèque.
- Bien sûr, depuis C++11 avec std::array, nous pouvons éviter l'allocation dynamique, tout en ayant encore de tous les autres avantages de conteneurs standard, y compris la capacité à faire des bornes-vérifié l'indexation (mais pas automatiquement que votre commentaire peut être lu à l'indiquent) à l'aide de .at() comme dans vector
- C'est vrai; cependant, la réponse est à partir de 2010 où C++11 standard était pas encore largement acceptée. Je vais modifier la réponse cependant. Merci pour la suggestion!
- Je sais que vous avez écrit la réponse avant C++11 est définitive; j'ai juste pensé qu'il serait utile d'avoir au minimum un commentaire en donnant une mise à jour. 🙂
- "La taille, cependant, doit être connue au moment de la compilation ğ. tout comme n'importe quel autre tableau
InformationsquelleAutor Vlad
4

Normalement un tableau ne sera pas initialisée par défaut, mais si vous utilisez un ou plusieurs des éléments explicitement ensuite tous les autres éléments seront automatiquement initialisées à 0. Puisque 0 et NULL sont équivalents par conséquent, vous pouvez initialiser un tableau de pointeurs NULL comme ceci:
```
float * foo[42] = { NULL }; //init array of pointers to NULL
```
- Sachez que "int toto1[42] = { 1 };" seulement inits le premier à 1 et les autres à 0, puisque par défaut en C++ inits les éléments du tableau à 0! Dans votre exemple, vous réglez uniquement le premier élément à 0 et le reste est réglé par défaut à 0.
- Je ne sais pas pourquoi vous pensez que la réponse n'est pas claire, ou pourquoi il mérite un vote ? L'OP a une question sur l'initialisation des tableaux de pointeurs de NULL.
- veuillez voir mon commentaire. C'est parce que int toto1[42] = { 0 }; est trompeuse.
- eh bien, je ne vois pas pourquoi il est trompeur, mais je vais ajouter quelques précisions si vous le souhaitez.
InformationsquelleAutor Paul R
2

Je ne suis pas certain de la façon dont cela est fait. J'ai entendu dire qu'un pointeur est NULL par défaut, bien que je ne sais pas si cela est garanti/dans la norme C++.

Il n'est pas garanti par la norme C++. Construit dans les types ( comme les pointeurs ) sont remplis avec les ordures ménagères, sauf autrement.

Je suis également pas sûr si l'initialisation par le nouvel opérateur par rapport à la normale de répartition peut aussi faire la différence.

Qu'entendez-vous par "répartition normale" ? Si vous parlez d'une variable automatique, alors vous pouvez faire ceci:

MyType * pointers[2] = {}

et les pointeurs doit être initialisé à NULL.
- Les pointeurs ne sont pas garantis pour être initialisé à NULL, tout comme les services de renseignements ne sont pas initialisées à 0, dans de nombreux contextes. Notez que votre exemple est équivalent à {NULL, 0} et {} (ce dernier étant de préférence), plutôt que de spécifier une valeur pour tous les éléments dans le tableau.
- Je sais que cette réponse est à des années de retard, mais qu'il est corrigé maintenant. 🙂
InformationsquelleAutor Billy ONeal
0
```
void* p[10] = { 0 };
```
- Sachez que ce n'est expressément initialisation du premier élément à 0, les autres sont initialisées à zéro par défaut en C++. Par exemple, "int toto1[42] = { 1 };" seulement inits le premier à 1 et les autres à 0, puisque par défaut en C++ inits les éléments du tableau à 0!
- Plus important encore, le compilateur initialise les autres entrées de tous les bits à zéro, ce qui ne garantit pas être la même que la représentation par un pointeur null.
- En fait le reste entrées sont OK; c'est donnant explicitement 0 qui pourrait être un problème - c'est à dire que vous obtenez 0-initialisation si vous ne pas explicitement mention de 0. :S "Zéro initialisation est effectuée [...] pour les membres de la valeur initialisée types de classe qui n'ont pas de constructeurs, y compris la valeur d'initialisation des éléments de granulats pour laquelle aucun des initialiseurs sont fournis. [...] Un initialisé à zéro pointeur de pointeur null la valeur de son type, même si la valeur du pointeur null n'est pas partie intégrante de zéro." en.cppreference.com/w/cpp/language/zero_initialization Depuis C++11, utiliser {}.
InformationsquelleAutor Johan Kotlinski
-1

Si vous avez un membre de la matrice puis il n'y a aucun moyen de les initialiser, sauf si c'est un membre statique. Si le tableau n'est pas un membre statique, alors vous aurez à remplir à l'intérieur du corps du constructeur.

Cela dit, les chances sont que vous êtes vraiment préférable d'utiliser une std::vector. Autre que pour des raisons techniques telles que l'indisponibilité d'un standard STL pour votre plate-forme, ou de la moindre performance d'un std::vector est mieux qu'un tableau par tout et tous les critères. Si la performance est la question, alors assurez-vous de profilés et de savoir par les numéros que c'est une question.

InformationsquelleAutor wilhelmtell

Vous devez vous connecter pour publier un commentaire.