<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Reference</title>
<link rel="stylesheet" href="../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.78.1">
<link rel="home" href="../index.html" title="The Boost C++ Libraries BoostBook Documentation Subset">
<link rel="up" href="../align.html" title="Chapter 2. Boost.Align">
<link rel="prev" href="examples.html" title="Examples">
<link rel="next" href="vocabulary.html" title="Vocabulary">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../boost.png"></td>
<td align="center"><a href="../../../index.html">Home</a></td>
<td align="center"><a href="../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="examples.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../align.html"><img src="../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="vocabulary.html"><img src="../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
<a name="align.reference"></a><a class="link" href="reference.html" title="Reference">Reference</a>
</h2></div></div></div>
<div class="toc"><dl class="toc">
<dt><span class="section"><a href="reference.html#align.reference.align">align</a></span></dt>
<dt><span class="section"><a href="reference.html#align.reference.aligned_alloc">aligned_alloc and aligned_free</a></span></dt>
<dt><span class="section"><a href="reference.html#align.reference.aligned_allocator">aligned_allocator</a></span></dt>
<dt><span class="section"><a href="reference.html#align.reference.aligned_allocator_adaptor">aligned_allocator_adaptor</a></span></dt>
<dt><span class="section"><a href="reference.html#align.reference.aligned_delete">aligned_delete</a></span></dt>
<dt><span class="section"><a href="reference.html#align.reference.alignment_of">alignment_of</a></span></dt>
<dt><span class="section"><a href="reference.html#align.reference.assume_aligned">assume_aligned</a></span></dt>
<dt><span class="section"><a href="reference.html#align.reference.is_aligned">is_aligned</a></span></dt>
</dl></div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="align.reference.align"></a><a class="link" href="reference.html#align.reference.align" title="align">align</a>
</h3></div></div></div>
<p>
The alignment function is used to obtain a pointer to the first address within
the specified buffer that is a multiple of the specified alignment value.
This function exists in the C++11 standard library but is provided in this
library for those C++11 and C++03 library implementations which do not yet
support it.
</p>
<h5>
<a name="align.reference.align.h0"></a>
<span class="phrase"><a name="align.reference.align.synopsis"></a></span><a class="link" href="reference.html#align.reference.align.synopsis">Header
<boost/align/align.hpp></a>
</h5>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
<span class="keyword">namespace</span> <span class="identifier">alignment</span> <span class="special">{</span>
<span class="keyword">void</span><span class="special">*</span> <span class="identifier">align</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">alignment</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">size</span><span class="special">,</span> <span class="keyword">void</span><span class="special">*&</span> <span class="identifier">ptr</span><span class="special">,</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span><span class="special">&</span> <span class="identifier">space</span><span class="special">);</span>
<span class="special">}</span>
<span class="special">}</span>
</pre>
<h5>
<a name="align.reference.align.h1"></a>
<span class="phrase"><a name="align.reference.align.align"></a></span><a class="link" href="reference.html#align.reference.align.align">Function
align</a>
</h5>
<pre class="programlisting"><span class="keyword">void</span><span class="special">*</span> <span class="identifier">align</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">alignment</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">size</span><span class="special">,</span> <span class="keyword">void</span><span class="special">*&</span> <span class="identifier">ptr</span><span class="special">,</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span><span class="special">&</span> <span class="identifier">space</span><span class="special">);</span>
</pre>
<div class="blockquote"><blockquote class="blockquote">
<p>
<span class="bold"><strong>Effects:</strong></span> If it is possible to fit <code class="computeroutput"><span class="identifier">size</span></code> bytes of storage aligned by <code class="computeroutput"><span class="identifier">alignment</span></code> into the buffer pointed to
by <code class="computeroutput"><span class="identifier">ptr</span></code> with length <code class="computeroutput"><span class="identifier">space</span></code>, the function updates <code class="computeroutput"><span class="identifier">ptr</span></code> to point to the first possible address
of such storage and decreases <code class="computeroutput"><span class="identifier">space</span></code>
by the number of bytes used for alignment. Otherwise, the function does
nothing.
</p>
<p>
<span class="bold"><strong>Requires:</strong></span>
</p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
<code class="computeroutput"><span class="identifier">alignment</span></code> shall be
a fundamental alignment value or an extended alignment value, and shall
be a power of two
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">ptr</span></code> shall point to
contiguous storage of at least <code class="computeroutput"><span class="identifier">space</span></code>
bytes
</li>
</ul></div>
<p>
<span class="bold"><strong>Returns:</strong></span> A null pointer if the requested
aligned buffer would not fit into the available space, otherwise the adjusted
value of <code class="computeroutput"><span class="identifier">ptr</span></code>.
</p>
<p>
<span class="bold"><strong>Note:</strong></span> The function updates its <code class="computeroutput"><span class="identifier">ptr</span></code> and <code class="computeroutput"><span class="identifier">space</span></code>
arguments so that it can be called repeatedly with possibly different
<code class="computeroutput"><span class="identifier">alignment</span></code> and <code class="computeroutput"><span class="identifier">size</span></code> arguments for the same buffer.
</p>
</blockquote></div>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="align.reference.aligned_alloc"></a><a class="link" href="reference.html#align.reference.aligned_alloc" title="aligned_alloc and aligned_free">aligned_alloc and aligned_free</a>
</h3></div></div></div>
<p>
The aligned allocation function is a replacement for <code class="computeroutput"><span class="special">::</span><span class="keyword">operator</span> <span class="keyword">new</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">no_throw_t</span><span class="special">&)</span></code> that allows requesting aligned memory.
The deallocation function replaces the corresponding <code class="computeroutput"><span class="special">::</span><span class="keyword">operator</span> <span class="keyword">delete</span><span class="special">(</span><span class="keyword">void</span><span class="special">*)</span></code>
function. This functionality is not yet provided by the C++ standard.
</p>
<h5>
<a name="align.reference.aligned_alloc.h0"></a>
<span class="phrase"><a name="align.reference.aligned_alloc.synopsis"></a></span><a class="link" href="reference.html#align.reference.aligned_alloc.synopsis">Header
<boost/align/aligned_alloc.hpp></a>
</h5>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
<span class="keyword">namespace</span> <span class="identifier">alignment</span> <span class="special">{</span>
<span class="keyword">void</span><span class="special">*</span> <span class="identifier">aligned_alloc</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">alignment</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">size</span><span class="special">);</span>
<span class="keyword">void</span> <span class="identifier">aligned_free</span><span class="special">(</span><span class="keyword">void</span><span class="special">*</span> <span class="identifier">ptr</span><span class="special">);</span>
<span class="special">}</span>
<span class="special">}</span>
</pre>
<h5>
<a name="align.reference.aligned_alloc.h1"></a>
<span class="phrase"><a name="align.reference.aligned_alloc.aligned_alloc"></a></span><a class="link" href="reference.html#align.reference.aligned_alloc.aligned_alloc">Function
aligned_alloc</a>
</h5>
<pre class="programlisting"><span class="keyword">void</span><span class="special">*</span> <span class="identifier">aligned_alloc</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">alignment</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">size</span><span class="special">);</span>
</pre>
<div class="blockquote"><blockquote class="blockquote">
<p>
<span class="bold"><strong>Effects:</strong></span> Allocates space for an object
whose alignment is specified by <code class="computeroutput"><span class="identifier">alignment</span></code>,
whose size is specified by <code class="computeroutput"><span class="identifier">size</span></code>,
and whose value is indeterminate. The value of <code class="computeroutput"><span class="identifier">alignment</span></code>
shall be a power of two.
</p>
<p>
<span class="bold"><strong>Requires:</strong></span> <code class="computeroutput"><span class="identifier">alignment</span></code>
shall be a power of two.
</p>
<p>
<span class="bold"><strong>Returns:</strong></span> A null pointer or a pointer to
the allocated space.
</p>
<p>
<span class="bold"><strong>Note:</strong></span> On certain platforms, the alignment
may be rounded up to <code class="computeroutput"><span class="keyword">alignof</span><span class="special">(</span><span class="keyword">void</span><span class="special">*)</span></code>
and the space allocated may be slightly larger than <code class="computeroutput"><span class="identifier">size</span></code>
bytes, by an additional <code class="computeroutput"><span class="keyword">sizeof</span><span class="special">(</span><span class="keyword">void</span><span class="special">*)</span></code>
and <code class="computeroutput"><span class="identifier">alignment</span> <span class="special">-</span>
<span class="number">1</span></code> bytes.
</p>
</blockquote></div>
<h5>
<a name="align.reference.aligned_alloc.h2"></a>
<span class="phrase"><a name="align.reference.aligned_alloc.aligned_free"></a></span><a class="link" href="reference.html#align.reference.aligned_alloc.aligned_free">Function
aligned_free</a>
</h5>
<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">aligned_free</span><span class="special">(</span><span class="keyword">void</span><span class="special">*</span> <span class="identifier">ptr</span><span class="special">);</span>
</pre>
<div class="blockquote"><blockquote class="blockquote">
<p>
<span class="bold"><strong>Effects:</strong></span> Causes the space pointed to by
<code class="computeroutput"><span class="identifier">ptr</span></code> to be deallocated,
that is, made available for further allocation. If <code class="computeroutput"><span class="identifier">ptr</span></code>
is a null pointer, no action occurs. Otherwise, if the argument does not
match a pointer earlier returned by the <code class="computeroutput"><span class="identifier">aligned_alloc</span></code>
function, or if the space has been deallocated by a call to <code class="computeroutput"><span class="identifier">aligned_free</span></code>, the behavior is undefined.
</p>
<p>
<span class="bold"><strong>Requires:</strong></span> <code class="computeroutput"><span class="identifier">ptr</span></code>
is a null pointer or a pointer earlier returned by the <code class="computeroutput"><span class="identifier">aligned_alloc</span></code>
function that has not been deallocated by a call to <code class="computeroutput"><span class="identifier">aligned_free</span></code>.
</p>
<p>
<span class="bold"><strong>Returns:</strong></span> The <code class="computeroutput"><span class="identifier">aligned_free</span></code>
function returns no value.
</p>
</blockquote></div>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="align.reference.aligned_allocator"></a><a class="link" href="reference.html#align.reference.aligned_allocator" title="aligned_allocator">aligned_allocator</a>
</h3></div></div></div>
<p>
The aligned allocator is a replacement for the default allocator, <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">allocator</span></code>,
that supports value types which are over-aligned. It also allows specifying
a minimum alignment value used for all allocations, via the optional template
parameter. An alignment aware allocator is not yet provided by the C++ standard.
</p>
<div class="tip"><table border="0" summary="Tip">
<tr>
<td rowspan="2" align="center" valign="top" width="25"><img alt="[Tip]" src="../../../doc/src/images/tip.png"></td>
<th align="left">Tip</th>
</tr>
<tr><td align="left" valign="top"><p>
Using the aligned allocator with a minimum alignment value is generally
only suitable with containers that are not node-based such as <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span></code>. With node-based containers, such
as list, the node object would have the minimum alignment instead of the
value type object.
</p></td></tr>
</table></div>
<h5>
<a name="align.reference.aligned_allocator.h0"></a>
<span class="phrase"><a name="align.reference.aligned_allocator.synopsis"></a></span><a class="link" href="reference.html#align.reference.aligned_allocator.synopsis">Header
<boost/align/aligned_allocator.hpp></a>
</h5>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
<span class="keyword">namespace</span> <span class="identifier">alignment</span> <span class="special">{</span>
<span class="keyword">template</span><span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">Alignment</span> <span class="special">=</span> <span class="number">1</span><span class="special">></span>
<span class="keyword">class</span> <span class="identifier">aligned_allocator</span><span class="special">;</span>
<span class="keyword">template</span><span class="special"><</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">Alignment</span><span class="special">></span>
<span class="keyword">class</span> <span class="identifier">aligned_allocator</span><span class="special"><</span><span class="keyword">void</span><span class="special">,</span> <span class="identifier">Alignment</span><span class="special">>;</span>
<span class="keyword">template</span><span class="special"><</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">Alignment</span><span class="special">></span>
<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==(</span><span class="keyword">const</span> <span class="identifier">aligned_allocator</span><span class="special"><</span><span class="identifier">T1</span><span class="special">,</span>
<span class="identifier">Alignment</span><span class="special">>&,</span> <span class="keyword">const</span> <span class="identifier">aligned_allocator</span><span class="special"><</span><span class="identifier">T2</span><span class="special">,</span>
<span class="identifier">Alignment</span><span class="special">>&)</span> <span class="keyword">noexcept</span><span class="special">;</span>
<span class="keyword">template</span><span class="special"><</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">Alignment</span><span class="special">></span>
<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!=(</span><span class="keyword">const</span> <span class="identifier">aligned_allocator</span><span class="special"><</span><span class="identifier">T1</span><span class="special">,</span>
<span class="identifier">Alignment</span><span class="special">>&,</span> <span class="keyword">const</span> <span class="identifier">aligned_allocator</span><span class="special"><</span><span class="identifier">T2</span><span class="special">,</span>
<span class="identifier">Alignment</span><span class="special">>&)</span> <span class="keyword">noexcept</span><span class="special">;</span>
<span class="special">}</span>
<span class="special">}</span>
</pre>
<h5>
<a name="align.reference.aligned_allocator.h1"></a>
<span class="phrase"><a name="align.reference.aligned_allocator.aligned_allocator"></a></span><a class="link" href="reference.html#align.reference.aligned_allocator.aligned_allocator">Class
template aligned_allocator</a>
</h5>
<pre class="programlisting"><span class="keyword">template</span><span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">Alignment</span> <span class="special">=</span> <span class="number">1</span><span class="special">></span>
<span class="keyword">class</span> <span class="identifier">aligned_allocator</span> <span class="special">{</span>
<span class="keyword">public</span><span class="special">:</span>
<span class="keyword">typedef</span> <span class="identifier">T</span> <span class="identifier">value_type</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">T</span><span class="special">*</span> <span class="identifier">pointer</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="keyword">const</span> <span class="identifier">T</span><span class="special">*</span> <span class="identifier">const_pointer</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="keyword">void</span><span class="special">*</span> <span class="identifier">void_pointer</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="keyword">const</span> <span class="keyword">void</span><span class="special">*</span> <span class="identifier">const_void_pointer</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">size_type</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">ptrdiff_t</span> <span class="identifier">difference_type</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">T</span><span class="special">&</span> <span class="identifier">reference</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="keyword">const</span> <span class="identifier">T</span><span class="special">&</span> <span class="identifier">const_reference</span><span class="special">;</span>
<span class="keyword">template</span><span class="special"><</span><span class="keyword">class</span> <span class="identifier">U</span><span class="special">></span>
<span class="keyword">struct</span> <span class="identifier">rebind</span> <span class="special">{</span>
<span class="keyword">typedef</span> <span class="identifier">aligned_allocator</span><span class="special"><</span><span class="identifier">U</span><span class="special">,</span> <span class="identifier">Alignment</span><span class="special">></span> <span class="identifier">other</span><span class="special">;</span>
<span class="special">};</span>
<span class="identifier">aligned_allocator</span><span class="special">()</span> <span class="special">=</span> <span class="keyword">default</span><span class="special">;</span>
<span class="keyword">template</span><span class="special"><</span><span class="keyword">class</span> <span class="identifier">U</span><span class="special">></span>
<span class="identifier">aligned_allocator</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">aligned_allocator</span><span class="special"><</span><span class="identifier">U</span><span class="special">,</span> <span class="identifier">Alignment</span><span class="special">>&)</span> <span class="keyword">noexcept</span><span class="special">;</span>
<span class="identifier">pointer</span> <span class="identifier">address</span><span class="special">(</span><span class="identifier">reference</span> <span class="identifier">value</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
<span class="identifier">const_pointer</span> <span class="identifier">address</span><span class="special">(</span><span class="identifier">const_reference</span> <span class="identifier">value</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
<span class="identifier">pointer</span> <span class="identifier">allocate</span><span class="special">(</span><span class="identifier">size_type</span> <span class="identifier">size</span><span class="special">,</span> <span class="identifier">const_void_pointer</span> <span class="special">=</span> <span class="number">0</span><span class="special">);</span>
<span class="keyword">void</span> <span class="identifier">deallocate</span><span class="special">(</span><span class="identifier">pointer</span> <span class="identifier">ptr</span><span class="special">,</span> <span class="identifier">size_type</span><span class="special">);</span>
<span class="identifier">size_type</span> <span class="identifier">max_size</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
<span class="keyword">template</span><span class="special"><</span><span class="keyword">class</span> <span class="identifier">U</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">Args</span><span class="special">></span>
<span class="keyword">void</span> <span class="identifier">construct</span><span class="special">(</span><span class="identifier">U</span><span class="special">*</span> <span class="identifier">ptr</span><span class="special">,</span> <span class="identifier">Args</span><span class="special">&&...</span> <span class="identifier">args</span><span class="special">);</span>
<span class="keyword">template</span><span class="special"><</span><span class="keyword">class</span> <span class="identifier">U</span><span class="special">></span>
<span class="keyword">void</span> <span class="identifier">destroy</span><span class="special">(</span><span class="identifier">U</span><span class="special">*</span> <span class="identifier">ptr</span><span class="special">);</span>
<span class="special">};</span>
<span class="keyword">template</span><span class="special"><</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">Alignment</span><span class="special">></span>
<span class="keyword">class</span> <span class="identifier">aligned_allocator</span><span class="special"><</span><span class="keyword">void</span><span class="special">,</span> <span class="identifier">Alignment</span><span class="special">></span> <span class="special">{</span>
<span class="keyword">public</span><span class="special">:</span>
<span class="keyword">typedef</span> <span class="keyword">void</span> <span class="identifier">value_type</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="keyword">void</span><span class="special">*</span> <span class="identifier">pointer</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="keyword">const</span> <span class="keyword">void</span><span class="special">*</span> <span class="identifier">const_pointer</span><span class="special">;</span>
<span class="keyword">template</span><span class="special"><</span><span class="keyword">class</span> <span class="identifier">U</span><span class="special">></span>
<span class="keyword">struct</span> <span class="identifier">rebind</span> <span class="special">{</span>
<span class="keyword">typedef</span> <span class="identifier">aligned_allocator</span><span class="special"><</span><span class="identifier">U</span><span class="special">,</span> <span class="identifier">Alignment</span><span class="special">></span> <span class="identifier">other</span><span class="special">;</span>
<span class="special">};</span>
<span class="special">};</span>
</pre>
<h5>
<a name="align.reference.aligned_allocator.h2"></a>
<span class="phrase"><a name="align.reference.aligned_allocator.members"></a></span><a class="link" href="reference.html#align.reference.aligned_allocator.members">Members</a>
</h5>
<p>
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.
</p>
<pre class="programlisting"><span class="identifier">pointer</span> <span class="identifier">address</span><span class="special">(</span><span class="identifier">reference</span> <span class="identifier">value</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre>
<div class="blockquote"><blockquote class="blockquote"><p>
<span class="bold"><strong>Returns:</strong></span> The actual address of the object
referenced by <code class="computeroutput"><span class="identifier">value</span></code>, even
in the presence of an overloaded <code class="computeroutput"><span class="keyword">operator</span><span class="special">&</span></code>.
</p></blockquote></div>
<pre class="programlisting"><span class="identifier">const_pointer</span> <span class="identifier">address</span><span class="special">(</span><span class="identifier">const_reference</span> <span class="identifier">value</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre>
<div class="blockquote"><blockquote class="blockquote"><p>
<span class="bold"><strong>Returns:</strong></span> The actual address of the object
referenced by <code class="computeroutput"><span class="identifier">value</span></code>, even
in the presence of an overloaded <code class="computeroutput"><span class="keyword">operator</span><span class="special">&</span></code>.
</p></blockquote></div>
<pre class="programlisting"><span class="identifier">pointer</span> <span class="identifier">allocate</span><span class="special">(</span><span class="identifier">size_type</span> <span class="identifier">size</span><span class="special">,</span> <span class="identifier">const_void_pointer</span> <span class="special">=</span> <span class="number">0</span><span class="special">);</span>
</pre>
<div class="blockquote"><blockquote class="blockquote">
<p>
<span class="bold"><strong>Returns:</strong></span> A pointer to the initial element
of an array of storage of size <code class="computeroutput"><span class="identifier">n</span>
<span class="special">*</span> <span class="keyword">sizeof</span><span class="special">(</span><span class="identifier">T</span><span class="special">)</span></code>,
aligned on the maximum of the minimum alignment specified and the alignment
of objects of type <code class="computeroutput"><span class="identifier">T</span></code>.
</p>
<p>
<span class="bold"><strong>Remark:</strong></span> The storage is obtained by calling
<code class="computeroutput"><span class="identifier">aligned_alloc</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span><span class="special">)</span></code>.
</p>
<p>
<span class="bold"><strong>Throws:</strong></span> <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">bad_alloc</span></code>
if the storage cannot be obtained.
</p>
</blockquote></div>
<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">deallocate</span><span class="special">(</span><span class="identifier">pointer</span> <span class="identifier">ptr</span><span class="special">,</span> <span class="identifier">size_type</span><span class="special">);</span>
</pre>
<div class="blockquote"><blockquote class="blockquote">
<p>
<span class="bold"><strong>Requires:</strong></span> <code class="computeroutput"><span class="identifier">ptr</span></code>
shall be a pointer value obtained from <code class="computeroutput"><span class="identifier">allocate</span><span class="special">()</span></code>.
</p>
<p>
<span class="bold"><strong>Effects:</strong></span> Deallocates the storage referenced
by <code class="computeroutput"><span class="identifier">ptr</span></code>.
</p>
<p>
<span class="bold"><strong>Remark:</strong></span> Uses <code class="computeroutput"><span class="identifier">alignment</span><span class="special">::</span><span class="identifier">aligned_free</span><span class="special">(</span><span class="keyword">void</span><span class="special">*)</span></code>.
</p>
</blockquote></div>
<pre class="programlisting"><span class="identifier">size_type</span> <span class="identifier">max_size</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre>
<div class="blockquote"><blockquote class="blockquote"><p>
<span class="bold"><strong>Returns:</strong></span> The largest value <code class="computeroutput"><span class="identifier">N</span></code> for which the call <code class="computeroutput"><span class="identifier">allocate</span><span class="special">(</span><span class="identifier">N</span><span class="special">)</span></code>
might succeed.
</p></blockquote></div>
<pre class="programlisting"><span class="keyword">template</span><span class="special"><</span><span class="keyword">class</span> <span class="identifier">U</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">Args</span><span class="special">></span>
<span class="keyword">void</span> <span class="identifier">construct</span><span class="special">(</span><span class="identifier">U</span><span class="special">*</span> <span class="identifier">ptr</span><span class="special">,</span> <span class="identifier">Args</span><span class="special">&&...</span> <span class="identifier">args</span><span class="special">);</span>
</pre>
<div class="blockquote"><blockquote class="blockquote"><p>
<span class="bold"><strong>Effects:</strong></span> <code class="computeroutput"><span class="special">::</span><span class="keyword">new</span><span class="special">((</span><span class="keyword">void</span><span class="special">*)</span><span class="identifier">ptr</span><span class="special">)</span> <span class="identifier">U</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">forward</span><span class="special"><</span><span class="identifier">Args</span><span class="special">>(</span><span class="identifier">args</span><span class="special">)...)</span></code>
</p></blockquote></div>
<pre class="programlisting"><span class="keyword">template</span><span class="special"><</span><span class="keyword">class</span> <span class="identifier">U</span><span class="special">></span>
<span class="keyword">void</span> <span class="identifier">destroy</span><span class="special">(</span><span class="identifier">U</span><span class="special">*</span> <span class="identifier">ptr</span><span class="special">);</span>
</pre>
<div class="blockquote"><blockquote class="blockquote"><p>
<span class="bold"><strong>Effects:</strong></span> <code class="computeroutput"><span class="identifier">ptr</span><span class="special">->~</span><span class="identifier">U</span><span class="special">()</span></code>
</p></blockquote></div>
<h5>
<a name="align.reference.aligned_allocator.h3"></a>
<span class="phrase"><a name="align.reference.aligned_allocator.globals"></a></span><a class="link" href="reference.html#align.reference.aligned_allocator.globals">Globals</a>
</h5>
<pre class="programlisting"><span class="keyword">template</span><span class="special"><</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">Alignment</span><span class="special">></span>
<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==(</span><span class="keyword">const</span> <span class="identifier">aligned_allocator</span><span class="special"><</span><span class="identifier">T1</span><span class="special">,</span>
<span class="identifier">Alignment</span><span class="special">>&,</span> <span class="keyword">const</span> <span class="identifier">aligned_allocator</span><span class="special"><</span><span class="identifier">T2</span><span class="special">,</span>
<span class="identifier">Alignment</span><span class="special">>&)</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre>
<div class="blockquote"><blockquote class="blockquote"><p>
<span class="bold"><strong>Returns:</strong></span> <code class="computeroutput"><span class="keyword">true</span></code>.
</p></blockquote></div>
<pre class="programlisting"><span class="keyword">template</span><span class="special"><</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">Alignment</span><span class="special">></span>
<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!=(</span><span class="keyword">const</span> <span class="identifier">aligned_allocator</span><span class="special"><</span><span class="identifier">T1</span><span class="special">,</span>
<span class="identifier">Alignment</span><span class="special">>&,</span> <span class="keyword">const</span> <span class="identifier">aligned_allocator</span><span class="special"><</span><span class="identifier">T2</span><span class="special">,</span>
<span class="identifier">Alignment</span><span class="special">>&)</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre>
<div class="blockquote"><blockquote class="blockquote"><p>
<span class="bold"><strong>Returns:</strong></span> <code class="computeroutput"><span class="keyword">false</span></code>.
</p></blockquote></div>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="align.reference.aligned_allocator_adaptor"></a><a class="link" href="reference.html#align.reference.aligned_allocator_adaptor" title="aligned_allocator_adaptor">aligned_allocator_adaptor</a>
</h3></div></div></div>
<p>
The aligned allocator adaptor can turn any existing C++03 or C++11 allocator
into one that supports value types that are over-aligned. It also allows
specifying a minimum alignment value used for all allocations, via the optional
template parameter. An alignment aware allocator adaptor is not yet provided
by the C++ standard.
</p>
<div class="tip"><table border="0" summary="Tip">
<tr>
<td rowspan="2" align="center" valign="top" width="25"><img alt="[Tip]" src="../../../doc/src/images/tip.png"></td>
<th align="left">Tip</th>
</tr>
<tr><td align="left" valign="top"><p>
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.
</p></td></tr>
</table></div>
<h5>
<a name="align.reference.aligned_allocator_adaptor.h0"></a>
<span class="phrase"><a name="align.reference.aligned_allocator_adaptor.synopsis"></a></span><a class="link" href="reference.html#align.reference.aligned_allocator_adaptor.synopsis">Header
<boost/align/aligned_allocator_adaptor.hpp></a>
</h5>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
<span class="keyword">namespace</span> <span class="identifier">alignment</span> <span class="special">{</span>
<span class="keyword">template</span><span class="special"><</span><span class="keyword">class</span> <span class="identifier">Allocator</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">Alignment</span> <span class="special">=</span> <span class="number">1</span><span class="special">></span>
<span class="keyword">class</span> <span class="identifier">aligned_allocator_adaptor</span><span class="special">;</span>
<span class="keyword">template</span><span class="special"><</span><span class="keyword">class</span> <span class="identifier">A1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">A2</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">Alignment</span><span class="special">></span>
<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==(</span><span class="keyword">const</span> <span class="identifier">aligned_allocator_adaptor</span><span class="special"><</span><span class="identifier">A1</span><span class="special">,</span>
<span class="identifier">Alignment</span><span class="special">>&</span> <span class="identifier">a1</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">aligned_allocator_adaptor</span><span class="special"><</span><span class="identifier">A2</span><span class="special">,</span>
<span class="identifier">Alignment</span><span class="special">>&</span> <span class="identifier">a2</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
<span class="keyword">template</span><span class="special"><</span><span class="keyword">class</span> <span class="identifier">A1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">A2</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">Alignment</span><span class="special">></span>
<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!=(</span><span class="keyword">const</span> <span class="identifier">aligned_allocator_adaptor</span><span class="special"><</span><span class="identifier">A1</span><span class="special">,</span>
<span class="identifier">Alignment</span><span class="special">>&</span> <span class="identifier">a1</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">aligned_allocator_adaptor</span><span class="special"><</span><span class="identifier">A2</span><span class="special">,</span>
<span class="identifier">Alignment</span><span class="special">>&</span> <span class="identifier">a2</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
<span class="special">}</span>
<span class="special">}</span>
</pre>
<h5>
<a name="align.reference.aligned_allocator_adaptor.h1"></a>
<span class="phrase"><a name="align.reference.aligned_allocator_adaptor.aligned_allocator_adaptor"></a></span><a class="link" href="reference.html#align.reference.aligned_allocator_adaptor.aligned_allocator_adaptor">Class
template aligned_allocator_adaptor</a>
</h5>
<pre class="programlisting"><span class="keyword">template</span><span class="special"><</span><span class="keyword">class</span> <span class="identifier">Allocator</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">Alignment</span> <span class="special">=</span> <span class="number">1</span><span class="special">></span>
<span class="keyword">class</span> <span class="identifier">aligned_allocator_adaptor</span>
<span class="special">:</span> <span class="keyword">public</span> <span class="identifier">Allocator</span> <span class="special">{</span>
<span class="keyword">typedef</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">allocator_traits</span><span class="special"><</span><span class="identifier">Allocator</span><span class="special">></span> <span class="identifier">Traits</span><span class="special">;</span> <span class="comment">// exposition</span>
<span class="keyword">public</span><span class="special">:</span>
<span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">Traits</span><span class="special">::</span><span class="identifier">value_type</span> <span class="identifier">value_type</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">Traits</span><span class="special">::</span><span class="identifier">size_type</span> <span class="identifier">size_type</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">value_type</span><span class="special">*</span> <span class="identifier">pointer</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="keyword">const</span> <span class="identifier">value_type</span><span class="special">*</span> <span class="identifier">const_pointer</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="keyword">void</span><span class="special">*</span> <span class="identifier">void_pointer</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="keyword">const</span> <span class="keyword">void</span><span class="special">*</span> <span class="identifier">const_void_pointer</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">ptrdiff_t</span> <span class="identifier">difference_type</span><span class="special">;</span>
<span class="keyword">template</span><span class="special"><</span><span class="keyword">class</span> <span class="identifier">U</span><span class="special">></span>
<span class="keyword">struct</span> <span class="identifier">rebind</span> <span class="special">{</span>
<span class="keyword">typedef</span> <span class="identifier">aligned_allocator_adaptor</span><span class="special"><</span><span class="keyword">typename</span> <span class="identifier">Traits</span><span class="special">::</span><span class="keyword">template</span>
<span class="identifier">rebind_alloc</span><span class="special"><</span><span class="identifier">U</span><span class="special">>,</span> <span class="identifier">Alignment</span><span class="special">></span> <span class="identifier">other</span><span class="special">;</span>
<span class="special">};</span>
<span class="identifier">aligned_allocator_adaptor</span><span class="special">()</span> <span class="special">=</span> <span class="keyword">default</span><span class="special">;</span>
<span class="keyword">template</span><span class="special"><</span><span class="keyword">class</span> <span class="identifier">A</span><span class="special">></span>
<span class="keyword">explicit</span> <span class="identifier">aligned_allocator_adaptor</span><span class="special">(</span><span class="identifier">A</span><span class="special">&&</span> <span class="identifier">alloc</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
<span class="keyword">template</span><span class="special"><</span><span class="keyword">class</span> <span class="identifier">U</span><span class="special">></span>
<span class="identifier">aligned_allocator_adaptor</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">aligned_allocator_adaptor</span><span class="special"><</span><span class="identifier">U</span><span class="special">,</span>
<span class="identifier">Alignment</span><span class="special">>&</span> <span class="identifier">other</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
<span class="identifier">Allocator</span><span class="special">&</span> <span class="identifier">base</span><span class="special">()</span> <span class="keyword">noexcept</span><span class="special">;</span>
<span class="keyword">const</span> <span class="identifier">Allocator</span><span class="special">&</span> <span class="identifier">base</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
<span class="identifier">pointer</span> <span class="identifier">allocate</span><span class="special">(</span><span class="identifier">size_type</span> <span class="identifier">size</span><span class="special">);</span>
<span class="identifier">pointer</span> <span class="identifier">allocate</span><span class="special">(</span><span class="identifier">size_type</span> <span class="identifier">size</span><span class="special">,</span> <span class="identifier">const_void_pointer</span> <span class="identifier">hint</span><span class="special">);</span>
<span class="keyword">void</span> <span class="identifier">deallocate</span><span class="special">(</span><span class="identifier">pointer</span> <span class="identifier">ptr</span><span class="special">,</span> <span class="identifier">size_type</span> <span class="identifier">size</span><span class="special">);</span>
<span class="special">};</span>
</pre>
<h5>
<a name="align.reference.aligned_allocator_adaptor.h2"></a>
<span class="phrase"><a name="align.reference.aligned_allocator_adaptor.constructors"></a></span><a class="link" href="reference.html#align.reference.aligned_allocator_adaptor.constructors">Constructors</a>
</h5>
<pre class="programlisting"><span class="identifier">aligned_allocator_adaptor</span><span class="special">()</span> <span class="special">=</span> <span class="keyword">default</span><span class="special">;</span>
</pre>
<div class="blockquote"><blockquote class="blockquote"><p>
<span class="bold"><strong>Effects:</strong></span> Value-initializes the <code class="computeroutput"><span class="identifier">Allocator</span></code> base class.
</p></blockquote></div>
<pre class="programlisting"><span class="keyword">template</span><span class="special"><</span><span class="keyword">class</span> <span class="identifier">A</span><span class="special">></span>
<span class="keyword">explicit</span> <span class="identifier">aligned_allocator_adaptor</span><span class="special">(</span><span class="identifier">A</span><span class="special">&&</span> <span class="identifier">alloc</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre>
<div class="blockquote"><blockquote class="blockquote">
<p>
<span class="bold"><strong>Requires:</strong></span> <code class="computeroutput"><span class="identifier">Allocator</span></code>
shall be constructible from <code class="computeroutput"><span class="identifier">A</span></code>.
</p>
<p>
<span class="bold"><strong>Effects:</strong></span> Initializes the <code class="computeroutput"><span class="identifier">Allocator</span></code> base class with <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">forward</span><span class="special"><</span><span class="identifier">A</span><span class="special">>(</span><span class="identifier">alloc</span><span class="special">)</span></code>.
</p>
</blockquote></div>
<pre class="programlisting"><span class="keyword">template</span><span class="special"><</span><span class="keyword">class</span> <span class="identifier">U</span><span class="special">></span>
<span class="identifier">aligned_allocator_adaptor</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">aligned_allocator_adaptor</span><span class="special"><</span><span class="identifier">U</span><span class="special">,</span>
<span class="identifier">Alignment</span><span class="special">>&</span> <span class="identifier">other</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre>
<div class="blockquote"><blockquote class="blockquote">
<p>
<span class="bold"><strong>Requires:</strong></span> <code class="computeroutput"><span class="identifier">Allocator</span></code>
shall be constructible from <code class="computeroutput"><span class="identifier">A</span></code>.
</p>
<p>
<span class="bold"><strong>Effects:</strong></span> Initializes the <code class="computeroutput"><span class="identifier">Allocator</span></code> base class with <code class="computeroutput"><span class="identifier">other</span><span class="special">.</span><span class="identifier">base</span><span class="special">()</span></code>.
</p>
</blockquote></div>
<h5>
<a name="align.reference.aligned_allocator_adaptor.h3"></a>
<span class="phrase"><a name="align.reference.aligned_allocator_adaptor.members"></a></span><a class="link" href="reference.html#align.reference.aligned_allocator_adaptor.members">Members</a>
</h5>
<pre class="programlisting"><span class="identifier">Allocator</span><span class="special">&</span> <span class="identifier">base</span><span class="special">()</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre>
<div class="blockquote"><blockquote class="blockquote"><p>
<span class="bold"><strong>Returns:</strong></span> <code class="computeroutput"><span class="keyword">static_cast</span><span class="special"><</span><span class="identifier">Allocator</span><span class="special">&>(*</span><span class="keyword">this</span><span class="special">)</span></code>
</p></blockquote></div>
<pre class="programlisting"><span class="keyword">const</span> <span class="identifier">Allocator</span><span class="special">&</span> <span class="identifier">base</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre>
<div class="blockquote"><blockquote class="blockquote"><p>
<span class="bold"><strong>Returns:</strong></span> <code class="computeroutput"><span class="keyword">static_cast</span><span class="special"><</span><span class="keyword">const</span> <span class="identifier">Allocator</span><span class="special">&>(*</span><span class="keyword">this</span><span class="special">)</span></code>
</p></blockquote></div>
<pre class="programlisting"><span class="identifier">pointer</span> <span class="identifier">allocate</span><span class="special">(</span><span class="identifier">size_type</span> <span class="identifier">size</span><span class="special">);</span>
</pre>
<div class="blockquote"><blockquote class="blockquote">
<p>
<span class="bold"><strong>Returns:</strong></span> A pointer to the initial element
of an array of storage of size <code class="computeroutput"><span class="identifier">n</span>
<span class="special">*</span> <span class="keyword">sizeof</span><span class="special">(</span><span class="identifier">value_type</span><span class="special">)</span></code>, aligned on the maximum of the minimum
alignment specified and the alignment of objects of type <code class="computeroutput"><span class="identifier">value_type</span></code>.
</p>
<p>
<span class="bold"><strong>Remark:</strong></span> The storage is obtained by calling
<code class="computeroutput"><span class="identifier">A2</span><span class="special">::</span><span class="identifier">allocate</span></code> on an object <code class="computeroutput"><span class="identifier">a2</span></code>,
where <code class="computeroutput"><span class="identifier">a2</span></code> of type <code class="computeroutput"><span class="identifier">A2</span></code> is a rebound copy of <code class="computeroutput"><span class="identifier">base</span><span class="special">()</span></code>
where its <code class="computeroutput"><span class="identifier">value_type</span></code> is
unspecified.
</p>
<p>
<span class="bold"><strong>Throws:</strong></span> Throws an exception thrown from
<code class="computeroutput"><span class="identifier">A2</span><span class="special">::</span><span class="identifier">allocate</span></code> if the storage cannot be obtained.
</p>
</blockquote></div>
<pre class="programlisting"><span class="identifier">pointer</span> <span class="identifier">allocate</span><span class="special">(</span><span class="identifier">size_type</span> <span class="identifier">size</span><span class="special">,</span> <span class="identifier">const_void_pointer</span> <span class="identifier">hint</span><span class="special">);</span>
</pre>
<div class="blockquote"><blockquote class="blockquote">
<p>
<span class="bold"><strong>Requires:</strong></span> <code class="computeroutput"><span class="identifier">hint</span></code>
is a value obtained by calling <code class="computeroutput"><span class="identifier">allocate</span><span class="special">()</span></code> on any equivalent aligned allocator adaptor
object, or else <code class="computeroutput"><span class="keyword">nullptr</span></code>.
</p>
<p>
<span class="bold"><strong>Returns:</strong></span> A pointer to the initial element
of an array of storage of size <code class="computeroutput"><span class="identifier">n</span>
<span class="special">*</span> <span class="keyword">sizeof</span><span class="special">(</span><span class="identifier">value_type</span><span class="special">)</span></code>, aligned on the maximum of the minimum
alignment specified and the alignment of objects of type <code class="computeroutput"><span class="identifier">value_type</span></code>.
</p>
<p>
<span class="bold"><strong>Remark:</strong></span> The storage is obtained by calling
<code class="computeroutput"><span class="identifier">A2</span><span class="special">::</span><span class="identifier">allocate</span></code> on an object <code class="computeroutput"><span class="identifier">a2</span></code>,
where <code class="computeroutput"><span class="identifier">a2</span></code> of type <code class="computeroutput"><span class="identifier">A2</span></code> is a rebound copy of <code class="computeroutput"><span class="identifier">base</span><span class="special">()</span></code>
where its <code class="computeroutput"><span class="identifier">value_type</span></code> is
unspecified.
</p>
<p>
<span class="bold"><strong>Throws:</strong></span> Throws an exception thrown from
<code class="computeroutput"><span class="identifier">A2</span><span class="special">::</span><span class="identifier">allocate</span></code> if the storage cannot be obtained.
</p>
</blockquote></div>
<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">deallocate</span><span class="special">(</span><span class="identifier">pointer</span> <span class="identifier">ptr</span><span class="special">,</span> <span class="identifier">size_type</span> <span class="identifier">size</span><span class="special">);</span>
</pre>
<div class="blockquote"><blockquote class="blockquote">
<p>
<span class="bold"><strong>Requires:</strong></span>
</p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
<code class="computeroutput"><span class="identifier">ptr</span></code> shall be a pointer
value obtained from <code class="computeroutput"><span class="identifier">allocate</span><span class="special">()</span></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">size</span></code> shall equal the
value passed as the first argument to the invocation of <code class="computeroutput"><span class="identifier">allocate</span><span class="special">()</span></code>
which returned <code class="computeroutput"><span class="identifier">ptr</span></code>
</li>
</ul></div>
<p>
<span class="bold"><strong>Effects:</strong></span> Deallocates the storage referenced
by <code class="computeroutput"><span class="identifier">ptr</span></code>.
</p>
</blockquote></div>
<p>
<span class="bold"><strong>Note:</strong></span> Uses <code class="computeroutput"><span class="identifier">A2</span><span class="special">::</span><span class="identifier">deallocate</span></code>
on an object <code class="computeroutput"><span class="identifier">a2</span></code>, where <code class="computeroutput"><span class="identifier">a2</span></code> of type <code class="computeroutput"><span class="identifier">A2</span></code>
is a rebound copy of <code class="computeroutput"><span class="identifier">base</span><span class="special">()</span></code> where its <code class="computeroutput"><span class="identifier">value_type</span></code>
is unspecified.
</p>
<h5>
<a name="align.reference.aligned_allocator_adaptor.h4"></a>
<span class="phrase"><a name="align.reference.aligned_allocator_adaptor.globals"></a></span><a class="link" href="reference.html#align.reference.aligned_allocator_adaptor.globals">Globals</a>
</h5>
<pre class="programlisting"><span class="keyword">template</span><span class="special"><</span><span class="keyword">class</span> <span class="identifier">A1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">A2</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">Alignment</span><span class="special">></span>
<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==(</span><span class="keyword">const</span> <span class="identifier">aligned_allocator_adaptor</span><span class="special"><</span><span class="identifier">A1</span><span class="special">,</span>
<span class="identifier">Alignment</span><span class="special">>&</span> <span class="identifier">a1</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">aligned_allocator_adaptor</span><span class="special"><</span><span class="identifier">A2</span><span class="special">,</span>
<span class="identifier">Alignment</span><span class="special">>&</span> <span class="identifier">a2</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre>
<div class="blockquote"><blockquote class="blockquote"><p>
<span class="bold"><strong>Returns:</strong></span> <code class="computeroutput"><span class="identifier">a1</span><span class="special">.</span><span class="identifier">base</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">a2</span><span class="special">.</span><span class="identifier">base</span><span class="special">()</span></code>
</p></blockquote></div>
<pre class="programlisting"><span class="keyword">template</span><span class="special"><</span><span class="keyword">class</span> <span class="identifier">A1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">A2</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">Alignment</span><span class="special">></span>
<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!=(</span><span class="keyword">const</span> <span class="identifier">aligned_allocator_adaptor</span><span class="special"><</span><span class="identifier">A1</span><span class="special">,</span>
<span class="identifier">Alignment</span><span class="special">>&</span> <span class="identifier">a1</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">aligned_allocator_adaptor</span><span class="special"><</span><span class="identifier">A2</span><span class="special">,</span>
<span class="identifier">Alignment</span><span class="special">>&</span> <span class="identifier">a2</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre>
<div class="blockquote"><blockquote class="blockquote"><p>
<span class="bold"><strong>Returns:</strong></span> <code class="computeroutput"><span class="special">!(</span><span class="identifier">a1</span> <span class="special">==</span> <span class="identifier">a2</span><span class="special">)</span></code>
</p></blockquote></div>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="align.reference.aligned_delete"></a><a class="link" href="reference.html#align.reference.aligned_delete" title="aligned_delete">aligned_delete</a>
</h3></div></div></div>
<p>
The aligned deleter class is convenient utility for destroying and then deallocating
the constructed objects that were allocated using aligned allocation function
provided in this library. It serves as a replacement for the <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">default_delete</span></code>
class for this case.
</p>
<h5>
<a name="align.reference.aligned_delete.h0"></a>
<span class="phrase"><a name="align.reference.aligned_delete.synopsis"></a></span><a class="link" href="reference.html#align.reference.aligned_delete.synopsis">Header
<boost/align/aligned_delete.hpp></a>
</h5>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
<span class="keyword">namespace</span> <span class="identifier">alignment</span> <span class="special">{</span>
<span class="keyword">class</span> <span class="identifier">aligned_delete</span><span class="special">;</span>
<span class="special">}</span>
<span class="special">}</span>
</pre>
<h5>
<a name="align.reference.aligned_delete.h1"></a>
<span class="phrase"><a name="align.reference.aligned_delete.aligned_delete"></a></span><a class="link" href="reference.html#align.reference.aligned_delete.aligned_delete">Class
aligned_delete</a>
</h5>
<pre class="programlisting"><span class="keyword">class</span> <span class="identifier">aligned_delete</span> <span class="special">{</span>
<span class="keyword">public</span><span class="special">:</span>
<span class="keyword">template</span><span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span>
<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">()(</span><span class="identifier">T</span><span class="special">*</span> <span class="identifier">ptr</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">(</span><span class="keyword">noexcept</span><span class="special">(</span><span class="identifier">ptr</span><span class="special">->~</span><span class="identifier">T</span><span class="special">()));</span>
<span class="special">};</span>
</pre>
<h5>
<a name="align.reference.aligned_delete.h2"></a>
<span class="phrase"><a name="align.reference.aligned_delete.members"></a></span><a class="link" href="reference.html#align.reference.aligned_delete.members">Members</a>
</h5>
<pre class="programlisting"><span class="keyword">template</span><span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span>
<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">()(</span><span class="identifier">T</span><span class="special">*</span> <span class="identifier">ptr</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">(</span><span class="keyword">noexcept</span><span class="special">(</span><span class="identifier">ptr</span><span class="special">->~</span><span class="identifier">T</span><span class="special">()));</span>
</pre>
<div class="blockquote"><blockquote class="blockquote">
<p>
<span class="bold"><strong>Effects:</strong></span> Calls <code class="computeroutput"><span class="special">~</span><span class="identifier">T</span><span class="special">()</span></code> on
<code class="computeroutput"><span class="identifier">ptr</span></code> to destroy the object
and then calls <code class="computeroutput"><span class="identifier">alignment</span><span class="special">::</span><span class="identifier">aligned_free</span></code>
on <code class="computeroutput"><span class="identifier">ptr</span></code> to free the allocated
memory.
</p>
<p>
<span class="bold"><strong>Note:</strong></span> If <code class="computeroutput"><span class="identifier">T</span></code>
is an incomplete type, the program is ill-formed.
</p>
</blockquote></div>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="align.reference.alignment_of"></a><a class="link" href="reference.html#align.reference.alignment_of" title="alignment_of">alignment_of</a>
</h3></div></div></div>
<p>
The alignment type trait is used to query the alignment requirement of a
type at compile time. It is provided by the C++11 standard library but is
provided in this library for C++11 and C++03 implementations that do not
provide this functionality.
</p>
<h5>
<a name="align.reference.alignment_of.h0"></a>
<span class="phrase"><a name="align.reference.alignment_of.synopsis"></a></span><a class="link" href="reference.html#align.reference.alignment_of.synopsis">Header
<boost/align/alignment_of.hpp></a>
</h5>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
<span class="keyword">namespace</span> <span class="identifier">alignment</span> <span class="special">{</span>
<span class="keyword">template</span><span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span>
<span class="keyword">struct</span> <span class="identifier">alignment_of</span><span class="special">;</span>
<span class="special">}</span>
<span class="special">}</span>
</pre>
<h5>
<a name="align.reference.alignment_of.h1"></a>
<span class="phrase"><a name="align.reference.alignment_of.alignment_of"></a></span><a class="link" href="reference.html#align.reference.alignment_of.alignment_of">Type
trait alignment_of</a>
</h5>
<pre class="programlisting"><span class="keyword">template</span><span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span>
<span class="keyword">struct</span> <span class="identifier">alignment_of</span>
<span class="special">:</span> <span class="identifier">integral_constant</span><span class="special"><</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span><span class="special">,</span> <span class="keyword">alignof</span><span class="special">(</span><span class="identifier">T</span><span class="special">)></span> <span class="special">{</span>
<span class="special">};</span>
</pre>
<div class="blockquote"><blockquote class="blockquote">
<p>
<span class="bold"><strong>Value:</strong></span> The alignment requirement of the
type <code class="computeroutput"><span class="identifier">T</span></code> as an integral constant
of type <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span></code>. When <code class="computeroutput"><span class="identifier">T</span></code>
is a reference array type, the value shall be the alignment of the referenced
type. When <code class="computeroutput"><span class="identifier">T</span></code> is an array
type, the value shall be the alignment of the element type.
</p>
<p>
<span class="bold"><strong>Requires:</strong></span> <code class="computeroutput"><span class="identifier">T</span></code>
shall be a complete object type, or an array thereof, or a reference to
one of those types.
</p>
</blockquote></div>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="align.reference.assume_aligned"></a><a class="link" href="reference.html#align.reference.assume_aligned" title="assume_aligned">assume_aligned</a>
</h3></div></div></div>
<p>
The alignment hint macro can be used to inform the compiler of the alignment
of a memory block, to enable vectorizing or other compiler specific alignment
related optimizations.
</p>
<h5>
<a name="align.reference.assume_aligned.h0"></a>
<span class="phrase"><a name="align.reference.assume_aligned.synopsis"></a></span><a class="link" href="reference.html#align.reference.assume_aligned.synopsis">Header
<boost/align/assume_aligned.hpp></a>
</h5>
<pre class="programlisting"><span class="identifier">BOOST_ALIGN_ASSUME_ALIGNED</span><span class="special">(</span><span class="identifier">ptr</span><span class="special">,</span> <span class="identifier">alignment</span><span class="special">)</span>
</pre>
<h5>
<a name="align.reference.assume_aligned.h1"></a>
<span class="phrase"><a name="align.reference.assume_aligned.assume_aligned"></a></span><a class="link" href="reference.html#align.reference.assume_aligned.assume_aligned">Macro
BOOST_ALIGN_ASSUME_ALIGNED</a>
</h5>
<pre class="programlisting"><span class="identifier">BOOST_ALIGN_ASSUME_ALIGNED</span><span class="special">(</span><span class="identifier">ptr</span><span class="special">,</span> <span class="identifier">alignment</span><span class="special">)</span>
</pre>
<div class="blockquote"><blockquote class="blockquote">
<p>
<span class="bold"><strong>Requires:</strong></span>
</p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
<code class="computeroutput"><span class="identifier">alignment</span></code> shall be
a power of two
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">ptr</span></code> shall be mutable
</li>
</ul></div>
<p>
<span class="bold"><strong>Effect:</strong></span> <code class="computeroutput"><span class="identifier">ptr</span></code>
may be modified in an implementation specific way to inform the compiler
of its alignment.
</p>
</blockquote></div>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="align.reference.is_aligned"></a><a class="link" href="reference.html#align.reference.is_aligned" title="is_aligned">is_aligned</a>
</h3></div></div></div>
<p>
The alignment validation function indicates whether or not an address is
a multiple of the specified alignment value. It is generally useful in assertions
to verify memory is correctly aligned. This functionality is not yet provided
by the C++ standard.
</p>
<h5>
<a name="align.reference.is_aligned.h0"></a>
<span class="phrase"><a name="align.reference.is_aligned.synopsis"></a></span><a class="link" href="reference.html#align.reference.is_aligned.synopsis">Header
<boost/align/is_aligned.hpp></a>
</h5>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
<span class="keyword">namespace</span> <span class="identifier">alignment</span> <span class="special">{</span>
<span class="keyword">bool</span> <span class="identifier">is_aligned</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">alignment</span><span class="special">,</span> <span class="keyword">const</span> <span class="keyword">void</span><span class="special">*</span> <span class="identifier">ptr</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
<span class="special">}</span>
<span class="special">}</span>
</pre>
<h5>
<a name="align.reference.is_aligned.h1"></a>
<span class="phrase"><a name="align.reference.is_aligned.is_aligned"></a></span><a class="link" href="reference.html#align.reference.is_aligned.is_aligned">Function
is_aligned</a>
</h5>
<pre class="programlisting"><span class="keyword">bool</span> <span class="identifier">is_aligned</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">alignment</span><span class="special">,</span> <span class="keyword">const</span> <span class="keyword">void</span><span class="special">*</span> <span class="identifier">ptr</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre>
<div class="blockquote"><blockquote class="blockquote">
<p>
<span class="bold"><strong>Requires:</strong></span> <code class="computeroutput"><span class="identifier">alignment</span></code>
shall be a power of two.
</p>
<p>
<span class="bold"><strong>Returns:</strong></span> <code class="computeroutput"><span class="keyword">true</span></code>
if the value of <code class="computeroutput"><span class="identifier">ptr</span></code> is
aligned on the boundary specified by <code class="computeroutput"><span class="identifier">alignment</span></code>,
otherwise <code class="computeroutput"><span class="keyword">false</span></code>.
</p>
</blockquote></div>
</div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2014, 2015 Glen Joseph Fernandes<p>
Distributed under the Boost Software License, Version 1.0.
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="examples.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../align.html"><img src="../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="vocabulary.html"><img src="../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>
