ceph/src/boost/libs/assign/doc/index.html

   1 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2//EN">
   2
   3 <html>
   4 <head>
   5 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
   6 <title>Boost.Assignment Documentation </title>
   7 <link rel="stylesheet" href="style.css" type="text/css">
   8 </head>
   9
  10 <body>
  11
  12   <table border="0" >
  13     <tr>
  14       <td ><img src="../../../boost.png" border="0" ></td>
  15       <td >
  16         <h1 align="center">Assignment Library</h1>
  17       </td>
  18     </tr>
  19   </table>
  20
  21   <p>
  22   Copyright © 2003-2006 Thorsten Ottosen
  23   </p>
  24   <p>
  25   Use, modification and distribution is subject to the Boost Software License, Version 1.0
  26   (see <a href="http://www.boost.org/LICENSE_1_0.txt">
  27    http://www.boost.org/LICENSE_1_0.txt</a>).
  28   </p>
  29   <h3>Table of Contents</h3>
  30   <ul>
  31     <li><a href="#intro">Introduction</a></li>
  32     <li>
  33         <a href="#tutorial" >Tutorial</a>
  34         <ul>
  35             <li>Function <a href="#operator+="><code>operator+=()</code></a>
  36             <li>Function <a href="#operator()"><code>operator()()</code></a>
  37             <li>Function <a href="#list_of"><code>list_of()</code></a>
  38             <li>Function <a href="#map_list_of"><code>map_list_of()</code></a>
  39             <li>Function <a href="#tuple_list_of"><code>tuple_list_of()</code></a>
  40             <li>Functions <a href="#repeat"><code>repeat()</code>, <code>repeat_fun()</code> and <code>range()</code> </a>
  41             <li>Functions <a href="#ref_list_of"><code>ref_list_of()</code> and <code>cref_list_of()</code></a>
  42             <li>A <a href="#complicated">"complicated"</a> example
  43             <li>Functions <a href="#ptr_push_back"><code>ptr_push_back(), ptr_push_front()</code>,
  44                                                    <code>ptr_insert()</code> and <code>ptr_map_insert()</code></a>
  45             <li>Function <a href="#ptr_list_of"><code>ptr_list_of()</code></a>
  46        </ul> <li>
  47
  48         <a href="#reference">Reference</a>
  49       <ul>
  50         <li><a href="#headers">Headers</a> </li>
  51         <li><a href="#std">Standard containers</a> </li>
  52         <li>Functions <a href="#list_of_ref"><code>list_of()</code> and <code>map_list_of()</code></a></li>
  53         <li>Functions <a href="#repeat_ref"><code>repeat()</code>,
  54             <code>repeat_fun()</code> and <code>range()</code> </a> </li>
  55         <li>Class <a href="#list_inserter"><code>list_inserter</code></a></li>
  56         <li>Function <a href="#make_list_inserter"><code>make_list_inserter()</code></a></li>
  57         <li><a href="#limit"> Customizing</a> argument list sizes</li>
  58      </ul>
  59     <li> <a href="#exceptions">Exceptions and exception-safety </a></li>
  60     <li> <a href="#extensions">Extending the library</a>
  61     <li> <a href="#boost_libs">Supported libraries </a>
  62     <li> <a href="#examples">Examples</a></li> <ul></ul>
  63     <li><a href="#portability">Portability</a></li>
  64     <li><a href="#history">History and Acknowledgment</a>
  65     <li><a href="#ref">References</a></li>
  66   </ul>
  67   <hr>
  68
  69
  70
  71 <h2><a name="intro">Introduction</a></h2> <p> <i>There appear to be few
  72 practical uses of <code>operator,()</code></i>.  <!-- p.  247 --> <br><b>Bjarne
  73 Stroustrup</b>, The Design and Evolution of C++ </p> <p> The purpose of this
  74 library is to make it easy to fill containers with data by overloading
  75 <code>operator,()</code> and <code>operator()()</code>.  These two operators
  76 make it possible to construct lists of values that are then copied into a
  77 container: </p> <ul> <li> A comma-separated list: <p>
  78        <!--  vector< int > v; v += 1,2,3,4,5,6,7,8,9; -->
  79
  80 <pre><span
  81 class=identifier>vector</span><span class=special><</span><span
  82 class=keyword>int</span><span class=special>></span><span
  83 class=identifier> v</span><span class=special>; </span>
  84 <span class=identifier>v </span><span class=special>+= </span><span
  85 class=number>1</span><span
  86 class=special>,</span><span class=number>2</span><span
  87 class=special>,</span><span class=number>3</span><span
  88 class=special>,</span><span class=number>4</span><span
  89 class=special>,</span><span class=number>5</span><span
  90 class=special>,</span><span class=number>6</span><span
  91 class=special>,</span><span class=number>7</span><span
  92 class=special>,</span><span class=number>8</span><span
  93 class=special>,</span><span class=number>9</span><span class=special>;</span></pre></p>
  94        <li> A parenthesis-separated list:
  95              <p>
  96              <pre>
  97 <span class=identifier>map</span><span class=special><</span><span
  98 class=identifier>string</span><span class=special>,</span><span class=keyword>int</span><span class=special>> </span><span class=identifier>m</span><span class=special>; </span>
  99 <span class=identifier>insert</span><span class=special>( </span><span class=identifier>m </span><span class=special>)( </span><span class=string>&quot;Bar&quot;</span><span class=special>, </span><span class=number>1 </span><span class=special>)( </span><span class=string>&quot;Foo&quot;</span><span class=special>, </span><span class=number>2 </span><span class=special>);</span></pre>
 100     </ul>
 101 <p>
 102     These lists are particularly useful in
 103     learning, testing, and prototyping situations, but can also be handy otherwise.
 104       The library comes with predefined operators for the containers of the
 105       standard library, but most functionality will work with any standard
 106 compliant container. The library also makes it possible to extend user
 107   defined types so for example a member function can be called for a list of
 108 values instead of its normal arguments. </p>
 109    <hr>
 110
 111    <a name="tutorial"></a>
 112    <h2>Tutorial</h2>
 113    <p>
 114    Within two minutes you should be able to use this library. The main
 115 components are explained in these sections:
 116    <ul>
 117         <li>Function <a href="#operator+="><code>operator+=()</code></a>
 118         <li>Function <a href="#operator()"><code>operator()()</code></a>
 119         <li>Function <a href="#list_of"><code>list_of()</code></a>
 120         <li>Function <a href="#map_list_of"><code>map_list_of()</code></a>
 121         <li>Function <a href="#tuple_list_of"><code>tuple_list_of()</code></a>
 122         <li>Functions <a href="#repeat"><code>repeat()</code>, <code>repeat_fun()</code> and <code>range()</code> </a>
 123         <li>Functions <a href="#ref_list_of"><code>ref_list_of()</code> and <code>cref_list_of()</code></a>
 124         <li>A <a href="#complicated">"complicated"</a> example
 125         <li>Functions <a href="#ptr_push_back"><code>ptr_push_back(), ptr_push_front()</code>, <code>ptr_insert()</code> and <code>ptr_map_insert()</code></a>
 126         <li>Function <a href="#ptr_list_of"><code>ptr_list_of()</code></a>
 127
 128    </ul>
 129    The two first functions are used for adding elements after a container object
 130    has been created whereas the next two is used when we need to initialize an
 131    object. </p>
 132    <h3>Function <code>operator+=()</code><a name="operator+="></h3>
 133    <p>
 134     To fill a vector (or any standard container) with values using
 135     <code>operator+=()</code> you write
 136     <blockquote><pre>
 137 <span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>boost</span><span class=special>/</span><span class=identifier>assign</span><span class=special>/</span><span class=identifier>std</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=comment>// for 'operator+=()'
 138 </span><span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>boost</span><span class=special>/</span><span class=identifier>assert</span><span class=special>.</span><span class=identifier>hpp</span><span class=special>&gt;;
 139 </span><span class=keyword>using </span><span class=keyword>namespace </span><span class=identifier>std</span><span class=special>;
 140 </span><span class=keyword>using </span><span class=keyword>namespace </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>assign</span><span class=special>; </span><span class=comment>// bring 'operator+=()' into scope
 141 </span><span class=special>
 142 </span><span class=special>{
 143     </span><span class=identifier>vector</span><span class=special>&lt;</span><span class=keyword>int</span><span class=special>&gt; </span><span class=identifier>values</span><span class=special>;
 144     </span><span class=identifier>values </span><span class=special>+= </span><span class=number>1</span><span class=special>,</span><span class=number>2</span><span class=special>,</span><span class=number>3</span><span class=special>,</span><span class=number>4</span><span class=special>,</span><span class=number>5</span><span class=special>,</span><span class=number>6</span><span class=special>,</span><span class=number>7</span><span class=special>,</span><span class=number>8</span><span class=special>,</span><span class=number>9</span><span class=special>; </span><span class=comment>// insert values at the end of the container
 145     </span><span class=identifier>BOOST_ASSERT</span><span class=special>( </span><span class=identifier>values</span><span class=special>.</span><span class=identifier>size</span><span class=special>() </span><span class=special>== </span><span class=number>9 </span><span class=special>);
 146     </span><span class=identifier>BOOST_ASSERT</span><span class=special>( </span><span class=identifier>values</span><span class=special>[</span><span class=number>0</span><span class=special>] </span><span class=special>== </span><span class=number>1 </span><span class=special>);
 147     </span><span class=identifier>BOOST_ASSERT</span><span class=special>( </span><span class=identifier>values</span><span class=special>[</span><span class=number>8</span><span class=special>] </span><span class=special>== </span><span class=number>9 </span><span class=special>);
 148 </span><span class=special>}</span></pre></blockquote>
 149
 150     Here we only stuffed constants into the container, but the list can
 151     consists of arbitrary expressions as long as the result of each
 152 expression is convertible to the <code>value_type</code> of the container.
 153    </p>
 154
 155
 156    <h3>Function <code>operator()()</code> <a name="operator()"></h3>
 157    <p>
 158    We do not call <code>operator()()</code> directly, but instead we call a
 159    function that returns a proxy-object that defines <code>operator()()</code>.
 160    The function that returns the proxy object is always named after the member
 161    function that is used to copy the values in the list into the container.
 162    So to fill a map with pairs of values you write
 163    <blockquote><pre>
 164 <span class=preprocessor>#include </span><span class=special>&lt;</span><span
 165 class=identifier>boost</span><span class=special>/</span><span
 166 class=identifier>assign</span><span class=special>/</span><span
 167 class=identifier>list_inserter</span><span class=special>.</span><span
 168 class=identifier>hpp</span><span class=special>&gt; </span><span class=comment>// for 'insert()'
 169 </span><span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>boost</span><span class=special>/</span><span class=identifier>assert</span><span class=special>.</span><span class=identifier>hpp</span><span class=special>&gt;
 170 </span><span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>string</span><span class=special>&gt;
 171 </span><span class=keyword>using </span><span class=keyword>namespace </span><span class=identifier>std</span><span class=special>;
 172 </span><span class=keyword>using </span><span class=keyword>namespace </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>assign</span><span class=special>; </span><span class=comment>// bring 'insert()' into scope
 173 </span><span class=special>
 174 </span><span class=special>{
 175     </span><span class=identifier>map</span><span class=special>&lt;</span><span class=identifier>string</span><span class=special>,</span><span class=keyword>int</span><span class=special>&gt; </span><span class=identifier>months</span><span class=special>;
 176     </span><span class=identifier>insert</span><span class=special>( </span><span class=identifier>months </span><span class=special>)
 177         </span><span class=special>( </span><span class=string>&quot;january&quot;</span><span class=special>,   </span><span class=number>31 </span><span class=special>)( </span><span class=string>&quot;february&quot;</span><span class=special>, </span><span class=number>28 </span><span class=special>)
 178         </span><span class=special>( </span><span class=string>&quot;march&quot;</span><span class=special>,     </span><span class=number>31 </span><span class=special>)( </span><span class=string>&quot;april&quot;</span><span class=special>,    </span><span class=number>30 </span><span class=special>)
 179         </span><span class=special>( </span><span class=string>&quot;may&quot;</span><span class=special>,       </span><span class=number>31 </span><span class=special>)( </span><span class=string>&quot;june&quot;</span><span class=special>,     </span><span class=number>30 </span><span class=special>)
 180         </span><span class=special>( </span><span class=string>&quot;july&quot;</span><span class=special>,      </span><span class=number>31 </span><span class=special>)( </span><span class=string>&quot;august&quot;</span><span class=special>,   </span><span class=number>31 </span><span class=special>)
 181         </span><span class=special>( </span><span class=string>&quot;september&quot;</span><span class=special>, </span><span class=number>30 </span><span class=special>)( </span><span class=string>&quot;october&quot;</span><span class=special>,  </span><span class=number>31 </span><span class=special>)
 182         </span><span class=special>( </span><span class=string>&quot;november&quot;</span><span class=special>,  </span><span class=number>30 </span><span class=special>)( </span><span class=string>&quot;december&quot;</span><span class=special>, </span><span class=number>31 </span><span class=special>);
 183     </span><span class=identifier>BOOST_ASSERT</span><span class=special>( </span><span class=identifier>months</span><span class=special>.</span><span
 184 class=identifier>size</span><span class=special>() </span><span class=special>== </span><span class=number>12 </span><span class=special>);
 185     </span><span class=identifier>BOOST_ASSERT</span><span class=special>( </span><span class=identifier>months</span><span class=special>[</span><span class=string>&quot;january&quot;</span><span class=special>] </span><span class=special>== </span><span class=number>31 </span><span class=special>);
 186 </span><span class=special>}</span> </pre></blockquote>
 187
 188    Note that <code>operator()()</code> is much more handy when
 189    we need to construct objects using several arguments
 190    (up to five arguments are supported by default, but the limit can be <a href="#limit">customized</a>).
 191     This is also true for sequences:
 192
 193       <blockquote><pre>
 194 <span class=preprocessor>#include </span><span class=special>&lt;</span><span
 195 class=identifier>boost</span><span class=special>/</span><span
 196 class=identifier>assign</span><span class=special>/</span>list_inserter</span><span class=special>.</span><span class=identifier>hpp</span><span class=special>&gt; </span><span class=comment>// for 'push_front()'
 197 </span><span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>boost</span><span class=special>/</span><span class=identifier>assert</span><span class=special>.</span><span class=identifier>hpp</span><span class=special>&gt;
 198 </span><span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>string</span><span class=special>&gt;
 199 </span><span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>utility</span><span class=special>&gt;
 200 </span><span class=keyword>using </span><span class=keyword>namespace </span><span class=identifier>std</span><span class=special>;
 201 </span><span class=keyword>using </span><span class=keyword>namespace </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>assign</span><span class=special>; </span><span class=comment>// bring 'push_front()' into scope
 202 </span><span class=special>
 203 </span><span class=special>{
 204     </span><span class=keyword>typedef </span><span class=identifier>pair</span><span class=special>&lt; </span><span class=identifier>string</span><span class=special>,</span><span class=identifier>string </span><span class=special>&gt; </span><span class=identifier>str_pair</span><span class=special>;
 205     </span><span class=identifier>deque</span><span class=special>&lt;</span><span class=identifier>str_pair</span><span class=special>&gt; </span><span class=identifier>deq</span><span class=special>;
 206     </span><span class=identifier>push_front</span><span class=special>( </span><span class=identifier>deq </span><span class=special>)( </span><span class=string>&quot;foo&quot;</span><span class=special>, </span><span class=string>&quot;bar&quot;</span><span class=special>)( </span><span class=string>&quot;boo&quot;</span><span class=special>, </span><span class=string>&quot;far&quot; </span><span class=special>);
 207     </span><span class=identifier>BOOST_ASSERT</span><span class=special>( </span><span class=identifier>deq</span><span class=special>.</span><span class=identifier>size</span><span class=special>() </span><span class=special>== </span><span class=number>2 </span><span class=special>);
 208     </span><span class=identifier>BOOST_ASSERT</span><span class=special>( </span><span class=identifier>deq</span><span class=special>.</span><span class=identifier>front</span><span class=special>().</span><span class=identifier>first </span><span class=special>== </span><span class=string>&quot;boo&quot; </span><span class=special>);
 209     </span><span class=identifier>BOOST_ASSERT</span><span class=special>( </span><span class=identifier>deq</span><span class=special>.</span><span class=identifier>back</span><span class=special>().</span><span class=identifier>second </span><span class=special>== </span><span class=string>&quot;bar&quot; </span><span class=special>);
 210 </span><span class=special>}   </span></pre></blockquote>
 211
 212    Besides <code>push_front()</code> we could also have used
 213    <code>push_back()</code> if the container has a corresponding member
 214    function. Empty parentheses can be used to insert default-constructed
 215 objects, for example,
 216 <code>push_front( deq )()()</code> will insert two default-constructed
 217 <code>str_pair</code> objects. </p>
 218
 219    <p>
 220    If <code>operator()()</code> is too cumbersome to use with eg.
 221 <code>push_front()</code>we can also say </p>
 222
 223 <blockquote>
 224     <pre>
 225 <span class=identifier>deque</span><span class=special>&lt;</span><span class=keyword>int</span><span class=special>&gt; </span><span class=identifier>di</span><span class=special>;    </span>
 226 <span class=identifier>push_front</span><span class=special>( </span><span class=identifier>di </span><span class=special>) </span><span class=special>= </span><span class=number>1</span><span class=special>,</span><span class=number>2</span><span class=special>,</span><span class=number>3</span><span class=special>,</span><span class=number>4</span><span class=special>,</span><span class=number>5</span><span class=special>,</span><span class=number>6</span><span class=special>,</span><span class=number>7</span><span class=special>,</span><span class=number>8</span><span class=special>,</span><span class=number>9</span><span class=special>;</span>
 227 <span class=identifier>BOOST_ASSERT</span><span class=special>( </span><span class=identifier>di</span><span class=special>.</span><span class=identifier>size</span><span class=special>() </span><span class=special>== </span><span class=number>9 </span><span class=special>);    </span>
 228 <span class=identifier>BOOST_ASSERT</span><span class=special>( </span><span
 229 class=identifier>di</span><span class=special>[</span><span class=number>0</span><span class=special>] </span><span class=special>== </span><span class=number>9 </span><span class=special>);    </span>
 230 </pre>
 231 </blockquote>
 232 <p>
 233 Just to make it perfectly clear, the code above is not restricted to the
 234 standard containers, but will work with all <i>standard compliant</i> containers
 235 with the right member function. It is only <code>operator+=()</code> that has been restricted to
 236 the standard containers. </p>
 237
 238   <h3>Function <code>list_of()</code> <a name="list_of"></h3>
 239   But what if we need to <i>initialize</i> a container? This is where
 240   <code>list_of()</code> comes into play. With <code>list_of()</code>
 241   we can create anonymous lists that automatically converts to
 242   any container:
 243   <blockquote><pre>
 244 <span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>boost</span><span class=special>/</span><span class=identifier>assign</span><span class=special>/</span><span class=identifier>list_of</span><span class=special>.</span><span class=identifier>hpp</span><span class=special>&gt; </span><span class=comment>// for 'list_of()'
 245 </span><span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>boost</span><span class=special>/</span><span class=identifier>assert</span><span class=special>.</span><span class=identifier>hpp</span><span class=special>&gt;
 246 </span><span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>list</span><span class=special>&gt;
 247 </span><span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>stack</span><span class=special>&gt;
 248 </span><span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>string</span><span class=special>&gt;
 249 </span><span class=keyword>using </span><span class=keyword>namespace </span><span class=identifier>std</span><span class=special>;
 250 </span><span class=keyword>using </span><span class=keyword>namespace </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>assign</span><span class=special>; </span><span class=comment>// bring 'list_of()' into scope
 251 </span><span class=special>
 252 </span><span class=special>{
 253     </span><span class=keyword>const </span><span class=identifier>list</span><span class=special>&lt;</span><span class=keyword>int</span><span class=special>&gt; </span><span class=identifier>primes </span><span class=special>= </span><span class=identifier>list_of</span><span class=special>(</span><span class=number>2</span><span class=special>)(</span><span class=number>3</span><span class=special>)(</span><span class=number>5</span><span class=special>)(</span><span class=number>7</span><span class=special>)(</span><span class=number>11</span><span class=special>);
 254     </span><span class=identifier>BOOST_ASSERT</span><span class=special>( </span><span class=identifier>primes</span><span class=special>.</span><span class=identifier>size</span><span class=special>() </span><span class=special>== </span><span class=number>5 </span><span class=special>);
 255     </span><span class=identifier>BOOST_ASSERT</span><span class=special>( </span><span class=identifier>primes</span><span class=special>.</span><span class=identifier>back</span><span class=special>() </span><span class=special>== </span><span class=number>11 </span><span class=special>);
 256     </span><span class=identifier>BOOST_ASSERT</span><span class=special>( </span><span class=identifier>primes</span><span class=special>.</span><span class=identifier>front</span><span class=special>() </span><span class=special>== </span><span class=number>2 </span><span class=special>);
 257
 258     </span><span class=keyword>const </span><span
 259 class=identifier>stack</span><span class=special>&lt;</span><span
 260 class=identifier>string</span><span class=special>&gt; </span><span
 261 class=identifier>names </span><span class=special>= </span><span
 262 class=special></span><span class=identifier>list_of</span><span class=special>( </span><span class=string>&quot;Mr. Foo&quot; </span><span class=special>)( </span><span class=string>&quot;Mr. Bar&quot;</span><span class=special>)( </span><span class=string>&quot;Mrs. FooBar&quot; </span><span
 263 class=special>).</span><span class=identifier>to_adapter();
 264     </span><span class=keyword>const </span><span
 265 class=identifier>stack</span><span class=special>&lt;</span><span
 266 class=identifier>string</span><span class=special>&gt; </span><span
 267 class=identifier>names2 </span><span class=special>= </span><span
 268 class=special>(</span><span class=identifier>list_of</span><span class=special>( </span><span class=string>&quot;Mr. Foo&quot; </span><span class=special>), </span><span class=string>&quot;Mr. Bar&quot;</span><span class=special>, </span><span class=string>&quot;Mrs. FooBar&quot; </span><span
 269 class=special>).</span><span class=identifier>to_adapter();
 270     </span><span class=identifier>BOOST_ASSERT</span><span class=special>( </span><span class=identifier>names</span><span class=special>.</span><span class=identifier>size</span><span class=special>() </span><span class=special>== </span><span class=number>3 </span><span class=special>);
 271     </span><span class=identifier>BOOST_ASSERT</span><span class=special>( </span><span class=identifier>names</span><span class=special>.</span><span class=identifier>top</span><span class=special>()</span><span class=special> == </span><span class=string>&quot;Mrs. FooBar&quot; </span><span class=special>);
 272 </span><span class=special>}   </span></pre></blockquote>
 273   If we need to initialize a container adapter, we need to help the compiler a
 274 little by calling <code>to_adapter()</code>. As the second example also shows,
 275 we can use a comma-separated
 276 list with <code>list_of()</code> if we add parenthesis around the
 277   entire right hand side. It is worth noticing that the first argument
 278   of <code>list_of()</code> determines the type of the anonymous list.
 279   In case of the stack, the anonymous list consists of
 280   <code>const char*</code> objects which are then converted to
 281   a stack of <code>string</code> objects. The conversion is always
 282   possible as long as the conversion between the stored types is possible.
 283  </p>
 284  <p>
 285  Please notice that <code>list_of()</code> can even convert to a
 286  <code>boost::<a
 287 href="../../array/index.html">array</a>&lt;T,sz></code> and see also the list
 288 of <a href="#boost_libs">supported libraries </a>. </p>
 289            <p>
 290                Note that the type returned by
 291                <code>list_of()</code> (and its variants) has overloaded comparison operators. This allows you to
 292                write test code such as
 293                    <code>
 294                        BOOST_CHECK_EQUAL( my_container, list_of(2)(3)(4)(5) );.
 295                    </code>
 296                </p>
 297
 298  <h3>Function <code>map_list_of()</code> <a name="map_list_of"></h3>
 299  This function is defined for pure convenience when working with
 300  maps. Its usage is simple:
 301  <blockquote><pre>
 302 <span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>boost</span><span class=special>/</span><span class=identifier>assign</span><span class=special>/</span><span class=identifier>list_of</span><span class=special>.</span><span class=identifier>hpp</span><span class=special>&gt; </span><span class=comment>// for 'map_list_of()'
 303 </span><span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>boost</span><span class=special>/</span><span class=identifier>assert</span><span class=special>.</span><span class=identifier>hpp</span><span class=special>&gt;
 304 </span><span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>map</span><span class=special>&gt;
 305 </span><span class=keyword>using </span><span class=keyword>namespace </span><span class=identifier>std</span><span class=special>;
 306 </span><span class=keyword>using </span><span class=keyword>namespace </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>assign</span><span class=special>; </span><span class=comment>// bring 'map_list_of()' into scope
 307 </span><span class=special>
 308 </span><span class=special>{
 309     </span><span class=identifier>map</span><span class=special>&lt;</span><span class=keyword>int</span><span class=special>,</span><span class=keyword>int</span><span class=special>&gt; </span><span class=identifier>next </span><span class=special>= </span><span class=identifier>map_list_of</span><span class=special>(</span><span class=number>1</span><span class=special>,</span><span class=number>2</span><span class=special>)(</span><span class=number>2</span><span class=special>,</span><span class=number>3</span><span class=special>)(</span><span class=number>3</span><span class=special>,</span><span class=number>4</span><span class=special>)(</span><span class=number>4</span><span class=special>,</span><span class=number>5</span><span class=special>)(</span><span class=number>5</span><span class=special>,</span><span class=number>6</span><span class=special>);
 310     </span><span class=identifier>BOOST_ASSERT</span><span class=special>( </span><span class=identifier>next</span><span class=special>.</span><span class=identifier>size</span><span class=special>() </span><span class=special>== </span><span class=number>5 </span><span class=special>);
 311     </span><span class=identifier>BOOST_ASSERT</span><span class=special>( </span><span class=identifier>next</span><span class=special>[ </span><span class=number>1 </span><span class=special>] </span><span class=special>== </span><span class=number>2 </span><span class=special>);
 312     </span><span class=identifier>BOOST_ASSERT</span><span class=special>( </span><span class=identifier>next</span><span class=special>[ </span><span class=number>5 </span><span class=special>] </span><span class=special>== </span><span class=number>6 </span><span class=special>);
 313
 314     </span><span class=comment>// or we can use 'list_of()' by specifying what type
 315     // the list consists of
 316     </span><span class=identifier>next </span><span class=special>= </span><span class=identifier>list_of</span><span class=special>&lt; </span><span class=identifier>pair</span><span class=special>&lt;</span><span class=keyword>int</span><span class=special>,</span><span class=keyword>int</span><span class=special>&gt; </span><span class=special>&gt;(</span><span class=number>6</span><span class=special>,</span><span class=number>7</span><span class=special>)(</span><span class=number>7</span><span class=special>,</span><span class=number>8</span><span class=special>)(</span><span class=number>8</span><span class=special>,</span><span class=number>9</span><span class=special>);
 317     </span><span class=identifier>BOOST_ASSERT</span><span class=special>( </span><span class=identifier>next</span><span class=special>.</span><span class=identifier>size</span><span class=special>() </span><span class=special>== </span><span class=number>3 </span><span class=special>);
 318     </span><span class=identifier>BOOST_ASSERT</span><span class=special>( </span><span class=identifier>next</span><span class=special>[ </span><span class=number>6 </span><span class=special>] </span><span class=special>== </span><span class=number>7 </span><span class=special>);
 319     </span><span class=identifier>BOOST_ASSERT</span><span class=special>( </span><span class=identifier>next</span><span class=special>[ </span><span class=number>8 </span><span class=special>] </span><span class=special>== </span><span class=number>9 </span><span class=special>);
 320 </span><span class=special>}   </span></pre></blockquote>
 321
 322 The function <code>pair_list_of()</code> may also be used.
 323
 324 <h3>Function <code>tuple_list_of()</code> <a name="tuple_list_of"></h3>
 325
 326 If you are working with tuples, it might be convenient to use
 327 <code>tuple_list_of()</code>:
 328
 329
 330 <blockquote>
 331     <pre>
 332 <span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>boost</span><span class=special>/</span><span class=identifier>assign</span><span class=special>/</span><span class=identifier>list_of</span><span class=special>.</span><span class=identifier>hpp</span><span class=special>&gt;</span>
 333 <span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>vector</span><span class=special>&gt;
 334 </span>
 335 <span class=keyword>using </span><span class=keyword>namespace </span><span class=identifier>std</span><span class=special>;</span>
 336 <span class=keyword>using </span><span class=keyword>namespace </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>assign</span><span class=special>;
 337 </span>
 338 <span class=special>{
 339     </span><span class=keyword>typedef </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>tuple</span><span class=special>&lt;</span><span class=keyword>int</span><span class=special>,</span><span class=identifier>std</span><span class=special>::</span><span class=identifier>string</span><span class=special>,</span><span class=keyword>int</span><span class=special>&gt; </span><span class=identifier>tuple</span><span class=special>;
 340
 341     </span><span class=identifier>vector</span><span class=special>&lt;</span><span class=identifier>tuple</span><span class=special>&gt; </span><span class=identifier>v </span><span class=special>= </span><span class=identifier>tuple_list_of</span><span class=special>( </span><span class=number>1</span><span class=special>, </span><span class=string>&quot;foo&quot;</span><span class=special>, </span><span class=number>2 </span><span class=special>)( </span><span class=number>3</span><span class=special>, </span><span class=string>&quot;bar&quot;</span><span class=special>, </span><span class=number>4 </span><span class=special>);
 342     </span><span class=identifier>BOOST_CHECK</span><span class=special>( </span><span class=identifier>v</span><span class=special>.</span><span class=identifier>size</span><span class=special>() </span><span class=special>== </span><span class=number>2 </span><span class=special>);
 343     </span><span class=identifier>BOOST_CHECK</span><span class=special>( </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>get</span><span class=special>&lt;</span><span class=number>0</span><span class=special>&gt;( </span><span class=identifier>v</span><span class=special>[</span><span class=number>1</span><span class=special>] </span><span class=special>) </span><span class=special>==  </span><span class=number>3 </span><span class=special>);</span>
 344 <span class=special>}</span>
 345     </pre>
 346 </blockquote>
 347
 348 <h3>Functions <code>repeat()</code>, <code>repeat_fun()</code> and <code>range()</code> <a name="repeat"></h3>
 349 <p>
 350 Sometimes it is too irritating to repeat the same value many times. This is
 351 where <code>repeat()</code> can be handy:
 352 <blockquote>
 353     <pre>
 354 <span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>boost</span><span class=special>/</span><span class=identifier>assign</span><span class=special>/</span><span class=identifier>list_of</span><span class=special>.</span><span class=identifier>hpp</span><span class=special>&gt;</span>
 355 <span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>boost</span><span class=special>/</span><span class=identifier>assign</span><span class=special>/</span><span class=identifier>std</span><span class=special>/</span><span class=identifier>vector</span><span class=special>.</span><span class=identifier>hpp</span><span class=special>&gt;</span>
 356 <span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>boost</span><span class=special>/</span><span class=identifier>assert</span><span class=special>.</span><span class=identifier>hpp</span><span class=special>&gt;
 357 </span>
 358 <span class=keyword>using </span><span class=keyword>namespace </span><span class=identifier>std</span><span class=special>;</span>
 359 <span class=keyword>using </span><span class=keyword>namespace </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>assign</span><span class=special>;</span>
 360 <span class=special> </span>
 361 <span class=special>{
 362     </span><span class=identifier>vector</span><span class=special>&lt;</span><span class=keyword>int</span><span class=special>&gt; </span><span class=identifier>v</span><span class=special>;
 363     </span><span class=identifier>v </span><span class=special>+= </span><span class=number>1</span><span class=special>,</span><span class=number>2</span><span class=special>,</span><span class=number>3</span><span class=special>,</span><span class=identifier>repeat</span><span class=special>(</span><span class=number>10</span><span class=special>,</span><span class=number>4</span><span class=special>),</span><span class=number>5</span><span class=special>,</span><span class=number>6</span><span class=special>,</span><span class=number>7</span><span class=special>,</span><span class=number>8</span><span class=special>,</span><span class=number>9</span><span class=special>;
 364     </span><span class=comment>// v = [1,2,3,4,4,4,4,4,4,4,4,4,4,5,6,7,8,9]
 365     </span><span class=identifier>BOOST_ASSERT</span><span class=special>( </span><span class=identifier>v</span><span class=special>.</span><span class=identifier>size</span><span class=special>() </span><span class=special>== </span><span class=number>3 </span><span class=special>+ </span><span class=number>10 </span><span class=special>+ </span><span class=number>5 </span><span class=special>);
 366
 367     </span><span class=identifier>v </span><span class=special>= </span><span class=identifier>list_of</span><span class=special>(</span><span class=number>1</span><span class=special>).</span><span class=identifier>repeat</span><span class=special>(</span><span class=number>5</span><span class=special>,</span><span class=number>2</span><span class=special>)(</span><span class=number>3</span><span class=special>);
 368     </span><span class=comment>// v = [1,2,2,2,2,2,3]
 369     </span><span class=identifier>BOOST_ASSERT</span><span class=special>( </span><span class=identifier>v</span><span class=special>.</span><span class=identifier>size</span><span class=special>() </span><span class=special>== </span><span class=number>1 </span><span class=special>+ </span><span class=number>5 </span><span class=special>+ </span><span class=number>1 </span><span class=special>);
 370
 371     </span><span class=identifier>push_back</span><span class=special>( </span><span class=identifier>v </span><span class=special>)(</span><span class=number>1</span><span class=special>).</span><span class=identifier>repeat</span><span class=special>(</span><span class=number>1</span><span class=special>,</span><span class=number>2</span><span class=special>)(</span><span class=number>3</span><span class=special>);
 372     </span><span class=comment>// v = old v + [1,2,3]
 373     </span><span class=identifier>BOOST_ASSERT</span><span class=special>( </span><span class=identifier>v</span><span class=special>.</span><span class=identifier>size</span><span class=special>() </span><span class=special>== </span><span class=number>10 </span><span class=special>);</span>
 374 <span class=special>}</span></pre>
 375 </blockquote>
 376 As we can see, then the first argument to <code>repeat()</code> is the number
 377 of times to repeat the second argument.
 378 </p>
 379 <p>
 380 A more general list can be constructed with <code>repeat_fun()</code>:
 381
 382 <blockquote>
 383     <pre>
 384 <span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>boost</span><span class=special>/</span><span class=identifier>assign</span><span class=special>/</span><span class=identifier>std</span><span class=special>/</span><span class=identifier>vector</span><span class=special>.</span><span class=identifier>hpp</span><span class=special>&gt;</span>
 385 <span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>boost</span><span class=special>/</span><span class=identifier>assert</span><span class=special>.</span><span class=identifier>hpp</span><span class=special>&gt;</span>
 386 <span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>cstdlib</span><span class=special>&gt; </span><span class=comment>// for 'rand()'
 387 </span>
 388 <span class=keyword>using </span><span class=keyword>namespace </span><span class=identifier>std</span><span class=special>;</span>
 389 <span class=keyword>using </span><span class=keyword>namespace </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>assign</span><span class=special>;</span>
 390 <span class=special> </span>
 391 <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>
 392 <span class=keyword>struct </span><span class=identifier>next    </span>
 393 <span class=special>{
 394     </span><span class=identifier>T </span><span class=identifier>seed</span><span class=special>;
 395     </span><span class=identifier>next</span><span class=special>( </span><span class=identifier>T </span><span class=identifier>seed </span><span class=special>) </span><span class=special>: </span><span class=identifier>seed</span><span class=special>(</span><span class=identifier>seed</span><span class=special>)
 396     </span><span class=special>{ </span><span class=special>}
 397
 398     </span><span class=identifier>T </span><span class=keyword>operator</span><span class=special>()() </span><span class=keyword>
 399     </span><span class=special>{
 400         </span><span class=keyword>return </span><span class=identifier>seed</span><span class=special>++;
 401     </span><span class=special>}</span>
 402 <span class=special>};</span>
 403 <span class=special>     </span>
 404 <span class=special>{
 405     </span><span class=identifier>vector</span><span class=special>&lt;</span><span class=keyword>int</span><span class=special>&gt; </span><span class=identifier>v</span><span class=special>;
 406     </span><span class=identifier>v </span><span class=special>+= </span><span class=number>1</span><span class=special>,</span><span class=number>2</span><span class=special>,</span><span class=identifier>repeat_fun</span><span class=special>(</span><span class=number>4</span><span class=special>,&amp;</span><span class=identifier>rand</span><span class=special>),</span><span class=number>4</span><span class=special>;
 407     </span><span class=comment>// v = [1,2,?,?,?,?,4]
 408     </span><span class=identifier>BOOST_ASSERT</span><span class=special>( </span><span class=identifier>v</span><span class=special>.</span><span class=identifier>size</span><span class=special>() </span><span class=special>== </span><span class=number>7 </span><span class=special>);
 409
 410     </span><span class=identifier>push_back</span><span class=special>( </span><span class=identifier>v </span><span class=special>).</span><span class=identifier>repeat_fun</span><span class=special>(</span><span class=number>4</span><span class=special>,</span><span class=identifier>next</span><span class=special>&lt;</span><span class=keyword>int</span><span class=special>&gt;(</span><span class=number>0</span><span class=special>))(</span><span class=number>4</span><span class=special>).</span><span class=identifier>repeat_fun</span><span class=special>(</span><span class=number>4</span><span class=special>,</span><span class=identifier>next</span><span class=special>&lt;</span><span class=keyword>int</span><span class=special>&gt;(</span><span class=number>5</span><span class=special>));
 411     </span><span class=comment>// v = old v + [0,1,2,3,4,5,6,7,8]
 412     </span><span class=identifier>BOOST_ASSERT</span><span class=special>( </span><span class=identifier>v</span><span class=special>.</span><span class=identifier>size</span><span class=special>() </span><span class=special>== </span><span class=number>16 </span><span class=special>);</span>
 413 <span class=special>}</span>        </pre>
 414 </blockquote>
 415 The only requirement of the second argument to <code>repeat_fun()</code> is that
 416 it is a nullary function. </p>
 417
 418
 419 <p>
 420 If you just need to insert an iterator-range somewhere in the list, the member function <code>range()</code> provides just what you want.
 421 It is based on <a href="../../range/index.html">Boost.Range</a>, so you can pass all the ranges supported by that library. For example
 422 <blockquote><pre><span class=preprocessor>#include</span> <span class=special>&lt;</span><span class=identifier>boost</span><span class=special>/</span><span class=identifier>assign</span><span class=special>/</span><span class=identifier>list_inserter</span><span class=special>.</span><span class=identifier>hpp</span><span class=special>&gt;</span> <span class=comment>// for 'push_back()'</span>
 423 <span class=preprocessor>#include</span> <span class=special>&lt;</span><span class=identifier>boost</span><span class=special>/</span><span class=identifier>assign</span><span class=special>/</span><span class=identifier>list_of</span><span class=special>.</span><span class=identifier>hpp</span><span class=special>&gt;</span>       <span class=comment>// for 'list_of()' and 'ref_list_of()'</span>
 424 <span class=preprocessor>#include</span> <span class=special>&lt;</span><span class=identifier>boost</span><span class=special>/</span><span class=identifier>assert</span><span class=special>.</span><span class=identifier>hpp</span><span class=special>&gt;</span>
 425
 426 <span class=keyword>using</span> <span class=keyword>namespace</span> <span class=identifier>std</span><span class=special>;</span>
 427 <span class=keyword>using</span> <span class=keyword>namespace</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>assign</span><span class=special>;</span>
 428
 429 <span class=special>{</span>
 430     <span class=identifier>vector</span><span class=special>&lt;</span><span class=keyword>int</span><span class=special>&gt;</span> <span class=identifier>v</span><span class=special>,</span> <span class=identifier>v2</span><span class=special>;</span>
 431     <span class=identifier>v</span>  <span class=special>=</span> <span class=identifier>list_of</span><span class=special>(</span><span class=number>1</span><span class=special>)(</span><span class=number>2</span><span class=special>)(</span><span class=number>3</span><span class=special>);</span>
 432     <span class=identifier>v2</span> <span class=special>=</span> <span class=identifier>list_of</span><span class=special>(</span><span class=number>0</span><span class=special>).</span><span class=identifier>range</span><span class=special>(</span><span class=identifier>v</span><span class=special>).</span><span class=identifier>range</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=identifier>v</span><span class=special>.</span><span class=identifier>end</span><span class=special>())(</span><span class=number>4</span><span class=special>);</span>
 433     <span class=comment>// v2 = [0,1,2,3,1,2,3,4]</span>
 434     <span class=identifier>BOOST_ASSERT</span><span class=special>(</span> <span class=identifier>v2</span><span class=special>.</span><span class=identifier>size</span><span class=special>()</span> <span class=special>==</span> <span class=number>8u</span> <span class=special>);</span>
 435
 436     <span class=identifier>push_back</span><span class=special>(</span> <span class=identifier>v</span> <span class=special>).</span><span class=identifier>range</span><span class=special>(</span><span class=identifier>v2</span><span class=special>)(</span><span class=number>5</span><span class=special>);</span>
 437     <span class=comment>// v = [1,2,3,0,1,2,3,1,2,3,4,5]</span>
 438     <span class=identifier>BOOST_ASSERT</span><span class=special>(</span> <span class=identifier>v</span><span class=special>.</span><span class=identifier>size</span><span class=special>()</span> <span class=special>==</span> <span class=number>12u</span> <span class=special>);</span>
 439
 440     <span class=comment>//
 441     // create a list of references, some coming from a container, others from the stack
 442     //</span>
 443     <span class=keyword>int</span> <span class=identifier>x</span> <span class=special>=</span> <span class=number>0</span><span class=special>;</span>
 444     <span class=keyword>int</span> <span class=identifier>y</span> <span class=special>=</span> <span class=number>1</span><span class=special>;</span>
 445     <span class=identifier>BOOST_ASSERT</span><span class=special>(</span> <span class=identifier>ref_list_of</span><span class=special>&lt;</span><span class=number>10</span><span class=special>&gt;(</span><span class=identifier>x</span><span class=special>).</span><span class=identifier>range</span><span class=special>(</span><span class=identifier>v2</span><span class=special>)(</span><span class=identifier>y</span><span class=special>).</span><span class=identifier>size</span><span class=special>()</span> <span class=special>==</span> <span class=number>10u</span> <span class=special>);</span>
 446 <span class=special>}</span></pre>
 447 </blockquote>
 448 As you can see, one can also pass two iterators if that is more appropriate.
 449 The last example also introduces list of references. More about that below.
 450 </p>
 451
 452 <h3>Functions <code>ref_list_of()</code> and <code>cref_list_of()</code> <a name="ref_list_of"></h3>
 453
 454 When you need to create an anonymous range of values and speed is essential,
 455 these two functions provide what you want. <blockquote>
 456     <pre>
 457 <span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>boost</span><span class=special>/</span><span class=identifier>assign</span><span class=special>/</span><span class=identifier>list_of</span><span class=special>.</span><span class=identifier>hpp</span><span class=special>&gt;</span>
 458 <span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>algorithm</span><span class=special>&gt;
 459 </span>
 460 <span class=comment>//
 461 // Define Range algorithm
 462 //</span>
 463 <span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>Range </span><span class=special>&gt;</span>
 464 <span class=keyword>typename </span><span class=identifier>Range</span><span class=special>::</span><span class=identifier>const_iterator </span><span class=identifier>max_element</span><span class=special>( </span><span class=keyword>const </span><span class=identifier>Range</span><span class=special>&amp; </span><span class=identifier>r </span><span class=special>)</span>
 465 <span class=special>{
 466     </span><span class=keyword>return </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>max_element</span><span class=special>( </span><span class=identifier>r</span><span class=special>.</span><span class=identifier>begin</span><span class=special>(), </span><span class=identifier>r</span><span class=special>.</span><span class=identifier>end</span><span class=special>() </span><span class=special>);</span>
 467 <span class=special>}
 468 </span>
 469 <span class=keyword>using </span><span class=keyword>namespace </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>assign</span><span class=special>;
 470 </span>
 471 <span class=special>{
 472     </span><span class=keyword>int </span><span class=identifier>a</span><span class=special>=</span><span class=number>1</span><span class=special>,</span><span class=identifier>b</span><span class=special>=</span><span class=number>5</span><span class=special>,</span><span class=identifier>c</span><span class=special>=</span><span class=number>3</span><span class=special>,</span><span class=identifier>d</span><span class=special>=</span><span class=number>4</span><span class=special>,</span><span class=identifier>e</span><span class=special>=</span><span class=number>2</span><span class=special>,</span><span class=identifier>f</span><span class=special>=</span><span class=number>9</span><span class=special>,</span><span class=identifier>g</span><span class=special>=</span><span class=number>0</span><span class=special>,</span><span class=identifier>h</span><span class=special>=</span><span class=number>7</span><span class=special>;
 473     </span><span class=keyword>int</span><span class=special>&amp; </span><span class=identifier>max </span><span class=special>= </span><span class=special>*</span><span class=identifier>max_element</span><span class=special>( </span><span class=identifier>ref_list_of</span><span class=special>&lt;</span><span class=number>8</span><span class=special>&gt;(</span><span class=identifier>a</span><span class=special>)(</span><span class=identifier>b</span><span class=special>)(</span><span class=identifier>c</span><span class=special>)(</span><span class=identifier>d</span><span class=special>)(</span><span class=identifier>e</span><span class=special>)(</span><span class=identifier>f</span><span class=special>)(</span><span class=identifier>g</span><span class=special>)(</span><span class=identifier>h</span><span class=special>) </span><span class=special>);
 474     </span><span class=identifier>BOOST_CHECK_EQUAL</span><span class=special>( </span><span class=identifier>max</span><span class=special>, </span><span class=identifier>f </span><span class=special>);
 475     </span><span class=identifier>max </span><span class=special>= </span><span class=number>8</span><span class=special>;
 476     </span><span class=identifier>BOOST_CHECK_EQUAL</span><span class=special>( </span><span class=identifier>f</span><span class=special>, </span><span class=number>8 </span><span class=special>);
 477     </span><span class=keyword>const </span><span class=keyword>int</span><span
 478 class=special>&amp; </span><span class=identifier>const_max </span><span class=special>= </span><span class=special>*</span><span class=identifier>max_element</span><span class=special>(</span><span class=identifier>cref_list_of</span><span class=special>&lt;</span><span class=number>8</span><span class=special>&gt;(</span><span class=identifier>a</span><span class=special>)(</span><span class=identifier>b</span><span class=special>)(</span><span class=identifier>c</span><span class=special>)(</span><span class=identifier>d</span><span class=special>)(</span><span class=identifier>e</span><span class=special>)(</span><span class=identifier>f</span><span class=special>)(</span><span class=identifier>g</span><span class=special>)(</span><span class=identifier>h</span><span class=special>) </span><span class=special>);
 479     </span><span class=identifier>BOOST_CHECK_EQUAL</span><span class=special>( </span><span class=identifier>max</span><span class=special>, </span><span class=identifier>const_max </span><span class=special>);</span>
 480 <span class=special>}</span>
 481     </pre>
 482 </blockquote>
 483
 484 You can only use lvalues with <code>ref_list_of()</code> while
 485 <code>cref_list_of()</code> accepts rvalues too. Do not worry about not
 486 specifying exactly the right size; the extra space used is minimal and there
 487 is no runtime overhead associated with it.
 488
 489 You may also use these functions instead of <code>list_of()</code> if speed is
 490 essential.
 491
 492 <h3>A "complicated" example <a name="complicated"></h3>
 493 <p>
 494 As a last example, let us assume that we need to keep track of the
 495 result of soccer matches. A team will get one point if it wins
 496 and zero otherwise. If there has been played three games in each group, the code might look
 497 like this:
 498
 499 <blockquote>
 500     <pre>
 501 <span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>boost</span><span class=special>/</span><span class=identifier>assign</span><span class=special>/</span><span class=identifier>list_of</span><span class=special>.</span><span class=identifier>hpp</span><span class=special>&gt;</span>
 502 <span class=preprocessor>#include </span><span class=special>&lt;</span><span
 503 class=identifier>boost</span><span class=special>/</span><span
 504 class=identifier>assign</span><span class=special>/</span><span
 505 class=identifier>list_inserter</span><span class=special>.</span><span
 506 class=identifier>hpp</span><span class=special>&gt;</span>
 507 <span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>boost</span><span class=special>/</span><span class=identifier>assert</span><span class=special>.</span><span class=identifier>hpp</span><span class=special>&gt;</span>
 508 <span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>string</span><span class=special>&gt;</span>
 509 <span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>vector</span><span class=special>&gt;
 510 </span>
 511 <span class=keyword>using </span><span class=keyword>namespace </span><span class=identifier>std</span><span class=special>;</span>
 512 <span class=keyword>using </span><span class=keyword>namespace </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>assign</span><span class=special>;
 513  </span>
 514 <span class=special>{
 515     </span><span class=keyword>typedef </span><span class=identifier>vector</span><span class=special>&lt;</span><span class=keyword>int</span><span class=special>&gt;                   </span><span class=identifier>score_type</span><span class=special>;
 516     </span><span class=keyword>typedef </span><span class=identifier>map</span><span class=special>&lt;</span><span class=identifier>string</span><span class=special>,</span><span class=identifier>score_type</span><span class=special>&gt;        </span><span class=identifier>team_score_map</span><span class=special>;
 517     </span><span class=keyword>typedef </span><span class=identifier>pair</span><span class=special>&lt;</span><span class=identifier>string</span><span class=special>,</span><span class=identifier>score_type</span><span class=special>&gt;       </span><span class=identifier>score_pair</span><span class=special>;
 518
 519     </span><span class=identifier>team_score_map </span><span class=identifier>group1</span><span class=special>, </span><span class=identifier>group2</span><span class=special>;
 520
 521     </span><span class=comment>//
 522     // method 1: using 'insert()'
 523     //
 524     </span><span class=identifier>insert</span><span class=special>( </span><span class=identifier>group1 </span><span class=special>)( </span><span class=string>&quot;Denmark&quot;</span><span class=special>, </span><span class=identifier>list_of</span><span class=special>(</span><span class=number>1</span><span class=special>)(</span><span class=number>1</span><span class=special>) </span><span class=special>)
 525                     </span><span class=special>( </span><span class=string>&quot;Germany&quot;</span><span class=special>, </span><span class=identifier>list_of</span><span class=special>(</span><span class=number>0</span><span class=special>)(</span><span class=number>0</span><span class=special>) </span><span class=special>)
 526                     </span><span class=special>( </span><span class=string>&quot;England&quot;</span><span class=special>, </span><span class=identifier>list_of</span><span class=special>(</span><span class=number>0</span><span class=special>)(</span><span class=number>1</span><span class=special>) </span><span class=special>);
 527     </span><span class=identifier>BOOST_ASSERT</span><span class=special>( </span><span class=identifier>group1</span><span class=special>.</span><span class=identifier>size</span><span class=special>() </span><span class=special>== </span><span class=number>3 </span><span class=special>);
 528     </span><span class=identifier>BOOST_ASSERT</span><span class=special>( </span><span class=identifier>group1</span><span class=special>[ </span><span class=string>&quot;Denmark&quot; </span><span class=special>][</span><span class=number>1</span><span class=special>] </span><span class=special>== </span><span class=number>1 </span><span class=special>);
 529     </span><span class=identifier>BOOST_ASSERT</span><span class=special>( </span><span class=identifier>group1</span><span class=special>[ </span><span class=string>&quot;Germany&quot; </span><span class=special>][</span><span class=number>0</span><span class=special>] </span><span class=special>== </span><span class=number>0 </span><span class=special>);
 530
 531     </span><span class=comment>//
 532     // method 2: using 'list_of()'
 533     //
 534     </span><span class=identifier>group2 </span><span class=special>= </span><span class=identifier>list_of</span><span class=special>&lt; </span><span class=identifier>score_pair </span><span class=special>&gt;
 535                         </span><span class=special>( </span><span class=string>&quot;Norway&quot;</span><span class=special>,  </span><span class=identifier>list_of</span><span class=special>(</span><span class=number>1</span><span class=special>)(</span><span class=number>0</span><span class=special>) </span><span class=special>)
 536                         </span><span class=special>( </span><span class=string>&quot;USA&quot;</span><span class=special>,     </span><span class=identifier>list_of</span><span class=special>(</span><span class=number>0</span><span class=special>)(</span><span class=number>0</span><span class=special>) </span><span class=special>)
 537                         </span><span class=special>( </span><span class=string>&quot;Andorra&quot;</span><span class=special>, </span><span class=identifier>list_of</span><span class=special>(</span><span class=number>1</span><span class=special>)(</span><span class=number>1</span><span class=special>) </span><span class=special>);
 538     </span><span class=identifier>BOOST_ASSERT</span><span class=special>( </span><span class=identifier>group2</span><span class=special>.</span><span class=identifier>size</span><span class=special>() </span><span class=special>== </span><span class=number>3 </span><span class=special>);
 539     </span><span class=identifier>BOOST_ASSERT</span><span class=special>( </span><span class=identifier>group2</span><span class=special>[ </span><span class=string>&quot;Norway&quot; </span><span class=special>][</span><span class=number>0</span><span class=special>] </span><span class=special>== </span><span class=number>1 </span><span class=special>);
 540     </span><span class=identifier>BOOST_ASSERT</span><span class=special>( </span><span class=identifier>group2</span><span class=special>[ </span><span class=string>&quot;USA&quot; </span><span class=special>][</span><span class=number>0</span><span class=special>] </span><span class=special>== </span><span class=number>0 </span><span class=special>);</span>
 541 <span class=special>}</span>
 542     </pre>
 543 </blockquote>
 544
 545 In the first example, notice how the result of <code>list_of()</code>
 546 can be converted automatically to a <code>vector&lt;int></code> because
 547 <code>insert()</code> knows it expects a <code>vector&lt;int></code>.
 548 In the second example we can see that <code>list_of()</code> is somewhat
 549 less intelligent since here it needs to be told explicitly what arguments to
 550 expect. (In the future it might be possible to introduce a more intelligent
 551 conversion layer in <code>list_of()</code>.)
 552 </p>
 553
 554 <h3>Functions <code>ptr_push_back(),
 555 ptr_push_front()</code>, <code>ptr_insert()</code> and <code>ptr_map_insert()</code> <a name="ptr_push_back"></h3>
 556
 557 For use with <a href="../../ptr_container/index.html">Boost.Pointer Container</a>
 558 a few special exception-safe functions are provided. Using these function you
 559 do not need to call <code>new</code> manually:
 560
 561
 562 <blockquote>
 563     <pre>
 564 <span class=preprocessor>#include</span> <span class=special>&lt;</span><span class=identifier>boost</span><span class=special>/</span><span class=identifier>assign</span><span class=special>/</span><span class=identifier>ptr_list_inserter</span><span class=special>.</span><span class=identifier>hpp</span><span class=special>&gt;</span> <span class=comment>// for 'ptr_push_back()', 'ptr_insert()' and 'ptr_push_front()'</span>
 565 <span class=preprocessor>#include</span> <span class=special>&lt;</span><span class=identifier>boost</span><span class=special>/</span><span class=identifier>assign</span><span class=special>/</span><span class=identifier>ptr_map_inserter</span><span class=special>.</span><span class=identifier>hpp</span><span class=special>&gt;</span>  <span class=comment>// for 'ptr_map_insert()'</span>
 566 <span class=preprocessor>#include</span> <span class=special>&lt;</span><span class=identifier>boost</span><span class=special>/</span><span class=identifier>ptr_container</span><span class=special>/</span><span class=identifier>ptr_deque</span><span class=special>.</span><span class=identifier>hpp</span><span class=special>&gt;</span>
 567 <span class=preprocessor>#include</span> <span class=special>&lt;</span><span class=identifier>boost</span><span class=special>/</span><span class=identifier>ptr_container</span><span class=special>/</span><span class=identifier>ptr_set</span><span class=special>.</span><span class=identifier>hpp</span><span class=special>&gt;</span>
 568 <span class=preprocessor>#include</span> <span class=special>&lt;</span><span class=identifier>boost</span><span class=special>/</span><span class=identifier>ptr_container</span><span class=special>/</span><span class=identifier>ptr_map</span><span class=special>.</span><span class=identifier>hpp</span><span class=special>&gt;</span>
 569
 570 <span class=comment>//
 571 // Example class
 572 //</span>
 573 <span class=keyword>struct</span> <span class=identifier>Foo</span>
 574 <span class=special>{</span>
 575     <span class=keyword>int</span> <span class=identifier>i</span><span class=special>;</span>
 576
 577     <span class=identifier>Foo</span><span class=special>()</span> <span class=special>:</span> <span class=identifier>i</span><span class=special>(</span><span class=number>0</span><span class=special>)</span>
 578     <span class=special>{</span> <span class=special>}</span>
 579     <span class=identifier>Foo</span><span class=special>(</span> <span class=keyword>int</span> <span class=identifier>i</span> <span class=special>)</span> <span class=special>:</span> <span class=identifier>i</span><span class=special>(</span><span class=identifier>i</span><span class=special>)</span>
 580     <span class=special>{</span> <span class=special>}</span>
 581     <span class=identifier>Foo</span><span class=special>(</span> <span class=keyword>int</span> <span class=identifier>i</span><span class=special>,</span> <span class=keyword>int</span> <span class=special>)</span> <span class=special>:</span> <span class=identifier>i</span><span class=special>(</span><span class=identifier>i</span><span class=special>)</span>
 582     <span class=special>{</span> <span class=special>}</span>
 583     <span class=identifier>Foo</span><span class=special>(</span> <span class=keyword>const</span> <span class=keyword>char</span><span class=special>*,</span> <span class=keyword>int</span> <span class=identifier>i</span><span class=special>,</span> <span class=keyword>int</span> <span class=special>)</span> <span class=special>:</span> <span class=identifier>i</span><span class=special>(</span><span class=identifier>i</span><span class=special>)</span>
 584     <span class=special>{</span> <span class=special>}</span>
 585
 586     <span class=keyword>virtual</span> <span class=special>~</span><span class=identifier>Foo</span><span class=special>()</span>
 587     <span class=special>{}</span>
 588 <span class=special>};</span>
 589
 590 <span class=keyword>struct</span> <span class=identifier>Bar</span> <span class=special>:</span> <span class=identifier>Foo</span>
 591 <span class=special>{</span>
 592     <span class=identifier>Bar</span><span class=special>()</span>
 593     <span class=special>{</span> <span class=special>}</span>
 594
 595     <span class=identifier>Bar</span><span class=special>(</span> <span class=keyword>int</span> <span class=identifier>i</span> <span class=special>)</span> <span class=special>:</span> <span class=identifier>Foo</span><span class=special>(</span> <span class=number>42</span> <span class=special>)</span>
 596     <span class=special>{</span> <span class=special>}</span>
 597 <span class=special>};</span>
 598
 599 <span class=comment>//
 600 // Required by ptr_set&lt;Foo&gt;
 601 //</span>
 602 <span class=keyword>inline</span> <span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>&lt;(</span> <span class=identifier>Foo</span> <span class=identifier>l</span><span class=special>,</span> <span class=identifier>Foo</span> <span class=identifier>r</span> <span class=special>)</span>
 603 <span class=special>{</span>
 604     <span class=keyword>return</span> <span class=identifier>l</span><span class=special>.</span><span class=identifier>i</span> <span class=special>&lt;</span> <span class=identifier>r</span><span class=special>.</span><span class=identifier>i</span><span class=special>;</span>
 605 <span class=special>}</span>
 606
 607
 608 <span class=keyword>using</span> <span class=keyword>namespace</span> <span class=identifier>boost</span><span class=special>;</span>
 609 <span class=keyword>using</span> <span class=keyword>namespace</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>assign</span><span class=special>;</span>
 610
 611 <span class=keyword>int</span> <span class=identifier>main</span><span class=special>()</span>
 612 <span class=special>{</span>
 613     <span class=identifier>ptr_deque</span><span class=special>&lt;</span><span class=identifier>Foo</span><span class=special>&gt;</span> <span class=identifier>deq</span><span class=special>;</span>
 614     <span class=identifier>ptr_push_back</span><span class=special>(</span> <span class=identifier>deq</span> <span class=special>)()();</span>
 615     <span class=identifier>BOOST_ASSERT</span><span class=special>(</span> <span class=identifier>deq</span><span class=special>.</span><span class=identifier>size</span><span class=special>()</span> <span class=special>==</span> <span class=number>2u</span> <span class=special>);</span>
 616     <span class=identifier>ptr_push_back</span><span class=special>&lt;</span><span class=identifier>Bar</span><span class=special>&gt;(</span> <span class=identifier>deq</span> <span class=special>)()();</span> <span class=comment>// insert 'Bar' objects</span>
 617     <span class=identifier>BOOST_ASSERT</span><span class=special>(</span> <span class=identifier>deq</span><span class=special>.</span><span class=identifier>size</span><span class=special>()</span> <span class=special>==</span> <span class=number>4u</span> <span class=special>);</span>
 618     <span class=identifier>ptr_push_front</span><span class=special>(</span> <span class=identifier>deq</span> <span class=special>)(</span> <span class=number>3</span> <span class=special>)(</span> <span class=number>42</span><span class=special>,</span> <span class=number>42</span> <span class=special>)(</span> <span class=string>&quot;foo&quot;</span><span class=special>,</span> <span class=number>42</span><span class=special>,</span> <span class=number>42</span> <span class=special>);</span>
 619     <span class=identifier>BOOST_ASSERT</span><span class=special>(</span> <span class=identifier>deq</span><span class=special>.</span><span class=identifier>size</span><span class=special>()</span> <span class=special>==</span> <span class=number>7u</span> <span class=special>);</span>
 620
 621     <span class=identifier>ptr_set</span><span class=special>&lt;</span><span class=identifier>Foo</span><span class=special>&gt;</span> <span class=identifier>a_set</span><span class=special>;</span>
 622     <span class=identifier>ptr_insert</span><span class=special>(</span> <span class=identifier>a_set</span> <span class=special>)()(</span> <span class=number>1</span> <span class=special>)(</span> <span class=number>2</span><span class=special>,</span> <span class=number>2</span> <span class=special>)(</span> <span class=string>&quot;foo&quot;</span><span class=special>,</span> <span class=number>3</span><span class=special>,</span> <span class=number>3</span> <span class=special>);</span>
 623     <span class=identifier>BOOST_ASSERT</span><span class=special>(</span> <span class=identifier>a_set</span><span class=special>.</span><span class=identifier>size</span><span class=special>()</span> <span class=special>==</span> <span class=number>4u</span> <span class=special>);</span>
 624     <span class=identifier>ptr_insert</span><span class=special>(</span> <span class=identifier>a_set</span> <span class=special>)()()()();</span>
 625     <span class=identifier>BOOST_ASSERT</span><span class=special>(</span> <span class=identifier>a_set</span><span class=special>.</span><span class=identifier>size</span><span class=special>()</span> <span class=special>==</span> <span class=number>4u</span> <span class=special>);</span> <span class=comment>// duplicates not inserted</span>
 626     <span class=identifier>ptr_insert</span><span class=special>&lt;</span><span class=identifier>Bar</span><span class=special>&gt;(</span> <span class=identifier>a_set</span> <span class=special>)(</span> <span class=number>42</span> <span class=special>);</span> <span class=comment>// insert a 'Bar' object</span>
 627     <span class=identifier>BOOST_ASSERT</span><span class=special>(</span> <span class=identifier>a_set</span><span class=special>.</span><span class=identifier>size</span><span class=special>()</span> <span class=special>==</span> <span class=number>5u</span> <span class=special>);</span>
 628
 629     <span class=identifier>ptr_map</span><span class=special>&lt;</span><span class=keyword>int</span><span class=special>,</span><span class=identifier>Foo</span><span class=special>&gt;</span> <span class=identifier>a_map</span><span class=special>;</span>
 630     <span class=identifier>ptr_map_insert</span><span class=special>(</span> <span class=identifier>a_map</span> <span class=special>)(</span> <span class=number>1</span> <span class=special>)(</span> <span class=number>2</span><span class=special>,</span> <span class=number>2</span> <span class=special>)(</span> <span class=number>3</span><span class=special>,</span> <span class=number>3</span><span class=special>,</span> <span class=number>3</span> <span class=special>)(</span> <span class=number>4</span><span class=special>,</span> <span class=string>&quot;foo&quot;</span><span class=special>,</span> <span class=number>4</span><span class=special>,</span> <span class=number>4</span> <span class=special>);</span>
 631     <span class=identifier>ptr_map_insert</span><span class=special>&lt;</span><span class=identifier>Bar</span><span class=special>&gt;(</span> <span class=identifier>a_map</span> <span class=special>)(</span> <span class=number>42</span><span class=special>,</span> <span class=number>42</span> <span class=special>);</span> <span class=comment>// insert a  'Bar' object</span>
 632 <span class=special>}</span>
 633     </pre>
 634 </blockquote>
 635
 636 Notice how you may provide a template argument to these functions. This argument determines the type to allocate with <code>new</code>.
 637 You have to specify this argument when the container is based on an abstract type (because one cannot create objects of such a type).
 638
 639 <p>
 640 For <code>ptr_map_insert()</code> the first argument <code>arg1</code> in an argument tuple <code>(arg1,arg2,...,argN)</code> is used to
 641 construct a key; this means that the first argument need only be convertible to the <code>key_type</code> of the container.
 642 The rest of the arguments are used to construct the mapped object.
 643 </p>
 644
 645 <h3>Function <code>ptr_list_of()</code> <a name="ptr_list_of"></h3>
 646
 647 Just like you can use <code>list_of()</code> to initialize containers, you can
 648 use <code>ptr_list_of()</code> to initialize a <a href="../../ptr_container/index.html">pointer container</a>.
 649 Here is a small example:
 650
 651 <blockquote>
 652     <pre>
 653 <span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>boost</span><span class=special>/</span><span class=identifier>assign</span><span class=special>/</span><span class=identifier>ptr_list_of</span><span class=special>.</span><span class=identifier>hpp</span><span class=special>&gt;</span>
 654 <span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>boost</span><span class=special>/</span><span class=identifier>ptr_container</span><span class=special>/</span><span class=identifier>ptr_deque</span><span class=special>.</span><span class=identifier>hpp</span><span class=special>&gt;
 655 </span>
 656 <span class=keyword>using </span><span class=keyword>namespace </span><span class=identifier>boost</span><span class=special>;</span>
 657 <span class=keyword>using </span><span class=keyword>namespace </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>assign</span><span class=special>;
 658 </span>
 659 <span class=special>{
 660     </span><span class=identifier>ptr_deque</span><span class=special>&lt;</span><span class=identifier>Foo</span><span class=special>&gt; </span><span class=identifier>deq</span><span class=special>;
 661     </span><span class=identifier>deq </span><span class=special>= </span><span class=identifier>ptr_list_of</span><span class=special>&lt;</span><span class=identifier>Foo</span><span class=special>&gt;( </span><span class=number>42 </span><span class=special>)()()( </span><span class=number>3</span><span class=special>, </span><span class=number>3 </span><span class=special>)( </span><span class=string>&quot;foo&quot;</span><span class=special>, </span><span class=number>2</span><span class=special>, </span><span class=number>1 </span><span class=special>);
 662     </span><span class=identifier>BOOST_CHECK</span><span class=special>( </span><span class=identifier>deq</span><span class=special>.</span><span class=identifier>size</span><span class=special>() </span><span class=special>== </span><span class=number>5 </span><span class=special>);</span>
 663 <span class=special>}</span>
 664     </pre>
 665 </blockquote>
 666
 667 Notice that a trailing <code>.to_container(deq)</code> may be added to help many poor
 668 compilers to figure out the conversion (a few get it right).
 669 Notice also that pointer maps are
 670 not supported.
 671
 672 <p>
 673 That is all; now you are ready to use this library.
 674  </p>
 675
 676   <hr>
 677   <h2><a name="reference">Reference</a></h2>
 678     <p>
 679   It is worth noticing the way the library is implemented.
 680   A free-standing function (eg. <code>push_back()</code>
 681   or <code>operator+=()</code>) returns a proxy
 682   object which is responsible for the insertion or the assignment. The proxy
 683 object does the insertion or assignment by overloading <code>operator,()</code>
 684   and <code>operator()()</code> and by calling the "insert" function from within
 685   those operators. The "insert" function is typically stored in the proxy object
 686   by using <code>boost::<a href="../../function/index.html">function</a></code>. </p>
 687
 688   <p>
 689   Often overloading
 690   of <code>operator,()</code> is discouraged because it can lead to surprising
 691   results, but the approach taken in this library is safe since the
 692   user never deals with objects that have overloaded <code>operator,()</code>
 693   directly. However, you should be aware of this:
 694   </p>
 695
 696   <p><i>
 697   The
 698   expressions in a comma-separated list no longer follow the rules of the
 699   built-in comma-operator. This means that the order of evaluation of
 700   expressions in a comma-separated list is undefined like when one specifies
 701   a list of function arguments.
 702   </i></p>
 703
 704     <p>
 705   Most of the code in this document use <code>int</code> in the examples,
 706   but of course it works for arbitrary types as long as they are
 707   Copy Constructible. The inserted data need not be constant data,
 708   but can be variables or data returned from functions; the only requirement
 709   is that the type of the data is convertible to the type stored in the
 710   container.
 711   </p>
 712
 713   <p>
 714   All forwarding is done by passing objects by <code>const</code> reference.
 715 Originally arguments were passed by value (and still is in
 716 <code>tuple_list_of()</code>). One thing to remember is that references
 717   can be passed by using <code>boost::<a href="http://www.boost.org/doc/html/ref.html">ref</a></code>.
 718   </p>
 719
 720   <p>
 721    Everything is put in namespace
 722   <code>boost::assign</code>. </p>
 723
 724   <p> More details can be found below: </p>
 725       <ul>
 726
 727         <li><a href="#headers">Headers</a> </li>
 728         <li><a href="#std">Standard containers</a> </li>
 729         <li>Functions <a href="#list_of_ref"><code>list_of()</code> and <code>map_list_of()</code></a></li>
 730         <li>Functions <a href="#repeat_ref"><code>repeat()</code>,<code>repeat_fun()</code> and
 731                                                                       <code>range()</code>
 732                                                                       </a></li>
 733         <li>Class <a href="#list_inserter"><code>list_inserter</code></a></li>
 734         <li>Function <a href="#make_list_inserter"><code>make_list_inserter()</code></a></li>
 735         <li><a href="#limit">Customizing</a> argument list sizes </li>
 736      </ul>
 737   <h3>Headers <a name="headers"></h3>
 738
 739   <p>
 740   An overview of the headers in this library
 741 is given below. Please notice <code>&lt;boost/assign/list_inserter.hpp></code>
 742 is included for each header that defines <code>operator+=()</code>.</p>
 743
 744 <table cellpadding=5 border=1 > <tr>
 745          <th>  Header                      </th>
 746          <th>        Includes              </th>
 747      <tr>
 748          <td> &lt;boost/assign.hpp>               </td>
 749          <td>     everything except support for pointer containers  </td>
 750      <tr>
 751          <td> &lt;boost/assign/list_of.hpp>       </td>
 752          <td> <a href="#list_of"><code>list_of()</a>, <a
 753 href="#map_list_of">map_list_of()</code></a>,
 754          <a href="#tuple_list_of">tuple_list_of()</code></a>,
 755          <a href="#ref_list_of">ref_list_of()</code> and
 756 <code>cref_list_of()</code></a>
 757
 758          </td> <tr>
 759          <td> &lt;boost/assign/std.hpp>       </td>
 760          <td> <a href="#operator+="><code>operator+=()</code></a> for all
 761 standard
 762 containers (see below)</td> <tr> <td>  &lt;boost/assign/std/deque.hpp> </td>
 763         <td>  <code>operator+=()</code> for
 764               <code>std::deque</code>, <code>&lt;deque></code>
 765     <tr>
 766         <td>  &lt;boost/assign/std/list.hpp> </td>
 767         <td>  <code>operator+=()</code> for
 768               <code>std::list</code>, <code>&lt;list></code>
 769     <tr>
 770         <td>  &lt;boost/assign/std/map.hpp> </td>
 771         <td>  <code>operator+=()</code> for
 772               <code>std::map</code> and <code>std::multimap</code> ,
 773 <code>&lt;map></code> <tr>
 774         <td>  &lt;boost/assign/std/queue.hpp> </td>
 775         <td>  <code>operator+=()</code> for
 776               <code>std::queue</code> and <code>std::priority_queue</code>,
 777 <code>&lt;queue></code> <tr>
 778         <td>  &lt;boost/assign/std/set.hpp> </td>
 779         <td>  <code>operator+=()</code> for
 780               <code>std::set</code> and <code>std::multiset</code>,
 781 <code>&lt;set></code> <tr>
 782         <td>  &lt;boost/assign/std/slist.hpp> </td>
 783         <td>  <code>operator+=()</code> for
 784               <code>std::slist</code> if the class is available ,
 785 <code>&lt;slist></code> <tr>
 786         <td>  &lt;boost/assign/std/stack.hpp> </td>
 787         <td>  <code>operator+=()</code> for
 788               <code>std::stack</code>, <code>&lt;stack></code>
 789     <tr>
 790         <td>  &lt;boost/assign/std/vector.hpp> </td>
 791         <td>  <code>operator+=()</code> for
 792               <code>std::vector</code>, <code>&lt;vector></code>
 793     <tr>
 794         <td>  &lt;boost/assign/assignment_exception.hpp> </td>
 795         <td>  Class <a
 796 href="#assignment_exception"><code>assignment_exception</code></a> which might
 797 be thrown by the proxy returned by <code>list_of()</code>
 798     <tr>
 799         <td>  &lt;boost/assign/list_inserter.hpp> </td>
 800             <td>Functions <a
 801                href="#make_list_inserter"><code>make_list_inserter()</code></a>, <code>push_back()</code>,
 802                 <code>push_front()</code>,<code>insert()</code>,
 803                 <code>
 804                 push()</code> and class <a href="#list_inserter"><code>list_inserter</code></a>
 805                 which is the back-bone of this entire library.
 806
 807             <tr>
 808             <td>  &lt;boost/assign/ptr_list_inserter.hpp> </td>
 809             <td>Functions <a href="#ptr_push_back"><code>ptr_push_back()</code></a>,
 810                 <code>ptr_push_front()</code> and <code>ptr_insert()</code>
 811
 812             <tr>
 813             <td>  &lt;boost/assign/ptr_map_inserter.hpp> </td>
 814             <td>Functions <a href="#ptr_push_back"><code>ptr_map_insert()</code></a>
 815
 816                             <tr>
 817             <td>  &lt;boost/assign/ptr_list_of.hpp> </td>
 818             <td>Function <a href="#ptr_list_of"><code>ptr_list_of()</code></a>
 819
 820     </table>
 821
 822   <h3>Standard containers <a name="std"> </h3>
 823    <p> In the following three dots (...) will mean
 824        implementation defined.
 825        <code>operator+=()</code> returns a proxy that forwards calls to either
 826        <code>push_back()</code>,<code>insert()</code>, or <code>push()</code>
 827        depending on which operation the container supports. </p> <b>Synopsis</b>
 828   <p>
 829 <blockquote>
 830 <pre>
 831 <span class=keyword>namespace </span><span class=identifier>boost</span>
 832 <span class=special>{</span>
 833 <span class=keyword>namespace </span><span class=identifier>assign</span>
 834 <span class=special>{
 835     </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>V</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>A</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>V2 </span><span class=special>&gt;
 836     </span><span class=identifier>list_inserter</span><span class=special>&lt; </span><span class=special>... </span><span class=special>&gt;    </span><span class=keyword>operator</span><span class=special>+=( </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>deque</span><span class=special>&lt;</span><span class=identifier>V</span><span class=special>,</span><span class=identifier>A</span><span class=special>&gt;&amp; </span><span class=identifier>c</span><span class=special>, </span><span class=identifier>V2 </span><span class=identifier>v </span><span class=special>);
 837
 838     </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>V</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>A</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>V2 </span><span class=special>&gt;
 839     </span><span class=identifier>list_inserter</span><span class=special>&lt; </span><span class=special>... </span><span class=special>&gt;    </span><span class=keyword>operator</span><span class=special>+=( </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>list</span><span class=special>&lt;</span><span class=identifier>V</span><span class=special>,</span><span class=identifier>A</span><span class=special>&gt;&amp; </span><span class=identifier>c</span><span class=special>, </span><span class=identifier>V2 </span><span class=identifier>v </span><span class=special>);
 840
 841     </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>K</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>V</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>C</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>A</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>P </span><span class=special>&gt;
 842     </span><span class=identifier>list_inserter</span><span class=special>&lt; </span><span class=special>... </span><span class=special>&gt;    </span><span class=keyword>operator</span><span class=special>+=( </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>map</span><span class=special>&lt;</span><span class=identifier>K</span><span class=special>,</span><span class=identifier>V</span><span class=special>,</span><span class=identifier>C</span><span class=special>,</span><span class=identifier>A</span><span class=special>&gt;&amp; </span><span class=identifier>m</span><span class=special>, </span><span class=keyword>const </span><span class=identifier>P</span><span class=special>&amp; </span><span class=identifier>p </span><span class=special>);
 843
 844     </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>K</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>V</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>C</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>A</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>P </span><span class=special>&gt;
 845     </span><span class=identifier>list_inserter</span><span class=special>&lt; </span><span class=special>... </span><span class=special>&gt;    </span><span class=keyword>operator</span><span class=special>+=( </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>multimap</span><span class=special>&lt;</span><span class=identifier>K</span><span class=special>,</span><span class=identifier>V</span><span class=special>,</span><span class=identifier>C</span><span class=special>,</span><span class=identifier>A</span><span class=special>&gt;&amp; </span><span class=identifier>m</span><span class=special>, </span><span class=keyword>const </span><span class=identifier>P</span><span class=special>&amp; </span><span class=identifier>p </span><span class=special>);
 846
 847     </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>V</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>C</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>V2 </span><span class=special>&gt;
 848     </span><span class=identifier>list_inserter</span><span class=special>&lt; </span><span class=special>... </span><span class=special>&gt;    </span><span class=keyword>operator</span><span class=special>+=( </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>queue</span><span class=special>&lt;</span><span class=identifier>V</span><span class=special>,</span><span class=identifier>C</span><span class=special>&gt;&amp; </span><span class=identifier>c</span><span class=special>, </span><span class=identifier>V2 </span><span class=identifier>v </span><span class=special>);
 849
 850     </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>V</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>C</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>V2 </span><span class=special>&gt;
 851     </span><span class=identifier>list_inserter</span><span class=special>&lt; </span><span class=special>... </span><span class=special>&gt;    </span><span class=keyword>operator</span><span class=special>+=( </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>priority_queue</span><span class=special>&lt;</span><span class=identifier>V</span><span class=special>,</span><span class=identifier>C</span><span class=special>&gt;&amp; </span><span class=identifier>c</span><span class=special>, </span><span class=identifier>V2 </span><span class=identifier>v </span><span class=special>);
 852
 853     </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>K</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>C</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>A</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>K2 </span><span class=special>&gt;
 854     </span><span class=identifier>list_inserter</span><span class=special>&lt; </span><span class=special>... </span><span class=special>&gt; </span><span class=keyword>operator</span><span class=special>+=( </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>set</span><span class=special>&lt;</span><span class=identifier>K</span><span class=special>,</span><span class=identifier>C</span><span class=special>,</span><span class=identifier>A</span><span class=special>&gt;&amp; </span><span class=identifier>c</span><span class=special>, </span><span class=identifier>K2 </span><span class=identifier>k </span><span class=special>);
 855
 856     </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>K</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>C</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>A</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>K2 </span><span class=special>&gt;
 857     </span><span class=identifier>list_inserter</span><span class=special>&lt; </span><span class=special>... </span><span class=special>&gt; </span><span class=keyword>operator</span><span class=special>+=( </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>multiset</span><span class=special>&lt;</span><span class=identifier>K</span><span class=special>,</span><span class=identifier>C</span><span class=special>,</span><span class=identifier>A</span><span class=special>&gt;&amp; </span><span class=identifier>c</span><span class=special>, </span><span class=identifier>K2 </span><span class=identifier>k </span><span class=special>);
 858
 859     </span><span class=preprocessor>#ifdef </span><span class=identifier>BOOST_HAS_SLIST
 860
 861     </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>V</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>A</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>V2 </span><span class=special>&gt;
 862     </span><span class=identifier>list_inserter</span><span class=special>&lt; </span><span class=special>... </span><span class=special>&gt;    </span><span class=keyword>operator</span><span class=special>+=( </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>slist</span><span class=special>&lt;</span><span class=identifier>V</span><span class=special>,</span><span class=identifier>A</span><span class=special>&gt;&amp; </span><span class=identifier>c</span><span class=special>, </span><span class=identifier>V2 </span><span class=identifier>v </span><span class=special>);
 863
 864     </span><span class=preprocessor>#endif
 865
 866     </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>V</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>C</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>V2 </span><span class=special>&gt;
 867     </span><span class=identifier>list_inserter</span><span class=special>&lt; </span><span class=special>... </span><span class=special>&gt;    </span><span class=keyword>operator</span><span class=special>+=( </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>stack</span><span class=special>&lt;</span><span class=identifier>V</span><span class=special>,</span><span class=identifier>C</span><span class=special>&gt;&amp; </span><span class=identifier>c</span><span class=special>, </span><span class=identifier>V2 </span><span class=identifier>v </span><span class=special>);
 868
 869     </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>V</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>A</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>V2 </span><span class=special>&gt;
 870     </span><span class=identifier>list_inserter</span><span class=special>&lt; </span><span class=special>... </span><span class=special>&gt;    </span><span class=keyword>operator</span><span class=special>+=( </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>vector</span><span class=special>&lt;</span><span class=identifier>V</span><span class=special>,</span><span class=identifier>A</span><span class=special>&gt;&amp; </span><span class=identifier>c</span><span class=special>, </span><span class=identifier>V2 </span><span class=identifier>v </span><span class=special>);    </span>
 871
 872 <span class=special>} </span><span class=comment>// namespace 'assign'</span>
 873 <span class=special>} </span><span class=comment>// namespace 'boost'</span>  </pre></blockquote>
 874     Note that the extra template argument <code>V2</code> etc. is
 875     necessary to allow for types convertible to <code>V</code>.
 876
 877   <h3>Functions <code>list_of()</code> and
 878       <code>map_list_of()</code> <a name="list_of_ref"> </h3>
 879     <p>
 880   These two functions are used to construct anonymous
 881   list which can be converted to any standard container
 882   and <code>boost::<a href="../../array/index.html">array</a>&lt;T,sz>.</code>
 883 The object returned by the two
 884   functions is guaranteed to have the interface described below.
 885   </p>
 886   <b>Synopsis</b>
 887   <blockquote>
 888   <pre><span class=keyword>namespace </span><span class=identifier>boost  </span>
 889 <span class=special>{</span>
 890 <span class=keyword>namespace </span><span class=identifier>assign</span>
 891 <span class=special>{
 892     </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;
 893     </span><span class=keyword>class </span><span class=identifier>Implementation</span><span class=special>-</span><span class=identifier>defined</span>
 894     </span><span class=special>{
 895     </span><span class=keyword>public</span><span class=special>:
 896         </span><span class=identifier>const_iterator  </span><span class=identifier>begin</span><span class=special>() <span class=keyword>const</span>;
 897         </span><span class=identifier>const_iterator  </span><span class=identifier>end</span><span class=special>() <span class=keyword>const</span>;
 898
 899         </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;
 900         </span><span class=identifier>Implementation</span><span class=special>-</span><span class=identifier>defined</span>&amp; </span><span class=keyword>operator</span><span class=special>,( </span><span class=identifier>U </span><span class=identifier>u </span><span class=special>);
 901
 902         </span><span class=comment>// inserts default-constructed object
 903         </span><span class=identifier>Implementation</span><span class=special>-</span><span class=identifier>defined</span>&amp; </span><span class=keyword>operator</span><span class=special>()();
 904
 905         </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;
 906         </span><span class=identifier>Implementation</span><span class=special>-</span><span class=identifier>defined</span>&amp; </span><span class=keyword>operator</span><span class=special>()( </span><span class=identifier>U </span><span class=identifier>u </span><span class=special>);
 907
 908         </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>U</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>U2 </span><span class=special>&gt;
 909         </span><span class=identifier>Implementation</span><span class=special>-</span><span class=identifier>defined</span>&amp; </span><span class=keyword>operator</span><span class=special>()( </span><span class=identifier>U </span><span class=identifier>u</span><span class=special>, </span><span class=identifier>U2 </span><span class=identifier>u2 </span><span class=special>);
 910
 911         </span><span class=comment>//
 912         // and similarly up to 5 arguments
 913         //
 914
 915         //
 916         // Convert to a 'Container'. 'Container' must have a constructor
 917         // which takes two iterators.
 918         //
 919         </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>Container </span><span class=special>&gt;
 920         </span><span class=keyword>operator </span><span class=identifier>Container</span><span class=special>() </span><span class=keyword>const</span><span class=special>;
 921
 922         </span><span class=comment>//
 923         // Convert to a container adapter like 'std::stack&lt;&gt;'.
 924         //
 925         </span><span class=identifier>Convertible</span><span class=special>-</span><span class=identifier>to</span><span class=special>-</span><span class=identifier>adapter</span> </span><span class=identifier>to_adapter</span><span class=special>() </span><span class=keyword>const</span><span class=special>;
 926
 927         </span><span class=comment>//
 928         //
 929         // Convert to eg. 'boost::array&lt;T,std::size_t&gt;'. If the
 930         // assigned variable is too small,
 931         // a <a href="#assignment_exception">assignment_exception</a> is thrown.
 932         // If the assigned variable it is too big, the rest of the
 933         // values are  default-constructed.
 934         //
 935         </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>template </span><span class=special>&lt;</span><span class=keyword>class</span><span class=special>,</span><span class=identifier>std</span><span class=special>::</span><span class=identifier>size_t</span><span class=special>&gt; </span><span class=keyword>class </span><span class=identifier>Array</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>U</span><span class=special>, </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>size_t </span><span class=identifier>sz </span><span class=special>&gt;
 936         </span><span class=keyword>operator </span><span class=identifier>Array</span><span class=special>&lt;</span><span class=identifier>U</span><span class=special>,</span><span class=identifier>sz</span><span class=special>&gt;() </span><span class=keyword>const</span><span class=special>;
 937     </span><span class=special>};</span>
 938
 939     <span class=comment>//
 940     // Comparison operators. 'op' can be &lt;,&gt;,&lt;=,&gt;=,==,!=
 941     //</span>
 942     <span class=keyword>template</span><span class=special>&lt;</span> <span class=keyword>class</span> <span class=identifier>Range</span> <span class=special>&gt;</span>
 943     <span class=keyword>bool</span> <span class=identifier>op</span><span class=special>(</span> <span class=keyword>const</span> <span class=identifier>Implementation</span><span class=special>-</span><span class=identifier>defined</span><span class=special>&amp;,</span> <span class=keyword>const</span> <span class=identifier>Range</span><span class=special>&amp;</span> <span class=special>);</span>
 944     <span class=keyword>template</span><span class=special>&lt;</span> <span class=keyword>class</span> <span class=identifier>Range</span> <span class=special>&gt;</span>
 945     <span class=keyword>bool</span> <span class=identifier>op</span><span class=special>(</span> <span class=keyword>const</span> <span class=identifier>Range</span><span class=special>&amp;,</span> <span class=keyword>const</span> <span class=identifier>Implementation</span><span class=special>-</span><span class=identifier>defined</span><span class=special>&amp;</span> <span class=special>);</span>
 946
 947     <span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;
 948     </span><span class=identifier>Implementation</span><span class=special>-</span><span class=identifier>defined</span>   </span><span class=identifier>list_of</span><span class=special>(</span><span class=special>);
 949
 950     </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;
 951     </span><span class=identifier>Implementation</span><span class=special>-</span><span class=identifier>defined</span>   </span><span class=identifier>list_of</span><span class=special>( </span><span class=identifier>T </span><span class=identifier>t </span><span class=special>);
 952
 953     </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>U</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>U2 </span><span class=special>&gt;
 954     </span><span class=identifier>Implementation</span><span class=special>-</span><span class=identifier>defined</span>   </span><span class=identifier>list_of</span><span class=special>( </span><span class=identifier>U </span><span class=identifier>u</span><span class=special>, </span><span class=identifier>U2 </span><span class=identifier>u2 </span><span class=special>);
 955
 956     </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>U</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>U2</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>U3 </span><span class=special>&gt;
 957     </span><span class=identifier>Implementation</span><span class=special>-</span><span class=identifier>defined</span>   </span><span class=identifier>list_of</span><span class=special>( </span><span class=identifier>U </span><span class=identifier>u</span><span class=special>, </span><span class=identifier>U2 </span><span class=identifier>u2</span><span class=special>, </span><span class=identifier>U3 </span><span class=identifier>u3 </span><span class=special>);
 958
 959     </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>U</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>U2</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>U3</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>U4 </span><span class=special>&gt;
 960     </span><span class=identifier>Implementation</span><span class=special>-</span><span class=identifier>defined</span>   </span><span class=identifier>list_of</span><span class=special>( </span><span class=identifier>U </span><span class=identifier>u</span><span class=special>, </span><span class=identifier>U2 </span><span class=identifier>u2</span><span class=special>, </span><span class=identifier>U3 </span><span class=identifier>u3</span><span class=special>, </span><span class=identifier>U4 </span><span class=identifier>u4 </span><span class=special>);
 961
 962     </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>U</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>U2</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>U3</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>U4</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>U5 </span><span class=special>&gt;
 963     </span><span class=identifier>Implementation</span><span class=special>-</span><span class=identifier>defined</span>   </span><span class=identifier>list_of</span><span class=special>( </span><span class=identifier>U </span><span class=identifier>u</span><span class=special>, </span><span class=identifier>U2 </span><span class=identifier>u2</span><span class=special>, </span><span class=identifier>U3 </span><span class=identifier>u3</span><span class=special>, </span><span class=identifier>U4 </span><span class=identifier>u4</span><span class=special>, </span><span class=identifier>U5 </span><span class=identifier>u5 </span><span class=special>);
 964
 965     </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>Key</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;
 966     </span><span class=identifier>Implementation</span><span class=special>-</span><span class=identifier>defined</span>   </span><span class=identifier>map_list_of</span><span class=special>( </span><span class=identifier>Key </span><span class=identifier>k</span><span class=special>, </span><span class=identifier>T </span><span class=identifier>t </span><span class=special>)
 967     </span><span class=special>{
 968         </span><span class=keyword>return </span><span class=identifier>list_of</span><span class=special>&lt; </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>pair</span><span class=special>&lt;</span><span class=identifier>Key</span><span class=special>,</span><span class=identifier>T</span><span class=special>&gt; </span><span class=special>&gt;()( </span><span class=identifier>k</span><span class=special>, </span><span class=identifier>t </span><span class=special>);
 969     </span><span class=special>}</span>
 970 <span class=special>} </span><span class=comment>// namespace 'assign'</span>
 971 <span class=special>} </span><span class=comment>// namespace 'boost'</span>  </pre></blockquote>
 972
 973
 974   <h3>Functions <code>repeat()</code>,
 975      <code>repeat_fun()</code> and <code>range()</code> <a name="repeat_ref"> </h3>
 976   <p>
 977             These first two function exist both as free-standing functions and as member functions of the object returned by
 978       <code>list_of()</code> and of <code>list_inserter</code>.
 979       The free-standing versions are used to create a
 980       hook for <code>operator,()</code> so we can call the functions in the middle of a comma-list. The member functions
 981       are used when we need to call the functions in the middle of a parenthesis-list. In both cases we have that
 982       <ul>
 983           <li> the return type is always implementation defined for both functions,
 984           <li> the argument list of <code>repeat()</code> is <code>(std::size_t,T)</code>, and
 985           <li> the argument list of <code>repeat_fun()</code> is <code>(std::size_t,Nullary_function)</code>
 986       </ul>
 987
 988         </p>
 989   <p>
 990   The function <code>range()</code> only exists as a member function. The following two overloads are provided:
 991   <blockquote>
 992       <pre><span class=keyword>template</span><span class=special>&lt;</span> <span class=keyword>class</span> <span class=identifier>SinglePassIterator</span> <span class=special>&gt;</span>
 993 <span class=identifier>Implementation</span><span class=special>-</span><span class=identifier>defined</span> <span class=identifier>range</span><span class=special>(</span> <span class=identifier>SinglePassIterator</span> <span class=identifier>first</span><span class=special>,</span> <span class=identifier>SinglePassIterator</span> <span class=identifier>last</span> <span class=special>);</span>
 994
 995 <span class=keyword>template</span><span class=special>&lt;</span> <span class=keyword>class</span> <span class=identifier>SinglePassRange</span> <span class=special>&gt;</span>
 996 <span class=identifier>Implementation</span><span class=special>-</span><span class=identifier>defined</span> <span class=identifier>range</span><span class=special>(</span> <span class=keyword>const</span> <span class=identifier>SinglePassRange</span><span class=special>&amp;</span> <span class=identifier>rng</span> <span class=special>);</span></pre>
 997   </blockquote>
 998
 999   </p>
