Функция выравнивания используется для получения указателя на первый адрес в указанном буфере, который является кратным указанному значению выравнивания. Эта функция существует в стандартной библиотеке C++11, но предоставляется в этой библиотеке для тех реализаций библиотеки C++11 и C++03, которые еще не поддерживают ее.

Header <boost/align/align.hpp>

namespace boost {
  namespace alignment {
    void* align(std::size_t alignment, std::size_t size, void*& ptr,
      std::size_t& space);
  }
}

Function align

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

Эффекты:Если возможно уместить<size>байты хранения, выровненные по<alignment>, в буфер, указанный по<ptr>с длиной<space>, функция обновляет<ptr>, чтобы указать первый возможный адрес такого хранения и уменьшает<space>на количество байтов, используемых для выравнивания. В противном случае функция ничего не делает.

Требуется:

Возвращение:Нулевой указатель, если запрашиваемый выровненный буфер не вписывается в доступное пространство, в противном случае скорректированное значение<ptr>.

Примечание:Функция обновляет свои аргументы<ptr>и<space>так, чтобы ее можно было называть многократно с возможно разными аргументами<alignment>и<size>для одного и того же буфера.

Функции направленного выравнивания могут использоваться с указателями или интегральными значениями для выравнивания вниз. Данная функциональность пока не предусмотрена стандартом C++.

Header <boost/align/align_down.hpp>

namespace boost {
  namespace alignment {
    constexpr std::size_t align_down(std::size_t value, std::size_t
      alignment) noexcept;
    void* align_down(void* ptr, std::size_t alignment) noexcept;
  }
}

Function align_down

void* align_down(void* ptr, std::size_t alignment) noexcept;

Требуется:

Возврат:Значение указателя в<ptr>или до<ptr>, которое по меньшей мере<alignment>байтов выровнено.

Функции направленного выравнивания могут использоваться с указателями или интегральными значениями для выравнивания. Данная функциональность пока не предусмотрена стандартом C++.

Header <boost/align/align_up.hpp>

namespace boost {
  namespace alignment {
    constexpr std::size_t align_up(std::size_t value, std::size_t
      alignment) noexcept;
    void* align_up(void* ptr, std::size_t alignment) noexcept;
  }
}

Function align_up

void* align_up(void* ptr, std::size_t alignment) noexcept;

Требуется:

Возвращение:Значение указателя в<ptr>или после<ptr>, которое по меньшей мере<alignment>байт выровнено.

Выровненная функция распределения является заменой<::operatornew(std::size_t,conststd::no_throw_t&)>, которая позволяет запрашивать выровненную память. Функция распределения дел заменяет соответствующую<::operatordelete(void*)>функцию. Данная функциональность пока не предусмотрена стандартом C++.

Header <boost/align/aligned_alloc.hpp>

namespace boost {
  namespace alignment {
    void* aligned_alloc(std::size_t alignment, std::size_t size);
    void aligned_free(void* ptr);
  }
}

Function aligned_alloc

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

Эффекты:Выделяет пространство для объекта, выравнивание которого определяется<alignment>, размер которого определяется<size>и значение которого неопределенно. Величина<alignment>будет равна двум.

Требует:<alignment>должна быть сила двух.

Возвращается:Нулевой указатель или указатель на выделенное пространство.

Примечание:На некоторых платформах выравнивание может быть округлено до<alignof(void*)>и выделенное пространство может быть немного больше<size>байтов, дополнительным<sizeof(void*)>и<alignment- 1>байтов.

Function aligned_free

void aligned_free(void* ptr);

Эффекты:Это приводит к тому, что пространство, на которое указывает<ptr>, распределяется, то есть предоставляется для дальнейшего распределения. Если<ptr>— нулевой указатель, то никакого действия не происходит. В противном случае, если аргумент не совпадает с указателем, ранее возвращенным функцией<aligned_alloc>, или если пространство было разделено призывом к<aligned_free>, поведение не определено.

Требует:<ptr>является нулевым указателем или указателем, ранее возвращенным функцией<aligned_alloc>, которая не была размещена по вызову<aligned_free>.

Возврат:Функция<aligned_free>не возвращает значения.

Выровненный распределитель является заменой для распределителя по умолчанию<std::allocator>, который поддерживает типы значений, которые чрезмерно выровнены. Он также позволяет указать минимальное значение выравнивания, используемое для всех распределений, с помощью дополнительного параметра шаблона. Выравнивающий осведомленный распределитель еще не предусмотрен стандартом C++.

	Tip
	Использование выровненного распределителя с минимальным значением выравнивания обычно подходит только для контейнеров, которые не основаны на узлах, таких как<std::vector>. С контейнерами на основе узлов, такими как список, объект узла будет иметь минимальное выравнивание вместо объекта типа значения.

