quickcpplib::_xxx::aligned_allocator::aligned_allocator< T, Align, initialize > Class Template Reference

An STL allocator which allocates aligned memory. More...

#include "aligned_allocator.hpp"

Classes
struct	rebind

Public Types
enum	{ alignment = Align }
typedef T	value_type
typedef T *	pointer
typedef const T *	const_pointer
typedef T &	reference
typedef const T &	const_reference
typedef size_t	size_type
typedef ptrdiff_t	difference_type
typedef std::true_type	propagate_on_container_move_assignment

Public Member Functions
	aligned_allocator () noexcept
template<class U >
	aligned_allocator (const aligned_allocator< U, Align, initialize > &) noexcept
size_type	max_size () const noexcept
pointer	address (reference x) const noexcept
const_pointer	address (const_reference x) const noexcept
pointer	allocate (size_type n, typename aligned_allocator< void, Align, initialize >::const_pointer=0)
void	deallocate (pointer p, size_type) noexcept
template<class U , class... Args>
void	construct (U *p, Args &&...args)
void	destroy (pointer p)

Detailed Description

template<typename T, size_t Align = std::alignment_of<T>::value, bool initialize = true>
class quickcpplib::_xxx::aligned_allocator::aligned_allocator< T, Align, initialize >

An STL allocator which allocates aligned memory.

Stolen from http://stackoverflow.com/questions/12942548/making-stdvector-allocate-aligned-memory

Member Typedef Documentation

value_type

template<typename T , size_t Align = std::alignment_of<T>::value, bool initialize = true>

typedef T quickcpplib::_xxx::aligned_allocator::aligned_allocator< T, Align, initialize >::value_type

pointer

template<typename T , size_t Align = std::alignment_of<T>::value, bool initialize = true>

typedef T* quickcpplib::_xxx::aligned_allocator::aligned_allocator< T, Align, initialize >::pointer

const_pointer

template<typename T , size_t Align = std::alignment_of<T>::value, bool initialize = true>

typedef const T* quickcpplib::_xxx::aligned_allocator::aligned_allocator< T, Align, initialize >::const_pointer

reference

template<typename T , size_t Align = std::alignment_of<T>::value, bool initialize = true>

typedef T& quickcpplib::_xxx::aligned_allocator::aligned_allocator< T, Align, initialize >::reference

const_reference

template<typename T , size_t Align = std::alignment_of<T>::value, bool initialize = true>

typedef const T& quickcpplib::_xxx::aligned_allocator::aligned_allocator< T, Align, initialize >::const_reference

size_type

template<typename T , size_t Align = std::alignment_of<T>::value, bool initialize = true>

typedef size_t quickcpplib::_xxx::aligned_allocator::aligned_allocator< T, Align, initialize >::size_type

difference_type

template<typename T , size_t Align = std::alignment_of<T>::value, bool initialize = true>

typedef ptrdiff_t quickcpplib::_xxx::aligned_allocator::aligned_allocator< T, Align, initialize >::difference_type

propagate_on_container_move_assignment

template<typename T , size_t Align = std::alignment_of<T>::value, bool initialize = true>

typedef std::true_type quickcpplib::_xxx::aligned_allocator::aligned_allocator< T, Align, initialize >::propagate_on_container_move_assignment

Member Enumeration Documentation

anonymous enum

template<typename T , size_t Align = std::alignment_of<T>::value, bool initialize = true>

anonymous enum

Enumerator
alignment

    {
      alignment = Align
    };

Constructor & Destructor Documentation

aligned_allocator() [1/2]

template<typename T , size_t Align = std::alignment_of<T>::value, bool initialize = true>

quickcpplib::_xxx::aligned_allocator::aligned_allocator< T, Align, initialize >::aligned_allocator ( )

inlinenoexcept

{}

aligned_allocator() [2/2]

template<typename T , size_t Align = std::alignment_of<T>::value, bool initialize = true>

template<class U >

quickcpplib::_xxx::aligned_allocator::aligned_allocator< T, Align, initialize >::aligned_allocator ( const aligned_allocator< U, Align, initialize > &  )

inlinenoexcept

{}

Member Function Documentation

max_size()

template<typename T , size_t Align = std::alignment_of<T>::value, bool initialize = true>

size_type quickcpplib::_xxx::aligned_allocator::aligned_allocator< T, Align, initialize >::max_size ( ) const

inlinenoexcept

{ return (size_type(~0) - size_type(Align)) / sizeof(T); }

address() [1/2]

template<typename T , size_t Align = std::alignment_of<T>::value, bool initialize = true>

pointer quickcpplib::_xxx::aligned_allocator::aligned_allocator< T, Align, initialize >::address ( reference  x ) const

inlinenoexcept

{ return std::addressof(x); }

address() [2/2]

template<typename T , size_t Align = std::alignment_of<T>::value, bool initialize = true>

const_pointer quickcpplib::_xxx::aligned_allocator::aligned_allocator< T, Align, initialize >::address ( const_reference  x ) const

inlinenoexcept

{ return std::addressof(x); }

allocate()

template<typename T , size_t Align = std::alignment_of<T>::value, bool initialize = true>

pointer quickcpplib::_xxx::aligned_allocator::aligned_allocator< T, Align, initialize >::allocate ( size_type  n, typename aligned_allocator< void, Align, initialize >::const_pointer  = 0  )

inline

    {
      const size_type alignment = static_cast<size_type>(Align);
      void *ptr = detail::allocate_aligned_memory(alignment, n * sizeof(T));
      if(ptr == nullptr)
      {
#ifdef __cpp_exceptions
        throw std::bad_alloc();
#else
        abort();
#endif
      }
 
      return reinterpret_cast<pointer>(ptr);
    }

deallocate()

template<typename T , size_t Align = std::alignment_of<T>::value, bool initialize = true>

void quickcpplib::_xxx::aligned_allocator::aligned_allocator< T, Align, initialize >::deallocate ( pointer  p, size_type    )

inlinenoexcept

{ return detail::deallocate_aligned_memory(p); }

construct()

template<typename T , size_t Align = std::alignment_of<T>::value, bool initialize = true>

template<class U , class... Args>

void quickcpplib::_xxx::aligned_allocator::aligned_allocator< T, Align, initialize >::construct ( U *  p, Args &&...  args  )

inline

    {
      if(initialize || !std::is_same<char, U>::value)
        ::new(reinterpret_cast<void *>(p)) U(std::forward<Args>(args)...);
    }

destroy()

template<typename T , size_t Align = std::alignment_of<T>::value, bool initialize = true>

void quickcpplib::_xxx::aligned_allocator::aligned_allocator< T, Align, initialize >::destroy ( pointer  p )

inline

    {
      (void) p;
      p->~T();
    }

---

The documentation for this class was generated from the following file:

• include/quickcpplib/aligned_allocator.hpp