|
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
sizearguments
for the same buffer.
template<class T> constexpr
T align_up(T value, std::size_t alignment) noexcept;
#include <boost/align/align_up.hpp>
T is not a
pointer type
alignment shall
be a power of two
A value at or after value
that is a multiple of alignment.
template<class T> constexpr
T align_down(T value, std::size_t alignment) noexcept;
#include <boost/align/align_down.hpp>
T is not a
pointer type
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 volatile void* ptr, std::size_t
alignment)
noexcept;
#include <boost/align/is_aligned.hpp>
alignment shall
be a power of two.
true if ptr is aligned on the boundary
specified by alignment,
otherwise false.
template<class T> constexpr
bool is_aligned(T value, std::size_t alignment) noexcept;
#include <boost/align/is_aligned.hpp>
T is not a
pointer type
alignment shall
be a power of two.
true if the value
of value is
aligned on the boundary specified by alignment,
otherwise false.
template<class T, std::size_t
Alignment =
1>
class aligned_allocator;
#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::add_lvalue_reference_t<T> reference;
typedef std::add_lvalue_reference_t<const
T>
const_reference;
typedef std::size_t
size_type;
typedef std::ptrdiff_t
difference_type;
typedef std::true_type
propagate_on_container_move_assignment;
typedef std::true_type
is_always_equal;
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 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 rebound 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 rebound 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.