4

There is many primitive structs (several hundreds), that are used to transfer data between two components (for example a player and a server). There are no methods in them, just raw data. The task is to write all requests and answers to be able to replay a player scenario without a server (we remember all question and all answers, that are pure functions). So the task is put this structs in map without comparator. Now we use memcmp, it allows not to think about changes in this structs and it is compact, but there are too many problems with padding and etc.

Is it possible to get smth like getHashValue or any default comparator with metaprogramming in c++? Conditions: 1) I do not want to create a comparator for each struct. 2) I want to have an error if a field was added or deleted if it breaks existing behavior and needs fix. 3) I don't want to change header files with struct definitions.

Example of a struct

struct A {
  int a;
  int b;
  c c;
}

bool operator<(const A& a1, const A& a2)
{
  if (a1.a != a2.a) return a1.a < a2.a;
  if (a1.b != a2.b) return a1.b < a2.b;
  if (a1.c != a2.c) return a1.c < a2.c;
  return false;
}

I can consider other languages to implement this exact part (collect questions/answers), if it will not require to describe all this structs on that language again.

Yakk - Adam Nevraumont
  • 262,606
  • 27
  • 330
  • 524
AC-93
  • 85
  • 1
  • 7

3 Answers3

3

I suppose you could write your own compare operator based upon memcmp.

bool operator<(const A &lhs, const A &rhs) {
    return memcmp(&lhs, &rhs, sizeof(A)) < 0;
}

Off course, writing these for each object might be a burden, so you could write a template for this. Though without some SFINAE it will cover too much types.

 #include <type_traits>
 #include <cstring>

 template<typename T>
 std::enable_if_t<std::is_pod_v<std::decay_t<T>      //< Check if POD
                  && !std::is_fundamental_v<std::decay_t<T>>>, //< Don't override for fundamental types like 'int'
     bool>
     operator<(const T &lhs, const T &rhs) {
     return memcmp(&lhs, &rhs, sizeof(std::decay_t<T>)) < 0;
 }

EDIT: Note that this technique requires you to zero-initialize the structs.

JVApen
  • 11,008
  • 5
  • 31
  • 67
  • 2
    Wouldn't `memcmp` return incorrect values if a structure is padded? See, for example, [this answer](https://stackoverflow.com/a/141791/1683161). – rainer Jun 18 '17 at 17:18
  • Could be, one could care for NAN comparing equal or not (though it depends on what is important for you, -0.0 and 0.0 might be an issue, though again, it might depend on your usecase) – JVApen Jun 18 '17 at 17:24
  • The problem is that I can't zero-initialize them, it will affect the performance when we don't not collect this data, i mean in product build. – AC-93 Jun 18 '17 at 20:46
  • You cannot do a memset after newing? In that case, the above won't work when there is padding :( – JVApen Jun 19 '17 at 05:37
3

In C++17 you can pull this off if you are willing to (A) hard code how many elements are in each struct somewhere, and (B) write or generate code for each count of number of elements in the struct.

template<std::size_t N>
using size_k = std::integral_constant<std::size_t, N>;

template<class T>
auto auto_tie( size_k<0>, T&& t ) {
  return std::tie();
}
template<class T>
auto auto_tie( size_k<1>, T&& t ) {
  auto& [ x0 ] = std::forward<T>(t);
  return std::tie( x0 );
}
template<class T>
auto auto_tie( size_k<2>, T&& t ) {
  auto& [ x0, x1 ] = std::forward<T>(t);
  return std::tie( x0, x1 );
}
// etc

now, in the namespace of the struct in question, write

struct foo {
  int x;
};
struct bar {
  int a, b;
};
size_k<1> elems( foo const& ) { return {}; }
size_k<2> elems( bar const& ) { return {}; }

an elems function that return the size_k counting how many elements.

Now in the namespace of the structs, write:

template<class T, class Size=decltype(elems(std::declval<T const&>()))>
bool operator<( T const& lhs, T const& rhs ) {
  return auto_tie( Size{}, lhs ) < auto_tie( Size{}, rhs );
}

and you are done.

Test code:

foo f0{1}, f1{2};
bar b0{1,2}, b1{-7, -3};

std::cout << (f0<f1) << (f1<f0) << (f0<f0) << "\n";
std::cout << (b0<b1) << (b1<b0) << (b0<b0) << "\n";

Live example.

Getting further than this will require writing 3rd party tools or waiting for reflection extension to C++, maybe in C++20 or 23.

If you get elems wrong, I believe the structured bindings code in auto_tie should generate an error.

Yakk - Adam Nevraumont
  • 262,606
  • 27
  • 330
  • 524
  • 1
    You can eliminate the need for `elems` by using a technique in [Magic Get](https://github.com/apolukhin/magic_get) (described in a [cppcon video](https://youtu.be/abdeAew3gmQ)). Basically, you can get an upper bound on the number of elements of the struct and use a type that is convertible to anything to attempt to construct the type, reducing the number of elements you try to construct it with until it works – Justin Jun 20 '17 at 18:31
  • @Justin At the 9 minute mark I believe. May require a bit of work to make it generate a constexpr return value, but nothing tricky I think. – Yakk - Adam Nevraumont Jun 20 '17 at 19:46
0

Looks like the best way to do it is to write a generator, that will generate .h and .cpp with bool operator< for all types in this header file. Then add this project as pre-build step to the main.

It doesn't look like a nice solution, but it allows to avoid hand-written code duplication and will support adding/removing new structs/fields. So I didn't find a better way.

AC-93
  • 85
  • 1
  • 7