stl_alloc.h

Introduction

This is an internal header file, included by other library headers. You should not attempt to use it directly.

Classes

__debug_alloc

__default_alloc_template

__malloc_alloc_template

__new_alloc

__simple_alloc

allocator

Functions

operator ==

template<int inst> inline bool operator==(
    const __malloc_alloc_template<inst>&, 
    const __malloc_alloc_template<inst>&) 

Discussion

Comparison operators for all of the predifined SGI-style allocators. This ensures that __allocator (for example) will work correctly. As required, all allocators compare equal.

Typedefs

// The fully general version. 
template<typename _Tp, typename _Allocator> struct _Alloc_traits { 
    static const bool _S_instanceless = false; 
    typedef typename _Allocator::template rebind<_Tp>::other allocator_type; 
};  

Discussion

@if maint Another allocator adaptor: _Alloc_traits. This serves two purposes. First, make it possible to write containers that can use either "SGI" style allocators or "standard" allocators. Second, provide a mechanism so that containers can query whether or not the allocator has distinct instances. If not, the container can avoid wasting a word of memory to store an empty object. For examples of use, see stl_vector.h, etc, or any of the other classes derived from this one.

This adaptor uses partial specialization. The general case of _Alloc_traits<_Tp, _Alloc> assumes that _Alloc is a standard-conforming allocator, possibly with non-equal instances and non-static members. (It still behaves correctly even if _Alloc has static member and if all instances are equal. Refinements affect performance, not correctness.)

There are always two members: allocator_type, which is a standard- conforming allocator type for allocating objects of type _Tp, and _S_instanceless, a static const member of type bool. If _S_instanceless is true, this means that there is no difference between any two instances of type allocator_type. Furthermore, if _S_instanceless is true, then _Alloc_traits has one additional member: _Alloc_type. This type encapsulates allocation and deallocation of objects of type _Tp through a static interface; it has two member functions, whose signatures are

- static _Tp* allocate(size_t) - static void deallocate(_Tp*, size_t)

The size_t parameters are "standard" style (see top of stl_alloc.h) in that they take counts, not sizes.

@endif (See allocators info @endlink for more.)

Structs and Unions

template<typename _Tp, typename _Alloc> struct __allocator { 
    _Alloc __underlying_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<typename _Tp1> struct rebind {
        typedef __allocator<_Tp1, _Alloc> other;
        };  
    __allocator() throw() {
        } __allocator(
        const __allocator& __a) throw() : __underlying_alloc(__a.__underlying_alloc) {
        }  template<typename _Tp1> __allocator(
        const __allocator<_Tp1, _Alloc>& __a) throw() : __underlying_alloc(__a.__underlying_alloc) {
        }  ~__allocator() throw() {
        }  pointer address(
        reference __x) const {
        return &__x;
        }  const_pointer address(
        const_reference __x) const {
        return &__x;
        }  // NB: __n is permitted to be 0. The C++ standard says nothing 
    // about what the return value is when __n == 0. 
    _Tp* allocate(size_type __n, const void* = 0) { 
        _Tp* __ret = 0; 
        if (
            __n) __ret = static_cast<_Tp*>(
            _Alloc::allocate(
                __n * sizeof(
                    _Tp))); 
        return __ret; 
        }  // __p is not permitted to be a null pointer. 
    void deallocate(pointer __p, size_type __n) {
        __underlying_alloc.deallocate(
            __p,
            __n * sizeof(
                _Tp));
        }  size_type max_size() const throw() {
        return size_t(
            -1) / sizeof(
            _Tp);
        }  void construct(pointer __p, const _Tp& __val) {
        new(
            __p) _Tp(
            __val);
        }  void destroy(pointer __p) {
        __p->~_Tp();
        } 
};  

Discussion

@if maint Allocator adaptor to turn an "SGI" style allocator (e.g., __alloc, __malloc_alloc_template) into a "standard" conforming allocator. Note that this adaptor does *not* assume that all objects of the underlying alloc class are identical, nor does it assume that all of the underlying alloc's member functions are static member functions. Note, also, that __allocator<_Tp, __alloc> is essentially the same thing as allocator<_Tp>. @endif (See allocators info @endlink for more.)