1000
1001   <h3><a name="list_inserter">Class <code>list_inserter</code></a></h3>
1002
1003   This class is responsible for inserting elements into containers and
1004   it is the key to extending the library to support your favourite class.
1005
1006     <p>
1007   <b>Synopsis</b>
1008   </p>
1009   <blockquote><pre>
1010 <span class=keyword>namespace </span><span class=identifier>boost</span>
1011 <span class=special>{</span>
1012 <span class=keyword>namespace </span><span class=identifier>assign</span>
1013 <span class=special>{
1014     </span><span class=keyword>template</span><span class=special>&lt; </span><span class=identifier>Function</span><span class=special>, </span><span class=identifier>Argument </span><span class=special>= </span><span class=keyword>void </span><span class=special>&gt;
1015     </span><span class=keyword>class </span><span class=identifier>list_inserter
1016     </span><span class=special>{
1017         </span><span class=identifier>Function </span><span class=identifier>fun</span><span class=special>;
1018
1019     </span><span class=keyword>public</span><span class=special>:
1020         </span><span class=keyword>explicit </span><span class=identifier>list_inserter</span><span class=special>( </span><span class=identifier>Function </span><span class=identifier>fun </span><span class=special>);
1021
1022         </span><span class=comment>// conversion constructor
1023         </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>Function2</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>Arg </span><span class=special>&gt;
1024         </span><span class=identifier>list_inserter</span><span class=special>( </span><span class=keyword>const </span><span class=identifier>list_inserter</span><span class=special>&lt;</span><span class=identifier>Function2</span><span class=special>,</span><span class=identifier>Arg</span><span class=special>&gt;&amp; </span><span class=special>);
1025
1026     </span><span class=keyword>public</span><span class=special>:
1027         </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;
1028         </span><span class=identifier>list_inserter</span><span class=special>&amp; </span><span class=keyword>operator</span><span class=special>,( </span><span class=identifier>U </span><span class=identifier>u </span><span class=special>);
1029
1030         </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;
1031         </span><span class=identifier>list_inserter</span><span class=special>&amp; </span><span class=keyword>operator</span><span class=special>=( </span><span class=identifier>U </span><span class=identifier>u </span><span class=special>);
1032
1033         </span><span class=comment>// calls 'fun()' with default-constructed object
1034         </span><span class=identifier>list_inserter</span><span class=special>&amp; </span><span class=keyword>operator</span><span class=special>()();
1035
1036         </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;
1037         </span><span class=identifier>list_inserter</span><span class=special>&amp; </span><span class=keyword>operator</span><span class=special>()( </span><span class=identifier>U </span><span class=identifier>u </span><span class=special>);
1038
1039         </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>U</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>U2 </span><span class=special>&gt;
1040         </span><span class=identifier>list_inserter</span><span class=special>&amp; </span><span class=keyword>operator</span><span class=special>()( </span><span class=identifier>U </span><span class=identifier>u</span><span class=special>, </span><span class=identifier>U2 </span><span class=identifier>u2 </span><span class=special>)
1041         </span><span class=special>{
1042            </span><span class=comment>//
1043            // if 'Argument' is 'void'
1044            //     fun( u, u2 );
1045            // else
1046            //     fun( Argument( u, u2 ) );
1047            //
1048            </span><span class=keyword>return </span><span class=special>*</span><span class=keyword>this</span><span class=special>;
1049         </span><span class=special>}
1050
1051         </span><span class=comment>//
1052         // similarly up to 5 arguments
1053         //
1054     </span><span class=special>};</span>
1055
1056     <span class=keyword>template</span><span class=special>&lt; </span><span
1057 class=keyword>class </span><span class=identifier>C </span><span class=special>&gt;
1058     </span><span class=identifier>list_inserter</span><span class=special>&lt; </span><span class=special>... </span><span class=special>&gt; </span><span class=identifier>push_back</span><span class=special>( </span><span class=identifier>C</span><span class=special>&amp; </span><span class=special>);
1059
1060     </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>C </span><span class=special>&gt;
1061     </span><span class=identifier>list_inserter</span><span class=special>&lt; </span><span class=special>... </span><span class=special>&gt; </span><span class=identifier>push_front</span><span class=special>( </span><span class=identifier>C</span><span class=special>&amp; </span><span class=special>);
1062
1063     </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>C </span><span class=special>&gt;
1064     </span><span class=identifier>list_inserter</span><span class=special>&lt; </span><span class=special>... </span><span class=special>&gt; </span><span class=identifier>insert</span><span class=special>( </span><span class=identifier>C</span><span class=special>&amp; </span><span class=special>);
1065
1066     </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>C </span><span class=special>&gt;
1067     </span><span class=identifier>list_inserter</span><span class=special>&lt; </span><span class=special>... </span><span class=special>&gt; </span><span class=identifier>push</span><span class=special>( </span><span class=identifier>C</span><span class=special>&amp; </span><span class=special>);</span>
1068
1069 <span class=special>} </span><span class=comment>// namespace 'assign'</span>
1070 <span class=special>} </span><span class=comment>// namespace 'boost'</span></pre></blockquote>
1071   <p>
1072   Notice how the arguments to <code>operator,()</code> and
1073   <code>operator()()</code> are passed differently to
1074   <code>fun</code> depending of the type of <code>Argument</code>.
1075   So if we only pass one template argument to <code>list_inserter,</code>
1076   we can forward "arbitrary" argument lists of functions. If we pass
1077   two template arguments to <code>list_inserter</code> we can
1078   construct types with "arbitrary" constructors.
1079   </p>
1080
1081   <p>
1082    And because
1083   a reference to <code>list_inserter</code> is returned, we can
1084   chain argument list together in a very space-efficient manner.
1085   </p>
1086
1087   <h3><a name="make_list_inserter">Function <code>make_list_inserter()</code></a></h3>
1088   <p>
1089   A simple "constructor" function for <code>list_inserter</code>. A typical
1090   use of this function is to call it with the result of
1091 <code>boost::bind()</code>
1092   which in general returns some unreadable and weird class template.
1093   </p>
1094   <b>Synopsis</b>
1095   <blockquote><pre>
1096 <span class=keyword>namespace </span><span class=identifier>boost </span>
1097 <span class=special>{</span>
1098 <span class=keyword>namespace </span><span class=identifier>assign</span>
1099 <span class=special>{
1100     </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>Function </span><span class=special>&gt;
1101     </span><span class=identifier>list_inserter</span><span class=special>&lt;</span><span class=identifier>Function</span><span class=special>&gt;  </span><span class=identifier>make_list_inserter</span><span class=special>( </span><span class=identifier>Function </span><span class=identifier>fun </span><span class=special>)
1102     </span><span class=special>{
1103         </span><span class=keyword>return </span><span class=identifier>list_inserter</span><span class=special>&lt;</span><span class=identifier>Function</span><span class=special>&gt;( </span><span class=identifier>fun </span><span class=special>);
1104     </span><span class=special>} </span>
1105 <span class=special>}</span>
1106 <span class=special>}  </span>  </pre></blockquote>
1107
1108    <a name="limit"></a>
1109    <h3>Customizing argument list sizes</h3>
1110       <p>
1111     This library uses the boost Preprocessor Library to implement overloaded
1112     versions of <code>operator()()</code> and <code>list_of()</code>. By default you
1113     can call these functions with five arguments, but you can also customize this
1114     number by defining a macros before including a header from this library:
1115        <blockquote>
1116        <pre>
1117 <span class=preprocessor>#define </span><span class=identifier>BOOST_ASSIGN_MAX_PARAMS </span><span class=number>10
1118 </span><span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>boost</span><span class=special>/</span><span class=identifier>assign</span><span class=special>.</span><span class=identifier>hpp</span><span class=special>&gt;</span>
1119 </pre>
1120        </blockquote>
1121        </p>
1122   <hr>
1123   <h2><a name="exceptions">Exceptions and exception-safety</a></h2>
1124   <p>
1125   The exception guarantees by the library is the same as guarantee as the
1126   guarantee of the function that is forwarded to. For standard
1127   containers this means that the
1128   strong guarantee is given for a single insertions and that the basic guarantee
1129   is given for many insertions (provided that the object being copied
1130   gives the basic guarantee).
1131   </p>
1132   <p>
1133   The functions may throw standard exceptions
1134   like <code>std::bad_alloc</code>. Note however that, unfortunately, the standard does not guarantee allocation-failures
1135   in standard containers to be reported by <code>std::bad_alloc</code> or exceptions derived from <code>std::exception</code>.
1136  </p>
1137
1138   <h3><a name="assignment_exception">Class
1139   <code>assignment_exception</code></a></h3>
1140   <p>
1141    The exception is thrown by the conversion operator in the proxy object
1142    returned from <code>list_of()</code>.
1143   </p>
1144
1145   <blockquote><pre>
1146 <span class=keyword>namespace </span><span class=identifier>boost </span>
1147 <span class=special>{</span>
1148 <span class=keyword>namespace </span><span class=identifier>assign</span>
1149 <span class=special>{
1150     </span><span class=keyword>class </span><span class=identifier>assignment_exception </span><span class=special>: </span><span class=keyword>public </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>exception
1151     </span><span class=special>{
1152     </span><span class=keyword>public</span><span class=special>:
1153         </span><span class=keyword>explicit </span><span class=identifier>assignment_exception</span><span class=special>( </span><span class=keyword>const </span><span class=keyword>char</span><span class=special>* </span><span class=identifier>what </span><span class=special>);
1154         </span><span class=keyword>virtual </span><span class=keyword>const </span><span class=keyword>char</span><span class=special>* </span><span class=identifier>what</span><span class=special>() </span><span class=keyword>const </span><span class=keyword>throw</span><span class=special>();
1155     </span><span class=special>};</span>
1156 <span class=special>}   </span>
1157 <span class=special>}</span>  </pre></blockquote>
1158
1159   <hr>
1160   <h2><a name="extensions">Extending the library</a></h2>
1161   <p>
1162   It is very simple to make the library work with new classes.
1163   This code shows how to use <code>operator+=()</code> with
1164   a container:
1165   <blockquote><pre>
1166 <span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>V</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>A</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>V2 </span><span class=special>&gt;
1167 </span><span class=keyword>inline </span><span class=identifier>list_inserter</span><span class=special>&lt; </span><span class=identifier>assign_detail</span><span class=special>::</span><span class=identifier>call_push_back</span><span class=special>&lt; </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>vector</span><span class=special>&lt;</span><span class=identifier>V</span><span class=special>,</span><span class=identifier>A</span><span class=special>&gt; </span><span class=special>&gt;, </span><span class=identifier>V </span><span class=special>&gt;
1168 </span><span class=keyword>operator</span><span class=special>+=( </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>vector</span><span class=special>&lt;</span><span class=identifier>V</span><span class=special>,</span><span class=identifier>A</span><span class=special>&gt;&amp; </span><span class=identifier>c</span><span class=special>, </span><span class=identifier>V2 </span><span class=identifier>v </span><span class=special>)
1169 </span><span class=special>{
1170     </span><span class=keyword>return </span><span class=identifier>make_list_inserter</span><span class=special>( </span><span class=identifier>assign_detail</span><span class=special>::</span><span class=identifier>call_push_back</span><span class=special>&lt; </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>vector</span><span class=special>&lt;</span><span class=identifier>V</span><span class=special>,</span><span class=identifier>A</span><span class=special>&gt; </span><span class=special>&gt;( </span><span class=identifier>c </span><span class=special>) </span><span class=special>)( </span><span class=identifier>v </span><span class=special>);
1171 </span><span class=special>}
1172 </span></pre>
1173 </blockquote>
1174
1175
1176 where <code>call_push_back</code> is defined as
1177
1178 <blockquote>
1179 <pre>
1180 <span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>C </span><span class=special>&gt;
1181 </span><span class=keyword>class </span><span class=identifier>call_push_back
1182 </span><span class=special>{
1183     </span><span class=identifier>C</span><span class=special>&amp; </span><span class=identifier>c_</span><span class=special>;
1184 </span><span class=keyword>public</span><span class=special>:
1185
1186     </span><span class=identifier>call_push_back</span><span class=special>( </span><span class=identifier>C</span><span class=special>&amp; </span><span class=identifier>c </span><span class=special>) </span><span class=special>: </span><span class=identifier>c_</span><span class=special>( </span><span class=identifier>c </span><span class=special>)
1187     </span><span class=special>{ </span><span class=special>}
1188
1189     </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;
1190     </span><span class=keyword>void </span><span class=keyword>operator</span><span class=special>()( </span><span class=identifier>T </span><span class=identifier>r </span><span class=special>)
1191     </span><span class=special>{
1192         </span><span class=identifier>c_</span><span class=special>.</span><span class=identifier>push_back</span><span class=special>( </span><span class=identifier>r </span><span class=special>);
1193     </span><span class=special>}
1194 </span><span class=special>};</span></pre>
1195 </blockquote>
1196
1197       Note that we pass
1198   a second template argument to <code>list_inserter</code> so argument
1199   lists will be used to construct a <code>V</code> object. Otherwise we
1200   could end up trying to call <code>push_back()</code> with <i>n</i> arguments
1201   instead of one.
1202   </p>
1203
1204   <p>
1205   An alternative way would be to use <code>boost::function</code> and
1206   <code>boost::bind()</code> in combination. However, in this case one must
1207   remember that it is illegal to take the address of a function in
1208   the standard library.
1209   </p>
1210
1211   <p>
1212   Calling a function with more that one argument can be
1213   very useful too. This small example shows how we take advantage of this
1214   functionality:
1215   </p>
1216   <blockquote><pre>
1217 <span class=comment>//
1218 // A class representing emails
1219 //</span>
1220 <span class=keyword>class </span><span class=identifier>email</span>
1221 <span class=special>{</span>
1222 <span class=keyword>public</span><span class=special>:
1223     </span><span class=keyword>enum </span><span class=identifier>address_option
1224     </span><span class=special>{
1225         </span><span class=identifier>check_addr_book</span><span class=special>,
1226         </span><span class=identifier>dont_check_addr_book
1227     </span><span class=special>};
1228     </span>
1229 <span class=keyword>private</span><span class=special>:
1230
1231     </span><span class=keyword>typedef </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>map</span><span class=special>&lt; </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>string</span><span class=special>,</span><span class=identifier>address_option </span><span class=special>&gt;  </span><span class=identifier>address_map</span><span class=special>;
1232
1233     </span><span class=comment>//
1234     // Store list of persons that must be cc'ed
1235     //
1236     </span><span class=keyword>mutable </span><span class=identifier>address_map </span><span class=identifier>cc_list</span><span class=special>;
1237
1238     </span><span class=comment>//
1239     // This extra function-object will take care of the
1240     // insertion for us. It stores a reference to a
1241     // map and 'operator()()' does the work.
1242     //
1243     </span><span class=keyword>struct </span><span class=identifier>add_to_map
1244     </span><span class=special>{
1245         </span><span class=identifier>address_map</span><span class=special>&amp; </span><span class=identifier>m</span><span class=special>;
1246
1247         </span><span class=identifier>add_to_map</span><span class=special>( </span><span class=identifier>address_map</span><span class=special>&amp; </span><span class=identifier>m </span><span class=special>) </span><span class=special>: </span><span class=identifier>m</span><span class=special>(</span><span class=identifier>m</span><span class=special>)
1248         </span><span class=special>{}
1249
1250         </span><span class=keyword>void </span><span class=keyword>operator</span><span class=special>()( </span><span class=keyword>const </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>string</span><span class=special>&amp; </span><span class=identifier>name</span><span class=special>, </span><span class=identifier>address_option </span><span class=identifier>ao </span><span class=special>)
1251         </span><span class=special>{
1252             </span><span class=identifier>m</span><span class=special>[ </span><span class=identifier>name </span><span class=special>] </span><span class=special>= </span><span class=identifier>ao</span><span class=special>;
1253         </span><span class=special>}
1254     </span><span class=special>};
1255 </span>
1256 <span class=keyword>public</span><span class=special>:
1257
1258     </span><span class=comment>//
1259     // This function constructs the appropriate 'list_inserter'.
1260     // Again we could have use 'boost::function', but it is
1261     // trivial to use a function object.
1262     //
1263     // Notice that we do not specify an extra template
1264     // parameter to 'list_inserter'; this means we forward
1265     // all parameters directly to the function without
1266     // calling any constructor.
1267     //
1268     </span><span class=identifier>list_inserter</span><span class=special>&lt; </span><span class=identifier>add_to_map </span><span class=special>&gt;
1269     </span><span class=identifier>add_cc</span><span class=special>( </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>string </span><span class=identifier>name</span><span class=special>, </span><span class=identifier>address_option </span><span class=identifier>ao </span><span class=special>)
1270     </span><span class=special>{
1271         </span><span class=comment>//
1272         // Notice how we pass the arguments 'name' and 'ao' to
1273         // the 'list_inserter'.
1274         //
1275         </span><span class=keyword>return </span><span class=identifier>make_list_inserter</span><span class=special>( </span><span class=identifier>add_to_map</span><span class=special>( </span><span class=identifier>cc_list </span><span class=special>) </span><span class=special>)( </span><span class=identifier>name</span><span class=special>, </span><span class=identifier>ao </span><span class=special>);
1276     </span><span class=special>}</span>
1277 <span class=special>};
1278 </span>
1279 <span class=comment>//
1280 // Now we can use the class like this:
1281 //</span>
1282 <span class=identifier>email </span><span class=identifier>e</span><span class=special>;</span>
1283 <span class=identifier>e</span><span class=special>.</span><span class=identifier>add_cc</span><span class=special>( </span><span class=string>&quot;Mr. Foo&quot;</span><span class=special>, </span><span class=identifier>email</span><span class=special>::</span><span class=identifier>dont_check_addr_book </span><span class=special>)
1284         </span><span class=special>( </span><span class=string>&quot;Mr. Bar&quot;</span><span class=special>, </span><span class=identifier>email</span><span class=special>::</span><span class=identifier>check_addr_book </span><span class=special>)
1285         </span><span class=special>( </span><span class=string>&quot;Mrs. FooBar&quot;</span><span class=special>, </span><span class=identifier>email</span><span class=special>::</span><span class=identifier>check_addr_book </span><span class=special>);  </span>
1286 </pre></blockquote>
1287
1288
1289   The full example can be seen in <a href="email_example.html">email_example.cpp</a> </p>
1290   <hr>
1291   <h2>Examples <a name="examples"></h2>
1292   <p>
1293   Additional examples can be found in the test files:
1294   <ul>
1295       <li> <a href="email_example.html">email_example.cpp</a>
1296       <li> <a href="my_vector_example.html">my_vector_example.cpp</a>
1297       <li> <a href="multi_index_container.html">multi_index_container.cpp</a>
1298       <li> <a href="../test/array.cpp">array.cpp</a>
1299       <li> <a href="../test/list_of.cpp">list_of.cpp</a>
1300       <li> <a href="../test/std.cpp">std.cpp</a>
1301       <li> <a href="../test/list_inserter.cpp">list_inserter.cpp</a>
1302       <li> <a href="../test/list_of_workaround.cpp">list_of_work_around.cpp</a>
1303 </ul> </p>
1304
1305
1306   <hr>
1307   <h2><a name="boost_libs">Supported libraries</a></h2>
1308   Here is a list libraries has been tested with Boost.Assign:
1309
1310   <ol>
1311       <li> <code>boost::<a href="../../array/index.html">array</a></code>
1312       <li> <code>boost::<a href="../../multi_index/index.html">multi_index_container</a></code>
1313       <li> <code>Boost.<a href="../../ptr_container/index.html">Pointer Container</code> </ol> <p>
1314
1315   </p>
1316
1317
1318   <hr>
1319   <h2><a name="portability">Portability</a></h2>
1320   <p>
1321     Library has been successfully compiled and tested with
1322     MVC++ 7.1, GCC 3.2 (under Cygwin) Comeau 4.3.3
1323   </p>
1324   <p>
1325     There are known limitation on platforms not supporting templated
1326     conversion operators. The solution is to call certain member functions on
1327     the object returned by <code>list_of()</code>: </p>
1328  <blockquote>
1329      <pre>
1330 <span class=special>{
1331     </span><span class=keyword>using </span><span class=keyword>namespace </span><span class=identifier>std</span><span class=special>;
1332     </span><span class=keyword>using </span><span class=keyword>namespace </span><span class=identifier>boost</span><span class=special>;
1333     </span><span class=keyword>using </span><span class=keyword>namespace </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>assign</span><span class=special>;
1334
1335     </span><span class=keyword></span><span
1336 class=identifier>vector</span><span
1337 class=special>&lt;</span><span class=keyword>int</span><span
1338 class=special>&gt;</span>         <span class=identifier>v </span><span
1339 class=special>= </span><span class=identifier>list_of</span><span class=special>(</span><span class=number>1</span><span class=special>)(</span><span class=number>2</span><span class=special>)(</span><span class=number>3</span><span class=special>)(</span><span class=number>4</span><span class=special>).</span><span class=identifier>to_container</span><span class=special>( </span><span class=identifier>v </span><span class=special>);
1340     </span><span class=identifier>set</span><span class=special>&lt;</span><span class=keyword>int</span><span class=special>&gt;            </span><span class=identifier>s </span><span class=special>= </span><span class=identifier>list_of</span><span class=special>(</span><span class=number>1</span><span class=special>)(</span><span class=number>2</span><span class=special>)(</span><span class=number>3</span><span class=special>)(</span><span class=number>4</span><span class=special>).</span><span class=identifier>to_container</span><span class=special>( </span><span class=identifier>s </span><span class=special>);
1341     </span><span class=identifier>map</span><span class=special>&lt;</span><span class=keyword>int</span><span class=special>,</span><span class=keyword>int</span><span class=special>&gt;        </span><span class=identifier>m </span><span class=special>= </span><span class=identifier>map_list_of</span><span class=special>(</span><span class=number>1</span><span class=special>,</span><span class=number>2</span><span class=special>)(</span><span class=number>2</span><span class=special>,</span><span class=number>3</span><span class=special>).</span><span class=identifier>to_container</span><span class=special>( </span><span class=identifier>m </span><span class=special>);
1342     </span><span class=identifier>stack</span><span class=special>&lt;</span><span class=keyword>int</span><span class=special>&gt;         </span><span class=identifier>st </span><span class=special>= </span><span class=identifier>list_of</span><span class=special>(</span><span class=number>1</span><span class=special>)(</span><span class=number>2</span><span class=special>)(</span><span class=number>3</span><span class=special>)(</span><span class=number>4</span><span class=special>).</span><span class=identifier>to_adapter</span><span class=special>( </span><span class=identifier>st </span><span class=special>);
1343     </span><span class=identifier>queue</span><span class=special>&lt;</span><span class=keyword>int</span><span class=special>&gt;          </span><span class=identifier>q </span><span class=special>= </span><span class=identifier>list_of</span><span class=special>(</span><span class=number>1</span><span class=special>)(</span><span class=number>2</span><span class=special>)(</span><span class=number>3</span><span class=special>)(</span><span class=number>4</span><span class=special>).</span><span class=identifier>to_adapter</span><span class=special>( </span><span class=identifier>q </span><span class=special>);
1344     </span><span class=identifier>array</span><span class=special>&lt;</span><span class=keyword>int</span><span class=special>,</span><span class=number>4</span><span class=special>&gt;        </span><span class=identifier>a </span><span class=special>= </span><span class=identifier>list_of</span><span class=special>(</span><span class=number>1</span><span class=special>)(</span><span class=number>2</span><span class=special>)(</span><span class=number>3</span><span class=special>)(</span><span class=number>4</span><span class=special>).</span><span class=identifier>to_array</span><span class=special>( </span><span class=identifier>a </span><span class=special>);</span>
1345 <span class=special>}</span>     </pre>
1346  </blockquote>
1347  <p>
1348  Notice how one must supply the functions with an argument so the right
1349  return type can be deduced.
1350  </p>
1351  <p>Some standard libraries are also broken. One problem is that
1352 <code>insert()</code> might not work:
1353 <blockquote>
1354     <pre>
1355 <span class=identifier>map</span><span class=special>&lt;</span><span class=keyword>int</span><span class=special>,</span><span class=keyword>int</span><span class=special>&gt; </span><span class=identifier>next</span><span class=special>;
1356 </span><span class=identifier>insert</span><span class=special>( </span><span class=identifier>next </span><span class=special>)(</span><span class=number>1</span><span class=special>,</span><span class=number>2</span><span class=special>)(</span><span class=number>2</span><span class=special>,</span><span class=number>3</span><span class=special>); </span><span class=comment>// compile-time error</span> </pre>
1357 </blockquote>
1358 The solution is to use <code>map_list_of()</code> instead:
1359 <blockquote>
1360     <pre>
1361 <span class=identifier>map</span><span class=special>&lt;</span><span class=keyword>int</span><span class=special>,</span><span class=keyword>int</span><span class=special>&gt; </span><span class=identifier>next </span><span class=special>= </span><span class=identifier>map_list_of</span><span class=special>(</span><span class=number>1</span><span class=special>,</span><span class=number>2</span><span class=special>)(</span><span class=number>2</span><span class=special>,</span><span class=number>3</span><span class=special>);</span></pre></blockquote>
1362 </p>
1363  <hr>
1364   <h2><a name="history">History and Acknowledgment</a></h2>
1365   <p>
1366   The idea for an assignment/initialization library is not new. The
1367   functionality of this
1368   library resembles Leor Zolman's STL Container Initialization Library a great
1369   deal, but it does not rely on string parsing to achieve its goals.
1370   </p>
1371   <p>
1372   The
1373   library is non-intrusive and puts only a minimum of requirements
1374   on its supported classes.
1375  Overloading operator comma is sometimes viewed as a bad practice <a
1376 href="#meyers">[1]</A>. However, it has been done
1377   with success in eg. the Generative Matrix Computation Library  and Blitz to initialize matrices
1378       (see <a href="#gmcl">[2]</A>) and <a href="#blitz">[3]</A>). The
1379 Initialization Library overloads
1380       the comma operator in a safe manner by letting free standing functions
1381  return an object that is responsible for the initialization. Therefore it takes
1382 explicit
1383       action from the programmer to begin using the overloaded <code>operator,()</CODE>.
1384   </p>
1385   <p>
1386   There has recently been some discussion about enhancing the language to
1387 support better initialization (see <a href="#initializer">[4]</a>).
1388   </p>
1389   <p>
1390   Special thanks goes to
1391   <ul>
1392   <li> Leor Zolman for our many discussion that eventually led to this library.
1393   <li> Tom Brinkman for being review manager.
1394   <li> Joaquín Muñoz for vc6/vc7 portability.
1395   <li> Pavel Vozenilek for his countless suggestions, improvements and
1396        portability fixes.
1397   <li> Rene Rivera for Code Warrior portability.
1398
1399        </ul>
1400   </p>
1401   <hr>
1402   <h2><a name="ref">References</a></h2>
1403   <p>
1404   <ol>
1405       <li> <a name="meyers">     Scott. Meyers, "More Effective C++", Item 7, Addison Wesley, 1996
1406       <li> <a name="gmcl">       K. Czarnecki and U.W. Eisenecker, "Generative programming", Addison-Wesley, 2000
1407       <li> <a name="blitz">      <a href="http://www.oonumerics.org/blitz/"> http://www.oonumerics.org/blitz/ </A>
1408       <li> <a name="initializer">
1409           Gabriel Dos Reis and Bjarne Stroustrup,
1410           <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2003/n1509.pdf"> "Generalized Initializer
1411             Lists"</a>, 2003  </a>
1412  </OL>
1413  </p>
1414   <hr>
1415   <p>
1416     (C) Copyright Thorsten Ottosen 2003-2006
1417   </p>
1418
1419   <br>
1420   <br>
1421   <br>
1422   <br>
1423   <br>
1424   <br>
1425   <br>
1426   <br>
1427   <br>
1428   <br>
1429   <br>
1430   <br>
1431 </body>
1432 </html>