bad_allocation_size Class Reference
Core components

## Detailed Description

The exception class thrown when an allocation size is bigger than the supported maximum.

This size is either the node, array or alignment parameter in a call to an allocation function. If those exceed the supported maximum returned by `max_node_size()`, `max_array_size()` or `max_alignment()`, one of its derived classes will be thrown or this class if in a situation where the type is unknown. It is derived from `std::bad_alloc`. Throwing can be prohibited by the handler function.

Note
  Even if all parameters are less than the maximum, out_of_memory or a similar exception can be thrown, because the maximum functions return an upper bound and not the actual supported maximum size, since it always depends on fence memory, alignment buffer and the like.
  A user should only `catch` for `bad_allocation_size`, not the derived classes.
  Most checks will only be done if FOONATHAN_MEMORY_CHECK_ALLOCATION_SIZE is `true`.

## Typedefs

using | handler = void(*)(const allocator_info &info, std::size_t passed, std::size_t supported)
| The type of the handler called in the constructor of bad_allocation_size.

## Static Functions

static handler | set_handler (handler h)
static handler | get_handler ()

## Member Functions

| bad_allocation_size (const allocator_info &info, std::size_t passed, std::size_t supported)
const char * | what () const noexcept override
const allocator_info & | allocator () const noexcept
std::size_t | passed_value () const noexcept
std::size_t | supported_value () const noexcept

## Typedefs

## handler

using handler = void (*)(const allocator_info& info, std::size_t passed, std::size_t supported)

The type of the handler called in the constructor of bad_allocation_size.

When a bad allocation size is detected and the exception object created, this handler gets called. It is especially useful if exception support is disabled. It gets the allocator_info, the size passed to the function and the supported size (the latter is still an upper bound).

Required Behavior:
  It can log the error, throw a different exception derived from `std::bad_alloc` or abort the program. If it returns, this exception object will be created and thrown.

Default Behavior:
  On a hosted implementation it logs the error on `stderr` and continues execution, leading to this exception being thrown. On a freestanding implementation it does nothing.

## Constructors

## bad_allocation_size()

bad_allocation_size | ( | const allocator_info & | info,
|  | std::size_t | passed,
|  | std::size_t | supported
| ) |  |

Effects:
  Creates it by passing it the allocator_info, the size passed to the allocation function and an upper bound on the supported size. It also calls the handler to control whether or not it will be thrown.

## Member Functions

## set_handler()

static handler set_handler | ( | handler | h | ) |

static

Effects:
  Sets `h` as the new handler in an atomic operation. A `nullptr` sets the default handler.

Returns:
  The previous handler. This is never `nullptr`.

## get_handler()

static handler get_handler | ( |  | ) |

static

Returns:
  The current handler. This is never `nullptr`.

## what()

const char * what | ( |  | ) | const

override noexcept

Returns:
  A static NTBS that describes the error. It does not contain any specific information since there is no memory for formatting.

## allocator()

const allocator_info & allocator | ( |  | ) | const

noexcept

Returns:
  The allocator_info passed to it in the constructor.

## passed_value()

std::size_t passed_value | ( |  | ) | const

noexcept

Returns:
  The size or alignment value that was passed to the allocation function which was too big. This is the same value passed to the constructor.

## supported_value()

std::size_t supported_value | ( |  | ) | const

noexcept

Returns:
  An upper bound on the maximum supported size/alignment. It is only an upper bound, values below can fail, but values above will always fail.