如何在C ++中比较泛型结构？

我想以一种通用的方式比较结构，并且我做了这样的事情（我无法共享实际的源代码，因此如有必要，请提供更多详细信息）：

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;
}

这通常可以按预期工作，但有时即使两个结构实例具有相同的成员（我已经使用eclipse调试器进行了检查），它有时仍返回false。经过一些搜索，我发现memcmp由于填充了所使用的结构而导致失败。

有没有比较合适的内存填充方式？我无法修改所使用的结构（它们是我正在使用的API的一部分），并且所使用的许多不同结构具有一些不同的成员，因此无法以一般方式进行单独比较（据我所知）。

编辑：不幸的是，我坚持使用C ++ 11。应该早些提到...

不，memcmp不适合这样做。在这一点上，C ++中的反射还不足以做到这一点（将会有实验性的编译器支持足够强大的反射功能来执行此操作，而c ++ 23可能具有所需的功能）。

如果没有内置反射，解决问题的最简单方法就是进行一些手动反射。

拿着它：

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

我们希望进行最少的工作，因此我们可以比较其中的两个。

如果我们有：

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

要么

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 );
}

对于c ++ 11，则：

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

做得不错。

我们可以通过一些工作来将此过程扩展为递归的。而不是比较关系，而是比较包装在模板中的每个元素，并且该模板将operator==递归地应用此规则（将元素包装as_tie以进行比较），除非该元素已经具有work ==并处理数组。

这将需要一些库（100行代码？）以及编写一些手动的每个成员的“反射”数据。如果您拥有的结构数量有限，则手动编写每个结构的代码可能会更容易。

可能有办法

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

as_tie使用可怕的宏来生成结构。但是as_tie很简单。在c ++ 11中，重复很烦人。这很有用：

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

在这种情况下，还有许多其他情况。使用RETURNS，写作as_tie是：

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

删除重复。

这是递归的一个障碍：

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）（完全递归，甚至支持数组数组）：

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>{} ) )

现场例子。

在这里我使用std::array的refl_tie。这比我在编译时以前的refl_tie元组要快得多。

也

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

使用std::cref此处而不是std::tie可以节省编译时的开销，因为这cref是比类更简单的类tuple。

最后，您应该添加

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

这将防止数组成员退化为指针，而后退到指针相等（您可能不需要数组）。

没有这个，如果您将数组传递给未反射的结构，它就会退回到指针指向未反射的结构上refl_tie，该结构可以工作并返回无意义。

这样，您最终会遇到编译时错误。

通过库类型支持递归比较棘手。你可以std::tie他们：

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

但这不支持通过它进行递归。

没错，填充会妨碍您以这种方式比较任意类型。

您可以采取以下措施：

• 如果您可以控制，Data则例如gcc has __attribute__((packed))。它对性能有影响，但是可能值得尝试一下。虽然，我不得不承认我不知道是否packed能使您完全禁止填充。Gcc文件说：

附加到struct或union类型定义的此属性指定将结构或union的每个成员放置在最小化所需内存的位置。当附加到枚举定义时，它指示应使用最小的整数类型。

• 如果您无法控制，Data那么至少std::has_unique_object_representations<T>可以告诉您比较是否会得出正确的结果：

如果T是TriviallyCopyable，并且具有相同值的T类型的任何两个对象具有相同的对象表示，则提供等于true的成员常量值。对于任何其他类型，值均为false。

并进一步：

引入此特征可以通过将其对象表示形式哈希为字节数组来确定类型是否可以正确哈希。

PS：我只写给填充，但不要忘记的类型，可以比较相等与内存中的不同表现情况决非罕见的（例如std::string，std::vector和许多其他）。

简而言之：不可能以通用的方式。

问题memcmp在于填充可能包含任意数据，因此memcmp可能会失败。如果有一种方法可以找出填充的位置，则可以将这些位清零，然后比较数据表示形式，这将检查成员之间的可比性是否相等（不是这种情况，std::string因为两个字符串可以包含不同的指针，但指向的两个字符数组相等）。但是我不知道如何填充结构。您可以尝试告诉编译器打包这些结构，但这会使访问速度变慢，并且实际上并不能保证正常工作。

实现此目的的最干净的方法是比较所有成员。当然，这实际上不是通用的方法（直到我们在C ++ 23或更高版本中获得编译时反射和元类）。从C ++ 20开始，可以生成一个默认值，operator<=>但我认为这也只能作为成员函数，因此，这实际上并不适用。如果您很幸运，并且要比较的所有结构都有operator==定义，则当然可以使用它。但这并不能保证。

编辑：好的，实际上有一种完全hacky的聚合方式。（我只将转换写为元组，那些具有默认的比较运算符）。哥德宝

C ++ 20支持默认兼容性

#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;
}

假定POD数据，默认分配运算符仅复制成员字节。（实际上对此不是100％的确定，请不要相信我）

您可以利用此优势：

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; 
}

我相信您也许可以在库中使用Antony Polukhin奇妙而狡猾的伏都教为基础的解决方案magic_get-适用于结构，而不适用于复杂的类。

使用该库，我们可以在纯通用模板的代码中迭代结构的不同字段及其适当的类型。举例来说，Antony使用它来能够将任意结构流式传输到具有正确类型的输出流（完全通用）。有理由认为，比较也可能是这种方法的一种可能的应用。

...但是您将需要C ++ 14。至少它比C ++ 17和其他答案中的后续建议要好:-P