Boost C++ 库

“...世界上最受推崇、设计最精良的 C++ 库项目之一。” — Herb Sutter 和 Andrei Alexandrescu, C++ Coding Standards

参考 - Boost C++ 函数库
PrevUpHomeNext

参考

函数
类
特性
宏
align
align_up
align_down
aligned_alloc
aligned_free
is_aligned

void* align(std::size_t alignment, std::size_t size, void*& ptr, std::size_t& space);

头文件

#include <boost/align/align.hpp>

效果

如果能够将由 ptr 指向、长度为 space 的缓冲区中，分配 size 字节、以 alignment 对齐的存储空间，则函数会将 ptr 更新为指向该存储空间的第一个可能地址，并将 space 减去用于对齐所占用的字节数。否则，函数不做任何操作。

要求
  • alignment 必须是 2 的幂。
  • ptr 必须指向至少 space 字节的连续存储空间。
返回
如果请求的对齐缓冲区无法放入可用空间，则返回空指针，否则返回调整后的 ptr 值。
注意

该函数会更新其 ptr 和 space 参数，以便可以使用不同的 alignment 和 size 参数对同一缓冲区重复调用。

template<class T> constexpr T align_up(T value, std::size_t alignment) noexcept;

头文件

#include <boost/align/align_up.hpp>

限制

T 不能是指针类型。

要求

alignment 必须是 2 的幂。

返回

大于或等于 value 且是 alignment 的倍数的某个值。

template<class T> constexpr T align_down(T value, std::size_t alignment) noexcept;

头文件

#include <boost/align/align_down.hpp>

限制

T 不能是指针类型。

要求

alignment 必须是 2 的幂。

返回

小于或等于 value 且是 alignment 的倍数的某个值。

void* aligned_alloc(std::size_t alignment, std::size_t size);

头文件

#include <boost/align/aligned_alloc.hpp>

效果

分配一个对象的空间，其对齐方式由 alignment 指定，大小由 size 指定，且其值是不确定的。

要求

alignment 必须是 2 的幂。

返回

返回空指针或指向已分配空间的指针。

注意

在某些平台上，分配的空间可能比 size 字节略大，以允许对齐。

void aligned_free(void* ptr);

头文件

#include <boost/align/aligned_alloc.hpp>

效果

释放 ptr 所指向的空间，使其可用于后续分配。如果 ptr 是空指针，则不执行任何操作。否则，如果该参数不匹配之前由 aligned_alloc() 函数返回的指针，或者该空间已被 aligned_free() 调用释放，则行为是未定义的。

要求

ptr 是空指针或之前由 aligned_alloc() 函数返回但尚未被 aligned_free() 调用释放的指针。

返回

函数 aligned_free() 不返回值。

bool is_aligned(const volatile void* ptr, std::size_t alignment) noexcept;

头文件

#include <boost/align/is_aligned.hpp>

要求

alignment 必须是 2 的幂。

返回

如果 ptr 按 alignment 指定的边界对齐，则返回 true，否则返回 false。

template<class T> constexpr bool is_aligned(T value, std::size_t alignment) noexcept;

头文件

#include <boost/align/is_aligned.hpp>

限制

T 不能是指针类型。

要求

alignment 必须是 2 的幂。

返回

如果 value 的值按 alignment 指定的边界对齐，则返回 true，否则返回 false。

aligned_allocator
aligned_allocator_adaptor
aligned_delete

template<class T, std::size_t Alignment = 1> class aligned_allocator;

头文件

#include <boost/align/aligned_allocator.hpp>

注意

通常，仅当容器不是基于节点的（例如 vector）时，使用具有最小 Alignment 值的对齐分配器才有用。对于基于节点的容器（例如 list），节点对象将具有最小对齐，而不是值类型对象。

成员类型
  1. typedef T value_type;
  2. typedef T* pointer;
  3. typedef const T* const_pointer;
  4. typedef void* void_pointer;
  5. typedef const void* const_void_pointer;
  6. typedef std::add_lvalue_reference_t<T> reference;
  7. typedef std::add_lvalue_reference_t<const T> const_reference;
  8. typedef std::size_t size_type;
  9. typedef std::ptrdiff_t difference_type;
  10. typedef std::true_type propagate_on_container_move_assignment;
  11. typedef std::true_type is_always_equal;
  12. template<class U> struct rebind { typedef aligned_allocator<U, Alignment> other; };
构造函数

aligned_allocator() = default;

效果

构造分配器。

template<class U> aligned_allocator(const aligned_allocator<U, Alignment>&) noexcept;

效果

构造分配器。

成员函数

除了析构函数外，从不同线程并发调用对齐分配器的成员函数不会引起数据竞争。这些函数的调用，如果分配或释放特定的存储单元，必须按照一个总的顺序进行，并且每一次释放调用都必须发生在下一次分配（如果有）之前。

