Initialiser/reset struct à zéro/null

struct x {
    char a[10];
    char b[20];
    int i;
    char *c;
    char *d[10];
};

Je suis le remplissage de cette structure, puis en utilisant les valeurs. Sur la prochaine itération, je veux réinitialiser tous les champs de 0 ou null avant de me lancer de le réutiliser.

Comment puis-je le faire? Puis-je utiliser memset ou je dois passer par tous les membres et puis le faire individuellement?

InformationsquelleAutor hari | 2011-07-31

c initialization struct

100

Définir un const instance statique de la structure avec les valeurs initiales et puis tout simplement affecter cette valeur à la variable à chaque fois que vous souhaitez réinitialiser.

Par exemple:
```
static const struct x EmptyStruct;
```
Ici, je me fonde sur initialisation statique à l'ensemble de mes valeurs initiales, mais vous pouvez utiliser une structure d'initialiseur si vous voulez des valeurs initiales différentes.

Ensuite, à chaque tour de la boucle, vous pouvez écrire:
```
myStructVariable = EmptyStruct;
```
- Heffernan: est-ce mieux que d'utiliser memset si je ne veux réinitialiser tout à 0??
- Je préfère cette approche de moi. À l'aide de memset me fait me sentir sale. Je préfère laisser le compilateur s'inquiéter disposition de la mémoire dans la mesure du possible. Strictement parlant, une telle utilisation de memset est non-portable, mais dans la pratique, je serais étonné si jamais vous avez compilé votre code n'importe où ce qui comptait. Oui, vous pouvez probablement utiliser memset en toute sécurité si vous préférez.
- il est conceptuellement mieux, que vous fournir une initialisation par défaut des valeurs de (quelque chose comme un objet de modèle de fabrique.)
- David Heffernan et @Diego Sevilla Merci à vous deux.
- Heffernan: pour mon éducation, pourquoi avez-vous déclaré EmptyStruct comme static const?
- const de sorte qu'il ne peut pas être modifié. statique est facultatif. Si vous souhaitez établir un lien à partir d'autres unités de traduction, puis ne pas utiliser de l'électricité statique.
- Ainsi, si la structure contient certains flotteurs, memset ne sera pas beaucoup d'aide à zéro eux.
- en fait 0 bits est égal à 0.0 tous à virgule flottante représentation que je connais.
- Heffernan Voir la FAQ C: c-faq.com/malloc/calloc.html ... "Mais il ne garantit pas utile de pointeur null valeurs (voir la section 5 de la présente liste) ou en virgule flottante valeurs zéro".
- Je sais que c'. Notez que ma réponse ne recommande pas l'utilisation memset. Notez également le commentaire de l'endroit où j'point de la non-portabilité d'utiliser memset comme un moyen pour affecter des valeurs null. Mon précédent commentaire, juste des points de la réalité que 0 bits ne invariablement correspondent à virgule flottante zéros.
- Heffernan je suis désolé je n'ai pas pris le temps de lire attentivement les commentaires. Bien sûr, vous êtes tout à fait correct.
- Heffernan: Aussi, j'ai besoin de: EmptyStruct.a[0] = '\0'; EmptyStruct.b[0] = '\0'; EmptyStruct.i = 0; EmptyStruct.c = NULL; EmptyStruct.d = {0}; ---- et puis l'utilisation est plus tard, correcT?
- l'écrire comme je l'ai fait ou EmptyStruct = { 0 } et tous les champs sont initialisés à des valeurs null
- Affectation des variables de structure appelle "memcpy" interne.
- citation merci
- Fonctionne très bien sur les C, mais pas sur C++
- a eu une erreur lors de la tentative de C++ version avec g++. Se plaindre du manque de constructeur, ou le manque d'implicite de la construction des valeurs. (Remarque : vous ne pouvez pas utiliser un des constructeurs, comme je suis en train d'écrire un code qui compile sur les deux C & compilateurs C++ sans modification)
- Cette question est au sujet de C.
InformationsquelleAutor David Heffernan
82