Header <boost/align/aligned_allocator.hpp>

namespace boost {
  namespace alignment {
    template<class T, std::size_t Alignment = 1>
    class aligned_allocator;
    template<std::size_t Alignment>
    class aligned_allocator<void, Alignment>;
    template<class T1, class T2, std::size_t Alignment>
    bool operator==(const aligned_allocator<T1,
      Alignment>&, const aligned_allocator<T2,
      Alignment>&) noexcept;
    template<class T1, class T2, std::size_t Alignment>
    bool operator!=(const aligned_allocator<T1,
      Alignment>&, const aligned_allocator<T2,
      Alignment>&) noexcept;
  }
}

Class template aligned_allocator

template<class T, std::size_t Alignment = 1>
class aligned_allocator {
public:
    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;
    template<class U>
    aligned_allocator(const aligned_allocator<U, Alignment>&) noexcept;
    pointer address(reference value) const noexcept;
    const_pointer address(const_reference value) const noexcept;
    pointer allocate(size_type size, const_void_pointer = 0);
    void deallocate(pointer ptr, size_type);
    size_type max_size() const noexcept;
    template<class U, class... Args>
    void construct(U* ptr, Args&&... args);
    template<class U>
    void destroy(U* ptr);
};
template<std::size_t Alignment>
class aligned_allocator<void, Alignment> {
public:
    typedef void value_type;
    typedef void* pointer;
    typedef const void* const_pointer;
    template<class U>
    struct rebind {
        typedef aligned_allocator<U, Alignment> other;
    };
};

Members

За исключением деструктора, функции члена выровненного распределителя не должны вводить расы данных в результате одновременного вызова этих функций члена из разных потоков. Звонки в эти функции, которые распределяют или распределяют конкретную единицу хранения, должны происходить в одном общем порядке, и каждый такой вызов распределения должен происходить до следующего распределения (если таковое имеется) в этом порядке.

pointer address(reference value) const noexcept;

Возвращение:Фактический адрес объекта, на который ссылается<value>, даже при наличии перегруженного<operator&>.

const_pointer address(const_reference value) const noexcept;

Возвращение:Фактический адрес объекта, на который ссылается<value>, даже при наличии перегруженного<operator&>.

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>.

Использует<alignment::aligned_free(void*)>.

size_type max_size() const noexcept;

