Bitwise comparison of any structure

Question

What I tried to do is compare arbitrary structures independent of the == operator implementation.

template<typename T>
bool bitWiseCompare(T a, T b)
{
  size_t size = sizeof(T) / sizeof(char);
  char* array_a = (char*)(&a);
  char* array_b = (char*)(&b);
  for(size_t i = 0; i<size; i++)
  {
    if(array_a[i] != array_b[i])
    {
      return false;
    }
  }
  return true;
}

Answer 1

This comparison can fail if there are any padding bytes within T, as those extra bytes are not initialized to any particular value.

Another source of failure can come from inheritance. If one of the objects is part of a larger class (T is being used as a base class) with virtual functions, the vtable pointers can be different if a and b are part of different class hierarchies. Virtual inheritance of base classes of T can also cause problems.

sizeof(char) is always 1, so there is no need to divide by it.

Since you're only reading from your parameters, you should take them by const &T to avoid making unnecessary copies.

Answer 2

The C++ way isn't necessarily to stay away of such things as bit comparisons, but rather to do it in the most obvious way possible -by that I mean that your code should look dangerous and explicit at the same time. You have tools for this at your disposal: namespaces, ugly looking casts and algorithms:

#include <algorithm>
namespace unsafe {
    template <typename T>
    constexpr auto begin(const T& item) {
        return reinterpret_cast<const char*>(&item);
    }
    template <typename T>
    constexpr auto end(const T& item) {
        return reinterpret_cast<const char*>(&item)+sizeof(T);
    }
    template <typename T>
    auto bitwise_equal(const T& lhs, const T& rhs) {
        return std::equal(begin(lhs), end(lhs), // will become constexpr with C++20
                          begin(rhs), end(rhs));
    }
}

So it won't look innocuous when you use it:

int main() {
    auto a = 125.5;
    std::cout << std::boolalpha << unsafe::bitwise_equal(a, a);
} 

A few further remarks:

• bitwise_compare isn't the most accurate name for the function, since compare is traditionally reserved for functions returning order (-1, 0, 1), and not only equality.

• providing begin() and end() isn't necessary, since begin(item)+sizeof(T) is as correct, and probably as readable a replacement, but aesthetic reasons are sometimes enough

• std::equal is set to become constexpr with the new standard, meaning this C++'s style implementation might become more efficient than the memcmp implementation given compile-time values.

• it's generally better to use the four-argument versions of algorithms over two ranges; in this case it is obviously redundant since the length of the two arguments are by construction equal, but then consistency is a virtue.

• reusing algorithms is a good way to avoid dumb but frequent errors one would make with a raw loop,

for instance:

auto  pa = reinterpret_cast<const char*>(&a);
for (auto pb = reinterpret_cast<const char*>(&b); pb != pb+sizeof(T); ++pb) // oops!
    // ...