class Foo { ... };
Foo* pf = new Foo;
...
delete pf;

// 標(biāo)識數(shù)據(jù)類型的成員變量，關(guān)于中間的6個變量的涵義見后續(xù)文章（關(guān)于Traits編程技巧）
typedef alloc _Alloc;
typedef size_t     size_type;
typedef ptrdiff_t  difference_type;
typedef _Tp*       pointer;
typedef const _Tp* const_pointer;
typedef _Tp&       reference;
typedef const _Tp& const_reference;
typedef _Tp        value_type;
template <class _Tp1> struct rebind {
  typedef allocator<_Tp1> other;
}; // 一個嵌套的class template，僅包含一個成員變量 other
// 成員函數(shù)
allocator() __STL_NOTHROW {}  // 默認構(gòu)造函數(shù)，其中__STL_NOTHROW 在 stl_config.h中定義，要么為空，要么為 throw()
allocator(const allocator&) __STL_NOTHROW {}  // 拷貝構(gòu)造函數(shù)
template <class _Tp1> allocator(const allocator<_Tp1>&) __STL_NOTHROW {} // 泛化的拷貝構(gòu)造函數(shù)
~allocator() __STL_NOTHROW {} // 析構(gòu)函數(shù)
pointer address(reference __x) const { return &__x; } // 返回對象的地址
const_pointer address(const_reference __x) const { return &__x; }  // 返回const對象的地址
_Tp* allocate(size_type __n, const void* = 0) {
  return __n != 0 ? static_cast<_Tp*>(_Alloc::allocate(__n * sizeof(_Tp))) : 0; 
  // 配置空間，如果申請的空間塊數(shù)不為0，那么調(diào)用 _Alloc 也即 alloc 的 allocate 函數(shù)來分配內(nèi)存，
} //這里的 alloc 在 SGI STL 中默認使用的是__default_alloc_template<__NODE_ALLOCATOR_THREADS, 0>這個實現(xiàn)（見第402行）
void deallocate(pointer __p, size_type __n) { _Alloc::deallocate(__p, __n * sizeof(_Tp)); } // 釋放空間
size_type max_size() const __STL_NOTHROW  // max_size() 函數(shù)，返回可成功配置的最大值
    { return size_t(-1) / sizeof(_Tp); }  //這里沒看懂，這里的size_t(-1)是什么意思？
void construct(pointer __p, const _Tp& __val) { new(__p) _Tp(__val); } // 調(diào)用 new 來給新變量分配空間并賦值
void destroy(pointer __p) { __p->~_Tp(); } // 調(diào)用 _Tp 的析構(gòu)函數(shù)來釋放空間

template <int __inst> class __malloc_alloc_template // Malloc-based allocator.  Typically slower than default alloc
typedef __malloc_alloc_template<0> malloc_alloc
template<class _Tp, class _Alloc> class simple_alloc
template <class _Alloc> class debug_alloc
template <bool threads, int inst> class __default_alloc_template // Default node allocator.
typedef __default_alloc_template<__NODE_ALLOCATOR_THREADS, 0> alloc
typedef __default_alloc_template<false, 0> single_client_alloc
template <class _Tp>class allocator
template<>class allocator<void>
template <class _Tp, class _Alloc>struct __allocator
template <class _Alloc>class __allocator<void, _Alloc>

private:
#ifndef __STL_STATIC_TEMPLATE_MEMBER_BUG
  static void (* __malloc_alloc_oom_handler)();  // 函數(shù)指針
#endif
public:
  static void (* __set_malloc_handler(void (*__f)()))() // 設(shè)置函數(shù)指針的public方法
  {
    void (* __old)() = __malloc_alloc_oom_handler;
    __malloc_alloc_oom_handler = __f;
    return(__old);
  }

