fork download
copy 
  1. #include <iostream>
  2. using std::cout;
  3. using std::endl;
  4. using std::cerr;
  5.  
  6. #include <algorithm>
  7. using std::max;
  8.  
  9. #include <vector>
  10. using std::vector;
  11.  
  12. #include <list>
  13. using std::list;
  14.  
  15. #include <cstdlib>
  16.  
  17. template<typename T>
  18. inline T *allocate( size_t size, T * )
  19. {
  20.     T *result = ( T * )malloc( size * sizeof( T ) );
  21.  
  22.     if( result == 0 )
  23.     {
  24.         cerr << "Out of memory" << endl;
  25.         exit( EXIT_FAILURE );
  26.     }
  27.  
  28.     return result;
  29. }
  30.  
  31. template<typename T>
  32. inline void deallocate( T *buffer )
  33. {
  34.     free( buffer );
  35. }
  36.  
  37. template<typename T>
  38. class myAllocator
  39. {
  40.     public:
  41.     typedef T           value_type;
  42.     typedef T           *pointer;
  43.     typedef T           &reference;
  44.     typedef const       T *const_pointer;
  45.     typedef const       T &const_reference;
  46.     typedef size_t      size_type;
  47.     typedef ptrdiff_t   difference_type;
  48.  
  49.     template<typename U>
  50.     struct rebind
  51.     {
  52.         typedef myAllocator<U> other;
  53.     };
  54.  
  55.     myAllocator()
  56.     {
  57.     }
  58.  
  59.     myAllocator( const myAllocator & )
  60.     {
  61.     }
  62.  
  63.     template<typename U>
  64.     myAllocator( const myAllocator<U> & )
  65.     {
  66.     }
  67.  
  68.     ~myAllocator()
  69.     {
  70.     }
  71.  
  72.     pointer allocate( size_type n )
  73.     {
  74.         //return reinterpret_cast<T *>( Allocate( sizeof( T ) * n ) );
  75.         return ::allocate( n, ( pointer )0 );
  76.     }
  77.  
  78.     void deallocate( pointer p, size_t /* n */ )
  79.     {
  80.         // Free(p, sizeof(T) * n);
  81.         ::deallocate( p );
  82.     }
  83.  
  84.     template<typename U>
  85.     void construct( pointer p, const U &value )
  86.     {
  87.         new ( p ) T( value );
  88.     }
  89.  
  90.     void destroy( pointer p )
  91.     {
  92.         p->~T();
  93.     }
  94.  
  95.     pointer address( reference x ) const
  96.     {
  97.         return &x;
  98.     };
  99.  
  100.     const_pointer address( const_reference x ) const
  101.     {
  102.         return &x;
  103.     }
  104.  
  105.     size_type max_size() const
  106.     {
  107.         return max( size_type( 1 ), size_type( size_type( -1 ) / sizeof( value_type ) ) );
  108.     }
  109.  
  110.     bool operator==( const myAllocator & )
  111.     {
  112.         return true;
  113.     }
  114.  
  115.     bool operator!=( const myAllocator & )
  116.     {
  117.         return false;
  118.     }
  119.  
  120.     template<typename U>
  121.     bool operator==( const myAllocator<U> & )
  122.     {
  123.         return true;
  124.     }
  125.  
  126.     template<typename U>
  127.     bool operator!=( const myAllocator<U> & )
  128.     {
  129.         return false;
  130.     }
  131. };
  132.  
  133. template<>
  134. class myAllocator<void>
  135. {
  136.     public:
  137.     typedef size_t      size_type;
  138.     typedef ptrdiff_t   difference_type;
  139.     typedef void        *pointer;
  140.     typedef const void  *const_pointer;
  141.     typedef void        value_type;
  142.  
  143.     template<typename U>
  144.     struct rebind
  145.     {
  146.         typedef myAllocator<U>  other;
  147.     };
  148. };
  149.  
  150. int main()
  151. {
  152.     /* tell STL containers to use our allocator */
  153.     vector< int, myAllocator<int> > v;
  154.     list< int, myAllocator<int> >   l;
  155.  
  156.     for( int i = 0; i < 50; ++i )
  157.     {
  158.         v.push_back( i + 1 );
  159.         l.push_back( i + 1 );
  160.     }
  161.  
  162.     for( vector<int>::size_type i = 0; i < 50; ++i )
  163.         cout << ' ' << v[i];
  164.  
  165.     cout << endl;
  166.  
  167.     for( list<int>::iterator it = l.begin(); it != l.end(); ++it )
  168.         cout << ' ' << *it;
  169.  
  170.     cout << endl;
  171.  
  172.     return 0;
  173. }
  174.  
  175.  
  176.  
Compilation error #stdin compilation error #stdout 0s 0KB
comments ()
stdin
copy 
Standard input is empty
compilation info 
prog.cpp:47:13: error: ‘ptrdiff_t’ does not name a type
prog.cpp:138:13: error: ‘ptrdiff_t’ does not name a type
stdout
copy 
Standard output is empty
https://ideone.com/0KFQGQ
language:
C++ (gcc 8.3)
created:
11 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!