pointer allocate(size_type size, const_void_pointer = 0);

返回

指向一个大小为 n * sizeof(T) 的数组存储的第一个元素的指针，该存储空间在指定的最小对齐和类型 T 的对象的对齐中取最大值进行对齐。

备注

存储空间通过调用 aligned_alloc(std::size_t, std::size_t) 来获取。

抛出

如果无法获得存储空间，则抛出 std::bad_alloc。

void deallocate(pointer ptr, size_type);

要求

ptr 必须是通过 allocate() 获取的指针值。

效果

释放 ptr 引用的存储空间。

备注

使用 aligned_free(void*)。

size_type max_size() const noexcept;

返回

调用 allocate(N) 可能成功所允许的最大 N 值。

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>

注意

此适配器可与指针类型为智能指针的 C++11 分配器一起使用，但适配器可以选择仅公开原始指针类型。

成员类型
  1. typedef typename Allocator::value_type value_type;
  2. typedef value_type* pointer;
  3. typedef const value_type* const_pointer;
  4. typedef void* void_pointer;
  5. typedef const void* const_void_pointer;
  6. typedef std::size_t size_type;
  7. typedef std::ptrdiff_t difference_type;
  8. template<class U> struct rebind { typedef aligned_allocator_adaptor<typename std::allocator_traits<Allocator>::template rebind_alloc<U>, Alignment> other; };
构造函数

aligned_allocator_adaptor() = default;

效果

对 Allocator 基类进行值初始化。

template<class A> aligned_allocator_adaptor(A&& alloc) noexcept;

要求

Allocator 必须可以从 A 构建。

效果

使用 std::forward<A>(alloc) 初始化 Allocator 基类。

template<class U> aligned_allocator_adaptor(const aligned_allocator_adaptor<U, Alignment>& other) noexcept;

要求

Allocator 必须可以从 A 构建。

效果

使用 other.base() 初始化 Allocator 基类。

成员函数

Allocator& base() noexcept;

返回

static_cast<Allocator&>(*this)

const Allocator& base() const noexcept;

返回

static_cast<const Allocator&>(*this)

pointer allocate(size_type size);

返回

指向一个大小为 n * sizeof(value_type) 的数组存储的第一个元素的指针，该存储空间在指定的最小对齐和类型 value_type 的对象的对齐中取最大值进行对齐。

备注

存储空间通过在对象 a2 上调用 A2::allocate() 来获取，其中 A2 是 base() 的一个重新绑定副本，且其 value_type 是实现定义的。

抛出

如果存储空间无法获得，则抛出从 A2::allocate() 抛出的异常。

pointer allocate(size_type size, const_void_pointer hint);

要求

hint 是通过在任何等效的分配器对象上调用 allocate() 获取的值，否则为 null 指针。

返回

指向一个大小为 n * sizeof(value_type) 的数组存储的第一个元素的指针，该存储空间在指定的最小对齐和类型 value_type 的对象的对齐中取最大值进行对齐。

备注

存储空间通过在对象 a2 上调用 A2::allocate() 来获取，其中 A2 是 base() 的一个重新绑定副本，且其 value_type 是实现定义的。

抛出

如果存储空间无法获得，则抛出从 A2::allocate() 抛出的异常。

void deallocate(pointer ptr, size_type size);

要求
  • ptr 必须是通过 allocate() 获取的指针值。
  • size 必须等于调用 allocate() 时传递给它的第一个参数值，该调用返回了 ptr。
效果
释放 ptr 引用的存储空间。
注意

在对象 a2 上调用 A2::deallocate()，其中 A2 是 base() 的一个重新绑定副本，且其 value_type 是实现定义的。

全局运算符

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()));

效果

调用 ~T() 在 ptr 上销毁对象，然后调用 aligned_free() 在 ptr 上释放已分配的内存。

注意

如果 T 是不完整类型，则程序是格式错误的。

alignment_of

template<class T> struct alignment_of;

头文件

#include <boost/align/alignment_of.hpp>

值

类型 T 的对齐要求，表示为一个类型为 std::size_t 的整数常量。当 T 是引用数组类型时，其值应为被引用类型的对齐。当 T 是数组类型时，其值应为元素类型的对齐。

要求

T 必须是完整对象类型，或其数组，或这些类型的引用。

BOOST_ALIGN_ASSUME_ALIGNED

BOOST_ALIGN_ASSUME_ALIGNED(ptr, alignment)

头文件

#include <boost/align/assume_aligned.hpp>

要求
  • alignment 必须是 2 的幂。
  • ptr 必须是可修改的。
效果
ptr 可以根据实现定义的方式进行修改，以告知编译器其对齐方式。
Copyright © 2014-2017 Glen Joseph Fernandes

根据 Boost 软件许可证，版本 1.0 分发。

PrevUpHomeNext