[DEV] add v1.76.0

This commit is contained in:
2021-10-05 21:37:46 +02:00
parent a97e9ae7d4
commit d0115b733d
45133 changed files with 4744437 additions and 1026325 deletions

View File

@@ -0,0 +1,157 @@
<!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=UTF-8">
<title>Composition or inheritance</title>
<link rel="stylesheet" href="../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../index.html" title="The Boost C++ Libraries BoostBook Documentation Subset">
<link rel="up" href="../move.html" title="Chapter 25. Boost.Move">
<link rel="prev" href="implementing_movable_classes.html" title="Implementing copyable and movable classes">
<link rel="next" href="movable_only_classes.html" title="Movable but Non-Copyable Types">
</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="implementing_movable_classes.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../move.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="movable_only_classes.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="move.composition_inheritance"></a><a class="link" href="composition_inheritance.html" title="Composition or inheritance">Composition or inheritance</a>
</h2></div></div></div>
<p>
For classes made up of other classes (via either composition or inheritance),
the move constructor and move assignment can be easily coded using the <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">move</span></code>
function:
</p>
<p>
</p>
<pre class="programlisting"><span class="keyword">class</span> <span class="identifier">Base</span>
<span class="special">{</span>
<span class="identifier">BOOST_COPYABLE_AND_MOVABLE</span><span class="special">(</span><span class="identifier">Base</span><span class="special">)</span>
<span class="keyword">public</span><span class="special">:</span>
<span class="identifier">Base</span><span class="special">(){}</span>
<span class="identifier">Base</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Base</span> <span class="special">&amp;/*</span><span class="identifier">x</span><span class="special">*/)</span> <span class="special">{/**/}</span> <span class="comment">// Copy ctor</span>
<span class="identifier">Base</span><span class="special">(</span><span class="identifier">BOOST_RV_REF</span><span class="special">(</span><span class="identifier">Base</span><span class="special">)</span> <span class="comment">/*x*/</span><span class="special">)</span> <span class="special">{/**/}</span> <span class="comment">// Move ctor</span>
<span class="identifier">Base</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="identifier">BOOST_RV_REF</span><span class="special">(</span><span class="identifier">Base</span><span class="special">)</span> <span class="comment">/*x*/</span><span class="special">)</span>
<span class="special">{/**/</span> <span class="keyword">return</span> <span class="special">*</span><span class="keyword">this</span><span class="special">;}</span> <span class="comment">// Move assign</span>
<span class="identifier">Base</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="identifier">BOOST_COPY_ASSIGN_REF</span><span class="special">(</span><span class="identifier">Base</span><span class="special">)</span> <span class="comment">/*x*/</span><span class="special">)</span>
<span class="special">{/**/</span> <span class="keyword">return</span> <span class="special">*</span><span class="keyword">this</span><span class="special">;}</span> <span class="comment">// Copy assign</span>
<span class="keyword">virtual</span> <span class="identifier">Base</span> <span class="special">*</span><span class="identifier">clone</span><span class="special">()</span> <span class="keyword">const</span>
<span class="special">{</span> <span class="keyword">return</span> <span class="keyword">new</span> <span class="identifier">Base</span><span class="special">(*</span><span class="keyword">this</span><span class="special">);</span> <span class="special">}</span>
<span class="keyword">virtual</span> <span class="special">~</span><span class="identifier">Base</span><span class="special">(){}</span>
<span class="special">};</span>
<span class="keyword">class</span> <span class="identifier">Member</span>
<span class="special">{</span>
<span class="identifier">BOOST_COPYABLE_AND_MOVABLE</span><span class="special">(</span><span class="identifier">Member</span><span class="special">)</span>
<span class="keyword">public</span><span class="special">:</span>
<span class="identifier">Member</span><span class="special">(){}</span>
<span class="comment">// Compiler-generated copy constructor...</span>
<span class="identifier">Member</span><span class="special">(</span><span class="identifier">BOOST_RV_REF</span><span class="special">(</span><span class="identifier">Member</span><span class="special">))</span> <span class="special">{/**/}</span> <span class="comment">// Move ctor</span>
<span class="identifier">Member</span> <span class="special">&amp;</span><span class="keyword">operator</span><span class="special">=(</span><span class="identifier">BOOST_RV_REF</span><span class="special">(</span><span class="identifier">Member</span><span class="special">))</span> <span class="comment">// Move assign</span>
<span class="special">{/**/</span> <span class="keyword">return</span> <span class="special">*</span><span class="keyword">this</span><span class="special">;</span> <span class="special">}</span>
<span class="identifier">Member</span> <span class="special">&amp;</span><span class="keyword">operator</span><span class="special">=(</span><span class="identifier">BOOST_COPY_ASSIGN_REF</span><span class="special">(</span><span class="identifier">Member</span><span class="special">))</span> <span class="comment">// Copy assign</span>
<span class="special">{/**/</span> <span class="keyword">return</span> <span class="special">*</span><span class="keyword">this</span><span class="special">;</span> <span class="special">}</span>
<span class="special">};</span>
<span class="keyword">class</span> <span class="identifier">Derived</span> <span class="special">:</span> <span class="keyword">public</span> <span class="identifier">Base</span>
<span class="special">{</span>
<span class="identifier">BOOST_COPYABLE_AND_MOVABLE</span><span class="special">(</span><span class="identifier">Derived</span><span class="special">)</span>
<span class="identifier">Member</span> <span class="identifier">mem_</span><span class="special">;</span>
<span class="keyword">public</span><span class="special">:</span>
<span class="identifier">Derived</span><span class="special">(){}</span>
<span class="comment">// Compiler-generated copy constructor...</span>
<span class="identifier">Derived</span><span class="special">(</span><span class="identifier">BOOST_RV_REF</span><span class="special">(</span><span class="identifier">Derived</span><span class="special">)</span> <span class="identifier">x</span><span class="special">)</span> <span class="comment">// Move ctor</span>
<span class="special">:</span> <span class="identifier">Base</span><span class="special">(</span><span class="identifier">BOOST_MOVE_BASE</span><span class="special">(</span><span class="identifier">Base</span><span class="special">,</span> <span class="identifier">x</span><span class="special">)),</span>
<span class="identifier">mem_</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">x</span><span class="special">.</span><span class="identifier">mem_</span><span class="special">))</span> <span class="special">{</span> <span class="special">}</span>
<span class="identifier">Derived</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="identifier">BOOST_RV_REF</span><span class="special">(</span><span class="identifier">Derived</span><span class="special">)</span> <span class="identifier">x</span><span class="special">)</span> <span class="comment">// Move assign</span>
<span class="special">{</span>
<span class="identifier">Base</span><span class="special">::</span><span class="keyword">operator</span><span class="special">=(</span><span class="identifier">BOOST_MOVE_BASE</span><span class="special">(</span><span class="identifier">Base</span><span class="special">,</span> <span class="identifier">x</span><span class="special">));</span>
<span class="identifier">mem_</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">x</span><span class="special">.</span><span class="identifier">mem_</span><span class="special">);</span>
<span class="keyword">return</span> <span class="special">*</span><span class="keyword">this</span><span class="special">;</span>
<span class="special">}</span>
<span class="identifier">Derived</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="identifier">BOOST_COPY_ASSIGN_REF</span><span class="special">(</span><span class="identifier">Derived</span><span class="special">)</span> <span class="identifier">x</span><span class="special">)</span> <span class="comment">// Copy assign</span>
<span class="special">{</span>
<span class="identifier">Base</span><span class="special">::</span><span class="keyword">operator</span><span class="special">=(</span><span class="identifier">x</span><span class="special">);</span>
<span class="identifier">mem_</span> <span class="special">=</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">mem_</span><span class="special">;</span>
<span class="keyword">return</span> <span class="special">*</span><span class="keyword">this</span><span class="special">;</span>
<span class="special">}</span>
<span class="comment">// ...</span>
<span class="special">};</span>
</pre>
<p>
</p>
<div class="important"><table border="0" summary="Important">
<tr>
<td rowspan="2" align="center" valign="top" width="25"><img alt="[Important]" src="../../../doc/src/images/important.png"></td>
<th align="left">Important</th>
</tr>
<tr><td align="left" valign="top"><p>
Due to limitations in the emulation code, a cast to <code class="computeroutput"><span class="identifier">Base</span>
<span class="special">&amp;</span></code> is needed before moving the
base part in the move constructor and call Base's move constructor instead
of the copy constructor.
</p></td></tr>
</table></div>
<p>
Each subobject will now be treated individually, calling move to bind to the
subobject's move constructors and move assignment operators. <code class="computeroutput"><span class="identifier">Member</span></code> has move operations coded (just like
our earlier <code class="computeroutput"><span class="identifier">clone_ptr</span></code> example)
which will completely avoid the tremendously more expensive copy operations:
</p>
<p>
</p>
<pre class="programlisting"><span class="identifier">Derived</span> <span class="identifier">d</span><span class="special">;</span>
<span class="identifier">Derived</span> <span class="identifier">d2</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">d</span><span class="special">));</span>
<span class="identifier">d2</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">d</span><span class="special">);</span>
</pre>
<p>
</p>
<p>
Note above that the argument x is treated as a lvalue reference. That's why
it is necessary to say <code class="computeroutput"><span class="identifier">move</span><span class="special">(</span><span class="identifier">x</span><span class="special">)</span></code>
instead of just x when passing down to the base class. This is a key safety
feature of move semantics designed to prevent accidently moving twice from
some named variable. All moves from lvalues occur explicitly.
</p>
</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 © 2008-2014 Ion Gaztanaga<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="implementing_movable_classes.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../move.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="movable_only_classes.html"><img src="../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@@ -0,0 +1,172 @@
<!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=UTF-8">
<title>Constructor Forwarding</title>
<link rel="stylesheet" href="../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../index.html" title="The Boost C++ Libraries BoostBook Documentation Subset">
<link rel="up" href="../move.html" title="Chapter 25. Boost.Move">
<link rel="prev" href="move_and_containers.html" title="Containers and move semantics">
<link rel="next" href="move_return.html" title="Implicit Move when returning a local object">
</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="move_and_containers.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../move.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="move_return.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="move.construct_forwarding"></a><a class="link" href="construct_forwarding.html" title="Constructor Forwarding">Constructor Forwarding</a>
</h2></div></div></div>
<p>
Consider writing a generic factory function that returns an object for a newly
constructed generic type. Factory functions such as this are valuable for encapsulating
and localizing the allocation of resources. Obviously, the factory function
must accept exactly the same sets of arguments as the constructors of the type
of objects constructed:
</p>
<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">T</span><span class="special">*</span> <span class="identifier">factory_new</span><span class="special">()</span>
<span class="special">{</span> <span class="keyword">return</span> <span class="keyword">new</span> <span class="identifier">T</span><span class="special">();</span> <span class="special">}</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">T</span><span class="special">*</span> <span class="identifier">factory_new</span><span class="special">(</span><span class="identifier">a1</span><span class="special">)</span>
<span class="special">{</span> <span class="keyword">return</span> <span class="keyword">new</span> <span class="identifier">T</span><span class="special">(</span><span class="identifier">a1</span><span class="special">);</span> <span class="special">}</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">T</span><span class="special">*</span> <span class="identifier">factory_new</span><span class="special">(</span><span class="identifier">a1</span><span class="special">,</span> <span class="identifier">a2</span><span class="special">)</span>
<span class="special">{</span> <span class="keyword">return</span> <span class="keyword">new</span> <span class="identifier">T</span><span class="special">(</span><span class="identifier">a1</span><span class="special">,</span> <span class="identifier">a2</span><span class="special">);</span> <span class="special">}</span>
</pre>
<p>
Unfortunately, in C++03 the much bigger issue with this approach is that the
N-argument case would require 2^N overloads, immediately discounting this as
a general solution. Fortunately, most constructors take arguments by value,
by const-reference or by rvalue reference. If these limitations are accepted,
the forwarding emulation of a N-argument case requires just N overloads. This
library makes this emulation easy with the help of <code class="computeroutput"><span class="identifier">BOOST_FWD_REF</span></code>
and <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">forward</span></code>:
</p>
<p>
</p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">move</span><span class="special">/</span><span class="identifier">utility_core</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">copyable_only_tester</span>
<span class="special">{</span>
<span class="keyword">public</span><span class="special">:</span>
<span class="identifier">copyable_only_tester</span><span class="special">()</span>
<span class="special">{</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"copyable_only_tester()"</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="special">}</span>
<span class="identifier">copyable_only_tester</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">copyable_only_tester</span><span class="special">&amp;)</span>
<span class="special">{</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"copyable_only_tester(const copyable_only_tester&amp;)"</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="special">}</span>
<span class="identifier">copyable_only_tester</span><span class="special">(</span><span class="keyword">int</span><span class="special">)</span>
<span class="special">{</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"copyable_only_tester(int)"</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="special">}</span>
<span class="identifier">copyable_only_tester</span><span class="special">(</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">)</span>
<span class="special">{</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"copyable_only_tester(int, double)"</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="special">}</span>
<span class="special">};</span>
<span class="keyword">class</span> <span class="identifier">copyable_movable_tester</span>
<span class="special">{</span>
<span class="comment">// move semantics</span>
<span class="identifier">BOOST_COPYABLE_AND_MOVABLE</span><span class="special">(</span><span class="identifier">copyable_movable_tester</span><span class="special">)</span>
<span class="keyword">public</span><span class="special">:</span>
<span class="identifier">copyable_movable_tester</span><span class="special">()</span>
<span class="special">{</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"copyable_movable_tester()"</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="special">}</span>
<span class="identifier">copyable_movable_tester</span><span class="special">(</span><span class="keyword">int</span><span class="special">)</span>
<span class="special">{</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"copyable_movable_tester(int)"</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="special">}</span>
<span class="identifier">copyable_movable_tester</span><span class="special">(</span><span class="identifier">BOOST_RV_REF</span><span class="special">(</span><span class="identifier">copyable_movable_tester</span><span class="special">))</span>
<span class="special">{</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"copyable_movable_tester(BOOST_RV_REF(copyable_movable_tester))"</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="special">}</span>
<span class="identifier">copyable_movable_tester</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">copyable_movable_tester</span> <span class="special">&amp;)</span>
<span class="special">{</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"copyable_movable_tester(const copyable_movable_tester &amp;)"</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="special">}</span>
<span class="identifier">copyable_movable_tester</span><span class="special">(</span><span class="identifier">BOOST_RV_REF</span><span class="special">(</span><span class="identifier">copyable_movable_tester</span><span class="special">),</span> <span class="identifier">BOOST_RV_REF</span><span class="special">(</span><span class="identifier">copyable_movable_tester</span><span class="special">))</span>
<span class="special">{</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"copyable_movable_tester(BOOST_RV_REF(copyable_movable_tester), BOOST_RV_REF(copyable_movable_tester))"</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="special">}</span>
<span class="identifier">copyable_movable_tester</span> <span class="special">&amp;</span><span class="keyword">operator</span><span class="special">=(</span><span class="identifier">BOOST_RV_REF</span><span class="special">(</span><span class="identifier">copyable_movable_tester</span><span class="special">))</span>
<span class="special">{</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"copyable_movable_tester &amp; operator=(BOOST_RV_REF(copyable_movable_tester))"</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
<span class="keyword">return</span> <span class="special">*</span><span class="keyword">this</span><span class="special">;</span> <span class="special">}</span>
<span class="identifier">copyable_movable_tester</span> <span class="special">&amp;</span><span class="keyword">operator</span><span class="special">=(</span><span class="identifier">BOOST_COPY_ASSIGN_REF</span><span class="special">(</span><span class="identifier">copyable_movable_tester</span><span class="special">))</span>
<span class="special">{</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"copyable_movable_tester &amp; operator=(BOOST_COPY_ASSIGN_REF(copyable_movable_tester))"</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
<span class="keyword">return</span> <span class="special">*</span><span class="keyword">this</span><span class="special">;</span> <span class="special">}</span>
<span class="special">};</span>
<span class="comment">//1 argument</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">MaybeMovable</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">MaybeRv</span><span class="special">&gt;</span>
<span class="keyword">void</span> <span class="identifier">function_construct</span><span class="special">(</span><span class="identifier">BOOST_FWD_REF</span><span class="special">(</span><span class="identifier">MaybeRv</span><span class="special">)</span> <span class="identifier">x</span><span class="special">)</span>
<span class="special">{</span> <span class="identifier">MaybeMovable</span> <span class="identifier">m</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">forward</span><span class="special">&lt;</span><span class="identifier">MaybeRv</span><span class="special">&gt;(</span><span class="identifier">x</span><span class="special">));</span> <span class="special">}</span>
<span class="comment">//2 argument</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">MaybeMovable</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">MaybeRv</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">MaybeRv2</span><span class="special">&gt;</span>
<span class="keyword">void</span> <span class="identifier">function_construct</span><span class="special">(</span><span class="identifier">BOOST_FWD_REF</span><span class="special">(</span><span class="identifier">MaybeRv</span><span class="special">)</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">BOOST_FWD_REF</span><span class="special">(</span><span class="identifier">MaybeRv2</span><span class="special">)</span> <span class="identifier">x2</span><span class="special">)</span>
<span class="special">{</span> <span class="identifier">MaybeMovable</span> <span class="identifier">m</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">forward</span><span class="special">&lt;</span><span class="identifier">MaybeRv</span><span class="special">&gt;(</span><span class="identifier">x</span><span class="special">),</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">forward</span><span class="special">&lt;</span><span class="identifier">MaybeRv2</span><span class="special">&gt;(</span><span class="identifier">x2</span><span class="special">));</span> <span class="special">}</span>
<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
<span class="special">{</span>
<span class="identifier">copyable_movable_tester</span> <span class="identifier">m</span><span class="special">;</span>
<span class="comment">//move constructor</span>
<span class="identifier">function_construct</span><span class="special">&lt;</span><span class="identifier">copyable_movable_tester</span><span class="special">&gt;(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">m</span><span class="special">));</span>
<span class="comment">//copy constructor</span>
<span class="identifier">function_construct</span><span class="special">&lt;</span><span class="identifier">copyable_movable_tester</span><span class="special">&gt;(</span><span class="identifier">copyable_movable_tester</span><span class="special">());</span>
<span class="comment">//two rvalue constructor</span>
<span class="identifier">function_construct</span><span class="special">&lt;</span><span class="identifier">copyable_movable_tester</span><span class="special">&gt;(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">m</span><span class="special">),</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">m</span><span class="special">));</span>
<span class="identifier">copyable_only_tester</span> <span class="identifier">nm</span><span class="special">;</span>
<span class="comment">//copy constructor (copyable_only_tester has no move ctor.)</span>
<span class="identifier">function_construct</span><span class="special">&lt;</span><span class="identifier">copyable_only_tester</span><span class="special">&gt;(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">nm</span><span class="special">));</span>
<span class="comment">//copy constructor</span>
<span class="identifier">function_construct</span><span class="special">&lt;</span><span class="identifier">copyable_only_tester</span><span class="special">&gt;(</span><span class="identifier">nm</span><span class="special">);</span>
<span class="comment">//int constructor</span>
<span class="identifier">function_construct</span><span class="special">&lt;</span><span class="identifier">copyable_only_tester</span><span class="special">&gt;(</span><span class="keyword">int</span><span class="special">(</span><span class="number">0</span><span class="special">));</span>
<span class="comment">//int, double constructor</span>
<span class="identifier">function_construct</span><span class="special">&lt;</span><span class="identifier">copyable_only_tester</span><span class="special">&gt;(</span><span class="keyword">int</span><span class="special">(</span><span class="number">0</span><span class="special">),</span> <span class="keyword">double</span><span class="special">(</span><span class="number">0.0</span><span class="special">));</span>
<span class="comment">//Output is:</span>
<span class="comment">//copyable_movable_tester()</span>
<span class="comment">//copyable_movable_tester(BOOST_RV_REF(copyable_movable_tester))</span>
<span class="comment">//copyable_movable_tester()</span>
<span class="comment">//copyable_movable_tester(const copyable_movable_tester &amp;)</span>
<span class="comment">//copyable_movable_tester(BOOST_RV_REF(copyable_movable_tester), BOOST_RV_REF(copyable_movable_tester))</span>
<span class="comment">//copyable_only_tester()</span>
<span class="comment">//copyable_only_tester(const copyable_only_tester&amp;)</span>
<span class="comment">//copyable_only_tester(const copyable_only_tester&amp;)</span>
<span class="comment">//copyable_only_tester(int)</span>
<span class="comment">//copyable_only_tester(int, double)</span>
<span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
<span class="special">}</span>
</pre>
<p>
</p>
<p>
Constructor forwarding comes in handy to implement placement insertion in containers
with just N overloads if the implementor accepts the limitations of this type
of forwarding for C++03 compilers. In compilers with rvalue references perfect
forwarding is achieved.
</p>
</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 © 2008-2014 Ion Gaztanaga<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="move_and_containers.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../move.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="move_return.html"><img src="../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@@ -0,0 +1,266 @@
<!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=UTF-8">
<title>Emulation limitations</title>
<link rel="stylesheet" href="../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../index.html" title="The Boost C++ Libraries BoostBook Documentation Subset">
<link rel="up" href="../move.html" title="Chapter 25. Boost.Move">
<link rel="prev" href="move_algorithms.html" title="Move algorithms">
<link rel="next" href="how_the_library_works.html" title="How the library works">
</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="move_algorithms.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../move.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="how_the_library_works.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="move.emulation_limitations"></a><a class="link" href="emulation_limitations.html" title="Emulation limitations">Emulation limitations</a>
</h2></div></div></div>
<div class="toc"><dl class="toc">
<dt><span class="section"><a href="emulation_limitations.html#move.emulation_limitations.emulation_limitations_base">Initializing
base classes</a></span></dt>
<dt><span class="section"><a href="emulation_limitations.html#move.emulation_limitations.template_parameters">Template
parameters for perfect forwarding</a></span></dt>
<dt><span class="section"><a href="emulation_limitations.html#move.emulation_limitations.emulation_limitations_binding">Binding
of rvalue references to lvalues</a></span></dt>
<dt><span class="section"><a href="emulation_limitations.html#move.emulation_limitations.assignment_operator">Assignment
operator in classes derived from or holding copyable and movable types</a></span></dt>
<dt><span class="section"><a href="emulation_limitations.html#move.emulation_limitations.templated_assignment_operator">Templated
assignment operator in copyable and movable types</a></span></dt>
</dl></div>
<p>
Like any emulation effort, the library has some limitations users should take
in care to achieve portable and efficient code when using the library with
C++03 conformant compilers:
</p>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="move.emulation_limitations.emulation_limitations_base"></a><a class="link" href="emulation_limitations.html#move.emulation_limitations.emulation_limitations_base" title="Initializing base classes">Initializing
base classes</a>
</h3></div></div></div>
<p>
When initializing base classes in move constructors, users must cast the
reference to a base class reference before moving it or just use <code class="computeroutput"><span class="identifier">BOOST_MOVE_BASE</span></code>. Example:
</p>
<pre class="programlisting"><span class="identifier">Derived</span><span class="special">(</span><span class="identifier">BOOST_RV_REF</span><span class="special">(</span><span class="identifier">Derived</span><span class="special">)</span> <span class="identifier">x</span><span class="special">)</span> <span class="comment">// Move ctor</span>
<span class="special">:</span> <span class="identifier">Base</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="keyword">static_cast</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">&amp;&gt;(</span><span class="identifier">x</span><span class="special">)))</span>
<span class="comment">//...</span>
</pre>
<p>
or
</p>
<pre class="programlisting"><span class="identifier">Derived</span><span class="special">(</span><span class="identifier">BOOST_RV_REF</span><span class="special">(</span><span class="identifier">Derived</span><span class="special">)</span> <span class="identifier">x</span><span class="special">)</span> <span class="comment">// Move ctor</span>
<span class="special">:</span> <span class="identifier">Base</span><span class="special">(</span><span class="identifier">BOOST_MOVE_BASE</span><span class="special">(</span><span class="identifier">Base</span><span class="special">,</span> <span class="identifier">x</span><span class="special">))</span>
<span class="comment">//...</span>
</pre>
<p>
If casting is not performed the emulation will not move construct the base
class, because no conversion is available from <code class="computeroutput"><span class="identifier">BOOST_RV_REF</span><span class="special">(</span><span class="identifier">Derived</span><span class="special">)</span></code> to <code class="computeroutput"><span class="identifier">BOOST_RV_REF</span><span class="special">(</span><span class="identifier">Base</span><span class="special">)</span></code>.
Without the cast or <code class="computeroutput"><span class="identifier">BOOST_MOVE_BASE</span></code>
we might obtain a compilation error (for non-copyable types) or a less-efficient
move constructor (for copyable types):
</p>
<pre class="programlisting"><span class="comment">//If Derived is copyable, then Base is copy-constructed.</span>
<span class="comment">//If not, a compilation error is issued</span>
<span class="identifier">Derived</span><span class="special">(</span><span class="identifier">BOOST_RV_REF</span><span class="special">(</span><span class="identifier">Derived</span><span class="special">)</span> <span class="identifier">x</span><span class="special">)</span> <span class="comment">// Move ctor</span>
<span class="special">:</span> <span class="identifier">Base</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">x</span><span class="special">))</span>
<span class="comment">//...</span>
</pre>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="move.emulation_limitations.template_parameters"></a><a class="link" href="emulation_limitations.html#move.emulation_limitations.template_parameters" title="Template parameters for perfect forwarding">Template
parameters for perfect forwarding</a>
</h3></div></div></div>
<p>
The emulation can't deal with C++0x reference collapsing rules that allow
perfect forwarding:
</p>
<pre class="programlisting"><span class="comment">//C++0x</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">void</span> <span class="identifier">forward_function</span><span class="special">(</span><span class="identifier">T</span> <span class="special">&amp;&amp;</span><span class="identifier">t</span><span class="special">)</span>
<span class="special">{</span> <span class="identifier">inner_function</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">forward</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;(</span><span class="identifier">t</span><span class="special">);</span> <span class="special">}</span>
<span class="comment">//Wrong C++03 emulation</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">void</span> <span class="identifier">forward_function</span><span class="special">(</span><span class="identifier">BOOST_RV_REF</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">t</span><span class="special">)</span>
<span class="special">{</span> <span class="identifier">inner_function</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">forward</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;(</span><span class="identifier">t</span><span class="special">);</span> <span class="special">}</span>
</pre>
<p>
In C++03 emulation BOOST_RV_REF doesn't catch any const rlvalues. For more
details on forwarding see <a class="link" href="construct_forwarding.html" title="Constructor Forwarding">Constructor
Forwarding</a> chapter.
</p>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="move.emulation_limitations.emulation_limitations_binding"></a><a class="link" href="emulation_limitations.html#move.emulation_limitations.emulation_limitations_binding" title="Binding of rvalue references to lvalues">Binding
of rvalue references to lvalues</a>
</h3></div></div></div>
<p>
The <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1690.html" target="_top">first
rvalue reference</a> proposal allowed the binding of rvalue references
to lvalues:
</p>
<pre class="programlisting"><span class="identifier">func</span><span class="special">(</span><span class="identifier">Type</span> <span class="special">&amp;&amp;</span><span class="identifier">t</span><span class="special">);</span>
<span class="comment">//....</span>
<span class="identifier">Type</span> <span class="identifier">t</span><span class="special">;</span> <span class="comment">//Allowed</span>
<span class="identifier">func</span><span class="special">(</span><span class="identifier">t</span><span class="special">)</span>
</pre>
<p>
Later, as explained in <a href="http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2008/n2812.html" target="_top"><span class="emphasis"><em>Fixing
a Safety Problem with Rvalue References</em></span></a> this behaviour
was considered dangerous and eliminated this binding so that rvalue references
adhere to the principle of type-safe overloading: <span class="emphasis"><em>Every function
must be type-safe in isolation, without regard to how it has been overloaded</em></span>
</p>
<p>
<span class="bold"><strong>Boost.Move</strong></span> can't emulate this type-safe
overloading principle for C++03 compilers:
</p>
<pre class="programlisting"><span class="comment">//Allowed by move emulation</span>
<span class="identifier">movable</span> <span class="identifier">m</span><span class="special">;</span>
<span class="identifier">BOOST_RV_REF</span><span class="special">(</span><span class="identifier">movable</span><span class="special">)</span> <span class="identifier">r</span> <span class="special">=</span> <span class="identifier">m</span><span class="special">;</span>
</pre>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="move.emulation_limitations.assignment_operator"></a><a class="link" href="emulation_limitations.html#move.emulation_limitations.assignment_operator" title="Assignment operator in classes derived from or holding copyable and movable types">Assignment
operator in classes derived from or holding copyable and movable types</a>
</h3></div></div></div>
<p>
The macro <code class="computeroutput"><a class="link" href="../BOOST_COPYABLE_AND_MOVABLE.html" title="Macro BOOST_COPYABLE_AND_MOVABLE">BOOST_COPYABLE_AND_MOVABLE</a></code>
needs to define a copy constructor for <code class="computeroutput"><span class="identifier">copyable_and_movable</span></code>
taking a non-const parameter in C++03 compilers:
</p>
<pre class="programlisting"><span class="comment">//Generated by BOOST_COPYABLE_AND_MOVABLE</span>
<span class="identifier">copyable_and_movable</span> <span class="special">&amp;</span><span class="keyword">operator</span><span class="special">=(</span><span class="identifier">copyable_and_movable</span><span class="special">&amp;){/**/}</span>
</pre>
<p>
Since the non-const overload of the copy constructor is generated, compiler-generated
assignment operators for classes containing <code class="computeroutput"><span class="identifier">copyable_and_movable</span></code>
will get the non-const copy constructor overload, which will surely surprise
users:
</p>
<pre class="programlisting"><span class="keyword">class</span> <span class="identifier">holder</span>
<span class="special">{</span>
<span class="identifier">copyable_and_movable</span> <span class="identifier">c</span><span class="special">;</span>
<span class="special">};</span>
<span class="keyword">void</span> <span class="identifier">func</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">holder</span><span class="special">&amp;</span> <span class="identifier">h</span><span class="special">)</span>
<span class="special">{</span>
<span class="identifier">holder</span> <span class="identifier">copy_h</span><span class="special">(</span><span class="identifier">h</span><span class="special">);</span> <span class="comment">//&lt;--- ERROR: can't convert 'const holder&amp;' to 'holder&amp;'</span>
<span class="comment">//Compiler-generated copy constructor is non-const:</span>
<span class="comment">// holder&amp; operator(holder &amp;)</span>
<span class="comment">//!!!</span>
<span class="special">}</span>
</pre>
<p>
This limitation forces the user to define a const version of the copy assignment,
in all classes holding copyable and movable classes which might be annoying
in some cases.
</p>
<p>
An alternative is to implement a single <code class="computeroutput"><span class="keyword">operator</span>
<span class="special">=()</span></code> for copyable and movable classes
<a href="http://cpp-next.com/archive/2009/08/want-speed-pass-by-value/" target="_top">using
"pass by value" semantics</a>:
</p>
<pre class="programlisting"><span class="identifier">T</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="identifier">T</span> <span class="identifier">x</span><span class="special">)</span> <span class="comment">// x is a copy of the source; hard work already done</span>
<span class="special">{</span>
<span class="identifier">swap</span><span class="special">(*</span><span class="keyword">this</span><span class="special">,</span> <span class="identifier">x</span><span class="special">);</span> <span class="comment">// trade our resources for x's</span>
<span class="keyword">return</span> <span class="special">*</span><span class="keyword">this</span><span class="special">;</span> <span class="comment">// our (old) resources get destroyed with x</span>
<span class="special">}</span>
</pre>
<p>
However, "pass by value" is not optimal for classes (like containers,
strings, etc.) that reuse resources (like previously allocated memory) when
x is assigned from a lvalue.
</p>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="move.emulation_limitations.templated_assignment_operator"></a><a class="link" href="emulation_limitations.html#move.emulation_limitations.templated_assignment_operator" title="Templated assignment operator in copyable and movable types">Templated
assignment operator in copyable and movable types</a>
</h3></div></div></div>
<p>
Given a movable and copyable class, if a templated assignment operator (*)
is added:
</p>
<p>
</p>
<pre class="programlisting"><span class="keyword">class</span> <span class="identifier">Foo</span>
<span class="special">{</span>
<span class="identifier">BOOST_COPYABLE_AND_MOVABLE</span><span class="special">(</span><span class="identifier">Foo</span><span class="special">)</span>
<span class="keyword">public</span><span class="special">:</span>
<span class="keyword">int</span> <span class="identifier">i</span><span class="special">;</span>
<span class="keyword">explicit</span> <span class="identifier">Foo</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">val</span><span class="special">)</span> <span class="special">:</span> <span class="identifier">i</span><span class="special">(</span><span class="identifier">val</span><span class="special">)</span> <span class="special">{}</span>
<span class="identifier">Foo</span><span class="special">(</span><span class="identifier">BOOST_RV_REF</span><span class="special">(</span><span class="identifier">Foo</span><span class="special">)</span> <span class="identifier">obj</span><span class="special">)</span> <span class="special">:</span> <span class="identifier">i</span><span class="special">(</span><span class="identifier">obj</span><span class="special">.</span><span class="identifier">i</span><span class="special">)</span> <span class="special">{}</span>
<span class="identifier">Foo</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="identifier">BOOST_RV_REF</span><span class="special">(</span><span class="identifier">Foo</span><span class="special">)</span> <span class="identifier">rhs</span><span class="special">)</span>
<span class="special">{</span> <span class="identifier">i</span> <span class="special">=</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">i</span><span class="special">;</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">i</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span> <span class="keyword">return</span> <span class="special">*</span><span class="keyword">this</span><span class="special">;</span> <span class="special">}</span>
<span class="identifier">Foo</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="identifier">BOOST_COPY_ASSIGN_REF</span><span class="special">(</span><span class="identifier">Foo</span><span class="special">)</span> <span class="identifier">rhs</span><span class="special">)</span>
<span class="special">{</span> <span class="identifier">i</span> <span class="special">=</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">i</span><span class="special">;</span> <span class="keyword">return</span> <span class="special">*</span><span class="keyword">this</span><span class="special">;</span> <span class="special">}</span> <span class="comment">//(1)</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">U</span><span class="special">&gt;</span> <span class="comment">//(*) TEMPLATED ASSIGNMENT, potential problem</span>
<span class="identifier">Foo</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="keyword">const</span> <span class="identifier">U</span><span class="special">&amp;</span> <span class="identifier">rhs</span><span class="special">)</span>
<span class="special">{</span> <span class="identifier">i</span> <span class="special">=</span> <span class="special">-</span><span class="identifier">rhs</span><span class="special">.</span><span class="identifier">i</span><span class="special">;</span> <span class="keyword">return</span> <span class="special">*</span><span class="keyword">this</span><span class="special">;</span> <span class="special">}</span> <span class="comment">//(2)</span>
<span class="special">};</span>
</pre>
<p>
</p>
<p>
C++98 and C++11 compilers will behave different when assigning from a <code class="computeroutput"><span class="special">[</span><span class="keyword">const</span><span class="special">]</span>
<span class="identifier">Foo</span></code> lvalue:
</p>
<p>
</p>
<pre class="programlisting"><span class="identifier">Foo</span> <span class="identifier">foo1</span><span class="special">(</span><span class="number">1</span><span class="special">);</span>
<span class="identifier">Foo</span> <span class="identifier">foo2</span><span class="special">(</span><span class="number">2</span><span class="special">);</span>
<span class="identifier">foo2</span> <span class="special">=</span> <span class="identifier">foo1</span><span class="special">;</span> <span class="comment">// Calls (1) in C++11 but (2) in C++98</span>
<span class="keyword">const</span> <span class="identifier">Foo</span> <span class="identifier">foo5</span><span class="special">(</span><span class="number">5</span><span class="special">);</span>
<span class="identifier">foo2</span> <span class="special">=</span> <span class="identifier">foo5</span><span class="special">;</span> <span class="comment">// Calls (1) in C++11 but (2) in C++98</span>
</pre>
<p>
</p>
<p>
This different behaviour is a side-effect of the move emulation that can't
be easily avoided by <span class="bold"><strong>Boost.Move</strong></span>. One workaround
is to SFINAE-out the templated assignment operator with <code class="computeroutput"><span class="identifier">disable_if</span></code>:
</p>
<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">U</span><span class="special">&gt;</span> <span class="comment">// Modified templated assignment</span>
<span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">disable_if</span><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">U</span><span class="special">,</span> <span class="identifier">Foo</span><span class="special">&gt;,</span> <span class="identifier">Foo</span><span class="special">&amp;&gt;::</span><span class="identifier">type</span>
<span class="keyword">operator</span><span class="special">=(</span><span class="keyword">const</span> <span class="identifier">U</span><span class="special">&amp;</span> <span class="identifier">rhs</span><span class="special">)</span>
<span class="special">{</span> <span class="identifier">i</span> <span class="special">=</span> <span class="special">-</span><span class="identifier">rhs</span><span class="special">.</span><span class="identifier">i</span><span class="special">;</span> <span class="keyword">return</span> <span class="special">*</span><span class="keyword">this</span><span class="special">;</span> <span class="special">}</span> <span class="comment">//(2)</span>
</pre>
</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 © 2008-2014 Ion Gaztanaga<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="move_algorithms.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../move.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="how_the_library_works.html"><img src="../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@@ -0,0 +1,181 @@
<!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=UTF-8">
<title>How the library works</title>
<link rel="stylesheet" href="../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../index.html" title="The Boost C++ Libraries BoostBook Documentation Subset">
<link rel="up" href="../move.html" title="Chapter 25. Boost.Move">
<link rel="prev" href="emulation_limitations.html" title="Emulation limitations">
<link rel="next" href="thanks_to.html" title="Thanks and credits">
</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="emulation_limitations.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../move.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="thanks_to.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="move.how_the_library_works"></a><a class="link" href="how_the_library_works.html" title="How the library works">How the library works</a>
</h2></div></div></div>
<p>
<span class="bold"><strong>Boost.Move</strong></span> is based on macros that are expanded
to true rvalue references in C++0x compilers and emulated rvalue reference
classes and conversion operators in C++03 compilers.
</p>
<p>
In C++03 compilers <span class="bold"><strong>Boost.Move</strong></span> defines a class
named <code class="computeroutput"><span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">rv</span></code>:
</p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">rv</span> <span class="special">:</span> <span class="keyword">public</span> <span class="identifier">T</span>
<span class="special">{</span>
<span class="identifier">rv</span><span class="special">();</span>
<span class="special">~</span><span class="identifier">rv</span><span class="special">();</span>
<span class="identifier">rv</span><span class="special">(</span><span class="identifier">rv</span> <span class="keyword">const</span><span class="special">&amp;);</span>
<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">=(</span><span class="identifier">rv</span> <span class="keyword">const</span><span class="special">&amp;);</span>
<span class="special">};</span>
</pre>
<p>
which is convertible to the movable base class (usual C++ derived to base conversion).
When users mark their classes as <code class="computeroutput"><a class="link" href="../BOOST_MOVABL_1_3_26_20_7_3.html" title="Macro BOOST_MOVABLE_BUT_NOT_COPYABLE">BOOST_MOVABLE_BUT_NOT_COPYABLE</a></code>
or <code class="computeroutput"><a class="link" href="../BOOST_COPYABLE_AND_MOVABLE.html" title="Macro BOOST_COPYABLE_AND_MOVABLE">BOOST_COPYABLE_AND_MOVABLE</a></code>,
these macros define conversion operators to references to <code class="computeroutput"><span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">rv</span></code>:
</p>
<pre class="programlisting"><span class="preprocessor">#define</span> <span class="identifier">BOOST_MOVABLE_BUT_NOT_COPYABLE</span><span class="special">(</span><span class="identifier">TYPE</span><span class="special">)\</span>
<span class="keyword">public</span><span class="special">:\</span>
<span class="keyword">operator</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">rv</span><span class="special">&lt;</span><span class="identifier">TYPE</span><span class="special">&gt;&amp;()</span> <span class="special">\</span>
<span class="special">{</span> <span class="keyword">return</span> <span class="special">*</span><span class="keyword">static_cast</span><span class="special">&lt;</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">rv</span><span class="special">&lt;</span><span class="identifier">TYPE</span><span class="special">&gt;*</span> <span class="special">&gt;(</span><span class="keyword">this</span><span class="special">);</span> <span class="special">}\</span>
<span class="keyword">operator</span> <span class="keyword">const</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">rv</span><span class="special">&lt;</span><span class="identifier">TYPE</span><span class="special">&gt;&amp;()</span> <span class="keyword">const</span> <span class="special">\</span>
<span class="special">{</span> <span class="keyword">return</span> <span class="keyword">static_cast</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">rv</span><span class="special">&lt;</span><span class="identifier">TYPE</span><span class="special">&gt;*</span> <span class="special">&gt;(</span><span class="keyword">this</span><span class="special">);</span> <span class="special">}\</span>
<span class="keyword">private</span><span class="special">:\</span>
<span class="comment">//More stuff...</span>
</pre>
<p>
<code class="computeroutput"><a class="link" href="../BOOST_MOVABL_1_3_26_20_7_3.html" title="Macro BOOST_MOVABLE_BUT_NOT_COPYABLE">BOOST_MOVABLE_BUT_NOT_COPYABLE</a></code>
also declares a private copy constructor and assignment. <code class="computeroutput"><a class="link" href="../BOOST_COPYABLE_AND_MOVABLE.html" title="Macro BOOST_COPYABLE_AND_MOVABLE">BOOST_COPYABLE_AND_MOVABLE</a></code>
defines a non-const copy constructor <code class="computeroutput"><span class="identifier">TYPE</span>
<span class="special">&amp;</span><span class="keyword">operator</span><span class="special">=(</span><span class="identifier">TYPE</span><span class="special">&amp;)</span></code>
that forwards to a const version:
</p>
<pre class="programlisting"><span class="preprocessor">#define</span> <span class="identifier">BOOST_COPYABLE_AND_MOVABLE</span><span class="special">(</span><span class="identifier">TYPE</span><span class="special">)\</span>
<span class="keyword">public</span><span class="special">:\</span>
<span class="identifier">TYPE</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="identifier">TYPE</span> <span class="special">&amp;</span><span class="identifier">t</span><span class="special">)\</span>
<span class="special">{</span> <span class="keyword">this</span><span class="special">-&gt;</span><span class="keyword">operator</span><span class="special">=(</span><span class="keyword">static_cast</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">rv</span><span class="special">&lt;</span><span class="identifier">TYPE</span><span class="special">&gt;</span> <span class="special">&amp;&gt;(</span><span class="keyword">const_cast</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="identifier">TYPE</span> <span class="special">&amp;&gt;(</span><span class="identifier">t</span><span class="special">)));</span> <span class="keyword">return</span> <span class="special">*</span><span class="keyword">this</span><span class="special">;}\</span>
<span class="comment">//More stuff...</span>
</pre>
<p>
In C++0x compilers <code class="computeroutput"><span class="identifier">BOOST_COPYABLE_AND_MOVABLE</span></code>
expands to nothing and <code class="computeroutput"><span class="identifier">BOOST_MOVABLE_BUT_NOT_COPYABLE</span></code>
declares copy constructor and assigment operator private.
</p>
<p>
When users define the <code class="computeroutput"><a class="link" href="../BOOST_RV_REF.html" title="Macro BOOST_RV_REF">BOOST_RV_REF</a></code>
overload of a copy constructor/assignment, in C++0x compilers it is expanded
to a rvalue reference (<code class="computeroutput"><span class="identifier">T</span><span class="special">&amp;&amp;</span></code>)
overload and in C++03 compilers it is expanded to a <code class="computeroutput"><span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">rv</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span>
<span class="special">&amp;</span></code> overload:
</p>
<pre class="programlisting"><span class="preprocessor">#define</span> <span class="identifier">BOOST_RV_REF</span><span class="special">(</span><span class="identifier">TYPE</span><span class="special">)</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">rv</span><span class="special">&lt;</span> <span class="identifier">TYPE</span> <span class="special">&gt;&amp;</span> <span class="special">\</span>
</pre>
<p>
When users define the <code class="computeroutput"><a class="link" href="../BOOST_COPY_ASSIGN_REF.html" title="Macro BOOST_COPY_ASSIGN_REF">BOOST_COPY_ASSIGN_REF</a></code>
overload, it is expanded to a usual copy assignment (<code class="computeroutput"><span class="keyword">const</span>
<span class="identifier">T</span> <span class="special">&amp;</span></code>)
overload in C++0x compilers and to a <code class="computeroutput"><span class="keyword">const</span>
<span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">rv</span> <span class="special">&amp;</span></code>
overload in C++03 compilers:
</p>
<pre class="programlisting"><span class="preprocessor">#define</span> <span class="identifier">BOOST_COPY_ASSIGN_REF</span><span class="special">(</span><span class="identifier">TYPE</span><span class="special">)</span> <span class="keyword">const</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">rv</span><span class="special">&lt;</span> <span class="identifier">TYPE</span> <span class="special">&gt;&amp;</span>
</pre>
<p>
As seen, in <span class="bold"><strong>Boost.Move</strong></span> generates efficient
and clean code for C++0x move semantics, without modifying any resolution overload.
For C++03 compilers when overload resolution is performed these are the bindings:
</p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
a) non-const rvalues (e.g.: temporaries), bind to <code class="computeroutput"><span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">rv</span><span class="special">&lt;</span> <span class="identifier">TYPE</span> <span class="special">&gt;&amp;</span></code>
</li>
<li class="listitem">
b) const rvalue and lvalues, bind to <code class="computeroutput"><span class="keyword">const</span>
<span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">rv</span><span class="special">&lt;</span> <span class="identifier">TYPE</span> <span class="special">&gt;&amp;</span></code>
</li>
<li class="listitem">
c) non-const lvalues (e.g. non-const references) bind to <code class="computeroutput"><span class="identifier">TYPE</span><span class="special">&amp;</span></code>
</li>
</ul></div>
<p>
The library does not define the equivalent of <code class="computeroutput"><a class="link" href="../BOOST_COPY_ASSIGN_REF.html" title="Macro BOOST_COPY_ASSIGN_REF">BOOST_COPY_ASSIGN_REF</a></code>
for copy construction (say, <code class="computeroutput"><span class="identifier">BOOST_COPY_CTOR_REF</span></code>)
because nearly all modern compilers implement RVO and this is much more efficient
than any move emulation. <code class="computeroutput"><a class="link" href="../boost/move_1_3_26_20_12_1_1.html" title="Function template move">move</a></code>
just casts <code class="computeroutput"><span class="identifier">TYPE</span> <span class="special">&amp;</span></code>
into <code class="computeroutput"><span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">rv</span><span class="special">&lt;</span><span class="identifier">TYPE</span><span class="special">&gt;</span> <span class="special">&amp;</span></code>.
</p>
<p>
Here's an example that demostrates how different rlvalue objects bind to <code class="computeroutput"><span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">rv</span></code> references in the presence of three overloads
and the conversion operators in C++03 compilers:
</p>
<p>
</p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">move</span><span class="special">/</span><span class="identifier">core</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">sink_tester</span>
<span class="special">{</span>
<span class="keyword">public</span><span class="special">:</span> <span class="comment">//conversions provided by BOOST_COPYABLE_AND_MOVABLE</span>
<span class="keyword">operator</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">rv</span><span class="special">&lt;</span><span class="identifier">sink_tester</span><span class="special">&gt;&amp;()</span>
<span class="special">{</span> <span class="keyword">return</span> <span class="special">*</span><span class="keyword">static_cast</span><span class="special">&lt;</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">rv</span><span class="special">&lt;</span><span class="identifier">sink_tester</span><span class="special">&gt;*</span> <span class="special">&gt;(</span><span class="keyword">this</span><span class="special">);</span> <span class="special">}</span>
<span class="keyword">operator</span> <span class="keyword">const</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">rv</span><span class="special">&lt;</span><span class="identifier">sink_tester</span><span class="special">&gt;&amp;()</span> <span class="keyword">const</span>
<span class="special">{</span> <span class="keyword">return</span> <span class="special">*</span><span class="keyword">static_cast</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">rv</span><span class="special">&lt;</span><span class="identifier">sink_tester</span><span class="special">&gt;*</span> <span class="special">&gt;(</span><span class="keyword">this</span><span class="special">);</span> <span class="special">}</span>
<span class="special">};</span>
<span class="comment">//Functions returning different r/lvalue types</span>
<span class="identifier">sink_tester</span> <span class="identifier">rvalue</span><span class="special">()</span> <span class="special">{</span> <span class="keyword">return</span> <span class="identifier">sink_tester</span><span class="special">();</span> <span class="special">}</span>
<span class="keyword">const</span> <span class="identifier">sink_tester</span> <span class="identifier">const_rvalue</span><span class="special">()</span> <span class="special">{</span> <span class="keyword">return</span> <span class="identifier">sink_tester</span><span class="special">();</span> <span class="special">}</span>
<span class="identifier">sink_tester</span> <span class="special">&amp;</span> <span class="identifier">lvalue</span><span class="special">()</span> <span class="special">{</span> <span class="keyword">static</span> <span class="identifier">sink_tester</span> <span class="identifier">lv</span><span class="special">;</span> <span class="keyword">return</span> <span class="identifier">lv</span><span class="special">;</span> <span class="special">}</span>
<span class="keyword">const</span> <span class="identifier">sink_tester</span> <span class="special">&amp;</span> <span class="identifier">const_lvalue</span><span class="special">()</span> <span class="special">{</span> <span class="keyword">static</span> <span class="keyword">const</span> <span class="identifier">sink_tester</span> <span class="identifier">clv</span> <span class="special">=</span> <span class="identifier">sink_tester</span><span class="special">();</span> <span class="keyword">return</span> <span class="identifier">clv</span><span class="special">;</span> <span class="special">}</span>
<span class="comment">//BOOST_RV_REF overload</span>
<span class="keyword">void</span> <span class="identifier">sink</span><span class="special">(::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">rv</span><span class="special">&lt;</span><span class="identifier">sink_tester</span><span class="special">&gt;</span> <span class="special">&amp;)</span> <span class="special">{</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"non-const rvalue catched"</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="special">}</span>
<span class="comment">//BOOST_COPY_ASSIGN_REF overload</span>
<span class="keyword">void</span> <span class="identifier">sink</span><span class="special">(</span><span class="keyword">const</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">rv</span><span class="special">&lt;</span><span class="identifier">sink_tester</span><span class="special">&gt;</span> <span class="special">&amp;){</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"const (r-l)value catched"</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="special">}</span>
<span class="comment">//Overload provided by BOOST_COPYABLE_AND_MOVABLE</span>
<span class="keyword">void</span> <span class="identifier">sink</span><span class="special">(</span><span class="identifier">sink_tester</span> <span class="special">&amp;)</span> <span class="special">{</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"non-const lvalue catched"</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="special">}</span>
<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
<span class="special">{</span>
<span class="identifier">sink</span><span class="special">(</span><span class="identifier">const_rvalue</span><span class="special">());</span> <span class="comment">//"const (r-l)value catched"</span>
<span class="identifier">sink</span><span class="special">(</span><span class="identifier">const_lvalue</span><span class="special">());</span> <span class="comment">//"const (r-l)value catched"</span>
<span class="identifier">sink</span><span class="special">(</span><span class="identifier">lvalue</span><span class="special">());</span> <span class="comment">//"non-const lvalue catched"</span>
<span class="identifier">sink</span><span class="special">(</span><span class="identifier">rvalue</span><span class="special">());</span> <span class="comment">//"non-const rvalue catched"</span>
<span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
<span class="special">}</span>
</pre>
<p>
</p>
</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 © 2008-2014 Ion Gaztanaga<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="emulation_limitations.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../move.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="thanks_to.html"><img src="../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@@ -0,0 +1,250 @@
<!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=UTF-8">
<title>Implementing copyable and movable classes</title>
<link rel="stylesheet" href="../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../index.html" title="The Boost C++ Libraries BoostBook Documentation Subset">
<link rel="up" href="../move.html" title="Chapter 25. Boost.Move">
<link rel="prev" href="introduction.html" title="Introduction">
<link rel="next" href="composition_inheritance.html" title="Composition or inheritance">
</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="introduction.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../move.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="composition_inheritance.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="move.implementing_movable_classes"></a><a class="link" href="implementing_movable_classes.html" title="Implementing copyable and movable classes">Implementing copyable
and movable classes</a>
</h2></div></div></div>
<div class="toc"><dl class="toc">
<dt><span class="section"><a href="implementing_movable_classes.html#move.implementing_movable_classes.copyable_and_movable_cpp0x">Copyable
and movable classes in C++0x</a></span></dt>
<dt><span class="section"><a href="implementing_movable_classes.html#move.implementing_movable_classes.copyable_and_movable_cpp03">Copyable
and movable classes in portable syntax for both C++03 and C++0x compilers</a></span></dt>
</dl></div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="move.implementing_movable_classes.copyable_and_movable_cpp0x"></a><a class="link" href="implementing_movable_classes.html#move.implementing_movable_classes.copyable_and_movable_cpp0x" title="Copyable and movable classes in C++0x">Copyable
and movable classes in C++0x</a>
</h3></div></div></div>
<p>
Consider a simple handle class that owns a resource and also provides copy
semantics (copy constructor and assignment). For example a <code class="computeroutput"><span class="identifier">clone_ptr</span></code> might own a pointer, and call
<code class="computeroutput"><span class="identifier">clone</span><span class="special">()</span></code>
on it for copying purposes:
</p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">clone_ptr</span>
<span class="special">{</span>
<span class="keyword">private</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">public</span><span class="special">:</span>
<span class="comment">// construction</span>
<span class="keyword">explicit</span> <span class="identifier">clone_ptr</span><span class="special">(</span><span class="identifier">T</span><span class="special">*</span> <span class="identifier">p</span> <span class="special">=</span> <span class="number">0</span><span class="special">)</span> <span class="special">:</span> <span class="identifier">ptr</span><span class="special">(</span><span class="identifier">p</span><span class="special">)</span> <span class="special">{}</span>
<span class="comment">// destruction</span>
<span class="special">~</span><span class="identifier">clone_ptr</span><span class="special">()</span> <span class="special">{</span> <span class="keyword">delete</span> <span class="identifier">ptr</span><span class="special">;</span> <span class="special">}</span>
<span class="comment">// copy semantics</span>
<span class="identifier">clone_ptr</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">clone_ptr</span><span class="special">&amp;</span> <span class="identifier">p</span><span class="special">)</span>
<span class="special">:</span> <span class="identifier">ptr</span><span class="special">(</span><span class="identifier">p</span><span class="special">.</span><span class="identifier">ptr</span> <span class="special">?</span> <span class="identifier">p</span><span class="special">.</span><span class="identifier">ptr</span><span class="special">-&gt;</span><span class="identifier">clone</span><span class="special">()</span> <span class="special">:</span> <span class="number">0</span><span class="special">)</span> <span class="special">{}</span>
<span class="identifier">clone_ptr</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="keyword">const</span> <span class="identifier">clone_ptr</span><span class="special">&amp;</span> <span class="identifier">p</span><span class="special">)</span>
<span class="special">{</span>
<span class="keyword">if</span> <span class="special">(</span><span class="keyword">this</span> <span class="special">!=</span> <span class="special">&amp;</span><span class="identifier">p</span><span class="special">)</span>
<span class="special">{</span>
<span class="identifier">T</span> <span class="special">*</span><span class="identifier">p</span> <span class="special">=</span> <span class="identifier">p</span><span class="special">.</span><span class="identifier">ptr</span> <span class="special">?</span> <span class="identifier">p</span><span class="special">.</span><span class="identifier">ptr</span><span class="special">-&gt;</span><span class="identifier">clone</span><span class="special">()</span> <span class="special">:</span> <span class="number">0</span><span class="special">;</span>
<span class="keyword">delete</span> <span class="identifier">ptr</span><span class="special">;</span>
<span class="identifier">ptr</span> <span class="special">=</span> <span class="identifier">p</span><span class="special">;</span>
<span class="special">}</span>
<span class="keyword">return</span> <span class="special">*</span><span class="keyword">this</span><span class="special">;</span>
<span class="special">}</span>
<span class="comment">// move semantics</span>
<span class="identifier">clone_ptr</span><span class="special">(</span><span class="identifier">clone_ptr</span><span class="special">&amp;&amp;</span> <span class="identifier">p</span><span class="special">)</span>
<span class="special">:</span> <span class="identifier">ptr</span><span class="special">(</span><span class="identifier">p</span><span class="special">.</span><span class="identifier">ptr</span><span class="special">)</span> <span class="special">{</span> <span class="identifier">p</span><span class="special">.</span><span class="identifier">ptr</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span> <span class="special">}</span>
<span class="identifier">clone_ptr</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="identifier">clone_ptr</span><span class="special">&amp;&amp;</span> <span class="identifier">p</span><span class="special">)</span>
<span class="special">{</span>
<span class="keyword">if</span><span class="special">(</span><span class="keyword">this</span> <span class="special">!=</span> <span class="special">&amp;</span><span class="identifier">p</span><span class="special">)</span>
<span class="special">{</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">swap</span><span class="special">(</span><span class="identifier">ptr</span><span class="special">,</span> <span class="identifier">p</span><span class="special">.</span><span class="identifier">ptr</span><span class="special">);</span>
<span class="keyword">delete</span> <span class="identifier">p</span><span class="special">.</span><span class="identifier">ptr</span><span class="special">;</span>
<span class="identifier">p</span><span class="special">.</span><span class="identifier">ptr</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span>
<span class="special">}</span>
<span class="keyword">return</span> <span class="special">*</span><span class="keyword">this</span><span class="special">;</span>
<span class="special">}</span>
<span class="comment">// Other operations...</span>
<span class="special">};</span>
</pre>
<p>
<code class="computeroutput"><span class="identifier">clone_ptr</span></code> has expected copy
constructor and assignment semantics, duplicating resources when copying.
Note that copy constructing or assigning a <code class="computeroutput"><span class="identifier">clone_ptr</span></code>
is a relatively expensive operation:
</p>
<p>
</p>
<pre class="programlisting"><span class="identifier">clone_ptr</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">&gt;</span> <span class="identifier">p1</span><span class="special">(</span><span class="keyword">new</span> <span class="identifier">Derived</span><span class="special">());</span>
<span class="comment">// ...</span>
<span class="identifier">clone_ptr</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">&gt;</span> <span class="identifier">p2</span> <span class="special">=</span> <span class="identifier">p1</span><span class="special">;</span> <span class="comment">// p2 and p1 each own their own pointer</span>
</pre>
<p>
</p>
<p>
<code class="computeroutput"><span class="identifier">clone_ptr</span></code> is code that you
might find in today's books on C++, except for the part marked as <code class="computeroutput"><span class="identifier">move</span> <span class="identifier">semantics</span></code>.
That part is implemented in terms of C++0x <code class="computeroutput"><span class="identifier">rvalue</span>
<span class="identifier">references</span></code>. You can find some good
introduction and tutorials on rvalue references in these papers:
</p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
<a href="http://www.artima.com/cppsource/rvalue.html" target="_top"><span class="emphasis"><em>A
Brief Introduction to Rvalue References</em></span></a>
</li>
<li class="listitem">
<a href="http://blogs.msdn.com/vcblog/archive/2009/02/03/rvalue-references-c-0x-features-in-vc10-part-2.aspx" target="_top"><span class="emphasis"><em>Rvalue
References: C++0x Features in VC10, Part 2</em></span></a>
</li>
</ul></div>
<p>
When the source of the copy is known to be a <code class="computeroutput"><span class="identifier">rvalue</span></code>
(e.g.: a temporary object), one can avoid the potentially expensive <code class="computeroutput"><span class="identifier">clone</span><span class="special">()</span></code>
operation by pilfering source's pointer (no one will notice!). The move constructor
above does exactly that, leaving the rvalue in a default constructed state.
The move assignment operator simply does the same freeing old resources.
</p>
<p>
Now when code tries to copy a rvalue <code class="computeroutput"><span class="identifier">clone_ptr</span></code>,
or if that code explicitly gives permission to consider the source of the
copy a rvalue (using <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">move</span></code>),
the operation will execute much faster.
</p>
<p>
</p>
<pre class="programlisting"><span class="identifier">clone_ptr</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">&gt;</span> <span class="identifier">p1</span><span class="special">(</span><span class="keyword">new</span> <span class="identifier">Derived</span><span class="special">());</span>
<span class="comment">// ...</span>
<span class="identifier">clone_ptr</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">&gt;</span> <span class="identifier">p2</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">p1</span><span class="special">);</span> <span class="comment">// p2 now owns the pointer instead of p1</span>
<span class="identifier">p2</span> <span class="special">=</span> <span class="identifier">clone_ptr</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">&gt;(</span><span class="keyword">new</span> <span class="identifier">Derived</span><span class="special">());</span> <span class="comment">// temporary is moved to p2</span>
<span class="special">}</span>
</pre>
<p>
</p>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="move.implementing_movable_classes.copyable_and_movable_cpp03"></a><a class="link" href="implementing_movable_classes.html#move.implementing_movable_classes.copyable_and_movable_cpp03" title="Copyable and movable classes in portable syntax for both C++03 and C++0x compilers">Copyable
and movable classes in portable syntax for both C++03 and C++0x compilers</a>
</h3></div></div></div>
<p>
Many aspects of move semantics can be emulated for compilers not supporting
<code class="computeroutput"><span class="identifier">rvalue</span> <span class="identifier">references</span></code>
and <span class="bold"><strong>Boost.Move</strong></span> offers tools for that purpose.
With <span class="bold"><strong>Boost.Move</strong></span> we can write <code class="computeroutput"><span class="identifier">clone_ptr</span></code> so that it will work both in
compilers with rvalue references and those who conform to C++03. You just
need to follow these simple steps:
</p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
Put the following macro in the <span class="bold"><strong>private</strong></span>
section: <code class="computeroutput"><a class="link" href="../BOOST_COPYABLE_AND_MOVABLE.html" title="Macro BOOST_COPYABLE_AND_MOVABLE">BOOST_COPYABLE_AND_MOVABLE(classname)</a></code>
</li>
<li class="listitem">
Leave copy constructor as is.
</li>
<li class="listitem">
Write a copy assignment taking the parameter as <code class="computeroutput"><a class="link" href="../BOOST_COPY_ASSIGN_REF.html" title="Macro BOOST_COPY_ASSIGN_REF">BOOST_COPY_ASSIGN_REF(classname)</a></code>
</li>
<li class="listitem">
Write a move constructor and a move assignment taking the parameter as
<code class="computeroutput"><a class="link" href="../BOOST_RV_REF.html" title="Macro BOOST_RV_REF">BOOST_RV_REF(classname)</a></code>
</li>
</ul></div>
<p>
Let's see how are applied to <code class="computeroutput"><span class="identifier">clone_ptr</span></code>:
</p>
<p>
</p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">clone_ptr</span>
<span class="special">{</span>
<span class="keyword">private</span><span class="special">:</span>
<span class="comment">// Mark this class copyable and movable</span>
<span class="identifier">BOOST_COPYABLE_AND_MOVABLE</span><span class="special">(</span><span class="identifier">clone_ptr</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">public</span><span class="special">:</span>
<span class="comment">// Construction</span>
<span class="keyword">explicit</span> <span class="identifier">clone_ptr</span><span class="special">(</span><span class="identifier">T</span><span class="special">*</span> <span class="identifier">p</span> <span class="special">=</span> <span class="number">0</span><span class="special">)</span> <span class="special">:</span> <span class="identifier">ptr</span><span class="special">(</span><span class="identifier">p</span><span class="special">)</span> <span class="special">{}</span>
<span class="comment">// Destruction</span>
<span class="special">~</span><span class="identifier">clone_ptr</span><span class="special">()</span> <span class="special">{</span> <span class="keyword">delete</span> <span class="identifier">ptr</span><span class="special">;</span> <span class="special">}</span>
<span class="identifier">clone_ptr</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">clone_ptr</span><span class="special">&amp;</span> <span class="identifier">p</span><span class="special">)</span> <span class="comment">// Copy constructor (as usual)</span>
<span class="special">:</span> <span class="identifier">ptr</span><span class="special">(</span><span class="identifier">p</span><span class="special">.</span><span class="identifier">ptr</span> <span class="special">?</span> <span class="identifier">p</span><span class="special">.</span><span class="identifier">ptr</span><span class="special">-&gt;</span><span class="identifier">clone</span><span class="special">()</span> <span class="special">:</span> <span class="number">0</span><span class="special">)</span> <span class="special">{}</span>
<span class="identifier">clone_ptr</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="identifier">BOOST_COPY_ASSIGN_REF</span><span class="special">(</span><span class="identifier">clone_ptr</span><span class="special">)</span> <span class="identifier">p</span><span class="special">)</span> <span class="comment">// Copy assignment</span>
<span class="special">{</span>
<span class="keyword">if</span> <span class="special">(</span><span class="keyword">this</span> <span class="special">!=</span> <span class="special">&amp;</span><span class="identifier">p</span><span class="special">){</span>
<span class="identifier">T</span> <span class="special">*</span><span class="identifier">tmp_p</span> <span class="special">=</span> <span class="identifier">p</span><span class="special">.</span><span class="identifier">ptr</span> <span class="special">?</span> <span class="identifier">p</span><span class="special">.</span><span class="identifier">ptr</span><span class="special">-&gt;</span><span class="identifier">clone</span><span class="special">()</span> <span class="special">:</span> <span class="number">0</span><span class="special">;</span>
<span class="keyword">delete</span> <span class="identifier">ptr</span><span class="special">;</span>
<span class="identifier">ptr</span> <span class="special">=</span> <span class="identifier">tmp_p</span><span class="special">;</span>
<span class="special">}</span>
<span class="keyword">return</span> <span class="special">*</span><span class="keyword">this</span><span class="special">;</span>
<span class="special">}</span>
<span class="comment">//Move semantics...</span>
<span class="identifier">clone_ptr</span><span class="special">(</span><span class="identifier">BOOST_RV_REF</span><span class="special">(</span><span class="identifier">clone_ptr</span><span class="special">)</span> <span class="identifier">p</span><span class="special">)</span> <span class="comment">//Move constructor</span>
<span class="special">:</span> <span class="identifier">ptr</span><span class="special">(</span><span class="identifier">p</span><span class="special">.</span><span class="identifier">ptr</span><span class="special">)</span> <span class="special">{</span> <span class="identifier">p</span><span class="special">.</span><span class="identifier">ptr</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span> <span class="special">}</span>
<span class="identifier">clone_ptr</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="identifier">BOOST_RV_REF</span><span class="special">(</span><span class="identifier">clone_ptr</span><span class="special">)</span> <span class="identifier">p</span><span class="special">)</span> <span class="comment">//Move assignment</span>
<span class="special">{</span>
<span class="keyword">if</span> <span class="special">(</span><span class="keyword">this</span> <span class="special">!=</span> <span class="special">&amp;</span><span class="identifier">p</span><span class="special">){</span>
<span class="keyword">delete</span> <span class="identifier">ptr</span><span class="special">;</span>
<span class="identifier">ptr</span> <span class="special">=</span> <span class="identifier">p</span><span class="special">.</span><span class="identifier">ptr</span><span class="special">;</span>
<span class="identifier">p</span><span class="special">.</span><span class="identifier">ptr</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span>
<span class="special">}</span>
<span class="keyword">return</span> <span class="special">*</span><span class="keyword">this</span><span class="special">;</span>
<span class="special">}</span>
<span class="special">};</span>
</pre>
<p>
</p>
</div>
<p>
<span class="bold"><strong>Question</strong></span>: What about types that don't own
resources? (E.g. <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">complex</span></code>?)
</p>
<p>
No work needs to be done in that case. The copy constructor is already optimal.
</p>
</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 © 2008-2014 Ion Gaztanaga<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="introduction.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../move.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="composition_inheritance.html"><img src="../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@@ -0,0 +1,101 @@
<!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=UTF-8">
<title>Introduction</title>
<link rel="stylesheet" href="../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../index.html" title="The Boost C++ Libraries BoostBook Documentation Subset">
<link rel="up" href="../move.html" title="Chapter 25. Boost.Move">
<link rel="prev" href="what_is_boost_move.html" title="What is Boost.Move?">
<link rel="next" href="implementing_movable_classes.html" title="Implementing copyable and movable classes">
</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="what_is_boost_move.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../move.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="implementing_movable_classes.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="move.introduction"></a><a class="link" href="introduction.html" title="Introduction">Introduction</a>
</h2></div></div></div>
<div class="note"><table border="0" summary="Note">
<tr>
<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../doc/src/images/note.png"></td>
<th align="left">Note</th>
</tr>
<tr><td align="left" valign="top"><p>
The first 3 chapters are the adapted from the article <a href="http://www.artima.com/cppsource/rvalue.html" target="_top"><span class="emphasis"><em>A
Brief Introduction to Rvalue References</em></span></a> by Howard E. Hinnant,
Bjarne Stroustrup, and Bronek Kozicki
</p></td></tr>
</table></div>
<p>
Copying can be expensive. For example, for vectors <code class="computeroutput"><span class="identifier">v2</span><span class="special">=</span><span class="identifier">v1</span></code> typically
involves a function call, a memory allocation, and a loop. This is of course
acceptable where we actually need two copies of a vector, but in many cases,
we don't: We often copy a <code class="computeroutput"><span class="identifier">vector</span></code>
from one place to another, just to proceed to overwrite the old copy. Consider:
</p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">void</span> <span class="identifier">swap</span><span class="special">(</span><span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">)</span>
<span class="special">{</span>
<span class="identifier">T</span> <span class="identifier">tmp</span><span class="special">(</span><span class="identifier">a</span><span class="special">);</span> <span class="comment">// now we have two copies of a</span>
<span class="identifier">a</span> <span class="special">=</span> <span class="identifier">b</span><span class="special">;</span> <span class="comment">// now we have two copies of b</span>
<span class="identifier">b</span> <span class="special">=</span> <span class="identifier">tmp</span><span class="special">;</span> <span class="comment">// now we have two copies of tmp (aka a)</span>
<span class="special">}</span>
</pre>
<p>
But, we didn't want to have any copies of a or b, we just wanted to swap them.
Let's try again:
</p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">void</span> <span class="identifier">swap</span><span class="special">(</span><span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">)</span>
<span class="special">{</span>
<span class="identifier">T</span> <span class="identifier">tmp</span><span class="special">(::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">a</span><span class="special">));</span>
<span class="identifier">a</span> <span class="special">=</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">b</span><span class="special">);</span>
<span class="identifier">b</span> <span class="special">=</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">tmp</span><span class="special">);</span>
<span class="special">}</span>
</pre>
<p>
This <code class="computeroutput"><span class="identifier">move</span><span class="special">()</span></code>
gives its target the value of its argument, but is not obliged to preserve
the value of its source. So, for a <code class="computeroutput"><span class="identifier">vector</span></code>,
<code class="computeroutput"><span class="identifier">move</span><span class="special">()</span></code>
could reasonably be expected to leave its argument as a zero-capacity vector
to avoid having to copy all the elements. In other words, <span class="bold"><strong>move
is a potentially destructive copy</strong></span>.
</p>
<p>
In this particular case, we could have optimized swap by a specialization.
However, we can't specialize every function that copies a large object just
before it deletes or overwrites it. That would be unmanageable.
</p>
<p>
In C++0x, move semantics are implemented with the introduction of rvalue references.
They allow us to implement <code class="computeroutput"><span class="identifier">move</span><span class="special">()</span></code> without verbosity or runtime overhead. <span class="bold"><strong>Boost.Move</strong></span> is a library that offers tools to implement
those move semantics not only in compilers with <code class="computeroutput"><span class="identifier">rvalue</span>
<span class="identifier">references</span></code> but also in compilers
conforming to C++03.
</p>
</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 © 2008-2014 Ion Gaztanaga<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="what_is_boost_move.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../move.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="implementing_movable_classes.html"><img src="../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@@ -0,0 +1,135 @@
<!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=UTF-8">
<title>Movable but Non-Copyable Types</title>
<link rel="stylesheet" href="../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../index.html" title="The Boost C++ Libraries BoostBook Documentation Subset">
<link rel="up" href="../move.html" title="Chapter 25. Boost.Move">
<link rel="prev" href="composition_inheritance.html" title="Composition or inheritance">
<link rel="next" href="move_and_containers.html" title="Containers and move semantics">
</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="composition_inheritance.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../move.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="move_and_containers.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="move.movable_only_classes"></a><a class="link" href="movable_only_classes.html" title="Movable but Non-Copyable Types">Movable but Non-Copyable Types</a>
</h2></div></div></div>
<p>
Some types are not amenable to copy semantics but can still be made movable.
For example:
</p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
<code class="computeroutput"><span class="identifier">unique_ptr</span></code> (non-shared,
non-copyable ownership)
</li>
<li class="listitem">
A type representing a thread of execution
</li>
<li class="listitem">
A type representing a file descriptor
</li>
</ul></div>
<p>
By making such types movable (though still non-copyable) their utility is tremendously
increased. Movable but non-copyable types can be returned by value from factory
functions:
</p>
<pre class="programlisting"><span class="identifier">file_descriptor</span> <span class="identifier">create_file</span><span class="special">(/*</span> <span class="special">...</span> <span class="special">*/);</span>
<span class="comment">//...</span>
<span class="identifier">file_descriptor</span> <span class="identifier">data_file</span><span class="special">;</span>
<span class="comment">//...</span>
<span class="identifier">data_file</span> <span class="special">=</span> <span class="identifier">create_file</span><span class="special">(/*</span> <span class="special">...</span> <span class="special">*/);</span> <span class="comment">// No copies!</span>
</pre>
<p>
In the above example, the underlying file handle is passed from object to object,
as long as the source <code class="computeroutput"><span class="identifier">file_descriptor</span></code>
is a rvalue. At all times, there is still only one underlying file handle,
and only one <code class="computeroutput"><span class="identifier">file_descriptor</span></code>
owns it at a time.
</p>
<p>
To write a movable but not copyable type in portable syntax, you need to follow
these simple steps:
</p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
Put the following macro in the <span class="bold"><strong>private</strong></span>
section: <code class="computeroutput"><a class="link" href="../BOOST_MOVABL_1_3_26_20_7_3.html" title="Macro BOOST_MOVABLE_BUT_NOT_COPYABLE">BOOST_MOVABLE_BUT_NOT_COPYABLE(classname)</a></code>
</li>
<li class="listitem">
Write a move constructor and a move assignment taking the parameter as
<code class="computeroutput"><a class="link" href="../BOOST_RV_REF.html" title="Macro BOOST_RV_REF">BOOST_RV_REF(classname)</a></code>
</li>
</ul></div>
<p>
Here's the definition of <code class="computeroutput"><span class="identifier">file</span> <span class="identifier">descriptor</span></code> using portable syntax:
</p>
<p>
</p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">move</span><span class="special">/</span><span class="identifier">utility_core</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">stdexcept</span><span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">file_descriptor</span>
<span class="special">{</span>
<span class="keyword">int</span> <span class="identifier">os_descr_</span><span class="special">;</span>
<span class="keyword">private</span><span class="special">:</span>
<span class="identifier">BOOST_MOVABLE_BUT_NOT_COPYABLE</span><span class="special">(</span><span class="identifier">file_descriptor</span><span class="special">)</span>
<span class="keyword">public</span><span class="special">:</span>
<span class="keyword">explicit</span> <span class="identifier">file_descriptor</span><span class="special">(</span><span class="keyword">const</span> <span class="keyword">char</span> <span class="special">*</span><span class="identifier">filename</span><span class="special">)</span> <span class="comment">//Constructor</span>
<span class="special">:</span> <span class="identifier">os_descr_</span><span class="special">(</span><span class="identifier">operating_system_open_file</span><span class="special">(</span><span class="identifier">filename</span><span class="special">))</span>
<span class="special">{</span>
<span class="keyword">if</span><span class="special">(!</span><span class="identifier">os_descr_</span><span class="special">)</span>
<span class="keyword">throw</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">runtime_error</span><span class="special">(</span><span class="string">"file not found"</span><span class="special">);</span>
<span class="special">}</span>
<span class="special">~</span><span class="identifier">file_descriptor</span><span class="special">()</span> <span class="comment">//Destructor</span>
<span class="special">{</span> <span class="keyword">if</span><span class="special">(</span><span class="identifier">os_descr_</span><span class="special">)</span> <span class="identifier">operating_system_close_file</span><span class="special">(</span><span class="identifier">os_descr_</span><span class="special">);</span> <span class="special">}</span>
<span class="identifier">file_descriptor</span><span class="special">(</span><span class="identifier">BOOST_RV_REF</span><span class="special">(</span><span class="identifier">file_descriptor</span><span class="special">)</span> <span class="identifier">x</span><span class="special">)</span> <span class="comment">// Move ctor</span>
<span class="special">:</span> <span class="identifier">os_descr_</span><span class="special">(</span><span class="identifier">x</span><span class="special">.</span><span class="identifier">os_descr_</span><span class="special">)</span>
<span class="special">{</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">os_descr_</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span> <span class="special">}</span>
<span class="identifier">file_descriptor</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="identifier">BOOST_RV_REF</span><span class="special">(</span><span class="identifier">file_descriptor</span><span class="special">)</span> <span class="identifier">x</span><span class="special">)</span> <span class="comment">// Move assign</span>
<span class="special">{</span>
<span class="keyword">if</span><span class="special">(</span><span class="identifier">os_descr_</span><span class="special">)</span> <span class="identifier">operating_system_close_file</span><span class="special">(</span><span class="identifier">os_descr_</span><span class="special">);</span>
<span class="identifier">os_descr_</span> <span class="special">=</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">os_descr_</span><span class="special">;</span>
<span class="identifier">x</span><span class="special">.</span><span class="identifier">os_descr_</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span>
<span class="keyword">return</span> <span class="special">*</span><span class="keyword">this</span><span class="special">;</span>
<span class="special">}</span>
<span class="keyword">bool</span> <span class="identifier">empty</span><span class="special">()</span> <span class="keyword">const</span> <span class="special">{</span> <span class="keyword">return</span> <span class="identifier">os_descr_</span> <span class="special">==</span> <span class="number">0</span><span class="special">;</span> <span class="special">}</span>
<span class="special">};</span>
</pre>
<p>
</p>
</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 © 2008-2014 Ion Gaztanaga<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="composition_inheritance.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../move.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="move_and_containers.html"><img src="../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@@ -0,0 +1,97 @@
<!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=UTF-8">
<title>Move algorithms</title>
<link rel="stylesheet" href="../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../index.html" title="The Boost C++ Libraries BoostBook Documentation Subset">
<link rel="up" href="../move.html" title="Chapter 25. Boost.Move">
<link rel="prev" href="move_inserters.html" title="Move inserters">
<link rel="next" href="emulation_limitations.html" title="Emulation limitations">
</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="move_inserters.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../move.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="emulation_limitations.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="move.move_algorithms"></a><a class="link" href="move_algorithms.html" title="Move algorithms">Move algorithms</a>
</h2></div></div></div>
<p>
The standard library offers several copy-based algorithms. Some of them, like
<code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">copy</span></code> or <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">uninitialized_copy</span></code>
are basic building blocks for containers and other data structures. This library
offers move-based functions for those purposes:
</p>
<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">I</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">O</span><span class="special">&gt;</span> <span class="identifier">O</span> <span class="identifier">move</span><span class="special">(</span><span class="identifier">I</span><span class="special">,</span> <span class="identifier">I</span><span class="special">,</span> <span class="identifier">O</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">I</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">O</span><span class="special">&gt;</span> <span class="identifier">O</span> <span class="identifier">move_backward</span><span class="special">(</span><span class="identifier">I</span><span class="special">,</span> <span class="identifier">I</span><span class="special">,</span> <span class="identifier">O</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">I</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">F</span><span class="special">&gt;</span> <span class="identifier">F</span> <span class="identifier">uninitialized_move</span><span class="special">(</span><span class="identifier">I</span><span class="special">,</span> <span class="identifier">I</span><span class="special">,</span> <span class="identifier">F</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">I</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">F</span><span class="special">&gt;</span> <span class="identifier">F</span> <span class="identifier">uninitialized_copy_or_move</span><span class="special">(</span><span class="identifier">I</span><span class="special">,</span> <span class="identifier">I</span><span class="special">,</span> <span class="identifier">F</span><span class="special">);</span>
</pre>
<p>
The first 3 are move variations of their equivalent copy algorithms, but copy
assignment and copy construction are replaced with move assignment and construction.
The last one has the same behaviour as <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">uninitialized_copy</span></code>
but since several standand library implementations don't play very well with
<code class="computeroutput"><span class="identifier">move_iterator</span></code>s, this version
is a portable version for those willing to use move iterators.
</p>
<p>
</p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="string">"movable.hpp"</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">move</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">cassert</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">aligned_storage</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
<span class="special">{</span>
<span class="keyword">const</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">ArraySize</span> <span class="special">=</span> <span class="number">10</span><span class="special">;</span>
<span class="identifier">movable</span> <span class="identifier">movable_array</span><span class="special">[</span><span class="identifier">ArraySize</span><span class="special">];</span>
<span class="identifier">movable</span> <span class="identifier">movable_array2</span><span class="special">[</span><span class="identifier">ArraySize</span><span class="special">];</span>
<span class="comment">//move</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">move</span><span class="special">(&amp;</span><span class="identifier">movable_array2</span><span class="special">[</span><span class="number">0</span><span class="special">],</span> <span class="special">&amp;</span><span class="identifier">movable_array2</span><span class="special">[</span><span class="identifier">ArraySize</span><span class="special">],</span> <span class="special">&amp;</span><span class="identifier">movable_array</span><span class="special">[</span><span class="number">0</span><span class="special">]);</span>
<span class="identifier">assert</span><span class="special">(</span><span class="identifier">movable_array2</span><span class="special">[</span><span class="number">0</span><span class="special">].</span><span class="identifier">moved</span><span class="special">());</span>
<span class="identifier">assert</span><span class="special">(!</span><span class="identifier">movable_array</span><span class="special">[</span><span class="number">0</span><span class="special">].</span><span class="identifier">moved</span><span class="special">());</span>
<span class="comment">//move backward</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">move_backward</span><span class="special">(&amp;</span><span class="identifier">movable_array</span><span class="special">[</span><span class="number">0</span><span class="special">],</span> <span class="special">&amp;</span><span class="identifier">movable_array</span><span class="special">[</span><span class="identifier">ArraySize</span><span class="special">],</span> <span class="special">&amp;</span><span class="identifier">movable_array2</span><span class="special">[</span><span class="identifier">ArraySize</span><span class="special">]);</span>
<span class="identifier">assert</span><span class="special">(</span><span class="identifier">movable_array</span><span class="special">[</span><span class="number">0</span><span class="special">].</span><span class="identifier">moved</span><span class="special">());</span>
<span class="identifier">assert</span><span class="special">(!</span><span class="identifier">movable_array2</span><span class="special">[</span><span class="number">0</span><span class="special">].</span><span class="identifier">moved</span><span class="special">());</span>
<span class="comment">//uninitialized_move</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">aligned_storage</span><span class="special">&lt;</span> <span class="keyword">sizeof</span><span class="special">(</span><span class="identifier">movable</span><span class="special">)*</span><span class="identifier">ArraySize</span>
<span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">alignment_of</span><span class="special">&lt;</span><span class="identifier">movable</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">storage</span><span class="special">;</span>
<span class="identifier">movable</span> <span class="special">*</span><span class="identifier">raw_movable</span> <span class="special">=</span> <span class="keyword">static_cast</span><span class="special">&lt;</span><span class="identifier">movable</span><span class="special">*&gt;(</span><span class="keyword">static_cast</span><span class="special">&lt;</span><span class="keyword">void</span><span class="special">*&gt;(&amp;</span><span class="identifier">storage</span><span class="special">));</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">uninitialized_move</span><span class="special">(&amp;</span><span class="identifier">movable_array2</span><span class="special">[</span><span class="number">0</span><span class="special">],</span> <span class="special">&amp;</span><span class="identifier">movable_array2</span><span class="special">[</span><span class="identifier">ArraySize</span><span class="special">],</span> <span class="identifier">raw_movable</span><span class="special">);</span>
<span class="identifier">assert</span><span class="special">(</span><span class="identifier">movable_array2</span><span class="special">[</span><span class="number">0</span><span class="special">].</span><span class="identifier">moved</span><span class="special">());</span>
<span class="identifier">assert</span><span class="special">(!</span><span class="identifier">raw_movable</span><span class="special">[</span><span class="number">0</span><span class="special">].</span><span class="identifier">moved</span><span class="special">());</span>
<span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
<span class="special">}</span>
</pre>
<p>
</p>
</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 © 2008-2014 Ion Gaztanaga<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="move_inserters.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../move.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="emulation_limitations.html"><img src="../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@@ -0,0 +1,85 @@
<!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=UTF-8">
<title>Containers and move semantics</title>
<link rel="stylesheet" href="../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../index.html" title="The Boost C++ Libraries BoostBook Documentation Subset">
<link rel="up" href="../move.html" title="Chapter 25. Boost.Move">
<link rel="prev" href="movable_only_classes.html" title="Movable but Non-Copyable Types">
<link rel="next" href="construct_forwarding.html" title="Constructor Forwarding">
</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="movable_only_classes.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../move.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="construct_forwarding.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="move.move_and_containers"></a><a class="link" href="move_and_containers.html" title="Containers and move semantics">Containers and move semantics</a>
</h2></div></div></div>
<p>
Movable but non-copyable types can be safely inserted into containers and movable
and copyable types are more efficiently handled if those containers internally
use move semantics instead of copy semantics. If the container needs to "change
the location" of an element internally (e.g. vector reallocation) it will
move the element instead of copying it. <span class="bold"><strong>Boost.Container</strong></span>
containers are move-aware so you can write the following:
</p>
<p>
</p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">container</span><span class="special">/</span><span class="identifier">vector</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">cassert</span><span class="special">&gt;</span>
<span class="comment">//Remember: 'file_descriptor' is NOT copyable, but it</span>
<span class="comment">//can be returned from functions thanks to move semantics</span>
<span class="identifier">file_descriptor</span> <span class="identifier">create_file_descriptor</span><span class="special">(</span><span class="keyword">const</span> <span class="keyword">char</span> <span class="special">*</span><span class="identifier">filename</span><span class="special">)</span>
<span class="special">{</span> <span class="keyword">return</span> <span class="identifier">file_descriptor</span><span class="special">(</span><span class="identifier">filename</span><span class="special">);</span> <span class="special">}</span>
<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
<span class="special">{</span>
<span class="comment">//Open a file obtaining its descriptor, the temporary</span>
<span class="comment">//returned from 'create_file_descriptor' is moved to 'fd'.</span>
<span class="identifier">file_descriptor</span> <span class="identifier">fd</span> <span class="special">=</span> <span class="identifier">create_file_descriptor</span><span class="special">(</span><span class="string">"filename"</span><span class="special">);</span>
<span class="identifier">assert</span><span class="special">(!</span><span class="identifier">fd</span><span class="special">.</span><span class="identifier">empty</span><span class="special">());</span>
<span class="comment">//Now move fd into a vector</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">container</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">file_descriptor</span><span class="special">&gt;</span> <span class="identifier">v</span><span class="special">;</span>
<span class="identifier">v</span><span class="special">.</span><span class="identifier">push_back</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">fd</span><span class="special">));</span>
<span class="comment">//Check ownership has been transferred</span>
<span class="identifier">assert</span><span class="special">(</span><span class="identifier">fd</span><span class="special">.</span><span class="identifier">empty</span><span class="special">());</span>
<span class="identifier">assert</span><span class="special">(!</span><span class="identifier">v</span><span class="special">[</span><span class="number">0</span><span class="special">].</span><span class="identifier">empty</span><span class="special">());</span>
<span class="comment">//Compilation error if uncommented since file_descriptor is not copyable</span>
<span class="comment">//and vector copy construction requires value_type's copy constructor:</span>
<span class="comment">//boost::container::vector&lt;file_descriptor&gt; v2(v);</span>
<span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
<span class="special">}</span>
</pre>
<p>
</p>
</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 © 2008-2014 Ion Gaztanaga<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="movable_only_classes.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../move.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="construct_forwarding.html"><img src="../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@@ -0,0 +1,134 @@
<!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=UTF-8">
<title>Move inserters</title>
<link rel="stylesheet" href="../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../index.html" title="The Boost C++ Libraries BoostBook Documentation Subset">
<link rel="up" href="../move.html" title="Chapter 25. Boost.Move">
<link rel="prev" href="move_iterator.html" title="Move iterators">
<link rel="next" href="move_algorithms.html" title="Move algorithms">
</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="move_iterator.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../move.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="move_algorithms.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="move.move_inserters"></a><a class="link" href="move_inserters.html" title="Move inserters">Move inserters</a>
</h2></div></div></div>
<p>
Similar to standard insert iterators, it's possible to deal with move insertion
in the same way as writing into an array. A special kind of iterator adaptors,
called move insert iterators, are provided with this library. With regular
iterator classes,
</p>
<pre class="programlisting"><span class="keyword">while</span> <span class="special">(</span><span class="identifier">first</span> <span class="special">!=</span> <span class="identifier">last</span><span class="special">)</span> <span class="special">*</span><span class="identifier">result</span><span class="special">++</span> <span class="special">=</span> <span class="special">*</span><span class="identifier">first</span><span class="special">++;</span>
</pre>
<p>
causes a range [first,last) to be copied into a range starting with result.
The same code with result being a move insert iterator will move insert corresponding
elements into the container. This device allows all of the copying algorithms
in the library to work in the move insert mode instead of the regular overwrite
mode. This library offers 3 move insert iterators and their helper functions:
</p>
<pre class="programlisting"><span class="comment">// Note: C models Container</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">C</span><span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">back_move_insert_iterator</span><span class="special">;</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">C</span><span class="special">&gt;</span>
<span class="identifier">back_move_insert_iterator</span><span class="special">&lt;</span><span class="identifier">C</span><span class="special">&gt;</span> <span class="identifier">back_move_inserter</span><span class="special">(</span><span class="identifier">C</span><span class="special">&amp;</span> <span class="identifier">x</span><span class="special">);</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">C</span><span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">front_move_insert_iterator</span><span class="special">;</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">C</span><span class="special">&gt;</span>
<span class="identifier">front_move_insert_iterator</span><span class="special">&lt;</span><span class="identifier">C</span><span class="special">&gt;</span> <span class="identifier">front_move_inserter</span><span class="special">(</span><span class="identifier">C</span><span class="special">&amp;</span> <span class="identifier">x</span><span class="special">);</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">C</span><span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">move_insert_iterator</span><span class="special">;</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">C</span><span class="special">&gt;</span>
<span class="identifier">move_insert_iterator</span><span class="special">&lt;</span><span class="identifier">C</span><span class="special">&gt;</span> <span class="identifier">move_inserter</span><span class="special">(</span><span class="identifier">C</span><span class="special">&amp;</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">C</span><span class="special">::</span><span class="identifier">iterator</span> <span class="identifier">it</span><span class="special">);</span>
</pre>
<p>
A move insert iterator is constructed from a container and possibly one of
its iterators pointing to where insertion takes place if it is neither at the
beginning nor at the end of the container. Insert iterators satisfy the requirements
of output iterators. <code class="computeroutput"><span class="keyword">operator</span><span class="special">*</span></code> returns the move insert iterator itself. The
assignment <code class="computeroutput"><span class="keyword">operator</span><span class="special">=(</span><span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">x</span><span class="special">)</span></code> is defined on insert iterators to allow writing
into them, it inserts x right before where the insert iterator is pointing.
In other words, an <code class="computeroutput"><span class="identifier">insert</span> <span class="identifier">iterator</span></code> is like a cursor pointing into the
container where the insertion takes place. <code class="computeroutput"><span class="identifier">back_move_iterator</span></code>
move inserts elements at the end of a container, <code class="computeroutput"><span class="identifier">front_insert_iterator</span></code>
move inserts elements at the beginning of a container, and <code class="computeroutput"><span class="identifier">move_insert_iterator</span></code>
move inserts elements where the iterator points to in a container. <code class="computeroutput"><span class="identifier">back_move_inserter</span></code>, <code class="computeroutput"><span class="identifier">front_move_inserter</span></code>,
and <code class="computeroutput"><span class="identifier">move_inserter</span></code> are three
functions making the insert iterators out of a container. Here's an example
of how to use them:
</p>
<p>
</p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">container</span><span class="special">/</span><span class="identifier">list</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="string">"movable.hpp"</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">cassert</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">algorithm</span><span class="special">&gt;</span>
<span class="keyword">using</span> <span class="keyword">namespace</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">container</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">list</span><span class="special">&lt;</span><span class="identifier">movable</span><span class="special">&gt;</span> <span class="identifier">list_t</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">list_t</span><span class="special">::</span><span class="identifier">iterator</span> <span class="identifier">l_iterator</span><span class="special">;</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">MoveInsertIterator</span><span class="special">&gt;</span>
<span class="keyword">void</span> <span class="identifier">test_move_inserter</span><span class="special">(</span><span class="identifier">list_t</span> <span class="special">&amp;</span><span class="identifier">l2</span><span class="special">,</span> <span class="identifier">MoveInsertIterator</span> <span class="identifier">mit</span><span class="special">)</span>
<span class="special">{</span>
<span class="comment">//Create a list with 10 default constructed objects</span>
<span class="identifier">list</span><span class="special">&lt;</span><span class="identifier">movable</span><span class="special">&gt;</span> <span class="identifier">l</span><span class="special">(</span><span class="number">10</span><span class="special">);</span>
<span class="identifier">assert</span><span class="special">(!</span><span class="identifier">l</span><span class="special">.</span><span class="identifier">begin</span><span class="special">()-&gt;</span><span class="identifier">moved</span><span class="special">());</span>
<span class="identifier">l2</span><span class="special">.</span><span class="identifier">clear</span><span class="special">();</span>
<span class="comment">//Move insert into l2 containers</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">copy</span><span class="special">(</span><span class="identifier">l</span><span class="special">.</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">l</span><span class="special">.</span><span class="identifier">end</span><span class="special">(),</span> <span class="identifier">mit</span><span class="special">);</span>
<span class="comment">//Check size and status</span>
<span class="identifier">assert</span><span class="special">(</span><span class="identifier">l2</span><span class="special">.</span><span class="identifier">size</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">l</span><span class="special">.</span><span class="identifier">size</span><span class="special">());</span>
<span class="identifier">assert</span><span class="special">(</span><span class="identifier">l</span><span class="special">.</span><span class="identifier">begin</span><span class="special">()-&gt;</span><span class="identifier">moved</span><span class="special">());</span>
<span class="identifier">assert</span><span class="special">(!</span><span class="identifier">l2</span><span class="special">.</span><span class="identifier">begin</span><span class="special">()-&gt;</span><span class="identifier">moved</span><span class="special">());</span>
<span class="special">}</span>
<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
<span class="special">{</span>
<span class="identifier">list_t</span> <span class="identifier">l2</span><span class="special">;</span>
<span class="identifier">test_move_inserter</span><span class="special">(</span><span class="identifier">l2</span><span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">back_move_inserter</span><span class="special">(</span><span class="identifier">l2</span><span class="special">));</span>
<span class="identifier">test_move_inserter</span><span class="special">(</span><span class="identifier">l2</span><span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">front_move_inserter</span><span class="special">(</span><span class="identifier">l2</span><span class="special">));</span>
<span class="identifier">test_move_inserter</span><span class="special">(</span><span class="identifier">l2</span><span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">move_inserter</span><span class="special">(</span><span class="identifier">l2</span><span class="special">,</span> <span class="identifier">l2</span><span class="special">.</span><span class="identifier">end</span><span class="special">()));</span>
<span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
<span class="special">}</span>
</pre>
<p>
</p>
</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 © 2008-2014 Ion Gaztanaga<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="move_iterator.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../move.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="move_algorithms.html"><img src="../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@@ -0,0 +1,139 @@
<!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=UTF-8">
<title>Move iterators</title>
<link rel="stylesheet" href="../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../index.html" title="The Boost C++ Libraries BoostBook Documentation Subset">
<link rel="up" href="../move.html" title="Chapter 25. Boost.Move">
<link rel="prev" href="move_return.html" title="Implicit Move when returning a local object">
<link rel="next" href="move_inserters.html" title="Move inserters">
</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="move_return.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../move.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="move_inserters.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="move.move_iterator"></a><a class="link" href="move_iterator.html" title="Move iterators">Move iterators</a>
</h2></div></div></div>
<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Iterator</span><span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">move_iterator</span><span class="special">;</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">It</span><span class="special">&gt;</span>
<span class="identifier">move_iterator</span><span class="special">&lt;</span><span class="identifier">It</span><span class="special">&gt;</span> <span class="identifier">make_move_iterator</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">It</span> <span class="special">&amp;</span><span class="identifier">it</span><span class="special">);</span>
</pre>
<p>
<code class="computeroutput"><a class="link" href="../boost/move_iterator.html" title="Class template move_iterator">move_iterator</a></code> is an iterator
adaptor with the same behavior as the underlying iterator except that its dereference
operator implicitly converts the value returned by the underlying iterator's
dereference operator to a rvalue reference: <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">move</span><span class="special">(*</span><span class="identifier">underlying_iterator</span><span class="special">)</span></code>
It is a read-once iterator, but can have up to random access traversal characteristics.
</p>
<p>
<code class="computeroutput"><span class="identifier">move_iterator</span></code> is very useful
because some generic algorithms and container insertion functions can be called
with move iterators to replace copying with moving. For example:
</p>
<p>
</p>
<pre class="programlisting"><span class="comment">//header file "movable.hpp"</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">move</span><span class="special">/</span><span class="identifier">core</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">move</span><span class="special">/</span><span class="identifier">traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="comment">//A movable class</span>
<span class="keyword">class</span> <span class="identifier">movable</span>
<span class="special">{</span>
<span class="identifier">BOOST_MOVABLE_BUT_NOT_COPYABLE</span><span class="special">(</span><span class="identifier">movable</span><span class="special">)</span>
<span class="keyword">int</span> <span class="identifier">value_</span><span class="special">;</span>
<span class="keyword">public</span><span class="special">:</span>
<span class="identifier">movable</span><span class="special">()</span> <span class="special">:</span> <span class="identifier">value_</span><span class="special">(</span><span class="number">1</span><span class="special">){}</span>
<span class="comment">//Move constructor and assignment</span>
<span class="identifier">movable</span><span class="special">(</span><span class="identifier">BOOST_RV_REF</span><span class="special">(</span><span class="identifier">movable</span><span class="special">)</span> <span class="identifier">m</span><span class="special">)</span>
<span class="special">{</span> <span class="identifier">value_</span> <span class="special">=</span> <span class="identifier">m</span><span class="special">.</span><span class="identifier">value_</span><span class="special">;</span> <span class="identifier">m</span><span class="special">.</span><span class="identifier">value_</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span> <span class="special">}</span>
<span class="identifier">movable</span> <span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="identifier">BOOST_RV_REF</span><span class="special">(</span><span class="identifier">movable</span><span class="special">)</span> <span class="identifier">m</span><span class="special">)</span>
<span class="special">{</span> <span class="identifier">value_</span> <span class="special">=</span> <span class="identifier">m</span><span class="special">.</span><span class="identifier">value_</span><span class="special">;</span> <span class="identifier">m</span><span class="special">.</span><span class="identifier">value_</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span> <span class="keyword">return</span> <span class="special">*</span><span class="keyword">this</span><span class="special">;</span> <span class="special">}</span>
<span class="keyword">bool</span> <span class="identifier">moved</span><span class="special">()</span> <span class="keyword">const</span> <span class="comment">//Observer</span>
<span class="special">{</span> <span class="keyword">return</span> <span class="special">!</span><span class="identifier">value_</span><span class="special">;</span> <span class="special">}</span>
<span class="keyword">int</span> <span class="identifier">value</span><span class="special">()</span> <span class="keyword">const</span> <span class="comment">//Observer</span>
<span class="special">{</span> <span class="keyword">return</span> <span class="identifier">value_</span><span class="special">;</span> <span class="special">}</span>
<span class="special">};</span>
<span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">{</span>
<span class="keyword">template</span><span class="special">&lt;&gt;</span>
<span class="keyword">struct</span> <span class="identifier">has_nothrow_move</span><span class="special">&lt;</span><span class="identifier">movable</span><span class="special">&gt;</span>
<span class="special">{</span>
<span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">bool</span> <span class="identifier">value</span> <span class="special">=</span> <span class="keyword">true</span><span class="special">;</span>
<span class="special">};</span>
<span class="special">}</span> <span class="comment">//namespace boost{</span>
</pre>
<p>
</p>
<p>
<code class="computeroutput"><span class="identifier">movable</span></code> objects can be moved
from one container to another using move iterators and insertion and assignment
operations.w
</p>
<p>
</p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">container</span><span class="special">/</span><span class="identifier">vector</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="string">"movable.hpp"</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">cassert</span><span class="special">&gt;</span>
<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
<span class="special">{</span>
<span class="keyword">using</span> <span class="keyword">namespace</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">container</span><span class="special">;</span>
<span class="comment">//Create a vector with 10 default constructed objects</span>
<span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">movable</span><span class="special">&gt;</span> <span class="identifier">v</span><span class="special">(</span><span class="number">10</span><span class="special">);</span>
<span class="identifier">assert</span><span class="special">(!</span><span class="identifier">v</span><span class="special">[</span><span class="number">0</span><span class="special">].</span><span class="identifier">moved</span><span class="special">());</span>
<span class="comment">//Move construct all elements in v into v2</span>
<span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">movable</span><span class="special">&gt;</span> <span class="identifier">v2</span><span class="special">(</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">make_move_iterator</span><span class="special">(</span><span class="identifier">v</span><span class="special">.</span><span class="identifier">begin</span><span class="special">())</span>
<span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">make_move_iterator</span><span class="special">(</span><span class="identifier">v</span><span class="special">.</span><span class="identifier">end</span><span class="special">()));</span>
<span class="identifier">assert</span><span class="special">(</span><span class="identifier">v</span><span class="special">[</span><span class="number">0</span><span class="special">].</span><span class="identifier">moved</span><span class="special">());</span>
<span class="identifier">assert</span><span class="special">(!</span><span class="identifier">v2</span><span class="special">[</span><span class="number">0</span><span class="special">].</span><span class="identifier">moved</span><span class="special">());</span>
<span class="comment">//Now move assign all elements from in v2 back into v</span>
<span class="identifier">v</span><span class="special">.</span><span class="identifier">assign</span><span class="special">(</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">make_move_iterator</span><span class="special">(</span><span class="identifier">v2</span><span class="special">.</span><span class="identifier">begin</span><span class="special">())</span>
<span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">make_move_iterator</span><span class="special">(</span><span class="identifier">v2</span><span class="special">.</span><span class="identifier">end</span><span class="special">()));</span>
<span class="identifier">assert</span><span class="special">(</span><span class="identifier">v2</span><span class="special">[</span><span class="number">0</span><span class="special">].</span><span class="identifier">moved</span><span class="special">());</span>
<span class="identifier">assert</span><span class="special">(!</span><span class="identifier">v</span><span class="special">[</span><span class="number">0</span><span class="special">].</span><span class="identifier">moved</span><span class="special">());</span>
<span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
<span class="special">}</span>
</pre>
<p>
</p>
</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 © 2008-2014 Ion Gaztanaga<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="move_return.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../move.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="move_inserters.html"><img src="../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@@ -0,0 +1,228 @@
<!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=UTF-8">
<title>Implicit Move when returning a local object</title>
<link rel="stylesheet" href="../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../index.html" title="The Boost C++ Libraries BoostBook Documentation Subset">
<link rel="up" href="../move.html" title="Chapter 25. Boost.Move">
<link rel="prev" href="construct_forwarding.html" title="Constructor Forwarding">
<link rel="next" href="move_iterator.html" title="Move iterators">
</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="construct_forwarding.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../move.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="move_iterator.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="move.move_return"></a><a class="link" href="move_return.html" title="Implicit Move when returning a local object">Implicit Move when returning a local
object</a>
</h2></div></div></div>
<p>
The C++ standard specifies situations where an implicit move operation is safe
and the compiler can use it in cases were the (Named) Return Value Optimization)
can't be used. The typical use case is when a function returns a named (non-temporary)
object by value and the following code will perfectly compile in C++11:
</p>
<pre class="programlisting"><span class="comment">//Even if movable can't be copied</span>
<span class="comment">//the compiler will call the move-constructor</span>
<span class="comment">//to generate the return value</span>
<span class="comment">//</span>
<span class="comment">//The compiler can also optimize out the move</span>
<span class="comment">//and directly construct the object 'm'</span>
<span class="identifier">movable</span> <span class="identifier">factory</span><span class="special">()</span>
<span class="special">{</span>
<span class="identifier">movable</span> <span class="identifier">tmp</span><span class="special">;</span>
<span class="identifier">m</span> <span class="special">=</span> <span class="special">...</span>
<span class="comment">//(1) moved instead of copied</span>
<span class="keyword">return</span> <span class="identifier">tmp</span><span class="special">;</span>
<span class="special">};</span>
<span class="comment">//Initialize object</span>
<span class="identifier">movable</span> <span class="identifier">m</span><span class="special">(</span><span class="identifier">factory</span><span class="special">());</span>
</pre>
<p>
In compilers without rvalue references and some non-conforming compilers (such
as Visual C++ 2010/2012) the line marked with <code class="computeroutput"><span class="special">(</span><span class="number">1</span><span class="special">)</span></code> would trigger
a compilation error because <code class="computeroutput"><span class="identifier">movable</span></code>
can't be copied. Using a explicit <code class="computeroutput"><span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">tmp</span><span class="special">)</span></code>
would workaround this limitation but it would code suboptimal in C++11 compilers
(as the compile could not use (N)RVO to optimize-away the copy/move).
</p>
<p>
<span class="bold"><strong>Boost.Move</strong></span> offers an additional macro called
<code class="computeroutput"><a class="link" href="../BOOST_MOVE_RET.html" title="Macro BOOST_MOVE_RET">BOOST_MOVE_RET</a></code> that can be used
to alleviate this problem obtaining portable move-on-return semantics. Let's
use the previously presented movable-only <code class="computeroutput"><span class="identifier">movable</span></code>
class with classes <code class="computeroutput"><span class="identifier">copyable</span></code>
(copy-only type), <code class="computeroutput"><span class="identifier">copy_movable</span></code>
(can be copied and moved) and <code class="computeroutput"><span class="identifier">non_copy_movable</span></code>
(non-copyable and non-movable):
</p>
<p>
</p>
<pre class="programlisting"><span class="comment">//header file "copymovable.hpp"</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">move</span><span class="special">/</span><span class="identifier">core</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="comment">//A copy_movable class</span>
<span class="keyword">class</span> <span class="identifier">copy_movable</span>
<span class="special">{</span>
<span class="identifier">BOOST_COPYABLE_AND_MOVABLE</span><span class="special">(</span><span class="identifier">copy_movable</span><span class="special">)</span>
<span class="keyword">int</span> <span class="identifier">value_</span><span class="special">;</span>
<span class="keyword">public</span><span class="special">:</span>
<span class="identifier">copy_movable</span><span class="special">()</span> <span class="special">:</span> <span class="identifier">value_</span><span class="special">(</span><span class="number">1</span><span class="special">){}</span>
<span class="comment">//Move constructor and assignment</span>
<span class="identifier">copy_movable</span><span class="special">(</span><span class="identifier">BOOST_RV_REF</span><span class="special">(</span><span class="identifier">copy_movable</span><span class="special">)</span> <span class="identifier">m</span><span class="special">)</span>
<span class="special">{</span> <span class="identifier">value_</span> <span class="special">=</span> <span class="identifier">m</span><span class="special">.</span><span class="identifier">value_</span><span class="special">;</span> <span class="identifier">m</span><span class="special">.</span><span class="identifier">value_</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span> <span class="special">}</span>
<span class="identifier">copy_movable</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">copy_movable</span> <span class="special">&amp;</span><span class="identifier">m</span><span class="special">)</span>
<span class="special">{</span> <span class="identifier">value_</span> <span class="special">=</span> <span class="identifier">m</span><span class="special">.</span><span class="identifier">value_</span><span class="special">;</span> <span class="special">}</span>
<span class="identifier">copy_movable</span> <span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="identifier">BOOST_RV_REF</span><span class="special">(</span><span class="identifier">copy_movable</span><span class="special">)</span> <span class="identifier">m</span><span class="special">)</span>
<span class="special">{</span> <span class="identifier">value_</span> <span class="special">=</span> <span class="identifier">m</span><span class="special">.</span><span class="identifier">value_</span><span class="special">;</span> <span class="identifier">m</span><span class="special">.</span><span class="identifier">value_</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span> <span class="keyword">return</span> <span class="special">*</span><span class="keyword">this</span><span class="special">;</span> <span class="special">}</span>
<span class="identifier">copy_movable</span> <span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="identifier">BOOST_COPY_ASSIGN_REF</span><span class="special">(</span><span class="identifier">copy_movable</span><span class="special">)</span> <span class="identifier">m</span><span class="special">)</span>
<span class="special">{</span> <span class="identifier">value_</span> <span class="special">=</span> <span class="identifier">m</span><span class="special">.</span><span class="identifier">value_</span><span class="special">;</span> <span class="keyword">return</span> <span class="special">*</span><span class="keyword">this</span><span class="special">;</span> <span class="special">}</span>
<span class="keyword">bool</span> <span class="identifier">moved</span><span class="special">()</span> <span class="keyword">const</span> <span class="comment">//Observer</span>
<span class="special">{</span> <span class="keyword">return</span> <span class="identifier">value_</span> <span class="special">==</span> <span class="number">0</span><span class="special">;</span> <span class="special">}</span>
<span class="special">};</span>
<span class="comment">//A copyable-only class</span>
<span class="keyword">class</span> <span class="identifier">copyable</span>
<span class="special">{};</span>
<span class="comment">//A copyable-only class</span>
<span class="keyword">class</span> <span class="identifier">non_copy_movable</span>
<span class="special">{</span>
<span class="keyword">public</span><span class="special">:</span>
<span class="identifier">non_copy_movable</span><span class="special">(){}</span>
<span class="keyword">private</span><span class="special">:</span>
<span class="identifier">non_copy_movable</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">non_copy_movable</span><span class="special">&amp;);</span>
<span class="identifier">non_copy_movable</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="keyword">const</span> <span class="identifier">non_copy_movable</span><span class="special">&amp;);</span>
<span class="special">};</span>
</pre>
<p>
</p>
<p>
and build a generic factory function that returns a newly constructed value
or a reference to an already constructed object.
</p>
<p>
</p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="string">"movable.hpp"</span>
<span class="preprocessor">#include</span> <span class="string">"copymovable.hpp"</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">move</span><span class="special">/</span><span class="identifier">core</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Type</span><span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">factory_functor</span>
<span class="special">{</span>
<span class="keyword">typedef</span> <span class="identifier">Type</span> <span class="identifier">return_type</span><span class="special">;</span>
<span class="identifier">Type</span> <span class="keyword">operator</span><span class="special">()()</span> <span class="keyword">const</span>
<span class="special">{</span> <span class="identifier">Type</span> <span class="identifier">t</span><span class="special">;</span> <span class="keyword">return</span> <span class="identifier">BOOST_MOVE_RET</span><span class="special">(</span><span class="identifier">Type</span><span class="special">,</span> <span class="identifier">t</span><span class="special">);</span> <span class="special">}</span>
<span class="special">};</span>
<span class="keyword">struct</span> <span class="identifier">return_reference</span>
<span class="special">{</span>
<span class="keyword">typedef</span> <span class="identifier">non_copy_movable</span> <span class="special">&amp;</span><span class="identifier">return_type</span><span class="special">;</span>
<span class="identifier">non_copy_movable</span> <span class="special">&amp;</span><span class="keyword">operator</span><span class="special">()()</span> <span class="keyword">const</span>
<span class="special">{</span> <span class="keyword">return</span> <span class="identifier">ncm</span><span class="special">;</span> <span class="special">}</span>
<span class="keyword">static</span> <span class="identifier">non_copy_movable</span> <span class="identifier">ncm</span><span class="special">;</span>
<span class="special">};</span>
<span class="identifier">non_copy_movable</span> <span class="identifier">return_reference</span><span class="special">::</span><span class="identifier">ncm</span><span class="special">;</span>
<span class="comment">//A wrapper that locks a mutex while the</span>
<span class="comment">//factory creates a new value.</span>
<span class="comment">//It must generically move the return value</span>
<span class="comment">//if possible both in C++03 and C++11</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Factory</span><span class="special">&gt;</span>
<span class="keyword">typename</span> <span class="identifier">Factory</span><span class="special">::</span><span class="identifier">return_type</span> <span class="identifier">lock_wrapper</span><span class="special">(</span><span class="identifier">Factory</span> <span class="identifier">f</span><span class="special">)</span>
<span class="special">{</span>
<span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">Factory</span><span class="special">::</span><span class="identifier">return_type</span> <span class="identifier">return_type</span><span class="special">;</span>
<span class="comment">//LOCK();</span>
<span class="identifier">return_type</span> <span class="identifier">r</span> <span class="special">=</span> <span class="identifier">f</span><span class="special">();</span>
<span class="comment">//UNLOCK();</span>
<span class="comment">//In C++03: boost::move() if R is not a reference and</span>
<span class="comment">//has move emulation enabled. In C++11: just return r.</span>
<span class="keyword">return</span> <span class="identifier">BOOST_MOVE_RET</span><span class="special">(</span><span class="identifier">return_type</span><span class="special">,</span> <span class="identifier">r</span><span class="special">);</span>
<span class="special">}</span>
<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
<span class="special">{</span>
<span class="identifier">movable</span> <span class="identifier">m</span> <span class="special">=</span> <span class="identifier">lock_wrapper</span><span class="special">(</span><span class="identifier">factory_functor</span><span class="special">&lt;</span><span class="identifier">movable</span><span class="special">&gt;</span> <span class="special">());</span>
<span class="identifier">copy_movable</span> <span class="identifier">cm</span> <span class="special">=</span> <span class="identifier">lock_wrapper</span><span class="special">(</span><span class="identifier">factory_functor</span><span class="special">&lt;</span><span class="identifier">copy_movable</span><span class="special">&gt;());</span>
<span class="identifier">copyable</span> <span class="identifier">c</span> <span class="special">=</span> <span class="identifier">lock_wrapper</span><span class="special">(</span><span class="identifier">factory_functor</span><span class="special">&lt;</span><span class="identifier">copyable</span><span class="special">&gt;</span> <span class="special">());</span>
<span class="identifier">non_copy_movable</span> <span class="special">&amp;</span><span class="identifier">mr</span> <span class="special">=</span> <span class="identifier">lock_wrapper</span><span class="special">(</span><span class="identifier">return_reference</span> <span class="special">());</span>
<span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
<span class="special">}</span>
</pre>
<p>
</p>
<p>
<span class="bold"><strong>Caution</strong></span>: When using this macro in a non-conforming
or C++03 compilers, a move will be performed even if the C++11 standard does
not allow it (e.g. returning a static variable). The user is responsible for
using this macro only used to return local objects that met C++11 criteria.
E.g.:
</p>
<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">foo</span>
<span class="special">{</span>
<span class="identifier">copy_movable</span> <span class="keyword">operator</span><span class="special">()()</span> <span class="keyword">const</span>
<span class="special">{</span>
<span class="comment">//ERROR! The Standard does not allow implicit move returns when the object to be returned </span>
<span class="comment">//does not met the criteria for elision of a copy operation (such as returning a static member data)</span>
<span class="comment">//In C++03 compilers this will MOVE resources from cm</span>
<span class="comment">//In C++11 compilers this will COPY resources from cm</span>
<span class="comment">//so DON'T use use BOOST_MOVE_RET without care.</span>
<span class="keyword">return</span> <span class="identifier">BOOST_MOVE_RET</span><span class="special">(</span><span class="identifier">copy_movable</span><span class="special">,</span> <span class="identifier">cm</span><span class="special">);</span>
<span class="special">}</span>
<span class="keyword">static</span> <span class="identifier">copy_movable</span> <span class="identifier">cm</span><span class="special">;</span>
<span class="special">};</span>
</pre>
<p>
<span class="bold"><strong>Note</strong></span>: When returning a temporary object <code class="computeroutput"><span class="identifier">BOOST_MOVE_REF</span></code> is not needed as copy ellision
rules will work on both C++03 and C++11 compilers.
</p>
<pre class="programlisting"><span class="comment">//Note: no BOOST_MOVE_RET</span>
<span class="identifier">movable</span> <span class="identifier">get_movable</span><span class="special">()</span>
<span class="special">{</span> <span class="keyword">return</span> <span class="identifier">movable</span><span class="special">();</span> <span class="special">}</span>
<span class="identifier">copy_movable</span> <span class="identifier">get_copy_movable</span><span class="special">()</span>
<span class="special">{</span> <span class="keyword">return</span> <span class="identifier">copy_movable</span><span class="special">();</span> <span class="special">}</span>
<span class="identifier">copyable</span> <span class="identifier">get_copyable</span><span class="special">()</span>
<span class="special">{</span> <span class="keyword">return</span> <span class="identifier">copyable</span><span class="special">();</span> <span class="special">}</span>
</pre>
</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 © 2008-2014 Ion Gaztanaga<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="construct_forwarding.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../move.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="move_iterator.html"><img src="../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@@ -0,0 +1,319 @@
<!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=UTF-8">
<title>Reference</title>
<link rel="stylesheet" href="../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../index.html" title="The Boost C++ Libraries BoostBook Documentation Subset">
<link rel="up" href="../move.html" title="Chapter 25. Boost.Move">
<link rel="prev" href="release_notes.html" title="Release Notes">
<link rel="next" href="../boost/adl_move_swap.html" title="Function template adl_move_swap">
</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="release_notes.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../move.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="../boost/adl_move_swap.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="move.reference"></a>Reference</h2></div></div></div>
<div class="toc"><dl class="toc">
<dt><span class="section"><a href="reference.html#header.boost.move.adl_move_swap_hpp">Header &lt;boost/move/adl_move_swap.hpp&gt;</a></span></dt>
<dt><span class="section"><a href="reference.html#header.boost.move.algo.adaptive_merge_hpp">Header &lt;boost/move/algo/adaptive_merge.hpp&gt;</a></span></dt>
<dt><span class="section"><a href="reference.html#header.boost.move.algo.adaptive_sort_hpp">Header &lt;boost/move/algo/adaptive_sort.hpp&gt;</a></span></dt>
<dt><span class="section"><a href="reference.html#header.boost.move.algo.predicate_hpp">Header &lt;boost/move/algo/predicate.hpp&gt;</a></span></dt>
<dt><span class="section"><a href="reference.html#header.boost.move.algo.unique_hpp">Header &lt;boost/move/algo/unique.hpp&gt;</a></span></dt>
<dt><span class="section"><a href="reference.html#header.boost.move.algorithm_hpp">Header &lt;boost/move/algorithm.hpp&gt;</a></span></dt>
<dt><span class="section"><a href="reference.html#header.boost.move.core_hpp">Header &lt;boost/move/core.hpp&gt;</a></span></dt>
<dt><span class="section"><a href="reference.html#header.boost.move.default_delete_hpp">Header &lt;boost/move/default_delete.hpp&gt;</a></span></dt>
<dt><span class="section"><a href="reference.html#header.boost.move.iterator_hpp">Header &lt;boost/move/iterator.hpp&gt;</a></span></dt>
<dt><span class="section"><a href="reference.html#header.boost.move.make_unique_hpp">Header &lt;boost/move/make_unique.hpp&gt;</a></span></dt>
<dt><span class="section"><a href="reference.html#header.boost.move.move_hpp">Header &lt;boost/move/move.hpp&gt;</a></span></dt>
<dt><span class="section"><a href="reference.html#header.boost.move.algo.move_hpp">Header &lt;boost/move/algo/move.hpp&gt;</a></span></dt>
<dt><span class="section"><a href="reference.html#header.boost.move.traits_hpp">Header &lt;boost/move/traits.hpp&gt;</a></span></dt>
<dt><span class="section"><a href="reference.html#header.boost.move.unique_ptr_hpp">Header &lt;boost/move/unique_ptr.hpp&gt;</a></span></dt>
<dt><span class="section"><a href="reference.html#header.boost.move.utility_hpp">Header &lt;boost/move/utility.hpp&gt;</a></span></dt>
<dt><span class="section"><a href="reference.html#header.boost.move.utility_core_hpp">Header &lt;boost/move/utility_core.hpp&gt;</a></span></dt>
</dl></div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="header.boost.move.adl_move_swap_hpp"></a>Header &lt;<a href="../../../boost/move/adl_move_swap.hpp" target="_top">boost/move/adl_move_swap.hpp</a>&gt;</h3></div></div></div>
<pre class="synopsis"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T<span class="special">&gt;</span> <span class="keyword">void</span> <a class="link" href="../boost/adl_move_swap.html" title="Function template adl_move_swap"><span class="identifier">adl_move_swap</span></a><span class="special">(</span><span class="identifier">T</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">T</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> ForwardIt1<span class="special">,</span> <span class="keyword">typename</span> ForwardIt2<span class="special">&gt;</span>
<span class="identifier">ForwardIt2</span> <a class="link" href="../boost/adl_move_swap_ranges.html" title="Function template adl_move_swap_ranges"><span class="identifier">adl_move_swap_ranges</span></a><span class="special">(</span><span class="identifier">ForwardIt1</span><span class="special">,</span> <span class="identifier">ForwardIt1</span><span class="special">,</span> <span class="identifier">ForwardIt2</span><span class="special">)</span><span class="special">;</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> BidirIt1<span class="special">,</span> <span class="keyword">typename</span> BidirIt2<span class="special">&gt;</span>
<span class="identifier">BidirIt2</span> <a name="boost.adl_move_s_1_3_26_20_1_1_3"></a><span class="identifier">adl_move_swap_ranges_backward</span><span class="special">(</span><span class="identifier">BidirIt1</span> first1<span class="special">,</span> <span class="identifier">BidirIt1</span> last1<span class="special">,</span>
<span class="identifier">BidirIt2</span> last2<span class="special">)</span><span class="special">;</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> ForwardIt1<span class="special">,</span> <span class="keyword">typename</span> ForwardIt2<span class="special">&gt;</span>
<span class="keyword">void</span> <a name="boost.adl_move_iter_swap"></a><span class="identifier">adl_move_iter_swap</span><span class="special">(</span><span class="identifier">ForwardIt1</span> a<span class="special">,</span> <span class="identifier">ForwardIt2</span> b<span class="special">)</span><span class="special">;</span>
<span class="special">}</span></pre>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="header.boost.move.algo.adaptive_merge_hpp"></a>Header &lt;<a href="../../../boost/move/algo/adaptive_merge.hpp" target="_top">boost/move/algo/adaptive_merge.hpp</a>&gt;</h3></div></div></div>
<pre class="synopsis"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
<span class="keyword">namespace</span> <span class="identifier">movelib</span> <span class="special">{</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> RandIt<span class="special">,</span> <span class="keyword">typename</span> Compare<span class="special">&gt;</span>
<span class="keyword">void</span> <a class="link" href="../boost/movelib/adaptive_merge.html" title="Function template adaptive_merge"><span class="identifier">adaptive_merge</span></a><span class="special">(</span><span class="identifier">RandIt</span><span class="special">,</span> <span class="identifier">RandIt</span><span class="special">,</span> <span class="identifier">RandIt</span><span class="special">,</span> <span class="identifier">Compare</span><span class="special">,</span>
<span class="keyword">typename</span> <span class="identifier">iterator_traits</span><span class="special">&lt;</span> <span class="identifier">RandIt</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">value_type</span> <span class="special">*</span> <span class="special">=</span> <span class="number">0</span><span class="special">,</span>
<span class="keyword">typename</span> <span class="identifier">iterator_traits</span><span class="special">&lt;</span> <span class="identifier">RandIt</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">size_type</span> <span class="special">=</span> <span class="number">0</span><span class="special">)</span><span class="special">;</span>
<span class="special">}</span>
<span class="special">}</span></pre>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="header.boost.move.algo.adaptive_sort_hpp"></a>Header &lt;<a href="../../../boost/move/algo/adaptive_sort.hpp" target="_top">boost/move/algo/adaptive_sort.hpp</a>&gt;</h3></div></div></div>
<pre class="synopsis"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
<span class="keyword">namespace</span> <span class="identifier">movelib</span> <span class="special">{</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> RandIt<span class="special">,</span> <span class="keyword">typename</span> RandRawIt<span class="special">,</span> <span class="keyword">typename</span> Compare<span class="special">&gt;</span>
<span class="keyword">void</span> <a class="link" href="../boost/movelib/adaptive_1_3_26_20_3_1_1_1.html" title="Function template adaptive_sort"><span class="identifier">adaptive_sort</span></a><span class="special">(</span><span class="identifier">RandIt</span><span class="special">,</span> <span class="identifier">RandIt</span><span class="special">,</span> <span class="identifier">Compare</span><span class="special">,</span> <span class="identifier">RandRawIt</span><span class="special">,</span>
<span class="keyword">typename</span> <span class="identifier">iterator_traits</span><span class="special">&lt;</span> <span class="identifier">RandIt</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">size_type</span><span class="special">)</span><span class="special">;</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> RandIt<span class="special">,</span> <span class="keyword">typename</span> Compare<span class="special">&gt;</span>
<span class="keyword">void</span> <a name="boost.movelib.adaptive_1_3_26_20_3_1_1_2"></a><span class="identifier">adaptive_sort</span><span class="special">(</span><span class="identifier">RandIt</span> first<span class="special">,</span> <span class="identifier">RandIt</span> last<span class="special">,</span> <span class="identifier">Compare</span> comp<span class="special">)</span><span class="special">;</span>
<span class="special">}</span>
<span class="special">}</span></pre>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="header.boost.move.algo.predicate_hpp"></a>Header &lt;<a href="../../../boost/move/algo/predicate.hpp" target="_top">boost/move/algo/predicate.hpp</a>&gt;</h3></div></div></div>
<pre class="synopsis"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
<span class="keyword">namespace</span> <span class="identifier">movelib</span> <span class="special">{</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Comp<span class="special">&gt;</span> <span class="keyword">struct</span> <a class="link" href="../boost/movelib/antistable.html" title="Struct template antistable">antistable</a><span class="special">;</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Comp<span class="special">&gt;</span> <span class="keyword">class</span> <a class="link" href="../boost/movelib/inverse.html" title="Class template inverse">inverse</a><span class="special">;</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Comp<span class="special">&gt;</span> <span class="keyword">class</span> <a class="link" href="../boost/movelib/negate.html" title="Class template negate">negate</a><span class="special">;</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Comp<span class="special">&gt;</span> <span class="identifier">Comp</span> <a name="boost.movelib.unantist_1_3_26_20_4_1_1_4"></a><span class="identifier">unantistable</span><span class="special">(</span><span class="identifier">Comp</span> comp<span class="special">)</span><span class="special">;</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Comp<span class="special">&gt;</span> <span class="identifier">Comp</span> <a name="boost.movelib.unantist_1_3_26_20_4_1_1_5"></a><span class="identifier">unantistable</span><span class="special">(</span><span class="identifier">antistable</span><span class="special">&lt;</span> <span class="identifier">Comp</span> <span class="special">&gt;</span> comp<span class="special">)</span><span class="special">;</span>
<span class="special">}</span>
<span class="special">}</span></pre>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="header.boost.move.algo.unique_hpp"></a>Header &lt;<a href="../../../boost/move/algo/unique.hpp" target="_top">boost/move/algo/unique.hpp</a>&gt;</h3></div></div></div>
<pre class="synopsis"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
<span class="keyword">namespace</span> <span class="identifier">movelib</span> <span class="special">{</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <a class="link" href="../ForwardIterator.html" title="Concept ForwardIterator">ForwardIterator</a><span class="special">,</span> <span class="keyword">typename</span> BinaryPredicate<span class="special">&gt;</span>
<span class="identifier">ForwardIterator</span>
<a class="link" href="../boost/movelib/unique.html" title="Function template unique"><span class="identifier">unique</span></a><span class="special">(</span><span class="identifier">ForwardIterator</span><span class="special">,</span> <span class="identifier">ForwardIterator</span><span class="special">,</span> <span class="identifier">BinaryPredicate</span><span class="special">)</span><span class="special">;</span>
<span class="special">}</span>
<span class="special">}</span></pre>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="header.boost.move.algorithm_hpp"></a>Header &lt;<a href="../../../boost/move/algorithm.hpp" target="_top">boost/move/algorithm.hpp</a>&gt;</h3></div></div></div>
<pre class="synopsis"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> I<span class="special">,</span> <span class="keyword">typename</span> F<span class="special">&gt;</span>
<span class="identifier">F</span> <a name="boost.uninitiali_1_3_26_20_6_1_1"></a><span class="identifier">uninitialized_copy_or_move</span><span class="special">(</span><span class="identifier">I</span> f<span class="special">,</span> <span class="identifier">I</span> l<span class="special">,</span> <span class="identifier">F</span> r<span class="special">,</span> <span class="emphasis"><em><span class="identifier">unspecified</span></em></span> <span class="special">=</span> <span class="number">0</span><span class="special">)</span><span class="special">;</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> I<span class="special">,</span> <span class="keyword">typename</span> F<span class="special">&gt;</span>
<span class="identifier">F</span> <a name="boost.copy_or_mo_1_3_26_20_6_1_2"></a><span class="identifier">copy_or_move</span><span class="special">(</span><span class="identifier">I</span> f<span class="special">,</span> <span class="identifier">I</span> l<span class="special">,</span> <span class="identifier">F</span> r<span class="special">,</span> <span class="emphasis"><em><span class="identifier">unspecified</span></em></span> <span class="special">=</span> <span class="number">0</span><span class="special">)</span><span class="special">;</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> I<span class="special">,</span> <span class="keyword">typename</span> F<span class="special">&gt;</span> <span class="identifier">F</span> <a class="link" href="../boost/uninitiali_1_3_26_20_6_1_3.html" title="Function template uninitialized_copy_or_move"><span class="identifier">uninitialized_copy_or_move</span></a><span class="special">(</span><span class="identifier">I</span><span class="special">,</span> <span class="identifier">I</span><span class="special">,</span> <span class="identifier">F</span><span class="special">)</span><span class="special">;</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> I<span class="special">,</span> <span class="keyword">typename</span> F<span class="special">&gt;</span> <span class="identifier">F</span> <a class="link" href="../boost/copy_or_mo_1_3_26_20_6_1_4.html" title="Function template copy_or_move"><span class="identifier">copy_or_move</span></a><span class="special">(</span><span class="identifier">I</span><span class="special">,</span> <span class="identifier">I</span><span class="special">,</span> <span class="identifier">F</span><span class="special">)</span><span class="special">;</span>
<span class="special">}</span></pre>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="header.boost.move.core_hpp"></a>Header &lt;<a href="../../../boost/move/core.hpp" target="_top">boost/move/core.hpp</a>&gt;</h3></div></div></div>
<p>This header implements macros to define movable classes and move-aware functions </p>
<pre class="synopsis">
<a class="link" href="../BOOST_MOVABL_1_3_26_20_7_3.html" title="Macro BOOST_MOVABLE_BUT_NOT_COPYABLE">BOOST_MOVABLE_BUT_NOT_COPYABLE</a>(TYPE)
<a class="link" href="../BOOST_COPYABLE_AND_MOVABLE.html" title="Macro BOOST_COPYABLE_AND_MOVABLE">BOOST_COPYABLE_AND_MOVABLE</a>(TYPE)
<a class="link" href="../BOOST_RV_REF.html" title="Macro BOOST_RV_REF">BOOST_RV_REF</a>(TYPE)
<a class="link" href="../BOOST_RV_REF_BEG.html" title="Macro BOOST_RV_REF_BEG">BOOST_RV_REF_BEG</a>
<a class="link" href="../BOOST_RV_REF_END.html" title="Macro BOOST_RV_REF_END">BOOST_RV_REF_END</a>
<a class="link" href="../BOOST_RV_REF_BEG_IF_CXX11.html" title="Macro BOOST_RV_REF_BEG_IF_CXX11">BOOST_RV_REF_BEG_IF_CXX11</a>
<a class="link" href="../BOOST_RV_REF_END_IF_CXX11.html" title="Macro BOOST_RV_REF_END_IF_CXX11">BOOST_RV_REF_END_IF_CXX11</a>
<a class="link" href="../BOOST_COPY_ASSIGN_REF.html" title="Macro BOOST_COPY_ASSIGN_REF">BOOST_COPY_ASSIGN_REF</a>(TYPE)
<a class="link" href="../BOOST_FWD_REF.html" title="Macro BOOST_FWD_REF">BOOST_FWD_REF</a>(TYPE)
<a class="link" href="../BOOST_MOVE_RET.html" title="Macro BOOST_MOVE_RET">BOOST_MOVE_RET</a>(RET_TYPE, REF)
<a class="link" href="../BOOST_MOVE_BASE.html" title="Macro BOOST_MOVE_BASE">BOOST_MOVE_BASE</a>(BASE_TYPE, ARG)</pre>
<pre class="synopsis"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T<span class="special">&gt;</span> <span class="keyword">struct</span> <a class="link" href="../boost/has_move_e_1_3_26_20_7_2_1.html" title="Struct template has_move_emulation_disabled">has_move_emulation_disabled</a><span class="special">;</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T<span class="special">&gt;</span> <span class="keyword">struct</span> <a class="link" href="../boost/has_move_emulation_enabled.html" title="Struct template has_move_emulation_enabled">has_move_emulation_enabled</a><span class="special">;</span>
<span class="special">}</span></pre>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="header.boost.move.default_delete_hpp"></a>Header &lt;<a href="../../../boost/move/default_delete.hpp" target="_top">boost/move/default_delete.hpp</a>&gt;</h3></div></div></div>
<p>Describes the default deleter (destruction policy) of <code class="computeroutput">unique_ptr</code>: <code class="computeroutput">default_delete</code>. </p>
<pre class="synopsis"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
<span class="keyword">namespace</span> <span class="identifier">movelib</span> <span class="special">{</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T<span class="special">&gt;</span> <span class="keyword">struct</span> <a class="link" href="../boost/movelib/default_delete.html" title="Struct template default_delete">default_delete</a><span class="special">;</span>
<span class="special">}</span>
<span class="special">}</span></pre>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="header.boost.move.iterator_hpp"></a>Header &lt;<a href="../../../boost/move/iterator.hpp" target="_top">boost/move/iterator.hpp</a>&gt;</h3></div></div></div>
<pre class="synopsis"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> C<span class="special">&gt;</span> <span class="keyword">class</span> <a class="link" href="../boost/back_move_insert_iterator.html" title="Class template back_move_insert_iterator">back_move_insert_iterator</a><span class="special">;</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> C<span class="special">&gt;</span> <span class="keyword">class</span> <a class="link" href="../boost/front_move_insert_iterator.html" title="Class template front_move_insert_iterator">front_move_insert_iterator</a><span class="special">;</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> C<span class="special">&gt;</span> <span class="keyword">class</span> <a class="link" href="../boost/move_insert_iterator.html" title="Class template move_insert_iterator">move_insert_iterator</a><span class="special">;</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> It<span class="special">&gt;</span> <span class="keyword">class</span> <a class="link" href="../boost/move_iterator.html" title="Class template move_iterator">move_iterator</a><span class="special">;</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> It<span class="special">&gt;</span> <a class="link" href="../boost/move_iterator.html" title="Class template move_iterator">move_iterator</a><span class="special">&lt;</span> <span class="identifier">It</span> <span class="special">&gt;</span> <a class="link" href="../boost/make_move_iterator.html" title="Function template make_move_iterator"><span class="identifier">make_move_iterator</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">It</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> C<span class="special">&gt;</span> <a class="link" href="../boost/back_move_insert_iterator.html" title="Class template back_move_insert_iterator">back_move_insert_iterator</a><span class="special">&lt;</span> <span class="identifier">C</span> <span class="special">&gt;</span> <a class="link" href="../boost/back_move_inserter.html" title="Function template back_move_inserter"><span class="identifier">back_move_inserter</span></a><span class="special">(</span><span class="identifier">C</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> C<span class="special">&gt;</span>
<a class="link" href="../boost/front_move_insert_iterator.html" title="Class template front_move_insert_iterator">front_move_insert_iterator</a><span class="special">&lt;</span> <span class="identifier">C</span> <span class="special">&gt;</span> <a class="link" href="../boost/front_move_inserter.html" title="Function template front_move_inserter"><span class="identifier">front_move_inserter</span></a><span class="special">(</span><span class="identifier">C</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> C<span class="special">&gt;</span>
<span class="identifier">move_insert_iterator</span><span class="special">&lt;</span> <span class="identifier">C</span> <span class="special">&gt;</span> <a class="link" href="../boost/move_inserter.html" title="Function template move_inserter"><span class="identifier">move_inserter</span></a><span class="special">(</span><span class="identifier">C</span> <span class="special">&amp;</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">C</span><span class="special">::</span><span class="identifier">iterator</span><span class="special">)</span><span class="special">;</span>
<span class="special">}</span></pre>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="header.boost.move.make_unique_hpp"></a>Header &lt;<a href="../../../boost/move/make_unique.hpp" target="_top">boost/move/make_unique.hpp</a>&gt;</h3></div></div></div>
<p>Defines "make_unique" functions, which are factories to create instances of unique_ptr depending on the passed arguments.</p>
<p>This header can be a bit heavyweight in C++03 compilers due to the use of the preprocessor library, that's why it's a a separate header from <code class="computeroutput">unique_ptr.hpp</code> </p>
<pre class="synopsis"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
<span class="keyword">namespace</span> <span class="identifier">movelib</span> <span class="special">{</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T<span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> Args<span class="special">&gt;</span>
<a class="link" href="../boost/movelib/unique_ptr.html" title="Class template unique_ptr">unique_ptr</a><span class="special">&lt;</span> <span class="identifier">T</span> <span class="special">&gt;</span> <a class="link" href="../boost/movelib/make_un_1_3_26_20_10_3_1_1.html" title="Function template make_unique"><span class="identifier">make_unique</span></a><span class="special">(</span><span class="identifier">Args</span> <span class="special">&amp;&amp;</span><span class="special">...</span><span class="special">)</span><span class="special">;</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T<span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> Args<span class="special">&gt;</span>
<a class="link" href="../boost/movelib/unique_ptr.html" title="Class template unique_ptr">unique_ptr</a><span class="special">&lt;</span> <span class="identifier">T</span> <span class="special">&gt;</span> <a class="link" href="../boost/movelib/make_un_1_3_26_20_10_3_1_2.html" title="Function template make_unique_nothrow"><span class="identifier">make_unique_nothrow</span></a><span class="special">(</span><span class="identifier">Args</span> <span class="special">&amp;&amp;</span><span class="special">...</span><span class="special">)</span><span class="special">;</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T<span class="special">&gt;</span> <a class="link" href="../boost/movelib/unique_ptr.html" title="Class template unique_ptr">unique_ptr</a><span class="special">&lt;</span> <span class="identifier">T</span> <span class="special">&gt;</span> <a class="link" href="../boost/movelib/make_un_1_3_26_20_10_3_1_3.html" title="Function template make_unique_definit"><span class="identifier">make_unique_definit</span></a><span class="special">(</span><span class="special">)</span><span class="special">;</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T<span class="special">&gt;</span> <a class="link" href="../boost/movelib/unique_ptr.html" title="Class template unique_ptr">unique_ptr</a><span class="special">&lt;</span> <span class="identifier">T</span> <span class="special">&gt;</span> <a class="link" href="../boost/movelib/make_un_1_3_26_20_10_3_1_4.html" title="Function template make_unique_nothrow_definit"><span class="identifier">make_unique_nothrow_definit</span></a><span class="special">(</span><span class="special">)</span><span class="special">;</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T<span class="special">&gt;</span> <a class="link" href="../boost/movelib/unique_ptr.html" title="Class template unique_ptr">unique_ptr</a><span class="special">&lt;</span> <span class="identifier">T</span> <span class="special">&gt;</span> <a class="link" href="../boost/movelib/make_un_1_3_26_20_10_3_1_5.html" title="Function template make_unique"><span class="identifier">make_unique</span></a><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="special">;</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T<span class="special">&gt;</span> <a class="link" href="../boost/movelib/unique_ptr.html" title="Class template unique_ptr">unique_ptr</a><span class="special">&lt;</span> <span class="identifier">T</span> <span class="special">&gt;</span> <a class="link" href="../boost/movelib/make_un_1_3_26_20_10_3_1_6.html" title="Function template make_unique_nothrow"><span class="identifier">make_unique_nothrow</span></a><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="special">;</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T<span class="special">&gt;</span> <a class="link" href="../boost/movelib/unique_ptr.html" title="Class template unique_ptr">unique_ptr</a><span class="special">&lt;</span> <span class="identifier">T</span> <span class="special">&gt;</span> <a class="link" href="../boost/movelib/make_un_1_3_26_20_10_3_1_7.html" title="Function template make_unique_definit"><span class="identifier">make_unique_definit</span></a><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="special">;</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T<span class="special">&gt;</span>
<a class="link" href="../boost/movelib/unique_ptr.html" title="Class template unique_ptr">unique_ptr</a><span class="special">&lt;</span> <span class="identifier">T</span> <span class="special">&gt;</span> <a class="link" href="../boost/movelib/make_un_1_3_26_20_10_3_1_8.html" title="Function template make_unique_nothrow_definit"><span class="identifier">make_unique_nothrow_definit</span></a><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="special">;</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T<span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> Args<span class="special">&gt;</span> <span class="identifier">unspecified</span> <a class="link" href="../boost/movelib/make_un_1_3_26_20_10_3_1_9.html" title="Function template make_unique"><span class="identifier">make_unique</span></a><span class="special">(</span><span class="identifier">Args</span> <span class="special">&amp;&amp;</span><span class="special">)</span><span class="special">;</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T<span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> Args<span class="special">&gt;</span>
<span class="identifier">unspecified</span> <a class="link" href="../boost/movelib/make_u_1_3_26_20_10_3_1_10.html" title="Function template make_unique_definit"><span class="identifier">make_unique_definit</span></a><span class="special">(</span><span class="identifier">Args</span> <span class="special">&amp;&amp;</span><span class="special">)</span><span class="special">;</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T<span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> Args<span class="special">&gt;</span>
<span class="identifier">unspecified</span> <a class="link" href="../boost/movelib/make_u_1_3_26_20_10_3_1_11.html" title="Function template make_unique_nothrow"><span class="identifier">make_unique_nothrow</span></a><span class="special">(</span><span class="identifier">Args</span> <span class="special">&amp;&amp;</span><span class="special">)</span><span class="special">;</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T<span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> Args<span class="special">&gt;</span>
<span class="identifier">unspecified</span> <a class="link" href="../boost/movelib/make_u_1_3_26_20_10_3_1_12.html" title="Function template make_unique_nothrow_definit"><span class="identifier">make_unique_nothrow_definit</span></a><span class="special">(</span><span class="identifier">Args</span> <span class="special">&amp;&amp;</span><span class="special">)</span><span class="special">;</span>
<span class="special">}</span>
<span class="special">}</span></pre>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="header.boost.move.move_hpp"></a>Header &lt;<a href="../../../boost/move/move.hpp" target="_top">boost/move/move.hpp</a>&gt;</h3></div></div></div>
<p>A general library header that includes the rest of top-level headers. </p>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="header.boost.move.algo.move_hpp"></a>Header &lt;<a href="../../../boost/move/algo/move.hpp" target="_top">boost/move/algo/move.hpp</a>&gt;</h3></div></div></div>
<pre class="synopsis"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> I<span class="special">,</span> <span class="keyword">typename</span> O<span class="special">&gt;</span> <span class="identifier">O</span> <a class="link" href="../boost/move_1_3_26_20_12_1_1.html" title="Function template move"><span class="identifier">move</span></a><span class="special">(</span><span class="identifier">I</span><span class="special">,</span> <span class="identifier">I</span><span class="special">,</span> <span class="identifier">O</span><span class="special">)</span><span class="special">;</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> I<span class="special">,</span> <span class="keyword">typename</span> O<span class="special">&gt;</span> <span class="identifier">O</span> <a class="link" href="../boost/move_backward.html" title="Function template move_backward"><span class="identifier">move_backward</span></a><span class="special">(</span><span class="identifier">I</span><span class="special">,</span> <span class="identifier">I</span><span class="special">,</span> <span class="identifier">O</span><span class="special">)</span><span class="special">;</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> I<span class="special">,</span> <span class="keyword">typename</span> F<span class="special">&gt;</span> <span class="identifier">F</span> <a class="link" href="../boost/uninitialized_move.html" title="Function template uninitialized_move"><span class="identifier">uninitialized_move</span></a><span class="special">(</span><span class="identifier">I</span><span class="special">,</span> <span class="identifier">I</span><span class="special">,</span> <span class="identifier">F</span><span class="special">)</span><span class="special">;</span>
<span class="special">}</span></pre>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="header.boost.move.traits_hpp"></a>Header &lt;<a href="../../../boost/move/traits.hpp" target="_top">boost/move/traits.hpp</a>&gt;</h3></div></div></div>
<pre class="synopsis"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T<span class="special">&gt;</span> <span class="keyword">struct</span> <a class="link" href="../boost/has_nothrow_move.html" title="Struct template has_nothrow_move">has_nothrow_move</a><span class="special">;</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T<span class="special">&gt;</span> <span class="keyword">struct</span> <a class="link" href="../boost/has_trivi_1_3_26_20_13_1_2.html" title="Struct template has_trivial_destructor_after_move">has_trivial_destructor_after_move</a><span class="special">;</span>
<span class="special">}</span></pre>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="header.boost.move.unique_ptr_hpp"></a>Header &lt;<a href="../../../boost/move/unique_ptr.hpp" target="_top">boost/move/unique_ptr.hpp</a>&gt;</h3></div></div></div>
<p>Describes the smart pointer unique_ptr, a drop-in replacement for std::unique_ptr, usable also from C++03 compilers.</p>
<p>Main differences from std::unique_ptr to avoid heavy dependencies, specially in C++03 compilers:</p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem"><p><code class="computeroutput">operator &lt; </code> uses pointer <code class="computeroutput">operator &lt; </code>instead of <code class="computeroutput">std::less&lt;common_type&gt;</code>. This avoids dependencies on <code class="computeroutput">std::common_type</code> and <code class="computeroutput">std::less</code> (<code class="computeroutput">&lt;type_traits&gt;/&lt;functional&gt;</code> headers). In C++03 this avoid pulling Boost.Typeof and other cascading dependencies. As in all Boost platforms <code class="computeroutput">operator &lt;</code> on raw pointers and other smart pointers provides strict weak ordering in practice this should not be a problem for users.</p></li>
<li class="listitem"><p>assignable from literal 0 for compilers without nullptr</p></li>
<li class="listitem"><p><code class="computeroutput">unique_ptr&lt;T[]&gt;</code> is constructible and assignable from <code class="computeroutput">unique_ptr&lt;U[]&gt;</code> if cv-less T and cv-less U are the same type and T is more CV qualified than U. </p></li>
</ul></div>
<p>
</p>
<pre class="synopsis"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
<span class="keyword">namespace</span> <span class="identifier">movelib</span> <span class="special">{</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T<span class="special">,</span> <span class="keyword">typename</span> D <span class="special">=</span> <a class="link" href="../boost/movelib/default_delete.html" title="Struct template default_delete">default_delete</a><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="keyword">class</span> <a class="link" href="../boost/movelib/unique_ptr.html" title="Class template unique_ptr">unique_ptr</a><span class="special">;</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T<span class="special">,</span> <span class="keyword">typename</span> D<span class="special">&gt;</span>
<span class="keyword">void</span> <a class="link" href="../boost/movelib/swap.html" title="Function template swap"><span class="identifier">swap</span></a><span class="special">(</span><a class="link" href="../boost/movelib/unique_ptr.html" title="Class template unique_ptr">unique_ptr</a><span class="special">&lt;</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">D</span> <span class="special">&gt;</span> <span class="special">&amp;</span><span class="special">,</span> <a class="link" href="../boost/movelib/unique_ptr.html" title="Class template unique_ptr">unique_ptr</a><span class="special">&lt;</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">D</span> <span class="special">&gt;</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T1<span class="special">,</span> <span class="keyword">typename</span> D1<span class="special">,</span> <span class="keyword">typename</span> T2<span class="special">,</span> <span class="keyword">typename</span> D2<span class="special">&gt;</span>
<span class="keyword">bool</span> <a class="link" href="../boost/movelib/operato_1_3_26_20_14_3_1_3.html" title="Function template operator=="><span class="keyword">operator</span><span class="special">==</span></a><span class="special">(</span><span class="keyword">const</span> <a class="link" href="../boost/movelib/unique_ptr.html" title="Class template unique_ptr">unique_ptr</a><span class="special">&lt;</span> <span class="identifier">T1</span><span class="special">,</span> <span class="identifier">D1</span> <span class="special">&gt;</span> <span class="special">&amp;</span><span class="special">,</span>
<span class="keyword">const</span> <a class="link" href="../boost/movelib/unique_ptr.html" title="Class template unique_ptr">unique_ptr</a><span class="special">&lt;</span> <span class="identifier">T2</span><span class="special">,</span> <span class="identifier">D2</span> <span class="special">&gt;</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T1<span class="special">,</span> <span class="keyword">typename</span> D1<span class="special">,</span> <span class="keyword">typename</span> T2<span class="special">,</span> <span class="keyword">typename</span> D2<span class="special">&gt;</span>
<span class="keyword">bool</span> <a class="link" href="../boost/movelib/operato_1_3_26_20_14_3_1_4.html" title="Function template operator!="><span class="keyword">operator</span><span class="special">!=</span></a><span class="special">(</span><span class="keyword">const</span> <a class="link" href="../boost/movelib/unique_ptr.html" title="Class template unique_ptr">unique_ptr</a><span class="special">&lt;</span> <span class="identifier">T1</span><span class="special">,</span> <span class="identifier">D1</span> <span class="special">&gt;</span> <span class="special">&amp;</span><span class="special">,</span>
<span class="keyword">const</span> <a class="link" href="../boost/movelib/unique_ptr.html" title="Class template unique_ptr">unique_ptr</a><span class="special">&lt;</span> <span class="identifier">T2</span><span class="special">,</span> <span class="identifier">D2</span> <span class="special">&gt;</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T1<span class="special">,</span> <span class="keyword">typename</span> D1<span class="special">,</span> <span class="keyword">typename</span> T2<span class="special">,</span> <span class="keyword">typename</span> D2<span class="special">&gt;</span>
<span class="keyword">bool</span> <a class="link" href="../boost/movelib/operato_1_3_26_20_14_3_1_5.html" title="Function template operator&lt;"><span class="keyword">operator</span><span class="special">&lt;</span></a><span class="special">(</span><span class="keyword">const</span> <a class="link" href="../boost/movelib/unique_ptr.html" title="Class template unique_ptr">unique_ptr</a><span class="special">&lt;</span> <span class="identifier">T1</span><span class="special">,</span> <span class="identifier">D1</span> <span class="special">&gt;</span> <span class="special">&amp;</span><span class="special">,</span>
<span class="keyword">const</span> <a class="link" href="../boost/movelib/unique_ptr.html" title="Class template unique_ptr">unique_ptr</a><span class="special">&lt;</span> <span class="identifier">T2</span><span class="special">,</span> <span class="identifier">D2</span> <span class="special">&gt;</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T1<span class="special">,</span> <span class="keyword">typename</span> D1<span class="special">,</span> <span class="keyword">typename</span> T2<span class="special">,</span> <span class="keyword">typename</span> D2<span class="special">&gt;</span>
<span class="keyword">bool</span> <a class="link" href="../boost/movelib/operato_1_3_26_20_14_3_1_6.html" title="Function template operator&lt;="><span class="keyword">operator</span><span class="special">&lt;=</span></a><span class="special">(</span><span class="keyword">const</span> <a class="link" href="../boost/movelib/unique_ptr.html" title="Class template unique_ptr">unique_ptr</a><span class="special">&lt;</span> <span class="identifier">T1</span><span class="special">,</span> <span class="identifier">D1</span> <span class="special">&gt;</span> <span class="special">&amp;</span><span class="special">,</span>
<span class="keyword">const</span> <a class="link" href="../boost/movelib/unique_ptr.html" title="Class template unique_ptr">unique_ptr</a><span class="special">&lt;</span> <span class="identifier">T2</span><span class="special">,</span> <span class="identifier">D2</span> <span class="special">&gt;</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T1<span class="special">,</span> <span class="keyword">typename</span> D1<span class="special">,</span> <span class="keyword">typename</span> T2<span class="special">,</span> <span class="keyword">typename</span> D2<span class="special">&gt;</span>
<span class="keyword">bool</span> <a class="link" href="../boost/movelib/operato_1_3_26_20_14_3_1_7.html" title="Function template operator&gt;"><span class="keyword">operator</span><span class="special">&gt;</span></a><span class="special">(</span><span class="keyword">const</span> <a class="link" href="../boost/movelib/unique_ptr.html" title="Class template unique_ptr">unique_ptr</a><span class="special">&lt;</span> <span class="identifier">T1</span><span class="special">,</span> <span class="identifier">D1</span> <span class="special">&gt;</span> <span class="special">&amp;</span><span class="special">,</span>
<span class="keyword">const</span> <a class="link" href="../boost/movelib/unique_ptr.html" title="Class template unique_ptr">unique_ptr</a><span class="special">&lt;</span> <span class="identifier">T2</span><span class="special">,</span> <span class="identifier">D2</span> <span class="special">&gt;</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T1<span class="special">,</span> <span class="keyword">typename</span> D1<span class="special">,</span> <span class="keyword">typename</span> T2<span class="special">,</span> <span class="keyword">typename</span> D2<span class="special">&gt;</span>
<span class="keyword">bool</span> <a class="link" href="../boost/movelib/operato_1_3_26_20_14_3_1_8.html" title="Function template operator&gt;="><span class="keyword">operator</span><span class="special">&gt;=</span></a><span class="special">(</span><span class="keyword">const</span> <a class="link" href="../boost/movelib/unique_ptr.html" title="Class template unique_ptr">unique_ptr</a><span class="special">&lt;</span> <span class="identifier">T1</span><span class="special">,</span> <span class="identifier">D1</span> <span class="special">&gt;</span> <span class="special">&amp;</span><span class="special">,</span>
<span class="keyword">const</span> <a class="link" href="../boost/movelib/unique_ptr.html" title="Class template unique_ptr">unique_ptr</a><span class="special">&lt;</span> <span class="identifier">T2</span><span class="special">,</span> <span class="identifier">D2</span> <span class="special">&gt;</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T<span class="special">,</span> <span class="keyword">typename</span> D<span class="special">&gt;</span>
<span class="keyword">bool</span> <a class="link" href="../boost/movelib/operato_1_3_26_20_14_3_1_9.html" title="Function template operator=="><span class="keyword">operator</span><span class="special">==</span></a><span class="special">(</span><span class="keyword">const</span> <a class="link" href="../boost/movelib/unique_ptr.html" title="Class template unique_ptr">unique_ptr</a><span class="special">&lt;</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">D</span> <span class="special">&gt;</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">nullptr_t</span><span class="special">)</span><span class="special">;</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T<span class="special">,</span> <span class="keyword">typename</span> D<span class="special">&gt;</span>
<span class="keyword">bool</span> <a class="link" href="../boost/movelib/operat_1_3_26_20_14_3_1_10.html" title="Function template operator=="><span class="keyword">operator</span><span class="special">==</span></a><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">nullptr_t</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="../boost/movelib/unique_ptr.html" title="Class template unique_ptr">unique_ptr</a><span class="special">&lt;</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">D</span> <span class="special">&gt;</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T<span class="special">,</span> <span class="keyword">typename</span> D<span class="special">&gt;</span>
<span class="keyword">bool</span> <a class="link" href="../boost/movelib/operat_1_3_26_20_14_3_1_11.html" title="Function template operator!="><span class="keyword">operator</span><span class="special">!=</span></a><span class="special">(</span><span class="keyword">const</span> <a class="link" href="../boost/movelib/unique_ptr.html" title="Class template unique_ptr">unique_ptr</a><span class="special">&lt;</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">D</span> <span class="special">&gt;</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">nullptr_t</span><span class="special">)</span><span class="special">;</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T<span class="special">,</span> <span class="keyword">typename</span> D<span class="special">&gt;</span>
<span class="keyword">bool</span> <a class="link" href="../boost/movelib/operat_1_3_26_20_14_3_1_12.html" title="Function template operator!="><span class="keyword">operator</span><span class="special">!=</span></a><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">nullptr_t</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="../boost/movelib/unique_ptr.html" title="Class template unique_ptr">unique_ptr</a><span class="special">&lt;</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">D</span> <span class="special">&gt;</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T<span class="special">,</span> <span class="keyword">typename</span> D<span class="special">&gt;</span>
<span class="keyword">bool</span> <a class="link" href="../boost/movelib/operat_1_3_26_20_14_3_1_13.html" title="Function template operator&lt;"><span class="keyword">operator</span><span class="special">&lt;</span></a><span class="special">(</span><span class="keyword">const</span> <a class="link" href="../boost/movelib/unique_ptr.html" title="Class template unique_ptr">unique_ptr</a><span class="special">&lt;</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">D</span> <span class="special">&gt;</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">nullptr_t</span><span class="special">)</span><span class="special">;</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T<span class="special">,</span> <span class="keyword">typename</span> D<span class="special">&gt;</span>
<span class="keyword">bool</span> <a class="link" href="../boost/movelib/operat_1_3_26_20_14_3_1_14.html" title="Function template operator&lt;"><span class="keyword">operator</span><span class="special">&lt;</span></a><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">nullptr_t</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="../boost/movelib/unique_ptr.html" title="Class template unique_ptr">unique_ptr</a><span class="special">&lt;</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">D</span> <span class="special">&gt;</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T<span class="special">,</span> <span class="keyword">typename</span> D<span class="special">&gt;</span>
<span class="keyword">bool</span> <a class="link" href="../boost/movelib/operat_1_3_26_20_14_3_1_15.html" title="Function template operator&gt;"><span class="keyword">operator</span><span class="special">&gt;</span></a><span class="special">(</span><span class="keyword">const</span> <a class="link" href="../boost/movelib/unique_ptr.html" title="Class template unique_ptr">unique_ptr</a><span class="special">&lt;</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">D</span> <span class="special">&gt;</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">nullptr_t</span><span class="special">)</span><span class="special">;</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T<span class="special">,</span> <span class="keyword">typename</span> D<span class="special">&gt;</span>
<span class="keyword">bool</span> <a class="link" href="../boost/movelib/operat_1_3_26_20_14_3_1_16.html" title="Function template operator&gt;"><span class="keyword">operator</span><span class="special">&gt;</span></a><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">nullptr_t</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="../boost/movelib/unique_ptr.html" title="Class template unique_ptr">unique_ptr</a><span class="special">&lt;</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">D</span> <span class="special">&gt;</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T<span class="special">,</span> <span class="keyword">typename</span> D<span class="special">&gt;</span>
<span class="keyword">bool</span> <a class="link" href="../boost/movelib/operat_1_3_26_20_14_3_1_17.html" title="Function template operator&lt;="><span class="keyword">operator</span><span class="special">&lt;=</span></a><span class="special">(</span><span class="keyword">const</span> <a class="link" href="../boost/movelib/unique_ptr.html" title="Class template unique_ptr">unique_ptr</a><span class="special">&lt;</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">D</span> <span class="special">&gt;</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">nullptr_t</span><span class="special">)</span><span class="special">;</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T<span class="special">,</span> <span class="keyword">typename</span> D<span class="special">&gt;</span>
<span class="keyword">bool</span> <a class="link" href="../boost/movelib/operat_1_3_26_20_14_3_1_18.html" title="Function template operator&lt;="><span class="keyword">operator</span><span class="special">&lt;=</span></a><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">nullptr_t</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="../boost/movelib/unique_ptr.html" title="Class template unique_ptr">unique_ptr</a><span class="special">&lt;</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">D</span> <span class="special">&gt;</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T<span class="special">,</span> <span class="keyword">typename</span> D<span class="special">&gt;</span>
<span class="keyword">bool</span> <a class="link" href="../boost/movelib/operat_1_3_26_20_14_3_1_19.html" title="Function template operator&gt;="><span class="keyword">operator</span><span class="special">&gt;=</span></a><span class="special">(</span><span class="keyword">const</span> <a class="link" href="../boost/movelib/unique_ptr.html" title="Class template unique_ptr">unique_ptr</a><span class="special">&lt;</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">D</span> <span class="special">&gt;</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">nullptr_t</span><span class="special">)</span><span class="special">;</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T<span class="special">,</span> <span class="keyword">typename</span> D<span class="special">&gt;</span>
<span class="keyword">bool</span> <a class="link" href="../boost/movelib/operat_1_3_26_20_14_3_1_20.html" title="Function template operator&gt;="><span class="keyword">operator</span><span class="special">&gt;=</span></a><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">nullptr_t</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="../boost/movelib/unique_ptr.html" title="Class template unique_ptr">unique_ptr</a><span class="special">&lt;</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">D</span> <span class="special">&gt;</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
<span class="special">}</span>
<span class="special">}</span></pre>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="header.boost.move.utility_hpp"></a>Header &lt;<a href="../../../boost/move/utility.hpp" target="_top">boost/move/utility.hpp</a>&gt;</h3></div></div></div>
<p>This header includes core utilities from <code class="computeroutput">&lt;boost/move/utility_core.hpp&gt;</code> and defines some more advanced utilities such as: </p>
<pre class="synopsis"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T<span class="special">&gt;</span>
<span class="identifier">rvalue_reference_or_const_lvalue_reference</span>
<a class="link" href="../boost/move_if_noexcept.html" title="Function template move_if_noexcept"><span class="identifier">move_if_noexcept</span></a><span class="special">(</span><span class="identifier">input_reference</span><span class="special">)</span><span class="special">;</span>
<span class="special">}</span></pre>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="header.boost.move.utility_core_hpp"></a>Header &lt;<a href="../../../boost/move/utility_core.hpp" target="_top">boost/move/utility_core.hpp</a>&gt;</h3></div></div></div>
<p>This header defines core utilities to ease the development of move-aware functions. This header minimizes dependencies from other libraries. </p>
<pre class="synopsis"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T<span class="special">&gt;</span> <span class="keyword">struct</span> <a class="link" href="../boost/enable_mo_1_3_26_20_16_2_1.html" title="Struct template enable_move_utility_emulation">enable_move_utility_emulation</a><span class="special">;</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T<span class="special">&gt;</span> <span class="identifier">rvalue_reference</span> <a class="link" href="../boost/move_1_3_26_20_16_2_2.html" title="Function template move"><span class="identifier">move</span></a><span class="special">(</span><span class="identifier">input_reference</span><span class="special">)</span><span class="special">;</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T<span class="special">&gt;</span> <span class="identifier">output_reference</span> <a class="link" href="../boost/forward.html" title="Function template forward"><span class="identifier">forward</span></a><span class="special">(</span><span class="identifier">input_reference</span><span class="special">)</span><span class="special">;</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T<span class="special">&gt;</span>
<span class="identifier">output_reference</span> <a class="link" href="../boost/move_if_n_1_3_26_20_16_2_4.html" title="Function template move_if_not_lvalue_reference"><span class="identifier">move_if_not_lvalue_reference</span></a><span class="special">(</span><span class="identifier">input_reference</span><span class="special">)</span><span class="special">;</span>
<span class="special">}</span></pre>
</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 © 2008-2014 Ion Gaztanaga<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="release_notes.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../move.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="../boost/adl_move_swap.html"><img src="../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@@ -0,0 +1,485 @@
<!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=UTF-8">
<title>Release Notes</title>
<link rel="stylesheet" href="../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../index.html" title="The Boost C++ Libraries BoostBook Documentation Subset">
<link rel="up" href="../move.html" title="Chapter 25. Boost.Move">
<link rel="prev" href="thanks_to.html" title="Thanks and credits">
<link rel="next" href="reference.html" title="Reference">
</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="thanks_to.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../move.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="reference.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="move.release_notes"></a><a class="link" href="release_notes.html" title="Release Notes">Release Notes</a>
</h2></div></div></div>
<div class="toc"><dl class="toc">
<dt><span class="section"><a href="release_notes.html#move.release_notes.release_notes_boost_1_76">Boost 1.76
Release</a></span></dt>
<dt><span class="section"><a href="release_notes.html#move.release_notes.release_notes_boost_1_75">Boost 1.75
Release</a></span></dt>
<dt><span class="section"><a href="release_notes.html#move.release_notes.release_notes_boost_1_73">Boost 1.73
Release</a></span></dt>
<dt><span class="section"><a href="release_notes.html#move.release_notes.release_notes_boost_1_71">Boost 1.71
Release</a></span></dt>
<dt><span class="section"><a href="release_notes.html#move.release_notes.release_notes_boost_1_70">Boost 1.70
Release</a></span></dt>
<dt><span class="section"><a href="release_notes.html#move.release_notes.release_notes_boost_1_69">Boost 1.69
Release</a></span></dt>
<dt><span class="section"><a href="release_notes.html#move.release_notes.release_notes_boost_1_67">Boost 1.67
Release</a></span></dt>
<dt><span class="section"><a href="release_notes.html#move.release_notes.release_notes_boost_1_66">Boost 1.66
Release</a></span></dt>
<dt><span class="section"><a href="release_notes.html#move.release_notes.release_notes_boost_1_65">Boost 1.65
Release</a></span></dt>
<dt><span class="section"><a href="release_notes.html#move.release_notes.release_notes_boost_1_64">Boost 1.64
Release</a></span></dt>
<dt><span class="section"><a href="release_notes.html#move.release_notes.release_notes_boost_1_62">Boost 1.62
Release</a></span></dt>
<dt><span class="section"><a href="release_notes.html#move.release_notes.release_notes_boost_1_61">Boost 1.61
Release</a></span></dt>
<dt><span class="section"><a href="release_notes.html#move.release_notes.release_notes_boost_1_60">Boost 1.60
Release</a></span></dt>
<dt><span class="section"><a href="release_notes.html#move.release_notes.release_notes_boost_1_59">Boost 1.59
Release</a></span></dt>
<dt><span class="section"><a href="release_notes.html#move.release_notes.release_notes_boost_1_58_00">Boost
1.58 Release</a></span></dt>
<dt><span class="section"><a href="release_notes.html#move.release_notes.release_notes_boost_1_57_00">Boost
1.57 Release</a></span></dt>
<dt><span class="section"><a href="release_notes.html#move.release_notes.release_notes_boost_1_56_00">Boost
1.56 Release</a></span></dt>
<dt><span class="section"><a href="release_notes.html#move.release_notes.release_notes_boost_1_55_00">Boost
1.55 Release</a></span></dt>
<dt><span class="section"><a href="release_notes.html#move.release_notes.release_notes_boost_1_54_00">Boost
1.54 Release</a></span></dt>
<dt><span class="section"><a href="release_notes.html#move.release_notes.release_notes_boost_1_53_00">Boost
1.53 Release</a></span></dt>
<dt><span class="section"><a href="release_notes.html#move.release_notes.release_notes_boost_1_51_00">Boost
1.51 Release</a></span></dt>
<dt><span class="section"><a href="release_notes.html#move.release_notes.release_notes_boost_1_49_00">Boost
1.49 Release</a></span></dt>
</dl></div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="move.release_notes.release_notes_boost_1_76"></a><a class="link" href="release_notes.html#move.release_notes.release_notes_boost_1_76" title="Boost 1.76 Release">Boost 1.76
Release</a>
</h3></div></div></div>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
Fixed bugs:
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: circle; "><li class="listitem">
<a href="https://github.com/boostorg/move/issues/35" target="_top">Git Issue
#35: <span class="emphasis"><em>"New nothrow move traits are incomplete"</em></span></a>.
</li></ul></div>
</li></ul></div>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="move.release_notes.release_notes_boost_1_75"></a><a class="link" href="release_notes.html#move.release_notes.release_notes_boost_1_75" title="Boost 1.75 Release">Boost 1.75
Release</a>
</h3></div></div></div>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
Fixed bugs:
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: circle; "><li class="listitem">
<a href="https://github.com/boostorg/move/issues/30" target="_top">Git Issue
#30: <span class="emphasis"><em>"(void) C-cast is a non-portable way of suppressing
compiler warnings"</em></span></a>.
</li></ul></div>
</li></ul></div>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="move.release_notes.release_notes_boost_1_73"></a><a class="link" href="release_notes.html#move.release_notes.release_notes_boost_1_73" title="Boost 1.73 Release">Boost 1.73
Release</a>
</h3></div></div></div>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
Fixed bugs:
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: circle; "><li class="listitem">
<a href="https://github.com/boostorg/move/issues/28" target="_top">Git Issue
#28: <span class="emphasis"><em>"Warning C4624 on MSVC 2019"</em></span></a>.
</li></ul></div>
</li></ul></div>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="move.release_notes.release_notes_boost_1_71"></a><a class="link" href="release_notes.html#move.release_notes.release_notes_boost_1_71" title="Boost 1.71 Release">Boost 1.71
Release</a>
</h3></div></div></div>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
Fixed bugs:
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: circle; "><li class="listitem">
<a href="https://github.com/boostorg/move/issues/26" target="_top">Git Issue
#26: <span class="emphasis"><em>"Invalid iterator increment/decrement in the
last iteration of adaptive_sort_combine_blocks"</em></span></a>.
</li></ul></div>
</li></ul></div>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="move.release_notes.release_notes_boost_1_70"></a><a class="link" href="release_notes.html#move.release_notes.release_notes_boost_1_70" title="Boost 1.70 Release">Boost 1.70
Release</a>
</h3></div></div></div>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
Removed support for deprecated GCC compilers.
</li>
<li class="listitem">
Fixed bugs:
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: circle; ">
<li class="listitem">
<a href="https://github.com/boostorg/move/pull/23" target="_top">Git Pull
#23: <span class="emphasis"><em>"Add minimal cmake file"</em></span></a>.
</li>
<li class="listitem">
<a href="https://github.com/boostorg/move/issues/25" target="_top">Git Issue
#25: <span class="emphasis"><em>"adaptive_merge is broken for iterator_traits&lt;RandIt&gt;::size_type
!= std::size_t"</em></span></a>.
</li>
</ul></div>
</li>
</ul></div>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="move.release_notes.release_notes_boost_1_69"></a><a class="link" href="release_notes.html#move.release_notes.release_notes_boost_1_69" title="Boost 1.69 Release">Boost 1.69
Release</a>
</h3></div></div></div>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
Deprecated GCC &lt; 4.3 and MSVC &lt; 9.0 (Visual 2008) compilers.
</li>
<li class="listitem">
Fixed bugs:
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: circle; "><li class="listitem">
<a href="https://github.com/boostorg/move/issues/15" target="_top">Git Issue
#19: <span class="emphasis"><em>"Compilation error with IBM xlC++ on AIX"</em></span></a>.
</li></ul></div>
</li>
</ul></div>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="move.release_notes.release_notes_boost_1_67"></a><a class="link" href="release_notes.html#move.release_notes.release_notes_boost_1_67" title="Boost 1.67 Release">Boost 1.67
Release</a>
</h3></div></div></div>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
Added pdqsort and heap_sort implementations, initially as a detail, they
will be official in the future once better tested.
</li></ul></div>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="move.release_notes.release_notes_boost_1_66"></a><a class="link" href="release_notes.html#move.release_notes.release_notes_boost_1_66" title="Boost 1.66 Release">Boost 1.66
Release</a>
</h3></div></div></div>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
Fixed bugs:
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: circle; ">
<li class="listitem">
<a href="https://github.com/boostorg/move/pull/14" target="_top">Git Pull
#14: <span class="emphasis"><em>"Workaround for bogus <span class="strikethrough">Wignored-attributes</span>
warning on GCC 6.x/7.x"</em></span></a>.
</li>
<li class="listitem">
<a href="https://github.com/boostorg/move/issues/15" target="_top">Git Issue
#15: <span class="emphasis"><em>"Incorrect merge in adaptive_merge when the
number of unique items is limited"</em></span></a>.
</li>
</ul></div>
</li></ul></div>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="move.release_notes.release_notes_boost_1_65"></a><a class="link" href="release_notes.html#move.release_notes.release_notes_boost_1_65" title="Boost 1.65 Release">Boost 1.65
Release</a>
</h3></div></div></div>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
Fixed bug:
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: circle; ">
<li class="listitem">
<a href="https://github.com/boostorg/move/pull/11" target="_top">Git Pull
#11: <span class="emphasis"><em>"replace 'std::random_shuffle' by '::random_shuffle'"</em></span></a>.
</li>
<li class="listitem">
<a href="https://github.com/boostorg/move/pull/12" target="_top">Git Pull
#12: <span class="emphasis"><em>"Adds support for MSVC ARM64 target'"</em></span></a>.
</li>
</ul></div>
</li></ul></div>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="move.release_notes.release_notes_boost_1_64"></a><a class="link" href="release_notes.html#move.release_notes.release_notes_boost_1_64" title="Boost 1.64 Release">Boost 1.64
Release</a>
</h3></div></div></div>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
Fixed bug:
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: circle; "><li class="listitem">
<a href="https://svn.boost.org/trac/boost/ticket/12920" target="_top">#12920
<span class="emphasis"><em>"movelib::unique_ptr: incorrect pointer type for
nested array"</em></span></a>.
</li></ul></div>
</li></ul></div>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="move.release_notes.release_notes_boost_1_62"></a><a class="link" href="release_notes.html#move.release_notes.release_notes_boost_1_62" title="Boost 1.62 Release">Boost 1.62
Release</a>
</h3></div></div></div>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
Documented new limitations reported in Trac tickets <a href="https://svn.boost.org/trac/boost/ticket/12194" target="_top">#12194
<span class="emphasis"><em>"Copy assignment on moveable and copyable classes uses
wrong type"</em></span></a> and <a href="https://svn.boost.org/trac/boost/ticket/12307" target="_top">#12307
<span class="emphasis"><em>"Copy assignment from const ref handled differently in
C++11/C++98"</em></span></a>.
</li></ul></div>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="move.release_notes.release_notes_boost_1_61"></a><a class="link" href="release_notes.html#move.release_notes.release_notes_boost_1_61" title="Boost 1.61 Release">Boost 1.61
Release</a>
</h3></div></div></div>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
Experimental: asymptotically optimal bufferless merge and sort algorithms:
<code class="computeroutput"><a class="link" href="../boost/movelib/adaptive_merge.html" title="Function template adaptive_merge">adaptive_merge</a></code>
and <code class="computeroutput"><a class="link" href="../boost/movelib/adaptive_1_3_26_20_3_1_1_1.html" title="Function template adaptive_sort">adaptive_sort</a></code>.
</li>
<li class="listitem">
Fixed bug:
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: circle; "><li class="listitem">
<a href="https://svn.boost.org/trac/boost/ticket/11758" target="_top">Trac
#11758: <span class="emphasis"><em>"BOOST_MOVABLE_BUT_NOT_COPYABLE doesn't
reset private access with rvalue ref version"</em></span></a>,
</li></ul></div>
</li>
</ul></div>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="move.release_notes.release_notes_boost_1_60"></a><a class="link" href="release_notes.html#move.release_notes.release_notes_boost_1_60" title="Boost 1.60 Release">Boost 1.60
Release</a>
</h3></div></div></div>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
Fixed bug:
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: circle; "><li class="listitem">
<a href="https://svn.boost.org/trac/boost/ticket/11615" target="_top">Trac
#11615: <span class="emphasis"><em>"Boost.Move should use the qualified name
for std::size_t in type_traits.hpp"</em></span></a>,
</li></ul></div>
</li></ul></div>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="move.release_notes.release_notes_boost_1_59"></a><a class="link" href="release_notes.html#move.release_notes.release_notes_boost_1_59" title="Boost 1.59 Release">Boost 1.59
Release</a>
</h3></div></div></div>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
Changed <code class="computeroutput"><span class="identifier">unique_ptr</span></code>'s
converting constructor taking the source by value in C++03 compilers
to allow simple conversions from convertible types returned by value.
</li>
<li class="listitem">
Fixed bug:
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: circle; ">
<li class="listitem">
<a href="https://svn.boost.org/trac/boost/ticket/11229" target="_top">Trac
#11229: <span class="emphasis"><em>"vector incorrectly copies move-only objects
using memcpy"</em></span></a>,
</li>
<li class="listitem">
<a href="https://svn.boost.org/trac/boost/ticket/11510" target="_top">Trac
#11510: <span class="emphasis"><em>"unique_ptr: -Wshadow warning issued"</em></span></a>,
</li>
</ul></div>
</li>
</ul></div>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="move.release_notes.release_notes_boost_1_58_00"></a><a class="link" href="release_notes.html#move.release_notes.release_notes_boost_1_58_00" title="Boost 1.58 Release">Boost
1.58 Release</a>
</h3></div></div></div>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
Added <code class="computeroutput"><a class="link" href="../BOOST_MOVE_BASE.html" title="Macro BOOST_MOVE_BASE">BOOST_MOVE_BASE</a></code> utility.
</li>
<li class="listitem">
Added <code class="computeroutput"><a class="link" href="../boost/adl_move_swap.html" title="Function template adl_move_swap">adl_move_swap</a></code>
utility.
</li>
<li class="listitem">
Reduced dependencies on other Boost libraries to make the library a bit
more lightweight.
</li>
<li class="listitem">
Fixed bugs:
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: circle; "><li class="listitem">
<a href="https://svn.boost.org/trac/boost/ticket/11044" target="_top">Trac
#11044: <span class="emphasis"><em>"boost::rv inherits off union, when such
passed as template argument"</em></span></a>.
</li></ul></div>
</li>
</ul></div>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="move.release_notes.release_notes_boost_1_57_00"></a><a class="link" href="release_notes.html#move.release_notes.release_notes_boost_1_57_00" title="Boost 1.57 Release">Boost
1.57 Release</a>
</h3></div></div></div>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
Added <code class="computeroutput"><span class="identifier">unique_ptr</span></code> smart
pointer. Thanks to Howard Hinnant for his excellent unique_ptr emulation
code and testsuite.
</li>
<li class="listitem">
Added <code class="computeroutput"><span class="identifier">move_if_noexcept</span></code>
utility. Thanks to Antony Polukhin for the implementation.
</li>
<li class="listitem">
Fixed bugs:
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: circle; ">
<li class="listitem">
<a href="https://svn.boost.org/trac/boost/ticket/9785" target="_top">Trac
#9785: <span class="emphasis"><em>"Compiler warning with intel icc in boost/move/core.hpp"</em></span></a>,
</li>
<li class="listitem">
<a href="https://svn.boost.org/trac/boost/ticket/10460" target="_top">Trac
#10460: <span class="emphasis"><em>"Compiler error due to looser throw specifier"</em></span></a>,
</li>
<li class="listitem">
<a href="https://github.com/boostorg/move/pull/3" target="_top">Git Pull #3:
<span class="emphasis"><em>"Don't delete copy constructor when rvalue references
are disabled"</em></span></a>,
</li>
</ul></div>
</li>
</ul></div>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="move.release_notes.release_notes_boost_1_56_00"></a><a class="link" href="release_notes.html#move.release_notes.release_notes_boost_1_56_00" title="Boost 1.56 Release">Boost
1.56 Release</a>
</h3></div></div></div>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
Added <code class="computeroutput"><a class="link" href="../BOOST_MOVE_RET.html" title="Macro BOOST_MOVE_RET">BOOST_MOVE_RET</a></code>.
</li>
<li class="listitem">
Fixed bugs:
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: circle; ">
<li class="listitem">
<a href="https://svn.boost.org/trac/boost/ticket/9482" target="_top">#9482:
<span class="emphasis"><em>"MSVC macros not undefined in boost/move/detail/config_end.hpp"</em></span></a>,
</li>
<li class="listitem">
<a href="https://svn.boost.org/trac/boost/ticket/9045" target="_top">#9045:
<span class="emphasis"><em>"Wrong macro name on docs"</em></span></a>,
</li>
<li class="listitem">
<a href="https://svn.boost.org/trac/boost/ticket/8420" target="_top">#8420:
<span class="emphasis"><em>"move's is_convertible does not compile with aligned
data"</em></span></a>.
</li>
</ul></div>
</li>
</ul></div>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="move.release_notes.release_notes_boost_1_55_00"></a><a class="link" href="release_notes.html#move.release_notes.release_notes_boost_1_55_00" title="Boost 1.55 Release">Boost
1.55 Release</a>
</h3></div></div></div>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
Fixed bugs <a href="https://svn.boost.org/trac/boost/ticket/7952" target="_top">#7952</a>,
<a href="https://svn.boost.org/trac/boost/ticket/8764" target="_top">#8764</a>,
<a href="https://svn.boost.org/trac/boost/ticket/8765" target="_top">#8765</a>,
<a href="https://svn.boost.org/trac/boost/ticket/8842" target="_top">#8842</a>,
<a href="https://svn.boost.org/trac/boost/ticket/8979" target="_top">#8979</a>.
</li></ul></div>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="move.release_notes.release_notes_boost_1_54_00"></a><a class="link" href="release_notes.html#move.release_notes.release_notes_boost_1_54_00" title="Boost 1.54 Release">Boost
1.54 Release</a>
</h3></div></div></div>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
Fixed bugs <a href="https://svn.boost.org/trac/boost/ticket/7969" target="_top">#7969</a>,
<a href="https://svn.boost.org/trac/boost/ticket/8231" target="_top">#8231</a>,
<a href="https://svn.boost.org/trac/boost/ticket/8765" target="_top">#8765</a>.
</li></ul></div>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="move.release_notes.release_notes_boost_1_53_00"></a><a class="link" href="release_notes.html#move.release_notes.release_notes_boost_1_53_00" title="Boost 1.53 Release">Boost
1.53 Release</a>
</h3></div></div></div>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
Better header segregation (bug <a href="https://svn.boost.org/trac/boost/ticket/6524" target="_top">#6524</a>).
</li>
<li class="listitem">
Small documentation fixes
</li>
<li class="listitem">
Replaced deprecated BOOST_NO_XXXX with newer BOOST_NO_CXX11_XXX macros.
</li>
<li class="listitem">
Fixed <a href="https://svn.boost.org/trac/boost/ticket/7830" target="_top">#7830</a>,
<a href="https://svn.boost.org/trac/boost/ticket/7832" target="_top">#7832</a>.
</li>
</ul></div>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="move.release_notes.release_notes_boost_1_51_00"></a><a class="link" href="release_notes.html#move.release_notes.release_notes_boost_1_51_00" title="Boost 1.51 Release">Boost
1.51 Release</a>
</h3></div></div></div>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
Fixed bugs <a href="https://svn.boost.org/trac/boost/ticket/7095" target="_top">#7095</a>,
<a href="https://svn.boost.org/trac/boost/ticket/7031" target="_top">#7031</a>.
</li></ul></div>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="move.release_notes.release_notes_boost_1_49_00"></a><a class="link" href="release_notes.html#move.release_notes.release_notes_boost_1_49_00" title="Boost 1.49 Release">Boost
1.49 Release</a>
</h3></div></div></div>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
Fixed bugs <a href="https://svn.boost.org/trac/boost/ticket/6417" target="_top">#6417</a>,
<a href="https://svn.boost.org/trac/boost/ticket/6183" target="_top">#6183</a>,
<a href="https://svn.boost.org/trac/boost/ticket/6185" target="_top">#6185</a>,
<a href="https://svn.boost.org/trac/boost/ticket/6395" target="_top">#6395</a>,
<a href="https://svn.boost.org/trac/boost/ticket/6396" target="_top">#6396</a>,
</li></ul></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 © 2008-2014 Ion Gaztanaga<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="thanks_to.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../move.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="reference.html"><img src="../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@@ -0,0 +1,68 @@
<!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=UTF-8">
<title>Thanks and credits</title>
<link rel="stylesheet" href="../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../index.html" title="The Boost C++ Libraries BoostBook Documentation Subset">
<link rel="up" href="../move.html" title="Chapter 25. Boost.Move">
<link rel="prev" href="how_the_library_works.html" title="How the library works">
<link rel="next" href="release_notes.html" title="Release Notes">
</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="how_the_library_works.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../move.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="release_notes.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="move.thanks_to"></a><a class="link" href="thanks_to.html" title="Thanks and credits">Thanks and credits</a>
</h2></div></div></div>
<p>
Thanks to all that developed ideas for move emulation: the first emulation
was based on Howard Hinnant emulation code for <code class="computeroutput"><span class="identifier">unique_ptr</span></code>,
David Abrahams suggested the use of <code class="computeroutput"><span class="keyword">class</span>
<span class="identifier">rv</span></code>, and Klaus Triendl discovered
how to bind const rlvalues using <code class="computeroutput"><span class="keyword">class</span>
<span class="identifier">rv</span></code>.
</p>
<p>
Many thanks to all boosters that have tested, reviewed and improved the library.
</p>
<p>
Special thanks to:
</p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
Orson Peters, author of <a href="https://github.com/orlp/pdqsort" target="_top">Pattern-defeating
quicksort (pdqsort)</a>.
</li>
<li class="listitem">
Andrey Astrelin, author of <a href="https://github.com/Mrrl/GrailSort" target="_top">Grail
Sort</a>.
</li>
</ul></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 © 2008-2014 Ion Gaztanaga<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="how_the_library_works.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../move.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="release_notes.html"><img src="../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@@ -0,0 +1,51 @@
<!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=UTF-8">
<title>What is Boost.Move?</title>
<link rel="stylesheet" href="../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../index.html" title="The Boost C++ Libraries BoostBook Documentation Subset">
<link rel="up" href="../move.html" title="Chapter 25. Boost.Move">
<link rel="prev" href="../move.html" title="Chapter 25. Boost.Move">
<link rel="next" href="introduction.html" title="Introduction">
</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="../move.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../move.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="introduction.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="move.what_is_boost_move"></a><a class="link" href="what_is_boost_move.html" title="What is Boost.Move?">What is Boost.Move?</a>
</h2></div></div></div>
<p>
Rvalue references are a major C++0x feature, enabling move semantics for C++
values. However, we don't need C++0x compilers to take advantage of move semanatics.
<span class="bold"><strong>Boost.Move</strong></span> emulates C++0x move semantics in
C++03 compilers and allows writing portable code that works optimally in C++03
and C++0x compilers.
</p>
</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 © 2008-2014 Ion Gaztanaga<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="../move.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../move.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="introduction.html"><img src="../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>