// line 152 ~ 155
#ifndef __STL_STATIC_TEMPLATE_MEMBER_BUG
template <int __inst>
void (* __malloc_alloc_template<__inst>::__malloc_alloc_oom_handler)() = 0;
#endif
// in _S_oom_malloc and _S_oom_realloc
__my_malloc_handler = __malloc_alloc_oom_handler;
if (0 == __my_malloc_handler) { __THROW_BAD_ALLOC; }
// in preprocess, line 41 ~ 50
#ifndef __THROW_BAD_ALLOC
#  if defined(__STL_NO_BAD_ALLOC) || !defined(__STL_USE_EXCEPTIONS)
#    include <stdio.h>
#    include <stdlib.h>
#    define __THROW_BAD_ALLOC fprintf(stderr, "out of memory\n"); exit(1)
#  else /* Standard conforming out-of-memory handling */
#    include <new>
#    define __THROW_BAD_ALLOC throw std::bad_alloc()
#  endif
#endif

private:
#if ! (defined(__SUNPRO_CC) || defined(__GNUC__))
    enum {_ALIGN = 8}; // 對齊大小
    enum {_MAX_BYTES = 128}; // 最大有內(nèi)置內(nèi)存池來分配的內(nèi)存大小
    enum {_NFREELISTS = 16}; // _MAX_BYTES/_ALIGN  // 空閑鏈表個數(shù)
# endif
  static size_t  _S_round_up(size_t __bytes) // 不是8的倍數(shù)，向上取整
    { return (((__bytes) + (size_t) _ALIGN-1) & ~((size_t) _ALIGN - 1)); }
__PRIVATE:
  union _Obj { // 空閑鏈表的每個node的定義
        union _Obj* _M_free_list_link;
        char _M_client_data[1];   };
  static _Obj* __STL_VOLATILE _S_free_list[]; // 空閑鏈表數(shù)組
  static size_t _S_freelist_index(size_t __bytes) { // __bytes 對應(yīng)的free list的index
        return (((__bytes) + (size_t)_ALIGN-1)/(size_t)_ALIGN - 1);
  }
  static void* _S_refill(size_t __n); // 從內(nèi)存池中申請空間并構(gòu)建free list，然后從free list中分配空間給用戶
  static char* _S_chunk_alloc(size_t __size, int& __nobjs); // 從內(nèi)存池中分配空間
  static char* _S_start_free;  // 內(nèi)存池空閑部分的起始地址
  static char* _S_end_free; // 內(nèi)存池結(jié)束地址
  static size_t _S_heap_size; // 內(nèi)存池堆大小，主要用于配置內(nèi)存池的大小

//// in __default_alloc_template
# ifdef __STL_THREADS
    static _STL_mutex_lock _S_node_allocator_lock; // 互斥鎖變量
# endif
class _Lock {
    public:
        _Lock() { __NODE_ALLOCATOR_LOCK; }
        ~_Lock() { __NODE_ALLOCATOR_UNLOCK; }
};
//// in preprocess
#ifdef __STL_THREADS
# include <stl_threads.h> // stl 的線程，只是對linux或windows線程的一個封裝
# define __NODE_ALLOCATOR_THREADS true
# ifdef __STL_SGI_THREADS
#   define __NODE_ALLOCATOR_LOCK if (threads && __us_rsthread_malloc) \
                { _S_node_allocator_lock._M_acquire_lock(); }  // 獲取鎖
#   define __NODE_ALLOCATOR_UNLOCK if (threads && __us_rsthread_malloc) \
                { _S_node_allocator_lock._M_release_lock(); }  // 釋放鎖
# else /* !__STL_SGI_THREADS */
#   define __NODE_ALLOCATOR_LOCK \
        { if (threads) _S_node_allocator_lock._M_acquire_lock(); }
#   define __NODE_ALLOCATOR_UNLOCK \
        { if (threads) _S_node_allocator_lock._M_release_lock(); }
# endif
#else /* !__STL_THREADS */
#   define __NODE_ALLOCATOR_LOCK
#   define __NODE_ALLOCATOR_UNLOCK
#   define __NODE_ALLOCATOR_THREADS false
#endif