template <typename T>
auto insert(T& container, int value) -> decltype(container.push_back(value), void()) {
 container.push_back(value);
}

template <typename T>
auto insert(T& container, int value) -> decltype(container.insert(value), void()) {
 container.insert(value);
}

template <typename T>
auto insertWithMove(T&& container, int value) -> decltype(container.push_back(value), std::decay_t()) {
 container.push_back(value);
 return std::move(container);
}

template <typename T>
auto insertWithMove(T&& container, int value) -> decltype(container.insert(value), std::decay_t()) {
 container.insert(value);
 return std::move(container);
}

template <typename T>
void testWithMove(const T& src) {
   auto start = std::chrono::steady_clock::now();
   T dest;
   for (auto&& x : src) {
       dest = insertWithMove(std::move(dest), x);
   }

   std::cout << "with move: " << std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now() - start).count() << "; " << dest.size() << "; "…

namespace my {

std::atomic_int g_memory_used(0);

template <typename T>
class Allocator : public std::allocator {
private:
   using Base = std::allocator;
   using Pointer = typename std::allocator_traits::pointer;
   using SizeType = typename std::allocator_traits::size_type;

public:
   Allocator() = default;

   template <typename U>
   Allocator(const Allocator& other)
       : Base(other)
   {
   }

   template <typename U>
   struct rebind {
       using other = Allocator;
   };

   Pointer allocate(SizeType n)
   {
       g_memory_used.fetch_add(n * sizeof(T));
       return Base::allocate(n);
   }

   void deallocate(Pointer p, SizeType n)
   {
       g_memory_used.fetch_sub(n * sizeof(T));
       Base::deallocate(p, n);
   }
};
}

template <template <typename T, typename AllocT> typename ContainerT>
void test()
{
   std::cout << __PRETTY_FUNCTION__ << std::endl;
   std::cout << "Memory usage before: " << my::g_memory_used.load() << std::endl;
   ContainerT<int, my::Allocator>…