Est memset(&mystruct, 0, sizeof mystruct) même que mystruct = { 0 };?

Je suis en train de lire à propos de la initialisée valeurs par défaut d'un tableau/struct et cette question:

est memset(&mystruct, 0, sizeof mystruct) même que mystruct = { 0 }; ?

si elle ne l'est pas, quelle est la différence?

Faites-vous? Alors qui était le sizeof variante qui n'a pas besoin de parens?
sizeof dans C, est un opérateur non pas une fonction. Le () est facultatif. Voir memset(&f, 0, sizeof f); il fonctionne très bien pour moi.
Les gens, les regarder jusqu'à ce que la définition de sizeof est. C'est un opérateur unaire qui s'opère soit sur une variable ou un expression cast. Comme vous le savez déjà, une expression cast est un type entre parenthèses. Donc sizeof lui-même n'a pas "besoin" de la parenthèse, c'est l'expression cast qui en a besoin.
Droit, mon propos était de souligner que la parenthèse n'est pas une partie de sizeof mais sur l '"objet", il fonctionne sur. De même avec returnqui me gêne beaucoup quand les gens mettent systématiquement entre parenthèses, comme si c'était une fonction.
Ok, je vais acheter que - désolé pour la prise de ce sur une tangente.
Non, vous avez eu raison de fait référence de la norme, mon commentaire était en effet un peu bâclée.
Pourquoi le premier commentaire a été supprimé? les commentaires maintenant semble un peu pas de sens.

InformationsquelleAutor Jack | 2012-05-28

c struct

22

est memset(&mystruct, 0, sizeof mystruct) même que mystruct = { 0 }; ?

Pas.
```
memset(&mystruct, 0, sizeof mystruct) ;
```
... dira le compilateur pour appeler une fonction que nous nous attendons à ce set lors de l'exécution les données dans mystruct à zéro.
```
mystruct = { 0 };
```
... va dire le compilateur défini par lui-même les données à zéro, ce qui signifie qu'il sera:
- si possible, définissez les données dans mystruct à zéro lors de la compilation (par exemple, pour les variables statiques, comme tristopia et Oli Charlesworth fait remarquer dans les commentaires)
- ou sinon (par exemple, auto variables), pour générer de l'assemblée de code qui permettra de définir les données à zéro lorsque la variable est initialisée (ce qui est mieux que d'appeler une fonction pour le faire).
Notez que peut-être, le compilateur peut optimiser le memset dans un moment de la compilation d'instruction (comme le remplacement de la première version avec la deuxième version), mais je ne voudrais pas compter sur qui que memset est une fonction de la bibliothèque d'exécution, pas de langue intrinsèque (je ne suis pas un compilateur/écrivain de langue d'avocat, bien que).

À venir à partir de C++, de mon propre point de vue est que le plus que vous pouvez faire à la compilation, et plus le compilateur sait au moment de la compilation, avant l'exécution, même commence, le mieux: Il permet au compilateur pour éventuellement optimiser le code et/ou de générer des avertissements/erreurs.

Dans le cas actuel, à l'aide de la mystruct = { 0 }; notation pour initialiser un struct est toujours plus sûr que d'utiliser le memset parce qu'il est très très facile d'écrire quelque chose de mal en C avec un memset sans le compilateur se plaindre.

Les exemples suivants montrent qu'il est facile pour le code pour faire quelque chose de différent de ce qu'il semble faire:
```
//only the 1st byte will be set to 0
memset(&mystruct, 0, sizeof(char)) ;          

//will probably overrun the data, possibly corrupting
//the data around it, and you hope, crashing the process.
memset(&mystruct, 0, sizeof(myLARGEstruct)) ; 

//will NOT set the data to 257. Instead it will truncate the
//integer and set each byte to 1
memset(&mystruct, 257, sizeof(mystruct)) ;    

//will set each byte to the value of sizeof(mystruct) modulo 256
memset(&mystruct, sizeof(mystruct), 0) ;      

//will work. Always.
mystruct = { 0 } ;
```
- Pas vrai si mystruct est une auto variable. Dans ce cas, les deux sont runtime initialisations et il va se passer à chaque appel à la fonction à laquelle elle est déclarée.
- Essayez typedef struct A { int v ; } A ; void setZero(void) { A a = {0} ; } à la place. Une auto de la variable est une variable locale, il n'a rien à voir avec les pointeurs.
- Vous avez raison. J'ai mal lu votre commentaire, et a supprimé mes commentaires précédents lorsque je l'ai réalisé. De toute façon, même sans parler de l'insécurité-ness de memset, je ne crois que l'initialisation d'une structure avec = {0} ; peut produire de meilleurs résultats que memsetting à zéro (regardant le démontage du ccag, le confirme, que memset implique un appel de fonction).
- "Lors de la compilation"? Cela ne peut être vrai pour les objets statiques...
- Ainsi, les deux cas j'ai le même côté de l'effet dans mon struct. Seule différence, quand cela sera régler. Mais il y a une différence de performance significative sur le plateau pendant executation temps au lieu de la compilation, ou vice-versa?
- Pas même les objets statiques sont nécessairement définie lors de la compilation. Très souvent, ils sont initialisés avant main() est appelée. Quand et où ils sont initialisés à la mise en œuvre est définie.
- Probablement pas. . . Avec = {0} ; le code est sûr, et seulement peut-être le plus rapide. Mais si vous avez des problèmes de performances, comme d'habitude, le profil de puis optimiser les goulets d'étranglement.
- Ne le quatrième exemple (memset(..,..,0)) de ne pas faire de tout depuis le paramètre de taille est égale à zéro?
- Il peut être intéressant de noter que les données représentant des "{0} " ne peut être stocké dans code, selon le compilateur, ce qui signifie pour une grande structure de la nacelle types de, vous avez peut-être des ballonnements code de l'espace avec un grand bloc de zéros, ce qui peut faire une différence dans un code de l'espace limité d'applications intégrées environnements (j'ai vu quelques bâclée, les grandes structures (question distincte) attribués de cette manière), mais étant donné les problèmes que vous mentionnez dans votre réponse, la prudence doit clairement être exercé dans cette décision.
- mystruct = { 0 } ; est une erreur de syntaxe, depuis { 0 } n'est pas une expression.
InformationsquelleAutor paercebal
11

