|  | Home | Libraries | People | FAQ | More | 
          void*
          align(std::size_t alignment, std::size_t size, void*& ptr, std::size_t&
          space);
        
#include <boost/align/align.hpp>
              
                If it is possible to fit size
                bytes of storage aligned by alignment
                into the buffer pointed to by ptr
                with length space,
                the function updates ptr
                to point to the first possible address of such storage and decreases
                space by the number
                of bytes used for alignment. Otherwise, the function does nothing.
              
alignment shall
                    be a power of two
                  ptr shall point
                    to contiguous storage of at least space
                    bytes
                  ptr.
              
                The function updates its ptr
                and space arguments
                so that it can be called repeatedly with possibly different alignment and size
                arguments for the same buffer.
              
          constexpr std::size_t align_up(std::size_t value, std::size_t alignment)
          noexcept;
        
                #include <boost/align/align_up.hpp>
              
                alignment shall be
                a power of two
              
                A value at or after value
                that is a multiple of alignment.
              
          constexpr std::size_t align_down(std::size_t value, std::size_t alignment)
          noexcept;
        
                #include <boost/align/align_down.hpp>
              
                alignment shall be
                a power of two
              
                A value at or before value
                that is a multiple of alignment.
              
          void*
          aligned_alloc(std::size_t alignment, std::size_t size);
        
                #include <boost/align/aligned_alloc.hpp>
              
                Allocates space for an object whose alignment is specified by alignment, whose size is specified
                by size, and whose
                value is indeterminate.
              
                alignment shall be
                a power of two.
              
A null pointer or a pointer to the allocated space.
                On certain platforms, the space allocated may be slightly larger
                than size bytes,
                to allow for alignment.
              
          void aligned_free(void*
          ptr);
        
                #include <boost/align/aligned_alloc.hpp>
              
                Causes the space pointed to by ptr
                to be deallocated, that is, made available for further allocation.
                If ptr is a null
                pointer, no action occurs. Otherwise, if the argument does not match
                a pointer earlier returned by the aligned_alloc() function, or if the space has been
                deallocated by a call to aligned_free(), the behavior is undefined.
              
                ptr is a null pointer
                or a pointer earlier returned by the aligned_alloc() function that has not been deallocated
                by a call to aligned_free().
              
                The aligned_free() function returns no value.
              
          bool is_aligned(const void* ptr, std::size_t alignment)
          noexcept;
        
          constexpr bool
          is_aligned(std::size_t value, std::size_t alignment)
          noexcept;
        
                #include <boost/align/is_aligned.hpp>
              
                alignment shall be
                a power of two.
              
                true if the value of
                the first argument is aligned on the boundary specified by alignment, otherwise false.
              
          template<class T, std::size_t Alignment =
          1> class aligned_allocator;
        
          template<std::size_t Alignment> class aligned_allocator<void, Alignment>;
        
                #include <boost/align/aligned_allocator.hpp>
              
                Using the aligned allocator with a minimum Alignment value is generally
                only useful with containers that are not node-based such as vector. With node-based containers,
                such as list, the
                node object would have the minimum alignment instead of the value
                type object.
              
typedef T
              value_type;
            typedef T* pointer;
            typedef const
              T*
              const_pointer;
            typedef void* void_pointer;
            typedef const
              void*
              const_void_pointer;
            typedef std::size_t
              size_type;
            typedef std::ptrdiff_t
              difference_type;
            typedef T& reference;
            typedef const
              T&
              const_reference;
            template<class U> struct
              rebind {
              typedef aligned_allocator<U, Alignment> other; };
            
              aligned_allocator()
              = default;
            
Constructs the allocator.
              template<class U> aligned_allocator(const aligned_allocator<U, Alignment>&)
              noexcept;
            
Constructs the allocator.
Except for the destructor, member functions of the aligned allocator shall not introduce data races as a result of concurrent calls to those member functions from different threads. Calls to these functions that allocate or deallocate a particular unit of storage shall occur in a single total order, and each such deallocation call shall happen before the next allocation (if any) in this order.
              pointer address(reference
              value)
              const noexcept;
            
                    The actual address of the object referenced by value, even in the presence
                    of an overloaded operator&.
                  
              const_pointer address(const_reference
              value)
              const noexcept;
            
                    The actual address of the object referenced by value, even in the presence
                    of an overloaded operator&.
                  
              pointer allocate(size_type
              size,
              const_void_pointer =
              0);
            
                    A pointer to the initial element of an array of storage of size
                    n *
                    sizeof(T),
                    aligned on the maximum of the minimum alignment specified and
                    the alignment of objects of type T.
                  
                    The storage is obtained by calling aligned_alloc(std::size_t, std::size_t).
                  
                    std::bad_alloc if the storage cannot
                    be obtained.
                  
              void deallocate(pointer
              ptr,
              size_type);
            
                    ptr shall be
                    a pointer value obtained from allocate().
                  
                    Deallocates the storage referenced by ptr.
                  
                    Uses aligned_free(void*).
                  
              size_type max_size() const noexcept;
            
                    The largest value N
                    for which the call allocate(N) might succeed.
                  
              template<class U, class... Args> void
              construct(U* ptr, Args&&...
              args);
            
                    ::new((void*)ptr) U(std::forward<Args>(args)...).
                  
              template<class U> void
              destroy(U* ptr);
            
                    ptr->~U().
                  
              template<class T1, class T2, std::size_t Alignment> bool
              operator==(const aligned_allocator<T1, Alignment>&, const
              aligned_allocator<T2, Alignment>&)
              noexcept;
            
                    true
                  
              template<class T1, class T2, std::size_t Alignment> bool
              operator!=(const aligned_allocator<T1, Alignment>&, const
              aligned_allocator<T2, Alignment>&)
              noexcept;
            
                    false
                  
          template<class Allocator, std::size_t Alignment =
          1> class aligned_allocator_adaptor;
        
