Les allocateurs depuis C++ 11

#define _ITERATOR_DEBUG_LEVEL 0

#include <vector>
#include <chrono>
#include <iostream>
#include <cassert>
#include <utility>
using namespace std;
using namespace std::chrono;

template <class F, class ... Args>
   auto test(F f, Args &&... args) {
      auto pre = high_resolution_clock::now();
      auto res = f(std::forward<Args>(args)...);
      auto post = high_resolution_clock::now();
      return pair{ res, post - pre };
   }

template <class T>
   struct tit_allocateur {
      using value_type = T;
      using pointer = T*;
      using const_pointer = const T*;
      using reference = T&;
      using const_reference = const T&;
      using size_type = std::size_t;
      using difference_type = std::ptrdiff_t;
      constexpr size_type max_size() const {
         return std::numeric_limits<size_type>::max(); // bof
      }
      template <class U>
      struct rebind {
         using other = tit_allocateur<U>;
      };
      constexpr pointer address(reference r) const {
         return &r;
      }
      constexpr const_pointer address(const_reference r) const {
         return &r;
      }
      pointer allocate(size_type n) {
         auto p = static_cast<pointer>(malloc(n * sizeof(value_type)));
         if (!p) throw std::bad_alloc{};
         return p;
      }
      void deallocate(pointer p, size_type) {
         free(p);
      }
      void construct(pointer p, const_reference r) {
         new (static_cast<void*>(p)) value_type{ r };
      }
      void destroy(const_pointer p) {
         p->~value_type();
      }
   };

template <class T, class U>
   constexpr bool operator==(const tit_allocateur<T>&, const tit_allocateur<U>&) {
      return true;
   }
template <class T, class U>
   constexpr bool operator!=(const tit_allocateur<T>&, const tit_allocateur<U>&) {
      return false;
   }

template <class T>
   struct allocateur_minimaliste {
      using value_type = T;
      allocateur_minimaliste(/*ctor args*/) = default;
      template <class U>
      allocateur_minimaliste(const allocateur_minimaliste<U> &) {
      }
      value_type* allocate(std::size_t n) {
         auto p = static_cast<value_type*>(std::malloc(n * sizeof(T)));
         if (!p) throw std::bad_alloc{};
         return p;
      }
      void deallocate(value_type *p, std::size_t) {
         free(p);
      }
   };

template <class T, class U>
   constexpr bool operator==(const allocateur_minimaliste<T>&, const allocateur_minimaliste<U>&) {
      return true;
   }
template <class T, class U>
   constexpr bool operator!=(const allocateur_minimaliste<T>&, const allocateur_minimaliste<U>&) {
      return false;
   }

template <class T>
   struct buffered_sequential_allocator {
      char *buf, *cur;
      std::size_t size;
      using value_type = T;
      buffered_sequential_allocator(const buffered_sequential_allocator&) = default;
      buffered_sequential_allocator(buffered_sequential_allocator&&) = default;
      buffered_sequential_allocator(char *buf, std::size_t size) : buf{ buf }, cur{ buf }, size{ size } {
      }
      template <class U>
      buffered_sequential_allocator(const buffered_sequential_allocator<U> &other) {
         buf = other.buf;
         cur = other.cur;
         size = other.size;
      }
      value_type* allocate(std::size_t n) {
         if (cur + n * sizeof(value_type) > buf + size)
            return static_cast<value_type*>(::operator new(n)); // ICI: fuite volontaire
         auto p = cur;
         cur += n * sizeof(value_type);
         return reinterpret_cast<value_type*>(p);
      }
      void deallocate(value_type *, std::size_t) {
         // no-op
      }
   };

template <class C, class ... Args>
   void remplir(C & cont, int n, Args && ... args) {
      for (int i = 0; i < n; ++i)
         cont.emplace_back(std::forward<Args>(args)...);
   }

int main() {
   enum { N = 100'000 };
   enum : size_t { BUFSIZE = N * sizeof(double) };
   alignas (double) char buffer[BUFSIZE];
   buffered_sequential_allocator<double> ze_alloc(&buffer[0], BUFSIZE);

   auto [r0, dt0] = test([] {
      vector<double> v; // standard
      v.reserve(N);
      remplir(v, N, 3.5);
      return v.back();
   });
   cout << "Vanille\n\tEcoule: " << duration_cast<microseconds>(dt0).count() << " us." << endl;
   //
   //
   //
   auto [r1, dt1] = test([] {
      vector<double, tit_allocateur<double>> v; // devrait être plus lent, mais c'est une démo
      v.reserve(N);
      remplir(v, N, 3.5);
      return v.back();
   });
   cout << "Tit allocateur\n\tEcoule: " << duration_cast<microseconds>(dt1).count() << " us." << endl;
   //
   //
   //
   auto [r2, dt2] = test([] {
      vector<double, allocateur_minimaliste<double>> v; // devrait être plus lent, mais c'est une démo
      v.reserve(N);
      remplir(v, N, 3.5);
      return v.back();
   });
   cout << "Minimaliste\n\tEcoule: " << duration_cast<microseconds>(dt2).count() << " us." << endl;
   //
   //
   //
   auto [r3, dt3] = test([&ze_alloc] {
      vector<double, buffered_sequential_allocator<double>> v{ ze_alloc }; // ICI
      v.reserve(N);
      remplir(v, N, 3.5);
      return v.back();
   });
   cout << "Buffered-sequential\n\tEcoule: " << duration_cast<microseconds>(dt3).count() << " us." << endl;
}