La façon de faire une telle chose quand vous avez modernes C (C99) est d'utiliser un littéral composé.
```
a = (const struct x){ 0 };
```
C'est un peu similaire à la solution de David, seulement que vous n'avez pas à vous inquiéter de déclarer la structure vide ou si le déclarer static. Si vous utilisez le const comme je l'ai fait, le compilateur est libre de répartir le littéral composé de manière statique dans le stockage en lecture seule, le cas échéant.
- Le fait de créer une instance de x sur la pile puis de le copier à un? Pour les grandes structures/petites piles qui pourrait être un problème.
- Comme toutes les optimisations, ce qui est totalement dépendant du compilateur, de sorte que vous devriez vérifier ce que votre compilateur produit. "Normalement" sur les compilateurs modernes, il n'est pas le cas, ceux-ci peuvent trace initialisations très bien et ne faire que ce qui est nécessaire, pas plus. (Et ne pense pas que de telles choses sont des problèmes avant de vous mesurer à un réel ralentissement. Ils ne sont pas habituellement.)
- Avec le problème que je voulais dire débordement de pile, je vous remercie pour votre réponse!
- Quel est si spécial à propos de la nouvelle notation qu'il est pris en charge uniquement par C99?
- Je ne suis pas sûr que je comprends de votre question. Composé littéraux ont été introduites par le C99, de sorte que les compilateurs qui prennent en charge uniquement les versions anciennes de la norme, ne prennent pas en charge cette fonctionnalité.
- Composé de Littéraux est ce que je voulais dire. Je vais sur google ce que c'est exactement.
- Le problème avec cette approche est que l'on peut donner à un "manque d'initialiseur' avertissement pour quelque chose comme struct x { int prop[3]; }; struct x a = (const struct x){ 0 }; tandis que le startic const struct x EMPTY_STUCT méthode ne fonctionne pas.
- "manquant d'initialiseur" mises en garde sont vraiment bidon. La norme prescrit exactement ce qui doit arriver que, et forsees la { 0 } que l'initialisation par défaut. Interrupteur d'avertissement, il est fallacieux de fausse alarme.
- Est le "const" vraiment nécessaire? Sûrement le compilateur peut optimiser correctement à partir du fait que c'est un littéral qui est seulement utilisé pour cette mission.
- Si vous utilisez GCC, vous pouvez même le faire *ptr = (typeof(*ptr)){};
- Est-ce à typecasting vraiment nécessaire? Je ne peux pas écrire ça comme ça? struct x a = (const{0};
- bien que la syntaxe est la même que ce n'est pas un casting, mais un "composé littérale". Et vous mélangez de l'initialisation et de l'affectation.
InformationsquelleAutor Jens Gustedt
55

Mieux que tous les ci-dessus est jamais à utiliser le Standard C les spécifications pour struct initialisation:
```
struct StructType structVar = {0};
```
Voici tous les bits à zéro (jamais).
- Je ne pense pas que vous pouvez le faire à chaque fois autour d'une boucle si
- C'est, en effet, suppose de travailler. Mais malheureusement, gcc & g++ en plaindre. gcc génère des avertissements, tandis que g++ génère une erreur. Je sais que gcc & g++ sont en faute sur ce (ils sont censés suivre la Norme C les spécifications), mais tout de même, pour une bonne portabilité, il est obligatoire de prendre une telle limitation en considération.
- Vous pouvez utiliser {} en C++. La gcc devs semblent pas sûr que C++ est censé supporter {0} et je ne suis pas familier avec cette partie de la norme de moi-même.
- Oui, effectivement, j'ai fini par utiliser memset(), car il y avait trop de problèmes de portabilité avec {0} ou {}. Vous ne savez pas si le C & C++ normes sont claires et synchroniser sur cette question, mais apparemment, les compilateurs ne sont pas.
- sera-ce de travailler dans un tel cas? struct StructType structVar = malloc (sizeof(StructType)); structVar ={0}
- Je suis curieux, pourquoi ce n'est pas appropriée? x = malloc(sizeof(x)); memset(&x, 0, sizeof(x));
- Combiné avec la accepté de répondre à cette méthode fonctionne bien.
InformationsquelleAutor user411313
33

En C, c'est un idiome commun à zéro de la mémoire pour un struct à l'aide de memset:
```
struct x myStruct;
memset(&myStruct, 0, sizeof(myStruct));
```
Techniquement parlant, je ne pense pas que ce est portable car il suppose que le NULL pointeur sur une machine est représentée par la valeur de l'entier 0, mais il est largement utilisé car sur la plupart des machines c'est le cas.

Si vous vous déplacez à partir de C à C++, attention à ne pas utiliser cette technique sur chaque objet. C++ ne fait cette juridique sur les objets sans fonctions de membre et aucun héritage.
- La norme stipule que la valeur NULL est toujours 0. Si la machine est conçu de telle sorte que prédéterminée adresse non valide n'est pas littéralement 0, le compilateur pour que l'architecture doit régler lors de la compilation.
- Oui, le symbole "0" correspond toujours à la le pointeur NULL même si elle est de zéro pour tous; mais il n'en est rien, le compilateur peut faire si vous définissez les bits à zéro à l'aide de memset.
InformationsquelleAutor templatetypedef
18

Si vous avez un C99 conforme compilateur, vous pouvez utiliser
```
mystruct = (struct x){0};
```
sinon, tu devrais faire ce que David Heffernan a écrit, c'est à dire déclarer:
```
struct x empty = {0};
```
Et dans la boucle:
```
mystruct = empty;
```
InformationsquelleAutor Rudy Velthuis
5

Vous pouvez utiliser memset avec la taille de la structure:
```
struct x x_instance;
memset (&x_instance, 0, sizeof(x_instance));
```
- Je ne pense pas que le casting est nécessaire ici. S'agit-il?
- Eh bien, je suis tellement habitué à C++ que... eh bien, il travaillera également en C++, donc je ne vois pas cela comme un fardeau.
- Ouais, je n'étais pas assez précis. C'est un pointeur de cv qualifiés T peut être converti de cv qualifiés void*. Toutes les données pointeur de pointeurs de fonction sont une question tout à fait différente. Bravo @Kevin
- memset est une option, mais lorsque vous l'utilisez, vous devez vous assurer que la mémoire de l'écrit est exactement la même taille que le troisième paramètre, c'est pourquoi il est préférable de se référer à la taille de l'objet réel, pas de la taille du type vous savez il actuellement est. OIE memset (&x_instance, 0, sizeof(x_instance)); est un bien meilleur choix. BTW: le (void*) cast est inutile en C++ aussi.
- (désolé, j'ai manqué de s'occuper de la question, c'est mieux maintenant)
- Je suis surpris que personne n'a souligné que ce n'est pas correct. C ne garantit pas que NULL est un peu la représentation de zéro, et vous ne devriez pas utiliser memset/calloc/etc affecter la valeur null à des pointeurs. softwareengineering.stackexchange.com/a/128447
- Plusieurs compilateurs génèrent un avertissement si vous ne jettent pas cette. À mon humble avis, cet avertissement est utile pour attirer l'attention sur cet appel de fonction et assurez-vous que votre opérandes sont corrects. J'ai même besoin d'exprimer la valeur de retour dans certains compilateurs qui avertissent que la valeur de retour n'est pas utilisée. Pour indiquer que c'est intentionnel, je dois écrire (void) memset(...). C'est bon d'attirer l'attention sur les appels de la fonction de retour d'un succès/échec de la valeur qui n'a pas été pris en compte.
InformationsquelleAutor Diego Sevilla
3

Je crois que vous pouvez seulement affecter l'ensemble vide ({}) à votre variable.
```
struct x instance;

for(i = 0; i < n; i++) {
    instance = {};
    /* Do Calculations */
}
```
InformationsquelleAutor Archmede
0
```
 struct x myX;
 ...
 memset(&x, 0, sizeof(myX));
```
- Je pense que l'OP sait comment appeler memset, mais plutôt la question est de savoir si ou de ne pas le faire est sage
InformationsquelleAutor Josh Matthews
0

Ou si vous voulez avoir une API dans votre structure pour que vous pouvez faire:
```
struct Register {
    ..
    ..
    void reset() { *this = {}; }
    ..
}
```
plus tard, vous pouvez le faire:
```
Register reg;
//do some work
reg.reset()
```
InformationsquelleAutor gatis paeglis

Vous devez vous connecter pour publier un commentaire.