Comment comparer des structures génériques en C ++?

Je veux comparer les structures de manière générique et j'ai fait quelque chose comme ça (je ne peux pas partager la source réelle, alors demandez plus de détails si nécessaire):

template<typename Data>
bool structCmp(Data data1, Data data2)
{
  void* dataStart1 = (std::uint8_t*)&data1;
  void* dataStart2 = (std::uint8_t*)&data2;
  return memcmp(dataStart1, dataStart2, sizeof(Data)) == 0;
}

Cela fonctionne principalement comme prévu, sauf qu'il retourne parfois false même si les deux instances de structure ont des membres identiques (j'ai vérifié avec le débogueur eclipse). Après quelques recherches, j'ai découvert que cela memcmppouvait échouer en raison du remplissage de la structure utilisée.

Existe-t-il un moyen plus approprié de comparer la mémoire indifférente au rembourrage? Je ne suis pas en mesure de modifier les structures utilisées (elles font partie d'une API que j'utilise) et les nombreuses structures différentes utilisées ont des membres différents et ne peuvent donc pas être comparées individuellement de manière générique (à ma connaissance).

Edit: je suis malheureusement bloqué avec C ++ 11. J'aurais dû le mentionner plus tôt ...

Non, memcmpne convient pas pour cela. Et la réflexion en C ++ est insuffisante pour ce faire à ce stade (il y aura des compilateurs expérimentaux qui prennent en charge la réflexion suffisamment forte pour le faire déjà, et c ++ 23 pourrait avoir les fonctionnalités dont vous avez besoin).

Sans réflexion intégrée, la façon la plus simple de résoudre votre problème consiste à effectuer une réflexion manuelle.

Prends ça:

struct some_struct {
  int x;
  double d1, d2;
  char c;
};

nous voulons faire le minimum de travail afin de pouvoir comparer deux d'entre eux.

Si nous avons:

auto as_tie(some_struct const& s){ 
  return std::tie( s.x, s.d1, s.d2, s.c );
}

ou

auto as_tie(some_struct const& s)
-> decltype(std::tie( s.x, s.d1, s.d2, s.c ))
{
  return std::tie( s.x, s.d1, s.d2, s.c );
}

pour c ++ 11 , alors:

template<class S>
bool are_equal( S const& lhs, S const& rhs ) {
  return as_tie(lhs) == as_tie(rhs);
}

fait un travail assez décent.

Nous pouvons étendre ce processus pour qu'il soit récursif avec un peu de travail; au lieu de comparer les liens, comparez chaque élément encapsulé dans un modèle, et ce modèle operator==applique récursivement cette règle (encapsulant l'élément as_tiepour comparer) à moins que l'élément n'ait déjà un travail ==et gère les tableaux.

Cela nécessitera un peu de bibliothèque (100 lignes de code?) Avec l'écriture d'un peu de données de «réflexion» manuelles par membre. Si le nombre de structures que vous avez est limité, il pourrait être plus facile d'écrire manuellement du code par structure.

Il existe probablement des moyens

REFLECT( some_struct, x, d1, d2, c )

pour générer la as_tiestructure en utilisant d'horribles macros. Mais as_tiec'est assez simple. En c ++ 11, la répétition est ennuyeuse; c'est utile:

#define RETURNS(...) \
  noexcept(noexcept(__VA_ARGS__)) \
  -> decltype(__VA_ARGS__) \
  { return __VA_ARGS__; }

dans cette situation et bien d'autres. Avec RETURNS, écrire as_tiec'est:

auto as_tie(some_struct const& s)
  RETURNS( std::tie( s.x, s.d1, s.d2, s.c ) )

supprimer la répétition.

Voici un coup de couteau pour le rendre récursif:

template<class T,
  typename std::enable_if< !std::is_class<T>{}, bool>::type = true
>
auto refl_tie( T const& t )
  RETURNS(std::tie(t))

template<class...Ts,
  typename std::enable_if< (sizeof...(Ts) > 1), bool>::type = true
>
auto refl_tie( Ts const&... ts )
  RETURNS(std::make_tuple(refl_tie(ts)...))

template<class T, std::size_t N>
auto refl_tie( T const(&t)[N] ) {
  // lots of work in C++11 to support this case, todo.
  // in C++17 I could just make a tie of each of the N elements of the array?

  // in C++11 I might write a custom struct that supports an array
  // reference/pointer of fixed size and implements =, ==, !=, <, etc.
}

struct foo {
  int x;
};
struct bar {
  foo f1, f2;
};
auto refl_tie( foo const& s )
  RETURNS( refl_tie( s.x ) )
auto refl_tie( bar const& s )
  RETURNS( refl_tie( s.f1, s.f2 ) )

c ++ 17 refl_tie (array) (entièrement récursif, prend même en charge les tableaux de tableaux):

template<class T, std::size_t N, std::size_t...Is>
auto array_refl( T const(&t)[N], std::index_sequence<Is...> )
  RETURNS( std::array<decltype( refl_tie(t[0]) ), N>{ refl_tie( t[Is] )... } )

template<class T, std::size_t N>
auto refl_tie( T(&t)[N] )
  RETURNS( array_refl( t, std::make_index_sequence<N>{} ) )

Exemple en direct .

Ici, j'utilise un std::arrayde refl_tie. C'est beaucoup plus rapide que mon précédent tuple de refl_tie au moment de la compilation.

Aussi

template<class T,
  typename std::enable_if< !std::is_class<T>{}, bool>::type = true
>
auto refl_tie( T const& t )
  RETURNS(std::cref(t))

utiliser std::crefici au lieu de std::tiepourrait économiser sur la surcharge au moment de la compilation, comme crefc'est une classe beaucoup plus simple que tuple.

