Copy-assigning an unordered map with incompatible allocators - c++

Question

Consider the following dummy allocator (created for the sake of example):
template<typename T> class C
{
public:
typedef T value_type;
C() = default;
template<typename U>
C(C<U> const &a)
{}
T* allocate(std::size_t n, T const* = nullptr)
{
return new T[n];
}
void deallocate(T* p, std::size_t n)
{
return;
}
typedef value_type *pointer;
typedef const value_type *const_pointer;
typedef value_type & reference;
typedef value_type const &const_reference;
typedef std::size_t size_type;
typedef std::ptrdiff_t difference_type;
static pointer address(reference x) { return &x; }
static const_pointer address(const_reference x) { return &x; }
static size_type max_size() { return std::numeric_limits<size_type>::max(); }
template <typename U> static void destroy(U* ptr) { ptr->~U(); }
template <typename U> struct rebind { using other = C<U>; };
template<typename U, typename... Args>
static void construct(U* ptr, Args&&... args) {
new (ptr) U(std::forward<Args>(args)...);
}
};
template<class T1, class T2>
bool operator==(C<T1> const& lhs, C<T2> const& rhs)
{
return std::addressof(lhs) == std::addressof(rhs);
}
template<class T1, class T2>
bool operator!=(C<T1> const& lhs, C<T2> const& rhs)
{
return !(lhs == rhs);
}
Most of this code is boiler plate. The crucial detail is that any two instances of an allocator will be considered incompatible - bool operator== always returns false. When I try to use this allocator with most STL containers such as std::vector to copy-assign very simple elements, such as:
std::vector<int, C<int>> a;
a = std::vector<int, C<int>>();
Things work, and I get expected behavior. However, when I do the same thing, but with std::unordered_map instead, I get different behavior on the two platforms I need to support. On Linux with GCC 7.1, I continue to get expected behavior. On Windows with VS 2015, however, I get an assertion failure stating containers incompatible for swap in a VS header titled xmemory0. Note that the code used for std::unordered_map is pretty much the same as the above for std::vector:
using B = std::unordered_map<int, int, std::hash<int>, std::equal_to<int>, C<std::pair<int const, int>>>;
B b;
b = B();
Is there something inherently wrong with my allocator, and GCC 7.1 is giving me undefined behavior? If not, is this a failure with the VS 2015 runtime library? If so, why is this failure only present with unordered_map?

Answer 1

You can't have allocators that uniquely own state, they must be CopyConstructible. E.g. you should switch from std::unique_ptrs to std::shared_ptrs.
You should relax your comparisons
template<class T1, class T2>
bool operator==(C<T1> const& lhs, C<T2> const& rhs)
{
return /* check equality of some member of C */;
}
template<class T1, class T2>
bool operator!=(C<T1> const& lhs, C<T2> const& rhs)
{
return !(lhs == rhs);
}
You can also probably benefit from adhering to the Rule of zero/five, and defining propogate_on_container_copy_assignment, propogate_on_container_move_assignment and propogate_on_container_swap as std::true_type
A hint as to where MSVC is tripping up
Note: swapping two containers with unequal allocators if propagate_on_container_swap is false is undefined behavior.

Answer 2

This is not a conforming allocator. All copies of an allocator, including rebound ones, must compare equal to each other.
Additionally, unordered_map's value_type is pair<const Key, Value>, so your example should use C<pair<const int, int>>.