#include <boost/align/aligned_allocator_adaptor.hpp>
              This adaptor can be used with a C++11 Allocator whose pointer type is a smart pointer but the adaptor can choose to expose only raw pointer types.
typedef typename
              Allocator::value_type value_type;
            typedef value_type* pointer;
            typedef const
              value_type*
              const_pointer;
            typedef void* void_pointer;
            typedef const
              void*
              const_void_pointer;
            typedef std::size_t
              size_type;
            typedef std::ptrdiff_t
              difference_type;
            template<class U> struct
              rebind {
              typedef aligned_allocator_adaptor<typename
              std::allocator_traits<Allocator>::template rebind_alloc<U>, Alignment> other; };
            
              aligned_allocator_adaptor() = default;
            
                    Value-initializes the Allocator
                    base class.
                  
              template<class A> aligned_allocator_adaptor(A&& alloc) noexcept;
            
                    Allocator shall
                    be constructible from A.
                  
                    Initializes the Allocator
                    base class with std::forward<A>(alloc).
                  
              template<class U> aligned_allocator_adaptor(const aligned_allocator_adaptor<U, Alignment>&
              other)
              noexcept;
            
                    Allocator shall
                    be constructible from A.
                  
                    Initializes the Allocator
                    base class with other.base().
                  
              Allocator&
              base()
              noexcept;
            
                    static_cast<Allocator&>(*this)
                  
              const Allocator& base() const noexcept;
            
                    static_cast<const Allocator&>(*this)
                  
              pointer allocate(size_type
              size);
            
                    A pointer to the initial element of an array of storage of size
                    n *
                    sizeof(value_type),
                    aligned on the maximum of the minimum alignment specified and
                    the alignment of objects of type value_type.
                  
                    The storage is obtained by calling A2::allocate() on an object a2, where a2
                    of type A2 is
                    a rebind copy of base() where its value_type
                    is implementation defined.
                  
                    Throws an exception thrown from A2::allocate() if the storage cannot be obtained.
                  
              pointer allocate(size_type
              size,
              const_void_pointer hint);
            
                    hint is a value
                    obtained by calling allocate() on any equivalent allocator
                    object, or else a null pointer.
                  
                    A pointer to the initial element of an array of storage of size
                    n *
                    sizeof(value_type),
                    aligned on the maximum of the minimum alignment specified and
                    the alignment of objects of type value_type.
                  
                    The storage is obtained by calling A2::allocate() on an object a2, where a2
                    of type A2 is
                    a rebind copy of base() where its value_type
                    is an implementation defined.
                  
                    Throws an exception thrown from A2::allocate() if the storage cannot be obtained.
                  
              void deallocate(pointer
              ptr,
              size_type size);
            
ptr shall
                        be a pointer value obtained from allocate()
                      size shall
                        equal the value passed as the first argument to the invocation
                        of allocate() which returned ptr.
                      ptr.
                  
                    Uses A2::deallocate()
                    on an object a2,
                    where a2 of type
                    A2 is a rebound
                    copy of base() where its value_type
                    is implementation defined.
                  
              template<class A1, class A2, std::size_t Alignment> bool
              operator==(const aligned_allocator_adaptor<A1, Alignment>& a1, const aligned_allocator_adaptor<A2, Alignment>&
              a2)
              noexcept;
            
                    a1.base()
                    == a2.base()
                  
              template<class A1, class A2, std::size_t Alignment> bool
              operator!=(const aligned_allocator_adaptor<A1, Alignment>& a1, const aligned_allocator_adaptor<A2, Alignment>&
              a2)
              noexcept;
            
                    !(a1
                    == a2)
                  
          class aligned_delete;
        
#include <boost/align/aligned_delete.hpp>
              
              template<class T> void
              operator()(T* ptr) noexcept(noexcept(ptr->~T()));
            
                    Calls ~T() on ptr
                    to destroy the object and then calls aligned_free() on ptr
                    to free the allocated memory.
                  
                    If T is an incomplete
                    type, the program is ill-formed.
                  
          template<class T> struct alignment_of;
        
#include <boost/align/alignment_of.hpp>
              
                The alignment requirement of the type T
                as an integral constant of type std::size_t.
                When T is a reference
                array type, the value shall be the alignment of the referenced type.
                When T is an array
                type, the value shall be the alignment of the element type.
              
                T shall be a complete
                object type, or an array thereof, or a reference to one of those
                types.
              
          BOOST_ALIGN_ASSUME_ALIGNED(ptr, alignment)
        
                #include <boost/align/assume_aligned.hpp>
              
alignment shall
                    be a power of two
                  ptr shall be
                    mutable
                  ptr may be modified
                in an implementation specific way to inform the compiler of its alignment.