Enfin, vous devez ajouter

template<class T, std::size_t N, class...Ts>
auto refl_tie( T(&t)[N], Ts&&... ) = delete;

ce qui empêchera les membres du tableau de se décomposer en pointeurs et de retomber sur l'égalité du pointeur (ce que vous ne voulez probablement pas des tableaux).

Sans cela, si vous passez un tableau à une structure non réfléchie, il retombe sur une structure pointeur vers non réfléchie refl_tie, qui fonctionne et renvoie un non-sens.

Avec cela, vous vous retrouvez avec une erreur de compilation.

La prise en charge de la récursivité à travers les types de bibliothèques est délicate. Vous pourriez std::tieles:

template<class T, class A>
auto refl_tie( std::vector<T, A> const& v )
  RETURNS( std::tie(v) )

mais cela ne prend pas en charge la récursivité à travers elle.

Vous avez raison de dire que le remplissage vous empêche de comparer des types arbitraires de cette manière.

Vous pouvez prendre des mesures:

• Si vous contrôlez Dataalors par exemple gcc a __attribute__((packed)). Cela a un impact sur les performances, mais cela pourrait valoir la peine de l'essayer. Cependant, je dois admettre que je ne sais pas si packedvous permet d'interdire complètement le rembourrage. Le doc Gcc dit:

Cet attribut, attaché à la définition de type struct ou union, spécifie que chaque membre de la structure ou union est placé pour minimiser la mémoire requise. Lorsqu'il est attaché à une définition d'énumération, il indique que le plus petit type intégral doit être utilisé.

• Si vous n'êtes pas en contrôle, vous pouvez Dataau moins std::has_unique_object_representations<T>vous dire si votre comparaison donnera des résultats corrects:

Si T est TriviallyCopyable et si deux objets de type T avec la même valeur ont la même représentation d'objet, la valeur de la constante de membre est égale à true. Pour tout autre type, la valeur est false.

et plus loin:

Cette caractéristique a été introduite pour permettre de déterminer si un type peut être correctement haché en hachant sa représentation d'objet comme un tableau d'octets.

PS: je n'ai abordé que le remplissage, mais n'oubliez pas que les types qui peuvent comparer des instances égales avec une représentation différente en mémoire ne sont en aucun cas rares (par exemple std::string, std::vectoret bien d'autres).

En bref: pas possible de manière générique.

Le problème avec memcmpest que le remplissage peut contenir des données arbitraires et donc memcmppeut échouer. S'il y avait un moyen de savoir où se trouve le remplissage, vous pourriez mettre à zéro ces bits puis comparer les représentations de données, cela vérifierait l'égalité si les membres sont trivialement comparables (ce qui n'est pas le cas, std::stringcar deux chaînes peuvent contiennent des pointeurs différents, mais les deux tableaux de caractères pointés sont égaux). Mais je ne connais aucun moyen d'accéder au remplissage des structures. Vous pouvez essayer de dire à votre compilateur de compresser les structures, mais cela ralentira les accès et ne sera pas vraiment garanti de fonctionner.

La façon la plus simple de mettre en œuvre cela est de comparer tous les membres. Bien sûr, cela n'est pas vraiment possible de manière générique (jusqu'à ce que nous obtenions des réflexions de temps de compilation et des méta-classes en C ++ 23 ou version ultérieure). A partir de C ++ 20, on pourrait générer une valeur par défaut operator<=>mais je pense que cela ne serait également possible qu'en tant que fonction membre donc, encore une fois, cela n'est pas vraiment applicable. Si vous êtes chanceux et que toutes les structures que vous souhaitez comparer ont un operator==défini, vous pouvez bien sûr simplement l'utiliser. Mais ce n'est pas garanti.

EDIT: Ok, il existe en fait un moyen totalement hacky et quelque peu générique pour les agrégats. (J'ai seulement écrit la conversion en tuples, ceux-ci ont un opérateur de comparaison par défaut). Godbolt

C ++ 20 prend en charge les comparaisons par défaut

#include <iostream>
#include <compare>

struct XYZ
{
    int x;
    char y;
    long z;

    auto operator<=>(const XYZ&) const = default;
};

int main()
{
    XYZ obj1 = {4,5,6};
    XYZ obj2 = {4,5,6};

    if (obj1 == obj2)
    {
        std::cout << "objects are identical\n";
    }
    else
    {
        std::cout << "objects are not identical\n";
    }
    return 0;
}

En supposant des données POD, l'opérateur d'affectation par défaut copie uniquement les octets membres. (en fait, je n'en suis pas sûr à 100%, ne me croyez pas sur parole)

Vous pouvez utiliser ça à votre avantage:

template<typename Data>
bool structCmp(Data data1, Data data2) // Data is POD
{
  Data tmp;
  memcpy(&tmp, &data1, sizeof(Data)); // copy data1 including padding
  tmp = data2;                        // copy data2 only members
  return memcmp(&tmp, &data1, sizeof(Data)) == 0; 
}

Je pense que vous pourrez peut-être baser une solution sur le vaudou merveilleusement sournois d'Antony Polukhin dans la magic_getbibliothèque - pour les structures, pas pour les classes complexes.

Avec cette bibliothèque, nous sommes en mesure d'itérer les différents champs d'une structure, avec leur type approprié, en code purement général. Antony l'a utilisé, par exemple, pour pouvoir diffuser des structures arbitraires dans un flux de sortie avec les types corrects, de manière complètement générique. Il va de soi que la comparaison pourrait également être une application possible de cette approche.

... mais vous auriez besoin de C ++ 14. Au moins, c'est mieux que le C ++ 17 et les suggestions ultérieures dans d'autres réponses :-P