| Home | Libraries | People | FAQ | More

## 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 T value_type;

      // construct/copy/destruct
      polymorphic_allocator() noexcept;
      polymorphic_allocator(memory_resource *);
      polymorphic_allocator(const polymorphic_allocator &);
      template<typename U>
        polymorphic_allocator(const polymorphic_allocator< U > &) noexcept;
      polymorphic_allocator & operator=(const polymorphic_allocator &);

      // public member functions
      T * allocate(size_t);
      void deallocate(T *, size_t);
      template<typename U, class ... Args> void construct(U *, Args &&...);
      template<typename U> void destroy(U *);
      polymorphic_allocator select_on_container_copy_construction() const;
      memory_resource * resource() const;
    };

## 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

1.     polymorphic_allocator() noexcept;

   Effects: Sets m_resource to `get_default_resource()`.

2.     polymorphic_allocator(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*. Non-standard extension: if r is null m_resource is set to get_default_resource().

3.     polymorphic_allocator(const polymorphic_allocator & other);

   Effects: Sets m_resource to other.resource().

4.     template<typename U>
         polymorphic_allocator(const polymorphic_allocator< U > & other) noexcept;

   Effects: Sets m_resource to other.resource().

5.     polymorphic_allocator & operator=(const polymorphic_allocator & other);

   Effects: Sets m_resource to other.resource().

### `polymorphic_allocator` public member functions

1.     T * allocate(size_t n);

   Returns: Equivalent to `static_cast<T*>(m_resource->allocate(n * sizeof(T), alignof(T)))`.

2.     void deallocate(T * p, size_t 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.

3.     template<typename U, class ... Args> void construct(U * p, Args &&... 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.

4.     template<typename U> void destroy(U * p);

   Effects: p->~U().

5.     polymorphic_allocator select_on_container_copy_construction() const;

   Returns: Equivalent to `polymorphic_allocator()`.

6.     memory_resource * resource() const;

   Returns: m_resource.