Il s'agit d'un pédant de réponse, mais étant donné que la représentation interne d'un pointeur null est pas garanti d'être 0 le comportement de memset contre brace-initialisation serait différent (memset permettrait de faire la mauvaise chose). Cela dit, je n'ai jamais entendu parler d'une mise en œuvre qui a pris cette liberté d'avoir un non de tous les 0 modèle binaire pour les nuls.
- J'ai entendu dire que sur certains appareils embarqués, qui est en fait le cas. Jamais rencontré l'un de ceux-ci, cependant.
- Dans le cas spécifique de l'OP posté, il n'y a pas de pointeurs pour initialiser.
- Comment vous le savez? Il n'y a pas de déclaration de l' mystruct présent.
- qu'en virgule flottante? Même si memsetting un double zéro donner à zéro (mais qu'en est signé zéros?), Je préfère la ={ 0 } considérant qu'il est d'une logique (plutôt que binaire) de l'initialisation.
- Bien sûr, on pourrait utiliser des accolades, l'initialisation de faire l'initialisation, et memset à jouer du violon avec un faible niveau de bit mémoire-modèles.
InformationsquelleAutor K-ballo
9

Théoriquement il y a une différence. La initialiser n'est pas nécessaire d'initialiser le rembourrage si il y en a dans mystruct.
Par exemple:
```
int main(void) 
{
     struct mystruct {
          char    a;
          int     what;
     } s = {0};
}
```
Peut contenir:
```
00 xx yy zz 00 00 00 00
```
où xx, yy et zz sont indéfinis octets où sur la pile.
Le compilateur est autorisé à le faire.
Cela dit, dans tous les termes pratiques, je n'ai pas rencontré un compilateur qui n'a encore. Le plus sain d'esprit des implémentations sémantique gérer ce cas, comme le memset.
- Par 6.7.9(10) (en n1570), à partir de C11, le rembourrage doit être mis à zéro-bits: "si c'est un agrégat, chaque membre est initialisé (de manière récursive) conformément à ces règles, et tout rembourrage est initialisé à zéro bits;", idem pour les syndicats.
- Puisqu'il n'était pas en C99, j'ose dire que ce n'était pas dans C90.
- Ok merci, je laisse ma réponse tel qu'il est.
- Vous pouvez envisager l'ajout de la remarque qu'elle a changé avec le C11, mais je ne vois pas beaucoup de danger du commentaire soit supprimé, de sorte qu'il n'est pas nécessaire.
- Wow, j'ai appris quelque chose de nouveau (C11 et rembourrage bits).
- Intéressants qui allait changer en C11. Ne C11 imposer d'autres exigences sur le remplissage de bits? Par exemple, si l'on a struct {uint8_t b; uint32_t i;} s et l'on dit s.b++; sur une machine où octet magasins sont plus lents que la parole, les magasins, la machine d'effectuer un mot de l'incrément si chaque fois qu'il lit b, elle masque la valeur avec 0xFF (donc la valeur du padding bits n'a jamais été exposés à l'exception lors de la superposition de la structure avec uint8[]?)
InformationsquelleAutor Patrick Schlüter
8
```
memset(&mystruct, 0, sizeof mystruct);
```
est une instruction. Il peut être exécuté à tout moment où mystruct est visible, pas seulement au point où elle est définie.
```
mystruct = { 0 };
```
est en fait une erreur de syntaxe; { 0 } n'est pas une expression valide.

