Aucune raison de préférer memset/ZeroMemory à la valeur d'initialisation pour WinAPI les structures?

Dans la programmation Win32 une poignée de GOUSSES structs est utilisé. Ces structures ont souvent besoin d'être remis à zéro avant l'utilisation.

Cela peut être fait en appelant memset()/ZeroMemory()

STRUCT theStruct;
ZeroMemory( &theStruct, sizeof( theStruct ) );

ou par la valeur d'initialisation:

STRUCT theStruct = {};

Bien que les deux variantes ci-dessus ne sont pas équivalentes en général:

  • traiter rembourrage différemment
  • traiter les non-POD variables de membre différemment

en cas de POD les structures utilisées dans Win32 ils regardent équivalent.

Sont là tout cas, quand memset()/ZeroMemory() devrait être utilisé au lieu de la valeur d'initialisation avec Win32 POD structs?

Double de stackoverflow.com/q/1998752/471164
Ce n'est pas complète dupe - ce qui est demandé pour un cas particulier lors de la première approche doit être préféré.
Connexes: stackoverflow.com/questions/3038302/...
Un excellent Post sur ZeroMemory par Raymond Chen - Non, ce n'est pas la réponse à la question mais c'est une bonne lecture.

OriginalL'auteur sharptooth | 2010-10-04

  1. 20

    J'utilise toujours:

    STRUCT theStruct = {}; //for C++, in C use {0}

    C'est plus courte, standard, par conséquent, plus élégantes, et je n'ai pas vraiment de soins au sujet de la théorie des différences. Nous parlons de code pour un béton OS ici.

    Un autre avantage est que vous pouvez également régler immédiatement la structure de taille dans le premier membre comme ceci:

    STRUCT theStruct = {sizeof(STRUCT)};

    De nombreux Win32 structs vous obliger à définir la taille dans un premier membre.

    Il est intéressant de noter que l'OP tagged la question à la fois le C et le C++, mais STRUCT theStruct = {}; est pas valide C. Vous avez besoin {0} à la place.
    Je vais modifier.

    OriginalL'auteur

  2. 8

    Dans Win32, ZeroMemory est juste une Macro autour de RtlZeroRemory, qui est une macro memset. Donc, je ne pense pas que cela fait une différence.

    WinBase.h:

    \#define ZeroMemory RtlZeroMemory"

    WinNT.h:

    \#define RtlZeroMemory(Destination,Length) memset((Destination),0,(Length))
    La question est de savoir si l'une de ces différentes pour = {}
    merci! Je me demandais la différence entre memset et zeromemory et vous avez répondu à ma question

    OriginalL'auteur Dante

  3. 4

    Si votre code servira d'exemple à de nombreux développeurs de Visual Basic qui sont susceptibles de ne pas remarquer ou de comprendre le C++ = {} construire, ZeroMemory est un bon moyen de rendre le code C++ ressemble plus à de pseudo et de minimiser l'incidence de subtils, sèche-extraction de l'initialisation de bugs.

    C'est la préoccupation que le Article MSDN auteurs face, ce qui explique alors pourquoi ZeroMemory affiche dans tellement de code (même code C++).

    D'autre part, si le but de votre code C++ est de faire un produit de travail, plutôt que d'enseigner le monde, à l'aide de l'élégance et de la puissance expressive du langage C++ est une excellente idée.

    Les commentaires sur cette article MSDN sont hilarants

    OriginalL'auteur Edward Brey

  4. 2

    La seule raison (que je peux prévoir de ne pas utiliser de valeur d'initialisation pour la "réduction à zéro" est si vous avez des versions spéciales de memset/ZeroMemory(tel que de l'ESS en fonction d'un), ou vous avez besoin pour éviter les problèmes avec le compilateur(en se référant à MSVC ici, comme de VS2008 memset ne deviendra jamais une valeur intrinsèque, mais avec quelques petits malins de codage(asm), vous pouvez forcer la valeur intrinsèque(REP STOS))

    Pourriez-vous partager ce MSVC truc?
    un de mes amis(Nefarius de d2mods.com) découvert cela, si vous créez un remplissage simple boucle: while(pStart < pEnd) *pStart++ = dwFill; puis le compilateur transforme en REP STOS toutefois, cela ne fonctionne pas pour memcpy. aussi le code de remplacement seront également saisis(SSE2) ou optimisé mieux qu'un msvcrt.memset appel, il suffit de noter son jusqu'à vous pour gérer l'alignement(je genereally usage de long avec une branche sur & 3 pour attraper gauche sur octets)

    OriginalL'auteur Necrolis

  5. 2

    La seule raison de préférer memset/ZeroMemory pour ce genre d'initialisation est si WinAPI fonctions exiger ou attendre la mémoire pour être initialisé de cette façon, c'est à dire si WinAPI fonctions attendent de leurs zéros être physique zéros - les valeurs à zéro pour tous les modèles de bits.

    Gardez à l'esprit que la différence entre une représentation d'un zéro de la valeur d'un certain type et physique de tous les zéro-séquence de bits dépend du compilateur mise en œuvre, non pas sur l'OS. En théorie, un compilateur Windows pouvez utiliser non nulle modèles de bits pour représenter les valeurs zéro de différents types. Comme, un pointeur null peut être représenté par la non-nulle valeur physique dans certains imaginaire de C ou de C++ compilateur pour Windows. (Pas que quiconque puisse réellement le faire, bien sûr).

    "En théorie, un compilateur Windows pouvez utiliser non nulle modèles de bits pour représenter les valeurs zéro de différents types.". Non, il ne peut pas. Il ne serait pas un compilateur Windows si il l'a fait. La raison en est simple: le compilateur ne peut jamais savoir quelle valeur différente de zéro, vous aurez memcpy() en argument à une API Win32. L'API Win32 est une définition d'un pointeur null, tous les bits 0, et les deux définitions d'un flotteur (+0.0 f/-0.0 f). Par conséquent, un compilateur Windows doivent utiliser ce format de partout.
    Incorrect. Windows compilateur peut utiliser des "non-zéro" pointeurs. Si WinAPI nécessite physique de zéro pour les "pointeurs null" dans son interface, cela voudrait dire qu'avec un tel compilateur, l'utilisateur ne sera pas en mesure d'utiliser la langue de niveau zéro d'initialisation pour WinAPI appels. L'utilisateur devra en tenir à memset/ZeroMemory approche pour WinAPI liés à l'initialisation. Il serait très gênant, d'erreurs et n'aurait aucun sens, c'est pourquoi j'ai dit que personne ne serait jamais le faire. Mais il est noter impossible à ce sujet.
    Votre déclaration au sujet de "vous devez utiliser" est totalement infondée, même si elle commence par "donc".
    Comment aurait-il dire que vous ne pouvez pas utiliser la langue au niveau de l'initialisation? Le Windows ABI il faut le pointeur null à tous les zéro-octets, de sorte que n'importe quel compilateur pour windows devront se conformer à l'une ou il n'est pas un compilateur Windows. Ceci est analogue à POSIX nécessitant CHAR_BIT==8. N'importe quel compilateur C avec CHAR_BIT!=8 n'est pas une POSIX compilateur.
    Windows ABI? Où avez-ABI venir? Qui se soucie d'ABI? On peut facilement mettre en œuvre un compilateur Windows qui gratuitement viole [presque] tous les besoins de Windows ABI, mais permet à l'utilisateur d'utiliser WinAPI. Dans ce cas, l'utilisateur est obligé d'effectuer toutes les initialisations pour WinAPI "manuellement", à raw niveau de la mémoire (comme dans le cas de memset). Aussi longtemps que l'utilisateur initialise tout bien et aussi longtemps que le compilateur suit la WInAPI convention d'appel tout fonctionnera correctement.

    OriginalL'auteur AnT

  6. 1

    Le résultat final est identique (à condition que vous supposez que 0 est toujours représenté par tous les zéro-bits), c'est donc en grande partie une affaire de style. Personnellement, je préfère valeur d'initialisation, puisqu'il est plus simple et ne nécessite pas d'appels de fonction.

    Par ailleurs, vous devez l'initialiser au moins un membre:

    STRUCT theStruct = {0};

    En omettant les 0 est admise par certains compilateurs C, mais pas par la norme. C++ permet l'omission, mais je préfère toujours utiliser le 0.

    C++ 8.5.1/8 dit "vide de l'initialiseur-liste peut être utilisée pour initialiser un ensemble". C nécessite au moins une valeur.
    Désolé, je faisais allusion à C, mais il a oublié de le mentionner. J'ai modifié ma réponse.
    Un risque important pour la différence, c'est que la structure de l'initialisation n'a pas besoin d'initialiser le rembourrage, si par exemple la memcmp() peut ne pas retourner 0 pour les deux structures dont les valeurs sont par ailleurs identiques (même avant d'entrer dans -0.0). En supposant que les écritures sur les champs de ne pas tabasser adjacentes rembourrage (je ne sais pas ce que C99 garanties), il est possible de violer une API contrat qui prévoit la struct être remis à zéro avec memset(), si c'est un peu tiré par les cheveux.
    En C++, 0 peut ne pas être valide initialiseur pour le premier membre, qui est pourquoi { } est préféré.

    OriginalL'auteur Marcelo Cantos

  7. -1

    en c++11:

    struct A {
    int x = 10;
    int y = 100;
    int z = 0;
};

    vieux style c++

    struct A {
    int x;
    int y;
    int z;
    A() : x( 10 ), y( 100 ), z( 0 ) {} //constructor
};

    OriginalL'auteur vangodp