“ISO obstructs adoption of standards by paywalling them”(twitter.com)

  #include <vector>
  
  // #include <folly/FBVector.h>
  
  template<class T>
  struct my_pointer
  {
   typedef my_pointer this_type;
   typedef T element_type, value_type;
   typedef ptrdiff_t difference_type;
   typedef this_type pointer;
   typedef value_type &reference;
   bool operator!=(this_type const &other) const { return !(*this == other); }
   bool operator==(this_type const &other) const { return this->p == other.p; }
   difference_type operator-(this_type const &other) const { return this->p - other.p; }
   explicit operator bool() const { return !!this->p; }
   friend this_type operator +(difference_type n, this_type me) { return me + n; }
   explicit my_pointer(T *p) : p(p) { }
   my_pointer(std::nullptr_t p) : p(p) { }
   my_pointer() : p() { }
   reference operator *() const { return *this->p; }
   template<class U> using rebind = my_pointer<T>;
   this_type &operator++() { ++this->p; return *this; }
   this_type &operator+=(difference_type n) { this->p += n; return *this; }
   this_type &operator--() { --this->p; return *this; }
   this_type &operator-=(difference_type n) { this->p -= n; return *this; }
   this_type operator+(difference_type d) const { return this_type(this->p + d); }
   this_type operator++(int) { this_type copy(*this); ++*this; return copy; }
   this_type operator-(difference_type d) const { return this_type(this->p - d); }
   this_type operator--(int) { this_type copy(*this); --*this; return copy; }
   value_type *operator->() const { return this->p; }
   reference operator[](difference_type d) { return this->p[d]; }
  private:
   T *p;
  };
  
  template<class T>
  struct my_allocator
  {
   std::allocator<T> base;
   typedef T value_type;
   typedef size_t size_type;
   typedef my_pointer<T> pointer;
   template<class U> struct rebind { typedef my_allocator<U> other; };
   pointer allocate(size_type n) { return pointer(this->base.allocate(n)); }
   void deallocate(pointer p, size_type n) { return this->base.deallocate(&*p, n); }
  };
  
  namespace std
  {
   template<class T>
   struct iterator_traits<my_pointer<T> >
   {
    typedef typename my_pointer<T>::pointer pointer;
    typedef typename my_pointer<T>::reference reference;
    typedef typename my_pointer<T>::value_type value_type;
    typedef typename my_pointer<T>::difference_type difference_type;
    typedef std::random_access_iterator_tag iterator_category;
   };
  }
  
  int main()
  {
  #ifdef FOLLY_CPLUSPLUS
   folly::fbvector
  #else
   std::vector
  #endif
    <int, my_allocator<int> > numbers;
   numbers.push_back(1);
   return 0;
  }

  /usr/include/folly/FBVector.h:148:27: error: no viable conversion from 'folly::fbvector<int, my_allocator<int>>::Impl::pointer' (aka 'my_pointer<int>') to 'int *'
            S_destroy_range(b_, e_);
  /usr/include/folly/FBVector.h:365:34: note: passing argument to parameter 'first' here
    static void S_destroy_range(T* first, T* last) noexcept {