(Je vais supposer que mystruct est un objet de type struct foo.)

Ce que vous pensez probablement de l'est:
```
struct foo mystruct = { 0 };
```
où { 0 } est un initialiseur.

Si votre compilateur prend en charge, vous pouvez aussi écrire à:
```
mystruct = (struct foo){ 0 };
```
où (struct foo){ 0 } est un littéral composé. Composé littéraux ont été introduites dans C99; certains compilateurs C, en particulier de Microsoft n'est probablement pas le soutenir. (Notez que le (struct foo) est pas un opérateur de cast; il ressemble à l'un, mais il n'est pas suivi par une expression ou mis entre parenthèses le nom de type. C'est un distinctes de construction syntaxique.)

Si votre compilateur ne supporte pas les littéraux composés, vous pouvez le contourner par la déclaration d'une constante:
```
const struct foo foo_zero = { 0 };

struct foo mystruct;
/* ... */
mystruct = foo_zero;
```
Donc, c'est comment ils diffèrent dans la syntaxe et où vous pouvez les utiliser. Il y a aussi des différences sémantiques.

La memset appel jeux de tous les octets qui composent la représentation de mystruct à tous les zéros. C'est un très faible niveau de fonctionnement.

D'autre part, l'initialiseur:
```
struct foo mystruct = { 0 };
```
définit la première scalaire sous-composant de mystruct à 0, et établit toutes les autres sous-composants comme si ils ont été initialisé comme des objets statiques -- c'est à dire, de 0. (Ce serait bien si il y avait un nettoyeur de struct foo mystruct = { }; syntaxe de faire la même chose, mais il n'y en a pas.)

Le truc, c'est mettre quelque chose à 0 n'est pas nécessairement la même chose que le réglage de sa représentation à tous les bits à zéro. La valeur 0 est converti du type approprié pour chaque sous-composante scalaire.

Pour les entiers, la langue garantit que tous les bits à zéro est une représentation de 0 (mais pas nécessairement la seule représentation de la 0). Il est très probable que l'établissement d'un entier 0 allons mettre tous les bits à zéro, mais il est concevable qu'il puisse le régler à une autre représentation de 0. Dans la pratique, cela ne se produirait avec un dessein pervers compilateur.

Pour les pointeurs, plus implémentations représentent des pointeurs null comme tous les bits à zéro, mais la langue n'a pas de garantie que l', et il y a eu dans le monde réel de mises en utiliser une autre représentation. (Par exemple, en utilisant quelque chose comme tous les bits on peut faire de pointeur null déréférence plus facile à détecter au moment de l'exécution.) Et la représentation peuvent varier pour différents types de pointeur. Voir la section 5 de la comp.lang.c FAQ.

De même, pour les types à virgule flottante, la plupart des implémentations représentent 0.0 comme tous les bits à zéro, mais la norme du langage n'est pas garantie.

Vous pouvez probablement vous en sortir avec l'écriture de code que suppose la memset appel d'ensemble de tous les sous-composants à zéro, mais ce code n'est pas strictement portable -- et La Loi de Murphy implique que l'hypothèse ne seront pas en le plus inopportun moment possible, peut-être lorsque vous port le code d'un nouveau système important.

InformationsquelleAutor Keith Thompson

Vous devez vous connecter pour publier un commentaire.