Comment comparez-vous les structures d'égalité en C?

Comment comparez-vous deux instances de structures pour l'égalité dans le standard C?

C ne fournit aucun équipement linguistique pour ce faire - vous devez le faire vous-même et comparer chaque membre de la structure membre par membre.

Vous pouvez être tenté d'utiliser memcmp(&a, &b, sizeof(struct foo)), mais cela peut ne pas fonctionner dans toutes les situations. Le compilateur peut ajouter un espace tampon d'alignement à une structure, et les valeurs trouvées aux emplacements de mémoire situés dans l'espace tampon ne sont pas garanties être une valeur particulière.

Mais, si vous utilisez callocou memsetla taille complète des structures avant de les utiliser, vous pouvez faire une comparaison superficielle avec memcmp(si votre structure contient des pointeurs, elle ne correspondra que si l'adresse vers laquelle les pointeurs pointent est la même).

Si vous le faites beaucoup, je suggère d'écrire une fonction qui compare les deux structures. De cette façon, si jamais vous changez la structure, il vous suffit de changer la comparaison en un seul endroit.

Quant à savoir comment le faire .... Vous devez comparer chaque élément individuellement

Vous ne pouvez pas utiliser memcmp pour comparer les structures pour l'égalité en raison des caractères de remplissage aléatoires potentiels entre les champs dans les structures.

  // bad
  memcmp(&struct1, &struct2, sizeof(struct1));

Ce qui précède échouerait pour une structure comme celle-ci:

typedef struct Foo {
  char a;
  /* padding */
  double d;
  /* padding */
  char e;
  /* padding */
  int f;
} Foo ;

Vous devez utiliser la comparaison par membre pour être sûr.

@Greg a raison de dire qu'il faut écrire des fonctions de comparaison explicites dans le cas général.

Il est possible d'utiliser memcmpsi:

• les structures ne contiennent aucun champ à virgule flottante qui le soit NaN.
• les structures ne contiennent pas de remplissage (utilisez -Wpaddedavec clang pour vérifier cela) OU les structures sont explicitement initialisées avec memsetà l'initialisation.
• aucun type de membre (tel que Windows BOOL) n'a de valeurs distinctes mais équivalentes.

À moins que vous ne programmiez pour des systèmes embarqués (ou que vous n'écriviez une bibliothèque qui pourrait être utilisée sur eux), je ne m'inquiéterais pas de certains des cas d'angle dans la norme C. La distinction pointeur proche / éloigné n'existe sur aucun périphérique 32 ou 64 bits. Aucun système non intégré à ma connaissance ne possède plusieurs NULLpointeurs.

Une autre option consiste à générer automatiquement les fonctions d'égalité. Si vous disposez vos définitions de structure de manière simple, il est possible d'utiliser un traitement de texte simple pour gérer des définitions de structure simples. Vous pouvez utiliser libclang pour le cas général - car il utilise le même frontend que Clang, il gère correctement tous les cas d'angle (sauf bogues).

Je n'ai pas vu une telle bibliothèque de génération de code. Cependant, cela semble relativement simple.

Cependant, il est également vrai que de telles fonctions d'égalité générées feraient souvent la mauvaise chose au niveau de l'application. Par exemple, deux UNICODE_STRINGstructures dans Windows doivent-elles être comparées de manière superficielle ou profonde?

Notez que vous pouvez utiliser memcmp () sur des structures non statiques sans vous soucier du remplissage, tant que vous n'initialisez pas tous les membres (à la fois). Ceci est défini par C90:

http://www.pixelbeat.org/programming/gcc/auto_init.html

Cela dépend si la question que vous posez est:

1. Ces deux structures sont-elles le même objet?
2. Ont-ils la même valeur?

Pour savoir s'il s'agit du même objet, comparez les pointeurs aux deux structures pour l'égalité. Si vous voulez savoir en général s'ils ont la même valeur, vous devez faire une comparaison approfondie. Cela implique de comparer tous les membres. Si les membres sont des pointeurs vers d'autres structures, vous devez également revenir dans ces structures.

Dans le cas spécial où les structures ne contiennent pas de pointeurs, vous pouvez effectuer un memcmp pour effectuer une comparaison au niveau du bit des données contenues dans chacun sans avoir à savoir ce que les données signifient.

Assurez-vous que vous savez ce que «égal» signifie pour chaque membre - c'est évident pour les entiers mais plus subtil quand il s'agit de valeurs à virgule flottante ou de types définis par l'utilisateur.

memcmpne compare pas la structure, memcmpcompare le binaire, et il y a toujours des ordures dans la structure, donc il sort toujours faux en comparaison.

Comparez élément par élément son coffre-fort et ne manque pas.

Si les structures contiennent uniquement des primitives ou si vous êtes intéressé par une stricte égalité, vous pouvez faire quelque chose comme ceci:

int my_struct_cmp (const struct my_struct * lhs, const struct my_struct * rhs)
{
    return memcmp (lhs, rsh, sizeof (struct my_struct));
}

Cependant, si vos structures contiennent des pointeurs vers d'autres structures ou unions, vous devrez écrire une fonction qui compare correctement les primitives et effectuer des appels de comparaison avec les autres structures, le cas échéant.

Cependant, sachez que vous auriez dû utiliser memset (& a, sizeof (struct my_struct), 1) pour remettre à zéro la plage de mémoire des structures dans le cadre de votre initialisation ADT.

si la variable 2 structures est initialisée avec calloc ou si elle est définie sur 0 par memset, vous pouvez comparer vos 2 structures avec memcmp et vous n'avez pas à vous soucier des ordures de la structure et cela vous permettra de gagner du temps

Cet exemple conforme utilise l'extension de compilateur #pragma pack de Microsoft Visual Studio pour garantir que les membres de la structure sont compressés aussi étroitement que possible:

#include <string.h>

#pragma pack(push, 1)
struct s {
  char c;
  int i;
  char buffer[13];
};
#pragma pack(pop)

void compare(const struct s *left, const struct s *right) { 
  if (0 == memcmp(left, right, sizeof(struct s))) {
    /* ... */
  }
}