CODEWITHSUNDEEP
c++c++11structcomparisonmetaprogramming
AC-93
AC-93

Reputation: 85

c++ auto-comparator for structs

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.

Upvotes: 4

Views: 11591

Answers (3)

Yakk - Adam Nevraumont
Yakk - Adam Nevraumont

Reputation: 275435

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.

Upvotes: 3

AC-93
AC-93

Reputation: 85

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.

Upvotes: 0

JVApen
JVApen

Reputation: 11317

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.

Upvotes: 4

Related Questions