# memory_pool_allocator

Note

To enable this feature, set the `TBB_PREVIEW_MEMORY_POOL` macro to 1.

A class template that provides a memory pool with a C++ allocator interface.

## Description

`memory_pool_allocator` meets the allocator requirements from the [allocator.requirements] ISO C++ Standard section It also provides a constructor to allocate and deallocate memory. This constructor is linked with an instance of either the `memory_pool` or the `fixed_pool` class. The class is mainly intended for enabling memory pools within STL containers.

## API

### Header

    #include "oneapi/tbb/memory_pool.h"

### Synopsis

    namespace oneapi {
        namespace tbb {
            template<typename T>
            class memory_pool_allocator {
            public:
                using value_type = T;
                using pointer = value_type*;
                using const_pointer = const value_type*;
                using reference = value_type&;
                using const_reference = const value_type&;
                using size_type = size_t;
                using difference_type = ptrdiff_t;
                template<typename U> struct rebind {
                    using other = memory_pool_allocator<U>;
                };
                explicit memory_pool_allocator(memory_pool &pool) throw();
                explicit memory_pool_allocator(fixed_pool &pool) throw();
                memory_pool_allocator(const memory_pool_allocator& src) throw();
                template<typename U>
                memory_pool_allocator(const memory_pool_allocator<U,P>& src) throw();
                pointer address(reference x) const;
                const_pointer address(const_reference x) const;
                pointer allocate(size_type n, const void* hint=0);
                void deallocate(pointer p, size_type);
                size_type max_size() const throw();
                void construct(pointer p, const T& value);
                void destroy(pointer p);
            };

            template<>
            class memory_pool_allocator<void> {
            public:
                using pointer = void*;
                using const_pointer = const void*;
                using value_type = void;
                template<typename U> struct rebind {
                    using other = memory_pool_allocator<U>;
                };
                memory_pool_allocator(memory_pool &pool) throw();
                memory_pool_allocator(fixed_pool &pool) throw();
                memory_pool_allocator(const memory_pool_allocator& src) throw();
                template<typename U>
                memory_pool_allocator(const memory_pool_allocator<U>& src) throw();
            };
        } // namespace tbb
    } // namespace oneapi

    template<typename T, typename U>
    inline bool operator==( const memory_pool_allocator<T>& a,
                           const memory_pool_allocator<U>& b);
    template<typename T, typename U>
    inline bool operator!=( const memory_pool_allocator<T>& a,
                            const memory_pool_allocator<U>& b);

### Member Functions

explicit memory_pool_allocator(memory_pool &pool)

  Effects: Constructs a memory pool allocator serviced by `memory_pool` instance pool.

explicit memory_pool_allocator(fixed_pool &pool)

  Effects: Constructs a memory pool allocator serviced by `fixed_pool` instance pool.

## Examples

The code below provides a simple example of container construction with the use of a memory pool.

    #define TBB_PREVIEW_MEMORY_POOL 1
    #include "oneapi/tbb/memory_pool.h"
    #include <list>

    int main() {
        oneapi::tbb::memory_pool<std::allocator<int>> my_pool;

        typedef oneapi::tbb::memory_pool_allocator<int> pool_allocator_t;
        std::list<int, pool_allocator_t> my_list(pool_allocator_t{my_pool});

        my_list.emplace_back(1);
    }