Boost C++ Libraries

allocator() noexcept;

Default constructor Never throws

allocator(const allocator &) noexcept;

Constructor from other allocator. Never throws

template<typename T2> allocator(const allocator< T2 > &) noexcept;

Constructor from related allocator. Never throws

pointer allocate(size_type count, const void * hint = 0);

Allocates memory for an array of count elements. Throws std::bad_alloc if there is no enough memory If Version is 2, this allocated memory can only be deallocated with deallocate() or (for Version == 2) deallocate_many()

void deallocate(pointer ptr, size_type) noexcept;

Deallocates previously allocated memory. Never throws

size_type max_size() const noexcept;

Returns the maximum number of elements that could be allocated. Never throws

std::pair< pointer, bool > 
allocation_command(allocation_type command, size_type limit_size, 
                   size_type preferred_size, size_type & received_size, 
                   pointer reuse = pointer());

An advanced function that offers in-place expansion shrink to fit and new allocation capabilities. Memory allocated with this function can only be deallocated with deallocate() or deallocate_many(). This function is available only with Version == 2

size_type size(pointer p) const noexcept;

Returns maximum the number of objects the previously allocated memory pointed by p can hold. Memory must not have been allocated with allocate_one or allocate_individual. This function is available only with Version == 2

pointer allocate_one();

Allocates just one object. Memory allocated with this function must be deallocated only with deallocate_one(). Throws bad_alloc if there is no enough memory This function is available only with Version == 2

void allocate_individual(std::size_t num_elements, 
                         multiallocation_chain & chain);

Allocates many elements of size == 1. Elements must be individually deallocated with deallocate_one() This function is available only with Version == 2

void deallocate_one(pointer p) noexcept;

Deallocates memory previously allocated with allocate_one(). You should never use deallocate_one to deallocate memory allocated with other functions different from allocate_one() or allocate_individual.

void deallocate_individual(multiallocation_chain & chain) noexcept;

Deallocates memory allocated with allocate_one() or allocate_individual(). This function is available only with Version == 2

void allocate_many(size_type elem_size, std::size_t n_elements, 
                   multiallocation_chain & chain);

Allocates many elements of size elem_size. Elements must be individually deallocated with deallocate() This function is available only with Version == 2

void allocate_many(const size_type * elem_sizes, size_type n_elements, 
                   multiallocation_chain & chain);

Allocates n_elements elements, each one of size elem_sizes[i] Elements must be individually deallocated with deallocate() This function is available only with Version == 2

void deallocate_many(multiallocation_chain & chain) noexcept;

Deallocates several elements allocated by allocate_many(), allocate(), or allocation_command(). This function is available only with Version == 2

friend void swap(self_t &, self_t &) noexcept;

Swaps two allocators, does nothing because this allocator is stateless

friend bool operator==(const allocator &, const allocator &) noexcept;

An allocator always compares to true, as memory allocated with one instance can be deallocated by another instance

friend bool operator!=(const allocator &, const allocator &) noexcept;

An allocator always compares to false, as memory allocated with one instance can be deallocated by another instance

std::pair< pointer, bool > 
priv_allocation_command(allocation_type command, std::size_t limit_size, 
                        std::size_t preferred_size, 
                        std::size_t & received_size, void * reuse_ptr);