Возвращение:Самое большое значение<N>, для которого вызов<allocate(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()>

Globals

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>.

Выровненный адаптер распределителя может превратить любой существующий распределитель C++03 или C++11 в тот, который поддерживает типы значений, которые чрезмерно выровнены. Он также позволяет указать минимальное значение выравнивания, используемое для всех распределений, с помощью дополнительного параметра шаблона. Адаптер аллокатора выравнивания еще не предусмотрен стандартом C++.

	Tip
	Этот адаптер можно использовать с распределителем C++11, тип указателя которого является интеллектуальным указателем, но адаптер может выбирать только сырые типы указателей.

Header <boost/align/aligned_allocator_adaptor.hpp>

namespace boost {
  namespace alignment {
    template<class Allocator, std::size_t Alignment = 1>
    class aligned_allocator_adaptor;
    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;
    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;
  }
}

Class template aligned_allocator_adaptor

template<class Allocator, std::size_t Alignment = 1>
class aligned_allocator_adaptor
    : public Allocator {
    typedef std::allocator_traits<Allocator> Traits; // exposition
public:
    typedef typename Traits::value_type value_type;
    typedef typename Traits::size_type size_type;
    typedef value_type* pointer;
    typedef const value_type* const_pointer;
    typedef void* void_pointer;
    typedef const void* const_void_pointer;
    typedef std::ptrdiff_t difference_type;
    template<class U>
    struct rebind {
        typedef aligned_allocator_adaptor<typename Traits::template
            rebind_alloc<U>, Alignment> other;
    };
    aligned_allocator_adaptor() = default;
    template<class A>
    explicit aligned_allocator_adaptor(A&& alloc) noexcept;
    template<class U>
    aligned_allocator_adaptor(const aligned_allocator_adaptor<U,
        Alignment>& other) noexcept;
    Allocator& base() noexcept;
    const Allocator& base() const noexcept;
    pointer allocate(size_type size);
    pointer allocate(size_type size, const_void_pointer hint);
    void deallocate(pointer ptr, size_type size);
};

Constructors

aligned_allocator_adaptor() = default;

Эффекты:Ценность инициализирует базовый класс<Allocator>.

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

Требуется:<Allocator>должен быть сконструирован из<A>.

Эффекты:Инициирует базовый класс<Allocator>с<std::forward<A>(alloc)>.

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

Требуется:<Allocator>должен быть сконструирован из<A>.

Эффекты:Инициирует базовый класс<Allocator>с<other.base()>.

Members

Allocator& base() noexcept;

Возвращение:<static_cast<Allocator&>(*this)>

const Allocator& base() const noexcept;

Возвращение:<static_cast<constAllocator&>(*this)>

pointer allocate(size_type size);

Возвращает:Указатель на начальный элемент массива хранения размера<n *sizeof(value_type)>, выровненный по максимуму минимального заданного выравнивания и выравнивания объектов типа<value_type>.

Замечание:Хранилище получается путем вызова<A2::allocate>на объект<a2>, где<a2>типа<A2>является отскоком копии<base()>, где его<value_type>не указан.

Броски:Исключение выкидывает<A2::allocate>, если накопитель не может быть получен.

pointer allocate(size_type size, const_void_pointer hint);

Требуется:<hint>является значением, полученным путем вызова<allocate()>на любой эквивалентный выровненный объект адаптера распределителя, или же<nullptr>.

Возвращает:Указатель на начальный элемент массива хранения размера<n *sizeof(value_type)>, выровненный по максимуму минимального заданного выравнивания и выравнивания объектов типа<value_type>.

Замечание:Хранилище получается путем вызова<A2::allocate>на объект<a2>, где<a2>типа<A2>является отскоком копии<base()>, где его<value_type>не указан.

Броски:Исключение выкидывает<A2::allocate>, если накопитель не может быть получен.

void deallocate(pointer ptr, size_type size);

Требуется:

Эффекты:Выделяет хранилище, на которое ссылается<ptr>.

Примечание:Использует<A2::deallocate>на объекте<a2>, где<a2>типа<A2>является отскоком<base()>, где его<value_type>не указан.

Globals

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

Выровненный класс удаления - удобная утилита для уничтожения и последующего размещения построенных объектов, которые были выделены с использованием выровненной функции распределения, предоставленной в этой библиотеке. Он служит заменой классу<std::default_delete>для этого случая.

Header <boost/align/aligned_delete.hpp>

namespace boost {
  namespace alignment {
    class aligned_delete;
  }
}

Class aligned_delete

class aligned_delete {
public:
    template<class T>
    void operator()(T* ptr) const noexcept(noexcept(ptr->~T()));
};

Members

template<class T>
void operator()(T* ptr) const noexcept(noexcept(ptr->~T()));

Эффекты:Звонки<~T()>на<ptr>для уничтожения объекта, а затем вызовы<alignment::aligned_free>на<ptr>для освобождения выделенной памяти.

Примечание:Если<T>является неполным типом, программа плохо сформирована.

Черта типа выравнивания используется для запроса требования выравнивания типа во время компиляции. Он предоставляется стандартной библиотекой C++11, но предоставляется в этой библиотеке для реализаций C++11 и C++03, которые не обеспечивают эту функциональность.

Header <boost/align/alignment_of.hpp>

namespace boost {
  namespace alignment {
    template<class T>
    struct alignment_of;
    template<class T>
    constexpr std::size_t alignment_of_v = alignment_of<T>::value;
  }
}

Type trait alignment_of

template<class T>
struct alignment_of;

Значение:Требование выравнивания типа<T>как интегральной постоянной типа<std::size_t>. Если<T>является типом эталонного массива, то значение должно быть выравниванием этого типа. Если<T>является типом решетки, то значение должно соответствовать типу элемента.

Требуется:<T>должен быть полный тип объекта, или его массив, или ссылка на один из этих типов.

Макроподсказка выравнивания может использоваться для информирования компилятора о выравнивании блока памяти, для обеспечения векторизации или других оптимизаций, связанных с конкретным выравниванием компилятора.

Header <boost/align/assume_aligned.hpp>

BOOST_ALIGN_ASSUME_ALIGNED(ptr, alignment)

Macro BOOST_ALIGN_ASSUME_ALIGNED

BOOST_ALIGN_ASSUME_ALIGNED(ptr, alignment)

Требуется:

Эффект:<ptr>может быть изменен конкретным способом реализации для информирования компилятора о его выравнивании.

Функция проверки выравнивания указывает, является ли адрес кратным указанному значению выравнивания. Как правило, в утверждениях полезно проверить, правильно ли выровнена память. Данная функциональность пока не предусмотрена стандартом C++.

Header <boost/align/is_aligned.hpp>

namespace boost {
  namespace alignment {
    constexpr bool is_aligned(std::size_t value, std::size_t
      alignment) noexcept;
    bool is_aligned(const void* ptr, std::size_t alignment) noexcept;
  }
}

Function is_aligned

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

Требует:<alignment>должна быть сила двух.

Возврат:<true>, если значение<ptr>выровнено по границе, указанной<alignment>, в противном случае<false>.