There are three general components to the allocator: a datum describing the characteristics of the memory pool, a policy class containing this pool that links instantiation types to common or individual pools, and a class inheriting from the policy class that is the actual allocator.

The datum describing pools characteristics is

  template<bool _Thread>
    class __pool

This class is parametrized on thread support, and is explicitly specialized for both multiple threads (with bool==true) and single threads (via bool==false.) It is possible to use a custom pool datum instead of the default class that is provided.

There are two distinct policy classes, each of which can be used with either type of underlying pool datum.

  template<bool _Thread>
    struct __common_pool_policy

  template<typename _Tp, bool _Thread>
    struct __per_type_pool_policy

The first policy, __common_pool_policy, implements a common pool. This means that allocators that are instantiated with different types, say char and long will both use the same pool. This is the default policy.

The second policy, __per_type_pool_policy, implements a separate pool for each instantiating type. Thus, char and long will use separate pools. This allows per-type tuning, for instance.

Putting this all together, the actual allocator class is

  template<typename _Tp, typename _Poolp = __default_policy>
    class __mt_alloc : public __mt_alloc_base<_Tp>,  _Poolp

This class has the interface required for standard library allocator classes, namely member functions allocate and deallocate, plus others.