Memset() ou initialisation de la valeur à zéro d'une structure?

Question

En programmation API Win32, il est typique d'utiliser des structs C avec plusieurs champs. En général, seulement quelques-uns ont des valeurs significatives et tous les autres doivent être mis à zéro. Cela peut être accompli de l'une des deux manières :

STRUCT theStruct;
memset( &theStruct, 0, sizeof( STRUCT ) );

ou

STRUCT theStruct = {};

La deuxième variante semble plus propre - c'est une seule ligne, elle n'a pas de paramètres qui pourraient être mal tapés et entraîner une erreur.

Est-ce qu'elle présente des inconvénients par rapport à la première variante ? Quelle variante utiliser et pourquoi ?

Answer 1

Ces deux constructions sont très différentes dans leur signification. Le premier utilise une fonction memset, qui est destinée à définir un tampon mémoire sur une certaine valeur. Le deuxième pour initialiser un objet. Laissez-moi vous expliquer cela avec un peu de code :

Supposons que vous avez une structure qui a des membres uniquement de types POD ("Plain Old Data" - voir Quels sont les types POD en C++?)

struct StructurePOD_Seul
{
    int a;
    char b;
};

StructurePOD_Seul t = {};  // OK

StructurePOD_Seul t;
memset(&t, 0, sizeof t);  // OK aussi

Dans ce cas, écrire un StructurePOD_Seul t = {} ou StructurePOD_Seul t; memset(&t, 0, sizeof t) ne fait pas beaucoup de différence, car la seule différence que nous avons ici est que les octets d'alignement sont définis sur une valeur zéro en cas d'utilisation de memset. Comme vous n'avez normalement pas accès à ces octets, il n'y a pas de différence pour vous.

D'un autre côté, comme vous avez étiqueté votre question comme étant en C++, essayons un autre exemple, avec des types de membres différents des POD:

struct StructureTest
{
    int a;
    std::string b;
};

StructureTest t = {};  // OK

{
    StructureTest t1;
    memset(&t1, 0, sizeof t1);  // ruine le membre 'b' de notre structure
}  // L'application plante ici

Dans ce cas, utiliser une expression comme StructureTest t = {} est bien, et utiliser un memset sur cela entraînera un crash. Voici ce qui se passe si vous utilisez memset - un objet de type StructureTest est créé, créant ainsi un objet de type std::string, puisque c'est un membre de notre structure. Ensuite, memset définit la mémoire où l'objet b était situé sur une certaine valeur, disons zéro. Maintenant, une fois que notre objet StructureTest sort du contexte, il sera détruit et lorsque viendra le tour de son membre std::string b, vous verrez un crash, car toutes les structures internes de cet objet ont été ruinées par le memset.

Donc, en réalité, ces choses sont très différentes, et bien que parfois vous ayez besoin de memset une structure entière sur des zéros dans certains cas, il est toujours important de s'assurer de bien comprendre ce que vous faites, et de ne pas commettre d'erreur comme dans notre deuxième exemple.

Mon conseil - utiliser memset sur des objets uniquement si c'est nécessaire, et utiliser l'initialisation par défaut x = {} dans tous les autres cas.

Answer 2

En fonction des membres de la structure, les deux variantes ne sont pas nécessairement équivalentes. memset va définir la structure à tous les bits à zéro alors que l'initialisation de la valeur va initialiser tous les membres à la valeur zéro. La norme C garantit que ces deux méthodes sont les mêmes uniquement pour les types entiers, pas pour les valeurs à virgule flottante ou les pointeurs.

De plus, certaines API nécessitent que la structure soit réellement définie à tous les bits à zéro. Par exemple, l'API des sockets Berkeley utilise des structures de manière polymorphe, et il est important de vraiment définir toute la structure à zéro, pas seulement les valeurs apparentes. La documentation de l'API devrait préciser si la structure doit vraiment être définie à tous les bits à zéro, mais cela pourrait être insuffisant.

Mais si aucune de ces situations, ou un cas similaire, ne s'applique, alors c'est à vous de décider. Lorsque vous définissez la structure, je préfère l'initialisation de la valeur, car cela communique l'intention de manière plus claire. Bien sûr, si vous avez besoin de mettre à zéro une structure existante, memset est le seul choix (à part initialiser manuellement chaque membre à zéro, mais cela ne serait généralement pas fait, surtout pour de grandes structures).

Answer 3

Si votre structure contient des éléments tels que :

int a;
char b;
int c;

Alors des octets de remplissage seront insérés entre b et c. memset les mettra à zéro, l'autre manière ne le fera pas, donc il y aura 3 octets de données non désirées (si vos entiers font 32 bits). Si vous avez l'intention d'utiliser votre structure pour lire/écrire dans un fichier, cela pourrait être important.

Answer 4

Je préférerais utiliser l'initialisation de valeur car cela paraît propre et moins sujet aux erreurs comme vous l'avez mentionné. Je ne vois aucun inconvénient à le faire.

Vous pourriez utiliser memset pour mettre à zéro la structure après son utilisation cependant.

Answer 5

Pas que ce soit courant, mais je suppose que la deuxième méthode a également l'avantage d'initialiser les flottants à zéro, alors qu'un memset ne le ferait certainement pas.