Boost C++ Libraries Home Libraries People FAQ More

PrevUpHomeNext

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 ;

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

  // public member functions
  T * (size_t);
  void (T *, size_t) ;
  template<typename U,  Args> void (U *, Args &&...);
  template<typename U> void (U *);
  polymorphic_allocator () ;
  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

  1. () ;

    Effects: Sets m_resource to get_default_resource().

  2. (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*.

  3. (const polymorphic_allocator & other) ;

    Effects: Sets m_resource to other.resource().

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

    Effects: Sets m_resource to other.resource().

  5. polymorphic_allocator & 
    (const polymorphic_allocator & other) ;

    Effects: Sets m_resource to other.resource().

polymorphic_allocator public member functions

  1. T * (size_t n);

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

  2. void (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,  Args> void (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 (U * p);

    Effects: p->~U().

  5. polymorphic_allocator () ;

    Returns: Equivalent to polymorphic_allocator().

  6. memory_resource * () ;

    Returns: m_resource.


PrevUpHomeNext