Class template polymorphic

Class template polymorphic_allocator

boost::container::pmr::polymorphic_allocator

Synopsis

// In header: <boost/container/pmr/polymorphic_allocator.hpp>

template<typename T> 
class polymorphic_allocator {
public:
  // types
  typedef  ;

  // construct/copy/destruct
  () ;
  (memory_resource *) ;
  () ;
  template<typename U> 
    () ;
   () ;

  // public member functions
   ();
   (, ) ;
  template<typename U,  Args>  (, );
  template<typename U>  ();
   () ;
  memory_resource * () ;
};

Description

A specialization of class template polymorphic_allocator conforms to the Allocator requirements. Constructed with different memory resources, different instances of the same specialization of polymorphic_allocator can exhibit entirely different allocation behavior. This runtime polymorphism allows objects that use polymorphic_allocator to behave as if they used different allocator types at run time even though they use the same static allocator type.

`polymorphic_allocator` public construct/copy/destruct

```
() ;
```
Effects: Sets m_resource to get_default_resource().
```
(memory_resource * r) ;
```
Requires: r is non-null.

Effects: Sets m_resource to r.

Throws: Nothing

Notes: This constructor provides an implicit conversion from memory_resource*.
```
( other) ;
```
Effects: Sets m_resource to other.resource().
```
template<typename U> 
  ( other) ;
```
Effects: Sets m_resource to other.resource().
```
 
( other) ;
```
Effects: Sets m_resource to other.resource().

`polymorphic_allocator` public member functions

```
 ( n);
```
Returns: Equivalent to static_cast<T*>(m_resource->allocate(n * sizeof(T), alignof(T))).
```
 ( p,  n) ;
```
Requires: p was allocated from a memory resource, x, equal to *m_resource, using x.allocate(n * sizeof(T), alignof(T)).

Effects: Equivalent to m_resource->deallocate(p, n * sizeof(T), alignof(T)).

Throws: Nothing.
```
template<typename U,  Args>  ( p,  args);
```
Requires: Uses-allocator construction of T with allocator *this and constructor arguments std::forward<Args>(args)... is well-formed. [Note: uses-allocator construction is always well formed for types that do not use allocators. - end note]

Effects: Construct a T object at p by uses-allocator construction with allocator *this and constructor arguments std::forward<Args>(args)....

Throws: Nothing unless the constructor for T throws.
```
template<typename U>  ( p);
```
Effects: p->~U().
```
 () ;
```
Returns: Equivalent to polymorphic_allocator().
```
memory_resource * () ;
```
Returns: m_resource.