Home Explore Help
Register Sign In
devn00b
/
EQ2EMu
9
3
Fork 0
Files Issues 75 Pull Requests 0 Wiki
Tree: 0ad4e6b698
Branches Tags
EQ2EMu
/
EQ2
/
source
/
depends
/
boost_1_72_0
/
libs
/
assign
/
doc
/
index.html

index.html 143 KB
History Raw

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432 
  1. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2//EN">
    2. 

  2. 

  3. <html>
    4. 

  4. <head>
    5. 

  5. <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
    6. 

  6. <title>Boost.Assignment Documentation </title>
    7. 

  7. <link rel="stylesheet" href="style.css" type="text/css">
    8. 

  8. </head>
    9. 

  9. 

  10. <body>
    11. 

  11. 

  12.   <table border="0" >
    13. 

  13.     <tr>
    14. 

  14.       <td ><img src="../../../boost.png" border="0" ></td>
    15. 

  15.       <td >
    16. 

  16.         <h1 align="center">Assignment Library</h1>
    17. 

  17.       </td>
    18. 

  18.     </tr>
    19. 

  19.   </table>
    20. 

  20. 

  21.   <p>
    22. 

  22.   Copyright © 2003-2006 Thorsten Ottosen
    23. 

  23.   </p>
    24. 

  24.   <p>
    25. 

  25.   Use, modification and distribution is subject to the Boost Software License, Version 1.0
    26. 

  26.   (see <a href="http://www.boost.org/LICENSE_1_0.txt">
    27. 

  27.    http://www.boost.org/LICENSE_1_0.txt</a>).
    28. 

  28.   </p>
    29. 

  29.   <h3>Table of Contents</h3>
    30. 

  30.   <ul>
    31. 

  31.     <li><a href="#intro">Introduction</a></li>
    32. 

  32.     <li>     
    33. 

  33.         <a href="#tutorial" >Tutorial</a>
    34. 

  34.         <ul>
    35. 

  35.             <li>Function <a href="#operator+="><code>operator+=()</code></a>
    36. 

  36.             <li>Function <a href="#operator()"><code>operator()()</code></a>
    37. 

  37.             <li>Function <a href="#list_of"><code>list_of()</code></a>    
    38. 

  38.             <li>Function <a href="#map_list_of"><code>map_list_of()</code></a> 
    39. 

  39.             <li>Function <a href="#tuple_list_of"><code>tuple_list_of()</code></a>
    40. 

  40.             <li>Functions <a href="#repeat"><code>repeat()</code>, <code>repeat_fun()</code> and <code>range()</code> </a>
    41. 

  41.             <li>Functions <a href="#ref_list_of"><code>ref_list_of()</code> and <code>cref_list_of()</code></a>    
    42. 

  42.             <li>A <a href="#complicated">"complicated"</a> example    
    43. 

  43.             <li>Functions <a href="#ptr_push_back"><code>ptr_push_back(), ptr_push_front()</code>, 
    44. 

  44.                                                    <code>ptr_insert()</code> and <code>ptr_map_insert()</code></a>
    45. 

  45.             <li>Function <a href="#ptr_list_of"><code>ptr_list_of()</code></a>         
    46. 

  46.        </ul> <li>          
    47. 

  47.                 
    48. 

  48.         <a href="#reference">Reference</a>
    49. 

  49.       <ul>
    50. 

  50.         <li><a href="#headers">Headers</a> </li>
    51. 

  51.         <li><a href="#std">Standard containers</a> </li>
    52. 

  52.         <li>Functions <a href="#list_of_ref"><code>list_of()</code> and <code>map_list_of()</code></a></li>
    53. 

  53.         <li>Functions <a href="#repeat_ref"><code>repeat()</code>, 
    54. 

  54.             <code>repeat_fun()</code> and <code>range()</code> </a> </li> 
    55. 

  55.         <li>Class <a href="#list_inserter"><code>list_inserter</code></a></li>
    56. 

  56.         <li>Function <a href="#make_list_inserter"><code>make_list_inserter()</code></a></li>
    57. 

  57.         <li><a href="#limit"> Customizing</a> argument list sizes</li>   
    58. 

  58.      </ul>
    59. 

  59.     <li> <a href="#exceptions">Exceptions and exception-safety </a></li>
    60. 

  60.     <li> <a href="#extensions">Extending the library</a>            
    61. 

  61.     <li> <a href="#boost_libs">Supported libraries </a>        
    62. 

  62.     <li> <a href="#examples">Examples</a></li> <ul></ul>
    63. 

  63.     <li><a href="#portability">Portability</a></li>
    64. 

  64.     <li><a href="#history">History and Acknowledgment</a>    
    65. 

  65.     <li><a href="#ref">References</a></li>
    66. 

  66.   </ul>
    67. 

  67.   <hr>
    68. 

  68. 

  69.  
    70. 

  70.   
    71. 

  71. <h2><a name="intro">Introduction</a></h2> <p> <i>There appear to be few 
    72. 

  72. practical uses of <code>operator,()</code></i>.  <!-- p.  247 --> <br><b>Bjarne 
    73. 

  73. Stroustrup</b>, The Design and Evolution of C++ </p> <p> The purpose of this 
    74. 

  74. library is to make it easy to fill containers with data by overloading 
    75. 

  75. <code>operator,()</code> and <code>operator()()</code>.  These two operators 
    76. 

  76. make it possible to construct lists of values that are then copied into a 
    77. 

  77. container: </p> <ul> <li> A comma-separated list: <p> 
    78. 

  78.        <!--  vector< int > v; v += 1,2,3,4,5,6,7,8,9; -->
    79. 

  79.  
    80. 

  80. <pre><span 
    81. 

  81. class=identifier>vector</span><span class=special><</span><span 
    82. 

  82. class=keyword>int</span><span class=special>></span><span 
    83. 

  83. class=identifier> v</span><span class=special>; </span>
    84. 

  84. <span class=identifier>v </span><span class=special>+= </span><span 
    85. 

  85. class=number>1</span><span
    86. 

  86. class=special>,</span><span class=number>2</span><span 
    87. 

  87. class=special>,</span><span class=number>3</span><span 
    88. 

  88. class=special>,</span><span class=number>4</span><span 
    89. 

  89. class=special>,</span><span class=number>5</span><span 
    90. 

  90. class=special>,</span><span class=number>6</span><span 
    91. 

  91. class=special>,</span><span class=number>7</span><span 
    92. 

  92. class=special>,</span><span class=number>8</span><span 
    93. 

  93. class=special>,</span><span class=number>9</span><span class=special>;</span></pre></p>
    94. 

  94.        <li> A parenthesis-separated list: 
    95. 

  95.              <p>       
    96. 

  96.              <pre>
    97. 

  97. <span class=identifier>map</span><span class=special><</span><span 
    98. 

  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. 

  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. 

  100.     </ul> 
    101. 

  101. <p>
    102. 

  102.     These lists are particularly useful in
    103. 

  103.     learning, testing, and prototyping situations, but can also be handy otherwise. 
    104. 

  104.       The library comes with predefined operators for the containers of the  
    105. 

  105.       standard library, but most functionality will work with any standard 
    106. 

  106. compliant container. The library also makes it possible to extend user
    107. 

  107.   defined types so for example a member function can be called for a list of 
    108. 

  108. values instead of its normal arguments. </p>
    109. 

  109.    <hr>
    110. 

  110.    
    111. 

  111.    <a name="tutorial"></a>
    112. 

  112.    <h2>Tutorial</h2>
    113. 

  113.    <p>
    114. 

  114.    Within two minutes you should be able to use this library. The main 
    115. 

  115. components are explained in these sections:
    116. 

  116.    <ul>
    117. 

  117.         <li>Function <a href="#operator+="><code>operator+=()</code></a>
    118. 

  118.         <li>Function <a href="#operator()"><code>operator()()</code></a>
    119. 

  119.         <li>Function <a href="#list_of"><code>list_of()</code></a>    
    120. 

  120.         <li>Function <a href="#map_list_of"><code>map_list_of()</code></a> 
    121. 

  121.         <li>Function <a href="#tuple_list_of"><code>tuple_list_of()</code></a>   
    122. 

  122.         <li>Functions <a href="#repeat"><code>repeat()</code>, <code>repeat_fun()</code> and <code>range()</code> </a>
    123. 

  123.         <li>Functions <a href="#ref_list_of"><code>ref_list_of()</code> and <code>cref_list_of()</code></a>
    124. 

  124.         <li>A <a href="#complicated">"complicated"</a> example    
    125. 

  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. 

  126.         <li>Function <a href="#ptr_list_of"><code>ptr_list_of()</code></a>         
    127. 

  127.             
    128. 

  128.    </ul>
    129. 

  129.    The two first functions are used for adding elements after a container object
    130. 

  130.    has been created whereas the next two is used when we need to initialize an 
    131. 

  131.    object. </p>
    132. 

  132.    <h3>Function <code>operator+=()</code><a name="operator+="></h3>
    133. 

  133.    <p>
    134. 

  134.     To fill a vector (or any standard container) with values using 
    135. 

  135.     <code>operator+=()</code> you write   
    136. 

  136.     <blockquote><pre>
    137. 

  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. 

  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. 

  139. </span><span class=keyword>using </span><span class=keyword>namespace </span><span class=identifier>std</span><span class=special>;
    140. 

  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. 

  141. </span><span class=special>
    142. 

  142. </span><span class=special>{
    143. 

  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. 

  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. 

  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. 

  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. 

  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. 

  148. </span><span class=special>}</span></pre></blockquote>
    149. 

  149. 

  150.     Here we only stuffed constants into the container, but the list can
    151. 

  151.     consists of arbitrary expressions as long as the result of each  
    152. 

  152. expression is convertible to the <code>value_type</code> of the container.
    153. 

  153.    </p> 
    154. 

  154.    
    155. 

  155.    
    156. 

  156.    <h3>Function <code>operator()()</code> <a name="operator()"></h3>
    157. 

  157.    <p>
    158. 

  158.    We do not call <code>operator()()</code> directly, but instead we call a 
    159. 

  159.    function that returns a proxy-object that defines <code>operator()()</code>.
    160. 

  160.    The function that returns the proxy object is always named after the member
    161. 

  161.    function that is used to copy the values in the list into the container.
    162. 

  162.    So to fill a map with pairs of values you write 
    163. 

  163.    <blockquote><pre>
    164. 

  164. <span class=preprocessor>#include </span><span class=special>&lt;</span><span 
    165. 

  165. class=identifier>boost</span><span class=special>/</span><span 
    166. 

  166. class=identifier>assign</span><span class=special>/</span><span 
    167. 

  167. class=identifier>list_inserter</span><span class=special>.</span><span 
    168. 

  168. class=identifier>hpp</span><span class=special>&gt; </span><span class=comment>// for 'insert()'
    169. 

  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. 

  170. </span><span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>string</span><span class=special>&gt;
    171. 

  171. </span><span class=keyword>using </span><span class=keyword>namespace </span><span class=identifier>std</span><span class=special>;
    172. 

  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. 

  173. </span><span class=special> 
    174. 

  174. </span><span class=special>{
    175. 

  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. 

  176.     </span><span class=identifier>insert</span><span class=special>( </span><span class=identifier>months </span><span class=special>)
    177. 

  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. 

  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. 

  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. 

  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. 

  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. 

  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. 

  183.     </span><span class=identifier>BOOST_ASSERT</span><span class=special>( </span><span class=identifier>months</span><span class=special>.</span><span 
    184. 

  184. class=identifier>size</span><span class=special>() </span><span class=special>== </span><span class=number>12 </span><span class=special>);
    185. 

  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. 

  186. </span><span class=special>}</span> </pre></blockquote>
    187. 

  187. 

  188.    Note that <code>operator()()</code> is much more handy when
    189. 

  189.    we need to construct objects using several arguments
    190. 

  190.    (up to five arguments are supported by default, but the limit can be <a href="#limit">customized</a>).
    191. 

  191.     This is also true for sequences:
    192. 

  192. 

  193.       <blockquote><pre>
    194. 

  194. <span class=preprocessor>#include </span><span class=special>&lt;</span><span 
    195. 

  195. class=identifier>boost</span><span class=special>/</span><span 
    196. 

  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. 

  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. 

  198. </span><span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>string</span><span class=special>&gt;
    199. 

  199. </span><span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>utility</span><span class=special>&gt;
    200. 

  200. </span><span class=keyword>using </span><span class=keyword>namespace </span><span class=identifier>std</span><span class=special>;
    201. 

  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. 

  202. </span><span class=special> 
    203. 

  203. </span><span class=special>{
    204. 

  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. 

  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. 

  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. 

  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. 

  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. 

  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. 

  210. </span><span class=special>}   </span></pre></blockquote>
    211. 

  211. 

  212.    Besides <code>push_front()</code> we could also have used
    213. 

  213.    <code>push_back()</code> if the container has a corresponding member
    214. 

  214.    function. Empty parentheses can be used to insert default-constructed 
    215. 

  215. objects, for example, 
    216. 

  216. <code>push_front( deq )()()</code> will insert two default-constructed 
    217. 

  217. <code>str_pair</code> objects. </p>   
    218. 

  218.    
    219. 

  219.    <p>
    220. 

  220.    If <code>operator()()</code> is too cumbersome to use with eg. 
    221. 

  221. <code>push_front()</code>we can also say </p>
    222. 

  222. 

  223. <blockquote>
    224. 

  224.     <pre>
    225. 

  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. 

  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. 

  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. 

  228. <span class=identifier>BOOST_ASSERT</span><span class=special>( </span><span 
    229. 

  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. 

  230. </pre>
    231. 

  231. </blockquote>
    232. 

  232. <p>
    233. 

  233. Just to make it perfectly clear, the code above is not restricted to the 
    234. 

  234. standard containers, but will work with all <i>standard compliant</i> containers 
    235. 

  235. with the right member function. It is only <code>operator+=()</code> that has been restricted to 
    236. 

  236. the standard containers. </p>
    237. 

  237.   
    238. 

  238.   <h3>Function <code>list_of()</code> <a name="list_of"></h3>
    239. 

  239.   But what if we need to <i>initialize</i> a container? This is where 
    240. 

  240.   <code>list_of()</code> comes into play. With <code>list_of()</code>
    241. 

  241.   we can create anonymous lists that automatically converts to
    242. 

  242.   any container:
    243. 

  243.   <blockquote><pre>
    244. 

  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. 

  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. 

  246. </span><span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>list</span><span class=special>&gt;
    247. 

  247. </span><span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>stack</span><span class=special>&gt;
    248. 

  248. </span><span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>string</span><span class=special>&gt;
    249. 

  249. </span><span class=keyword>using </span><span class=keyword>namespace </span><span class=identifier>std</span><span class=special>;
    250. 

  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. 

  251. </span><span class=special> 
    252. 

  252. </span><span class=special>{
    253. 

  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. 

  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. 

  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. 

  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. 

  257.    
    258. 

  258.     </span><span class=keyword>const </span><span 
    259. 

  259. class=identifier>stack</span><span class=special>&lt;</span><span 
    260. 

  260. class=identifier>string</span><span class=special>&gt; </span><span 
    261. 

  261. class=identifier>names </span><span class=special>= </span><span 
    262. 

  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. 

  263. class=special>).</span><span class=identifier>to_adapter();
    264. 

  264.     </span><span class=keyword>const </span><span 
    265. 

  265. class=identifier>stack</span><span class=special>&lt;</span><span 
    266. 

  266. class=identifier>string</span><span class=special>&gt; </span><span 
    267. 

  267. class=identifier>names2 </span><span class=special>= </span><span 
    268. 

  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. 

  269. class=special>).</span><span class=identifier>to_adapter();
    270. 

  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. 

  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. 

  272. </span><span class=special>}   </span></pre></blockquote>
    273. 

  273.   If we need to initialize a container adapter, we need to help the compiler a 
    274. 

  274. little by calling <code>to_adapter()</code>. As the second example also shows, 
    275. 

  275. we can use a comma-separated
    276. 

  276. list with <code>list_of()</code> if we add parenthesis around the 
    277. 

  277.   entire right hand side. It is worth noticing that the first argument
    278. 

  278.   of <code>list_of()</code> determines the type of the anonymous list.
    279. 

  279.   In case of the stack, the anonymous list consists of
    280. 

  280.   <code>const char*</code> objects which are then converted to 
    281. 

  281.   a stack of <code>string</code> objects. The conversion is always  
    282. 

  282.   possible as long as the conversion between the stored types is possible.
    283. 

  283.  </p>
    284. 

  284.  <p>
    285. 

  285.  Please notice that <code>list_of()</code> can even convert to a 
    286. 

  286.  <code>boost::<a 
    287. 

  287. href="../../array/index.html">array</a>&lt;T,sz></code> and see also the list 
    288. 

  288. of <a href="#boost_libs">supported libraries </a>. </p>
    289. 

  289.            <p>
    290. 

  290.                Note that the type returned by 
    291. 

  291.                <code>list_of()</code> (and its variants) has overloaded comparison operators. This allows you to
    292. 

  292.                write test code such as 
    293. 

  293.                    <code>
    294. 

  294.                        BOOST_CHECK_EQUAL( my_container, list_of(2)(3)(4)(5) );.
    295. 

  295.                    </code>
    296. 

  296.                </p>
    297. 

  297.  
    298. 

  298.  <h3>Function <code>map_list_of()</code> <a name="map_list_of"></h3>
    299. 

  299.  This function is defined for pure convenience when working with
    300. 

  300.  maps. Its usage is simple:
    301. 

  301.  <blockquote><pre>
    302. 

  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. 

  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. 

  304. </span><span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>map</span><span class=special>&gt;
    305. 

  305. </span><span class=keyword>using </span><span class=keyword>namespace </span><span class=identifier>std</span><span class=special>;
    306. 

  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. 

  307. </span><span class=special> 
    308. 

  308. </span><span class=special>{
    309. 

  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. 

  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. 

  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. 

  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. 

  313.     
    314. 

  314.     </span><span class=comment>// or we can use 'list_of()' by specifying what type
    315. 

  315.     // the list consists of
    316. 

  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. 

  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. 

  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. 

  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. 

  320. </span><span class=special>}   </span></pre></blockquote>
    321. 

  321. 

  322. The function <code>pair_list_of()</code> may also be used.
    323. 

  323. 

  324. <h3>Function <code>tuple_list_of()</code> <a name="tuple_list_of"></h3>
    325. 

  325. 

  326. If you are working with tuples, it might be convenient to use 
    327. 

  327. <code>tuple_list_of()</code>:
    328. 

  328. 

  329. 

  330. <blockquote>
    331. 

  331.     <pre>
    332. 

  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. 

  333. <span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>vector</span><span class=special>&gt;
    334. 

  334. </span>
    335. 

  335. <span class=keyword>using </span><span class=keyword>namespace </span><span class=identifier>std</span><span class=special>;</span>
    336. 

  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. 

  337. </span>
    338. 

  338. <span class=special>{
    339. 

  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. 

  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. 

  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. 

  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. 

  344. <span class=special>}</span>
    345. 

  345.     </pre>
    346. 

  346. </blockquote>
    347. 

  347. 

  348. <h3>Functions <code>repeat()</code>, <code>repeat_fun()</code> and <code>range()</code> <a name="repeat"></h3> 
    349. 

  349. <p>
    350. 

  350. Sometimes it is too irritating to repeat the same value many times. This is 
    351. 

  351. where <code>repeat()</code> can be handy:
    352. 

  352. <blockquote>
    353. 

  353.     <pre>
    354. 

  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. 

  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. 

  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. 

  357. </span>
    358. 

  358. <span class=keyword>using </span><span class=keyword>namespace </span><span class=identifier>std</span><span class=special>;</span>
    359. 

  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. 

  360. <span class=special> </span>
    361. 

  361. <span class=special>{
    362. 

  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. 

  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. 

  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. 

  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. 

  366.     
    367. 

  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. 

  368.     </span><span class=comment>// v = [1,2,2,2,2,2,3]
    369. 

  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. 

  370.     
    371. 

  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. 

  372.     </span><span class=comment>// v = old v + [1,2,3]
    373. 

  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. 

  374. <span class=special>}</span></pre>
    375. 

  375. </blockquote>
    376. 

  376. As we can see, then the first argument to <code>repeat()</code> is the number
    377. 

  377. of times to repeat the second argument.
    378. 

  378. </p>
    379. 

  379. <p>
    380. 

  380. A more general list can be constructed with <code>repeat_fun()</code>:
    381. 

  381. 

  382. <blockquote>
    383. 

  383.     <pre>
    384. 

  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. 

  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. 

  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. 

  387. </span>
    388. 

  388. <span class=keyword>using </span><span class=keyword>namespace </span><span class=identifier>std</span><span class=special>;</span>
    389. 

  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. 

  390. <span class=special> </span>
    391. 

  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. 

  392. <span class=keyword>struct </span><span class=identifier>next    </span>
    393. 

  393. <span class=special>{
    394. 

  394.     </span><span class=identifier>T </span><span class=identifier>seed</span><span class=special>;
    395. 

  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. 

  396.     </span><span class=special>{ </span><span class=special>}
    397. 

  397.     
    398. 

  398.     </span><span class=identifier>T </span><span class=keyword>operator</span><span class=special>()() </span><span class=keyword>
    399. 

  399.     </span><span class=special>{
    400. 

  400.         </span><span class=keyword>return </span><span class=identifier>seed</span><span class=special>++;
    401. 

  401.     </span><span class=special>}</span>
    402. 

  402. <span class=special>};</span>
    403. 

  403. <span class=special>     </span>
    404. 

  404. <span class=special>{
    405. 

  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. 

  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. 

  407.     </span><span class=comment>// v = [1,2,?,?,?,?,4] 
    408. 

  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. 

  409.     
    410. 

  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. 

  411.     </span><span class=comment>// v = old v + [0,1,2,3,4,5,6,7,8] 
    412. 

  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. 

  413. <span class=special>}</span>        </pre>
    414. 

  414. </blockquote>
    415. 

  415. The only requirement of the second argument to <code>repeat_fun()</code> is that 
    416. 

  416. it is a nullary function. </p>
    417. 

  417. 

  418. 

  419. <p>
    420. 

  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. 

  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. 

  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. 

  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. 

  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. 

  425. 

  426. <span class=keyword>using</span> <span class=keyword>namespace</span> <span class=identifier>std</span><span class=special>;</span>
    427. 

  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. 

  428.  
    429. 

  429. <span class=special>{</span>
    430. 

  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. 

  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. 

  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. 

  433.     <span class=comment>// v2 = [0,1,2,3,1,2,3,4]</span>
    434. 

  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. 

  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. 

  437.     <span class=comment>// v = [1,2,3,0,1,2,3,1,2,3,4,5]</span>
    438. 

  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. 

  439. 

  440.     <span class=comment>//
    441. 

  441.     // create a list of references, some coming from a container, others from the stack 
    442. 

  442.     //</span>
    443. 

  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. 

  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. 

  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. 

  446. <span class=special>}</span></pre>
    447. 

  447. </blockquote>
    448. 

  448. As you can see, one can also pass two iterators if that is more appropriate.
    449. 

  449. The last example also introduces list of references. More about that below.
    450. 

  450. </p>
    451. 

  451. 

  452. <h3>Functions <code>ref_list_of()</code> and <code>cref_list_of()</code> <a name="ref_list_of"></h3>
    453. 

  453. 

  454. When you need to create an anonymous range of values and speed is essential, 
    455. 

  455. these two functions provide what you want. <blockquote>
    456. 

  456.     <pre>
    457. 

  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. 

  458. <span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>algorithm</span><span class=special>&gt;
    459. 

  459. </span>
    460. 

  460. <span class=comment>//
    461. 

  461. // Define Range algorithm
    462. 

  462. //</span>
    463. 

  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. 

  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. 

  465. <span class=special>{
    466. 

  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. 

  467. <span class=special>}
    468. 

  468. </span>
    469. 

  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. 

  470. </span>
    471. 

  471. <span class=special>{
    472. 

  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. 

  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. 

  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. 

  475.     </span><span class=identifier>max </span><span class=special>= </span><span class=number>8</span><span class=special>;
    476. 

  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. 

  477.     </span><span class=keyword>const </span><span class=keyword>int</span><span 
    478. 

  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. 

  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. 

  480. <span class=special>}</span>
    481. 

  481.     </pre>
    482. 

  482. </blockquote>
    483. 

  483. 

  484. You can only use lvalues with <code>ref_list_of()</code> while 
    485. 

  485. <code>cref_list_of()</code> accepts rvalues too. Do not worry about not 
    486. 

  486. specifying exactly the right size; the extra space used is minimal and there 
    487. 

  487. is no runtime overhead associated with it.
    488. 

  488. 

  489. You may also use these functions instead of <code>list_of()</code> if speed is 
    490. 

  490. essential.
    491. 

  491. 

  492. <h3>A "complicated" example <a name="complicated"></h3>
    493. 

  493. <p> 
    494. 

  494. As a last example, let us assume that we need to keep track of the
    495. 

  495. result of soccer matches. A team will get one point if it wins 
    496. 

  496. and zero otherwise. If there has been played three games in each group, the code might look
    497. 

  497. like this:
    498. 

  498. 

  499. <blockquote>
    500. 

  500.     <pre>
    501. 

  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. 

  502. <span class=preprocessor>#include </span><span class=special>&lt;</span><span 
    503. 

  503. class=identifier>boost</span><span class=special>/</span><span 
    504. 

  504. class=identifier>assign</span><span class=special>/</span><span 
    505. 

  505. class=identifier>list_inserter</span><span class=special>.</span><span 
    506. 

  506. class=identifier>hpp</span><span class=special>&gt;</span>
    507. 

  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. 

  508. <span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>string</span><span class=special>&gt;</span>
    509. 

  509. <span class=preprocessor>#include </span><span class=special>&lt;</span><span class=identifier>vector</span><span class=special>&gt;
    510. 

  510. </span>
    511. 

  511. <span class=keyword>using </span><span class=keyword>namespace </span><span class=identifier>std</span><span class=special>;</span>
    512. 

  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. 

  513.  </span>
    514. 

  514. <span class=special>{
    515. 

  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. 

  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. 

  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. 

  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. 

  520.     
    521. 

  521.     </span><span class=comment>//
    522. 

  522.     // method 1: using 'insert()'
    523. 

  523.     //
    524. 

  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. 

  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. 

  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. 

  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. 

  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. 

  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. 

  530.     
    531. 

  531.     </span><span class=comment>//
    532. 

  532.     // method 2: using 'list_of()'
    533. 

  533.     //
    534. 

  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. 

  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. 

  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. 

  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. 

  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. 

  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. 

  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. 

  541. <span class=special>}</span>
    542. 

  542.     </pre>
    543. 

  543. </blockquote>
    544. 

  544. 

  545. In the first example, notice how the result of <code>list_of()</code>
    546. 

  546. can be converted automatically to a <code>vector&lt;int></code> because
    547. 

  547. <code>insert()</code> knows it expects a <code>vector&lt;int></code>.
    548. 

  548. In the second example we can see that <code>list_of()</code> is somewhat
    549. 

  549. less intelligent since here it needs to be told explicitly what arguments to
    550. 

  550. expect. (In the future it might be possible to introduce a more intelligent
    551. 

  551. conversion layer in <code>list_of()</code>.)
    552. 

  552. </p>
    553. 

  553. 

  554. <h3>Functions <code>ptr_push_back(), 
    555. 

  555. ptr_push_front()</code>, <code>ptr_insert()</code> and <code>ptr_map_insert()</code> <a name="ptr_push_back"></h3>
    556. 

  556. 

  557. For use with <a href="../../ptr_container/index.html">Boost.Pointer Container</a>
    558. 

  558. a few special exception-safe functions are provided. Using these function you
    559. 

  559. do not need to call <code>new</code> manually:
    560. 

  560. 

  561. 

  562. <blockquote>
    563. 

  563.     <pre>
    564. 

  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. 

  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. 

  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. 

  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. 

  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. 

  569. 

  570. <span class=comment>//
    571. 

  571. // Example class
    572. 

  572. //</span>
    573. 

  573. <span class=keyword>struct</span> <span class=identifier>Foo</span>
    574. 

  574. <span class=special>{</span>
    575. 

  575.     <span class=keyword>int</span> <span class=identifier>i</span><span class=special>;</span>
    576. 

  576.     
    577. 

  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. 

  578.     <span class=special>{</span> <span class=special>}</span>
    579. 

  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. 

  580.     <span class=special>{</span> <span class=special>}</span>
    581. 

  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. 

  582.     <span class=special>{</span> <span class=special>}</span>
    583. 

  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. 

  584.     <span class=special>{</span> <span class=special>}</span>
    585. 

  585. 

  586.     <span class=keyword>virtual</span> <span class=special>~</span><span class=identifier>Foo</span><span class=special>()</span>
    587. 

  587.     <span class=special>{}</span>
    588. 

  588. <span class=special>};</span>
    589. 

  589. 

  590. <span class=keyword>struct</span> <span class=identifier>Bar</span> <span class=special>:</span> <span class=identifier>Foo</span>
    591. 

  591. <span class=special>{</span>
    592. 

  592.     <span class=identifier>Bar</span><span class=special>()</span>
    593. 

  593.     <span class=special>{</span> <span class=special>}</span>
    594. 

  594.     
    595. 

  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. 

  596.     <span class=special>{</span> <span class=special>}</span>
    597. 

  597. <span class=special>};</span>
    598. 

  598. 

  599. <span class=comment>//
    600. 

  600. // Required by ptr_set&lt;Foo&gt;
    601. 

  601. //</span>
    602. 

  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. 

  603. <span class=special>{</span>
    604. 

  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. 

  605. <span class=special>}</span>
    606. 

  606. 

  607.  
    608. 

  608. <span class=keyword>using</span> <span class=keyword>namespace</span> <span class=identifier>boost</span><span class=special>;</span>
    609. 

  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. 

  610. 

  611. <span class=keyword>int</span> <span class=identifier>main</span><span class=special>()</span>
    612. 

  612. <span class=special>{</span>
    613. 

  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. 

  614.     <span class=identifier>ptr_push_back</span><span class=special>(</span> <span class=identifier>deq</span> <span class=special>)()();</span>
    615. 

  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. 

  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. 

  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. 

  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. 

  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. 

  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. 

  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. 

  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. 

  624.     <span class=identifier>ptr_insert</span><span class=special>(</span> <span class=identifier>a_set</span> <span class=special>)()()()();</span>
    625. 

  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. 

  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. 

  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. 

  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. 

  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. 

  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. 

  632. <span class=special>}</span>
    633. 

  633.     </pre>
    634. 

  634. </blockquote>
    635. 

  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. 

  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. 

  638. 

  639. <p>
    640. 

  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. 

  641. construct a key; this means that the first argument need only be convertible to the <code>key_type</code> of the container.
    642. 

  642. The rest of the arguments are used to construct the mapped object.
    643. 

  643. </p>
    644. 

  644.                         
    645. 

  645. <h3>Function <code>ptr_list_of()</code> <a name="ptr_list_of"></h3>         
    646. 

  646. 

  647. Just like you can use <code>list_of()</code> to initialize containers, you can 
    648. 

  648. use <code>ptr_list_of()</code> to initialize a <a href="../../ptr_container/index.html">pointer container</a>.
    649. 

  649. Here is a small example:
    650. 

  650. 

  651. <blockquote>
    652. 

  652.     <pre>
    653. 

  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. 

  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. 

  655. </span>
    656. 

  656. <span class=keyword>using </span><span class=keyword>namespace </span><span class=identifier>boost</span><span class=special>;</span>
    657. 

  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. 

  658. </span>
    659. 

  659. <span class=special>{
    660. 

  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. 

  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. 

  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. 

  663. <span class=special>}</span>    
    664. 

  664.     </pre>
    665. 

  665. </blockquote>
    666. 

  666. 

  667. Notice that a trailing <code>.to_container(deq)</code> may be added to help many poor 
    668. 

  668. compilers to figure out the conversion (a few get it right). 
    669. 

  669. Notice also that pointer maps are 
    670. 

  670. not supported.
    671. 

  671. 

  672. <p>
    673. 

  673. That is all; now you are ready to use this library.
    674. 

  674.  </p>
    675. 

  675. 

  676.   <hr> 
    677. 

  677.   <h2><a name="reference">Reference</a></h2>
    678. 

  678.     <p>
    679. 

  679.   It is worth noticing the way the library is implemented.
    680. 

  680.   A free-standing function (eg. <code>push_back()</code>
    681. 

  681.   or <code>operator+=()</code>) returns a proxy
    682. 

  682.   object which is responsible for the insertion or the assignment. The proxy 
    683. 

  683. object does the insertion or assignment by overloading <code>operator,()</code>
    684. 

  684.   and <code>operator()()</code> and by calling the "insert" function from within 
    685. 

  685.   those operators. The "insert" function is typically stored in the proxy object 
    686. 

  686.   by using <code>boost::<a href="../../function/index.html">function</a></code>. </p>
    687. 

  687.   
    688. 

  688.   <p>
    689. 

  689.   Often overloading
    690. 

  690.   of <code>operator,()</code> is discouraged because it can lead to surprising
    691. 

  691.   results, but the approach taken in this library is safe since the
    692. 

  692.   user never deals with objects that have overloaded <code>operator,()</code>
    693. 

  693.   directly. However, you should be aware of this:
    694. 

  694.   </p>
    695. 

  695.   
    696. 

  696.   <p><i>
    697. 

  697.   The 
    698. 

  698.   expressions in a comma-separated list no longer follow the rules of the 
    699. 

  699.   built-in comma-operator. This means that the order of evaluation of 
    700. 

  700.   expressions in a comma-separated list is undefined like when one specifies 
    701. 

  701.   a list of function arguments.
    702. 

  702.   </i></p>
    703. 

  703.   
    704. 

  704.     <p>
    705. 

  705.   Most of the code in this document use <code>int</code> in the examples, 
    706. 

  706.   but of course it works for arbitrary types as long as they are 
    707. 

  707.   Copy Constructible. The inserted data need not be constant data,
    708. 

  708.   but can be variables or data returned from functions; the only requirement 
    709. 

  709.   is that the type of the data is convertible to the type stored in the 
    710. 

  710.   container. 
    711. 

  711.   </p>
    712. 

  712.   
    713. 

  713.   <p>
    714. 

  714.   All forwarding is done by passing objects by <code>const</code> reference. 
    715. 

  715. Originally arguments were passed by value (and still is in 
    716. 

  716. <code>tuple_list_of()</code>). One thing to remember is that references
    717. 

  717.   can be passed by using <code>boost::<a href="http://www.boost.org/doc/html/ref.html">ref</a></code>.
    718. 

  718.   </p>
    719. 

  719.   
    720. 

  720.   <p>
    721. 

  721.    Everything is put in namespace 
    722. 

  722.   <code>boost::assign</code>. </p>
    723. 

  723. 

  724.   <p> More details can be found below: </p>
    725. 

  725.       <ul>
    726. 

  726.           
    727. 

  727.         <li><a href="#headers">Headers</a> </li>
    728. 

  728.         <li><a href="#std">Standard containers</a> </li>
    729. 

  729.         <li>Functions <a href="#list_of_ref"><code>list_of()</code> and <code>map_list_of()</code></a></li>
    730. 

  730.         <li>Functions <a href="#repeat_ref"><code>repeat()</code>,<code>repeat_fun()</code> and 
    731. 

  731.                                                                       <code>range()</code>
    732. 

  732.                                                                       </a></li>
    733. 

  733.         <li>Class <a href="#list_inserter"><code>list_inserter</code></a></li>
    734. 

  734.         <li>Function <a href="#make_list_inserter"><code>make_list_inserter()</code></a></li>
    735. 

  735.         <li><a href="#limit">Customizing</a> argument list sizes </li>
    736. 

  736.      </ul>
    737. 

  737.   <h3>Headers <a name="headers"></h3>      
    738. 

  738.   
    739. 

  739.   <p>
    740. 

  740.   An overview of the headers in this library 
    741. 

  741. is given below. Please notice <code>&lt;boost/assign/list_inserter.hpp></code> 
    742. 

  742. is included for each header that defines <code>operator+=()</code>.</p>
    743. 

  743. 

  744. <table cellpadding=5 border=1 > <tr>
    745. 

  745.          <th>  Header                      </th>
    746. 

  746.          <th>        Includes              </th> 
    747. 

  747.      <tr>
    748. 

  748.          <td> &lt;boost/assign.hpp>               </td>
    749. 

  749.          <td>     everything except support for pointer containers  </td>
    750. 

  750.      <tr>
    751. 

  751.          <td> &lt;boost/assign/list_of.hpp>       </td>
    752. 

  752.          <td> <a href="#list_of"><code>list_of()</a>, <a 
    753. 

  753. href="#map_list_of">map_list_of()</code></a>, 
    754. 

  754.          <a href="#tuple_list_of">tuple_list_of()</code></a>,
    755. 

  755.          <a href="#ref_list_of">ref_list_of()</code> and 
    756. 

  756. <code>cref_list_of()</code></a>
    757. 

  757.                   
    758. 

  758.          </td> <tr>
    759. 

  759.          <td> &lt;boost/assign/std.hpp>       </td>
    760. 

  760.          <td> <a href="#operator+="><code>operator+=()</code></a> for all 
    761. 

  761. standard
    762. 

  762. containers (see below)</td> <tr> <td>  &lt;boost/assign/std/deque.hpp> </td>
    763. 

  763.         <td>  <code>operator+=()</code> for 
    764. 

  764.               <code>std::deque</code>, <code>&lt;deque></code> 
    765. 

  765.     <tr> 
    766. 

  766.         <td>  &lt;boost/assign/std/list.hpp> </td>
    767. 

  767.         <td>  <code>operator+=()</code> for 
    768. 

  768.               <code>std::list</code>, <code>&lt;list></code>  
    769. 

  769.     <tr> 
    770. 

  770.         <td>  &lt;boost/assign/std/map.hpp> </td>
    771. 

  771.         <td>  <code>operator+=()</code> for 
    772. 

  772.               <code>std::map</code> and <code>std::multimap</code> , 
    773. 

  773. <code>&lt;map></code> <tr> 
    774. 

  774.         <td>  &lt;boost/assign/std/queue.hpp> </td>
    775. 

  775.         <td>  <code>operator+=()</code> for 
    776. 

  776.               <code>std::queue</code> and <code>std::priority_queue</code>, 
    777. 

  777. <code>&lt;queue></code> <tr> 
    778. 

  778.         <td>  &lt;boost/assign/std/set.hpp> </td>
    779. 

  779.         <td>  <code>operator+=()</code> for 
    780. 

  780.               <code>std::set</code> and <code>std::multiset</code>, 
    781. 

  781. <code>&lt;set></code> <tr> 
    782. 

  782.         <td>  &lt;boost/assign/std/slist.hpp> </td>
    783. 

  783.         <td>  <code>operator+=()</code> for 
    784. 

  784.               <code>std::slist</code> if the class is available , 
    785. 

  785. <code>&lt;slist></code> <tr> 
    786. 

  786.         <td>  &lt;boost/assign/std/stack.hpp> </td>
    787. 

  787.         <td>  <code>operator+=()</code> for 
    788. 

  788.               <code>std::stack</code>, <code>&lt;stack></code>  
    789. 

  789.     <tr> 
    790. 

  790.         <td>  &lt;boost/assign/std/vector.hpp> </td>
    791. 

  791.         <td>  <code>operator+=()</code> for 
    792. 

  792.               <code>std::vector</code>, <code>&lt;vector></code>  
    793. 

  793.     <tr> 
    794. 

  794.         <td>  &lt;boost/assign/assignment_exception.hpp> </td>
    795. 

  795.         <td>  Class <a 
    796. 

  796. href="#assignment_exception"><code>assignment_exception</code></a> which might 
    797. 

  797. be thrown by the proxy returned by <code>list_of()</code>
    798. 

  798.     <tr> 
    799. 

  799.         <td>  &lt;boost/assign/list_inserter.hpp> </td>
    800. 

  800.             <td>Functions <a
    801. 

  801.                href="#make_list_inserter"><code>make_list_inserter()</code></a>, <code>push_back()</code>,
    802. 

  802.                 <code>push_front()</code>,<code>insert()</code>,
    803. 

  803.                 <code>
    804. 

  804.                 push()</code> and class <a href="#list_inserter"><code>list_inserter</code></a> 
    805. 

  805.                 which is the back-bone of this entire library.
    806. 

  806. 

  807.             <tr>    
    808. 

  808.             <td>  &lt;boost/assign/ptr_list_inserter.hpp> </td>
    809. 

  809.             <td>Functions <a href="#ptr_push_back"><code>ptr_push_back()</code></a>,
    810. 

  810.                 <code>ptr_push_front()</code> and <code>ptr_insert()</code>
    811. 

  811.                  
    812. 

  812.             <tr>    
    813. 

  813.             <td>  &lt;boost/assign/ptr_map_inserter.hpp> </td>
    814. 

  814.             <td>Functions <a href="#ptr_push_back"><code>ptr_map_insert()</code></a>
    815. 

  815.     
    816. 

  816.                             <tr>    
    817. 

  817.             <td>  &lt;boost/assign/ptr_list_of.hpp> </td>             
    818. 

  818.             <td>Function <a href="#ptr_list_of"><code>ptr_list_of()</code></a>
    819. 

  819. 

  820.     </table>
    821. 

  821.   
    822. 

  822.   <h3>Standard containers <a name="std"> </h3>
    823. 

  823.    <p> In the following three dots (...) will mean
    824. 

  824.        implementation defined.  
    825. 

  825.        <code>operator+=()</code> returns a proxy that forwards calls to either
    826. 

  826.        <code>push_back()</code>,<code>insert()</code>, or <code>push()</code>  
    827. 

  827.        depending on which operation the container supports. </p> <b>Synopsis</b>
    828. 

  828.   <p>
    829. 

  829. <blockquote>
    830. 

  830. <pre>
    831. 

  831. <span class=keyword>namespace </span><span class=identifier>boost</span>
    832. 

  832. <span class=special>{</span>
    833. 

  833. <span class=keyword>namespace </span><span class=identifier>assign</span>
    834. 

  834. <span class=special>{
    835. 

  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. 

  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. 

  837.     
    838. 

  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. 

  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. 

  840.     
    841. 

  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. 

  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. 

  843.     
    844. 

  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. 

  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. 

  846.     
    847. 

  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. 

  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. 

  849.     
    850. 

  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. 

  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. 

  852.     
    853. 

  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. 

  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. 

  855.     
    856. 

  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. 

  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. 

  858.     
    859. 

  859.     </span><span class=preprocessor>#ifdef </span><span class=identifier>BOOST_HAS_SLIST
    860. 

  860.               
    861. 

  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. 

  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. 

  863.     
    864. 

  864.     </span><span class=preprocessor>#endif
    865. 

  865.     
    866. 

  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. 

  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. 

  868.     
    869. 

  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. 

  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. 

  871. 

  872. <span class=special>} </span><span class=comment>// namespace 'assign'</span>
    873. 

  873. <span class=special>} </span><span class=comment>// namespace 'boost'</span>  </pre></blockquote>
    874. 

  874.     Note that the extra template argument <code>V2</code> etc. is 
    875. 

  875.     necessary to allow for types convertible to <code>V</code>.   
    876. 

  876.      
    877. 

  877.   <h3>Functions <code>list_of()</code> and 
    878. 

  878.       <code>map_list_of()</code> <a name="list_of_ref"> </h3>
    879. 

  879.     <p>  
    880. 

  880.   These two functions are used to construct anonymous    
    881. 

  881.   list which can be converted to any standard container
    882. 

  882.   and <code>boost::<a href="../../array/index.html">array</a>&lt;T,sz>.</code> 
    883. 

  883. The object returned by the two
    884. 

  884.   functions is guaranteed to have the interface described below. 
    885. 

  885.   </p>
    886. 

  886.   <b>Synopsis</b>
    887. 

  887.   <blockquote>  
    888. 

  888.   <pre><span class=keyword>namespace </span><span class=identifier>boost  </span>
    889. 

  889. <span class=special>{</span>
    890. 

  890. <span class=keyword>namespace </span><span class=identifier>assign</span>
    891. 

  891. <span class=special>{
    892. 

  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. 

  893.     </span><span class=keyword>class </span><span class=identifier>Implementation</span><span class=special>-</span><span class=identifier>defined</span>
    894. 

  894.     </span><span class=special>{
    895. 

  895.     </span><span class=keyword>public</span><span class=special>:
    896. 

  896.         </span><span class=identifier>const_iterator  </span><span class=identifier>begin</span><span class=special>() <span class=keyword>const</span>;
    897. 

  897.         </span><span class=identifier>const_iterator  </span><span class=identifier>end</span><span class=special>() <span class=keyword>const</span>;
    898. 

  898.         
    899. 

  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. 

  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. 

  901.         
    902. 

  902.         </span><span class=comment>// inserts default-constructed object
    903. 

  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. 

  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. 

  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. 

  907.         
    908. 

  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. 

  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. 

  910. 

  911.         </span><span class=comment>//
    912. 

  912.         // and similarly up to 5 arguments
    913. 

  913.         //
    914. 

  914.         
    915. 

  915.         //
    916. 

  916.         // Convert to a 'Container'. 'Container' must have a constructor 
    917. 

  917.         // which takes two iterators.  
    918. 

  918.         //
    919. 

  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. 

  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. 

  921. 

  922.         </span><span class=comment>//
    923. 

  923.         // Convert to a container adapter like 'std::stack&lt;&gt;'.
    924. 

  924.         //
    925. 

  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. 

  926.         
    927. 

  927.         </span><span class=comment>//
    928. 

  928.         //
    929. 

  929.         // Convert to eg. 'boost::array&lt;T,std::size_t&gt;'. If the  
    930. 

  930.         // assigned variable is too small, 
    931. 

  931.         // a <a href="#assignment_exception">assignment_exception</a> is thrown.
    932. 

  932.         // If the assigned variable it is too big, the rest of the 
    933. 

  933.         // values are  default-constructed.
    934. 

  934.         //
    935. 

  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. 

  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. 

  937.     </span><span class=special>};</span>
    938. 

  938.     
    939. 

  939.     <span class=comment>//
    940. 

  940.     // Comparison operators. 'op' can be &lt;,&gt;,&lt;=,&gt;=,==,!=
    941. 

  941.     //</span>
    942. 

  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. 

  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. 

  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. 

  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. 

  946.     
    947. 

  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. 

  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. 

  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. 

  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. 

  952.     
    953. 

  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. 

  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. 

  955.     
    956. 

  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. 

  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. 

  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. 

  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. 

  961.   
    962. 

  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. 

  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. 

  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. 

  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. 

  967.     </span><span class=special>{
    968. 

  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. 

  969.     </span><span class=special>}</span>
    970. 

  970. <span class=special>} </span><span class=comment>// namespace 'assign'</span>
    971. 

  971. <span class=special>} </span><span class=comment>// namespace 'boost'</span>  </pre></blockquote>
    972. 

  972. 

  973. 

  974.   <h3>Functions <code>repeat()</code>, 
    975. 

  975.      <code>repeat_fun()</code> and <code>range()</code> <a name="repeat_ref"> </h3>
    976. 

  976.   <p>
    977. 

  977.             These first two function exist both as free-standing functions and as member functions of the object returned by 
    978. 

  978.       <code>list_of()</code> and of <code>list_inserter</code>. 
    979. 

  979.       The free-standing versions are used to create a
    980. 

  980.       hook for <code>operator,()</code> so we can call the functions in the middle of a comma-list. The member functions
    981. 

  981.       are used when we need to call the functions in the middle of a parenthesis-list. In both cases we have that
    982. 

  982.       <ul>
    983. 

  983.           <li> the return type is always implementation defined for both functions, 
    984. 

  984.           <li> the argument list of <code>repeat()</code> is <code>(std::size_t,T)</code>, and  
    985. 

  985.           <li> the argument list of <code>repeat_fun()</code> is <code>(std::size_t,Nullary_function)</code>    
    986. 

  986.       </ul>
    987. 

  987.       
    988. 

  988.         </p>
    989. 

  989.   <p>
    990. 

  990.   The function <code>range()</code> only exists as a member function. The following two overloads are provided:
    991. 

  991.   <blockquote>
    992. 

  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. 

  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. 

  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. 

  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. 

  997.   </blockquote>
    998. 

  998. 

  999.   </p>
    1000. 

  1000.       
    1001. 

  1001.   <h3><a name="list_inserter">Class <code>list_inserter</code></a></h3> 
    1002. 

  1002.   
    1003. 

  1003.   This class is responsible for inserting elements into containers and 
    1004. 

  1004.   it is the key to extending the library to support your favourite class.
    1005. 

  1005. 

  1006.     <p>
    1007. 

  1007.   <b>Synopsis</b> 
    1008. 

  1008.   </p>
    1009. 

  1009.   <blockquote><pre>
    1010. 

  1010. <span class=keyword>namespace </span><span class=identifier>boost</span>
    1011. 

  1011. <span class=special>{</span>
    1012. 

  1012. <span class=keyword>namespace </span><span class=identifier>assign</span>
    1013. 

  1013. <span class=special>{
    1014. 

  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. 

  1015.     </span><span class=keyword>class </span><span class=identifier>list_inserter
    1016. 

  1016.     </span><span class=special>{
    1017. 

  1017.         </span><span class=identifier>Function </span><span class=identifier>fun</span><span class=special>;
    1018. 

  1018.         
    1019. 

  1019.     </span><span class=keyword>public</span><span class=special>:
    1020. 

  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. 

  1021.         
    1022. 

  1022.         </span><span class=comment>// conversion constructor
    1023. 

  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. 

  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. 

  1025.         
    1026. 

  1026.     </span><span class=keyword>public</span><span class=special>:
    1027. 

  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. 

  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. 

  1029.         
    1030. 

  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. 

  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. 

  1032.         
    1033. 

  1033.         </span><span class=comment>// calls 'fun()' with default-constructed object
    1034. 

  1034.         </span><span class=identifier>list_inserter</span><span class=special>&amp; </span><span class=keyword>operator</span><span class=special>()();
    1035. 

  1035.         
    1036. 

  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. 

  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. 

  1038.         
    1039. 

  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. 

  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. 

  1041.         </span><span class=special>{
    1042. 

  1042.            </span><span class=comment>//
    1043. 

  1043.            // if 'Argument' is 'void'
    1044. 

  1044.            //     fun( u, u2 );
    1045. 

  1045.            // else
    1046. 

  1046.            //     fun( Argument( u, u2 ) );
    1047. 

  1047.            //
    1048. 

  1048.            </span><span class=keyword>return </span><span class=special>*</span><span class=keyword>this</span><span class=special>;
    1049. 

  1049.         </span><span class=special>}
    1050. 

  1050. 

  1051.         </span><span class=comment>//
    1052. 

  1052.         // similarly up to 5 arguments
    1053. 

  1053.         //
    1054. 

  1054.     </span><span class=special>};</span>
    1055. 

  1055.     
    1056. 

  1056.     <span class=keyword>template</span><span class=special>&lt; </span><span 
    1057. 

  1057. class=keyword>class </span><span class=identifier>C </span><span class=special>&gt;
    1058. 

  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. 

  1059.       
    1060. 

  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. 

  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. 

  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. 

  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. 

  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. 

  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. 

  1068.       
    1069. 

  1069. <span class=special>} </span><span class=comment>// namespace 'assign'</span>
    1070. 

  1070. <span class=special>} </span><span class=comment>// namespace 'boost'</span></pre></blockquote>
    1071. 

  1071.   <p>
    1072. 

  1072.   Notice how the arguments to <code>operator,()</code> and 
    1073. 

  1073.   <code>operator()()</code> are passed differently to 
    1074. 

  1074.   <code>fun</code> depending of the type of <code>Argument</code>. 
    1075. 

  1075.   So if we only pass one template argument to <code>list_inserter,</code>
    1076. 

  1076.   we can forward "arbitrary" argument lists of functions. If we pass
    1077. 

  1077.   two template arguments to <code>list_inserter</code> we can 
    1078. 

  1078.   construct types with "arbitrary" constructors.
    1079. 

  1079.   </p> 
    1080. 

  1080.    
    1081. 

  1081.   <p> 
    1082. 

  1082.    And because
    1083. 

  1083.   a reference to <code>list_inserter</code> is returned, we can
    1084. 

  1084.   chain argument list together in a very space-efficient manner.
    1085. 

  1085.   </p>
    1086. 

  1086. 

  1087.   <h3><a name="make_list_inserter">Function <code>make_list_inserter()</code></a></h3>
    1088. 

  1088.   <p>
    1089. 

  1089.   A simple "constructor" function for <code>list_inserter</code>. A typical 
    1090. 

  1090.   use of this function is to call it with the result of 
    1091. 

  1091. <code>boost::bind()</code>
    1092. 

  1092.   which in general returns some unreadable and weird class template.
    1093. 

  1093.   </p>
    1094. 

  1094.   <b>Synopsis</b>
    1095. 

  1095.   <blockquote><pre>
    1096. 

  1096. <span class=keyword>namespace </span><span class=identifier>boost </span>
    1097. 

  1097. <span class=special>{</span>
    1098. 

  1098. <span class=keyword>namespace </span><span class=identifier>assign</span>
    1099. 

  1099. <span class=special>{  
    1100. 

  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. 

  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. 

  1102.     </span><span class=special>{
    1103. 

  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. 

  1104.     </span><span class=special>} </span>
    1105. 

  1105. <span class=special>}</span>
    1106. 

  1106. <span class=special>}  </span>  </pre></blockquote>
    1107. 

  1107. 

  1108.    <a name="limit"></a>   
    1109. 

  1109.    <h3>Customizing argument list sizes</h3>   
    1110. 

  1110.       <p>
    1111. 

  1111.     This library uses the boost Preprocessor Library to implement overloaded 
    1112. 

  1112.     versions of <code>operator()()</code> and <code>list_of()</code>. By default you 
    1113. 

  1113.     can call these functions with five arguments, but you can also customize this 
    1114. 

  1114.     number by defining a macros before including a header from this library:
    1115. 

  1115.        <blockquote>
    1116. 

  1116.        <pre>
    1117. 

  1117. <span class=preprocessor>#define </span><span class=identifier>BOOST_ASSIGN_MAX_PARAMS </span><span class=number>10
    1118. 

  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. 

  1119. </pre>
    1120. 

  1120.        </blockquote>      
    1121. 

  1121.        </p>
    1122. 

  1122.   <hr>    
    1123. 

  1123.   <h2><a name="exceptions">Exceptions and exception-safety</a></h2>
    1124. 

  1124.   <p>
    1125. 

  1125.   The exception guarantees by the library is the same as guarantee as the 
    1126. 

  1126.   guarantee of the function that is forwarded to. For standard 
    1127. 

  1127.   containers this means that the
    1128. 

  1128.   strong guarantee is given for a single insertions and that the basic guarantee 
    1129. 

  1129.   is given for many insertions (provided that the object being copied 
    1130. 

  1130.   gives the basic guarantee). 
    1131. 

  1131.   </p>
    1132. 

  1132.   <p>
    1133. 

  1133.   The functions may throw standard exceptions
    1134. 

  1134.   like <code>std::bad_alloc</code>. Note however that, unfortunately, the standard does not guarantee allocation-failures
    1135. 

  1135.   in standard containers to be reported by <code>std::bad_alloc</code> or exceptions derived from <code>std::exception</code>.
    1136. 

  1136.  </p>
    1137. 

  1137.   
    1138. 

  1138.   <h3><a name="assignment_exception">Class 
    1139. 

  1139.   <code>assignment_exception</code></a></h3>
    1140. 

  1140.   <p>
    1141. 

  1141.    The exception is thrown by the conversion operator in the proxy object
    1142. 

  1142.    returned from <code>list_of()</code>.
    1143. 

  1143.   </p>
    1144. 

  1144. 

  1145.   <blockquote><pre>
    1146. 

  1146. <span class=keyword>namespace </span><span class=identifier>boost </span>
    1147. 

  1147. <span class=special>{</span>
    1148. 

  1148. <span class=keyword>namespace </span><span class=identifier>assign</span>
    1149. 

  1149. <span class=special>{
    1150. 

  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. 

  1151.     </span><span class=special>{
    1152. 

  1152.     </span><span class=keyword>public</span><span class=special>:
    1153. 

  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. 

  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. 

  1155.     </span><span class=special>};</span>
    1156. 

  1156. <span class=special>}   </span>
    1157. 

  1157. <span class=special>}</span>  </pre></blockquote> 
    1158. 

  1158. 

  1159.   <hr>
    1160. 

  1160.   <h2><a name="extensions">Extending the library</a></h2> 
    1161. 

  1161.   <p>
    1162. 

  1162.   It is very simple to make the library work with new classes. 
    1163. 

  1163.   This code shows how to use <code>operator+=()</code> with 
    1164. 

  1164.   a container:
    1165. 

  1165.   <blockquote><pre>
    1166. 

  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. 

  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. 

  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. 

  1169. </span><span class=special>{
    1170. 

  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. 

  1171. </span><span class=special>}
    1172. 

  1172. </span></pre>
    1173. 

  1173. </blockquote>      
    1174. 

  1174. 

  1175. 

  1176. where <code>call_push_back</code> is defined as    
    1177. 

  1177.       
    1178. 

  1178. <blockquote>      
    1179. 

  1179. <pre>
    1180. 

  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. 

  1181. </span><span class=keyword>class </span><span class=identifier>call_push_back
    1182. 

  1182. </span><span class=special>{
    1183. 

  1183.     </span><span class=identifier>C</span><span class=special>&amp; </span><span class=identifier>c_</span><span class=special>;
    1184. 

  1184. </span><span class=keyword>public</span><span class=special>:
    1185. 

  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. 

  1187.     </span><span class=special>{ </span><span class=special>}
    1188. 

  1188.     
    1189. 

  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. 

  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. 

  1191.     </span><span class=special>{
    1192. 

  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. 

  1193.     </span><span class=special>}
    1194. 

  1194. </span><span class=special>};</span></pre>    
    1195. 

  1195. </blockquote>
    1196. 

  1196.       
    1197. 

  1197.       Note that we pass
    1198. 

  1198.   a second template argument to <code>list_inserter</code> so argument 
    1199. 

  1199.   lists will be used to construct a <code>V</code> object. Otherwise we
    1200. 

  1200.   could end up trying to call <code>push_back()</code> with <i>n</i> arguments 
    1201. 

  1201.   instead of one.
    1202. 

  1202.   </p>
    1203. 

  1203.       
    1204. 

  1204.   <p>    
    1205. 

  1205.   An alternative way would be to use <code>boost::function</code> and 
    1206. 

  1206.   <code>boost::bind()</code> in combination. However, in this case one must
    1207. 

  1207.   remember that it is illegal to take the address of a function in
    1208. 

  1208.   the standard library.
    1209. 

  1209.   </p>
    1210. 

  1210.       
    1211. 

  1211.   <p>
    1212. 

  1212.   Calling a function with more that one argument can be
    1213. 

  1213.   very useful too. This small example shows how we take advantage of this 
    1214. 

  1214.   functionality:
    1215. 

  1215.   </p>
    1216. 

  1216.   <blockquote><pre>
    1217. 

  1217. <span class=comment>//  
    1218. 

  1218. // A class representing emails
    1219. 

  1219. //</span>
    1220. 

  1220. <span class=keyword>class </span><span class=identifier>email</span>
    1221. 

  1221. <span class=special>{</span>
    1222. 

  1222. <span class=keyword>public</span><span class=special>:
    1223. 

  1223.     </span><span class=keyword>enum </span><span class=identifier>address_option
    1224. 

  1224.     </span><span class=special>{
    1225. 

  1225.         </span><span class=identifier>check_addr_book</span><span class=special>,
    1226. 

  1226.         </span><span class=identifier>dont_check_addr_book
    1227. 

  1227.     </span><span class=special>};
    1228. 

  1228.     </span>
    1229. 

  1229. <span class=keyword>private</span><span class=special>:
    1230. 

  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. 

  1232.     
    1233. 

  1233.     </span><span class=comment>//
    1234. 

  1234.     // Store list of persons that must be cc'ed
    1235. 

  1235.     //
    1236. 

  1236.     </span><span class=keyword>mutable </span><span class=identifier>address_map </span><span class=identifier>cc_list</span><span class=special>;
    1237. 

  1237.         
    1238. 

  1238.     </span><span class=comment>//
    1239. 

  1239.     // This extra function-object will take care of the 
    1240. 

  1240.     // insertion for us. It stores a reference to a 
    1241. 

  1241.     // map and 'operator()()' does the work. 
    1242. 

  1242.     //
    1243. 

  1243.     </span><span class=keyword>struct </span><span class=identifier>add_to_map
    1244. 

  1244.     </span><span class=special>{
    1245. 

  1245.         </span><span class=identifier>address_map</span><span class=special>&amp; </span><span class=identifier>m</span><span class=special>;
    1246. 

  1246.     
    1247. 

  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. 

  1248.         </span><span class=special>{}
    1249. 

  1249.     
    1250. 

  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. 

  1251.         </span><span class=special>{
    1252. 

  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. 

  1253.         </span><span class=special>}
    1254. 

  1254.     </span><span class=special>};
    1255. 

  1255. </span>
    1256. 

  1256. <span class=keyword>public</span><span class=special>:
    1257. 

  1257.     
    1258. 

  1258.     </span><span class=comment>//
    1259. 

  1259.     // This function constructs the appropriate 'list_inserter'.
    1260. 

  1260.     // Again we could have use 'boost::function', but it is
    1261. 

  1261.     // trivial to use a function object.
    1262. 

  1262.     //
    1263. 

  1263.     // Notice that we do not specify an extra template
    1264. 

  1264.     // parameter to 'list_inserter'; this means we forward
    1265. 

  1265.     // all parameters directly to the function without 
    1266. 

  1266.     // calling any constructor.
    1267. 

  1267.     //
    1268. 

  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. 

  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. 

  1270.     </span><span class=special>{
    1271. 

  1271.         </span><span class=comment>//
    1272. 

  1272.         // Notice how we pass the arguments 'name' and 'ao' to
    1273. 

  1273.         // the 'list_inserter'.
    1274. 

  1274.         //
    1275. 

  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. 

  1276.     </span><span class=special>}</span>
    1277. 

  1277. <span class=special>};
    1278. 

  1278. </span>
    1279. 

  1279. <span class=comment>//
    1280. 

  1280. // Now we can use the class like this:
    1281. 

  1281. //</span>
    1282. 

  1282. <span class=identifier>email </span><span class=identifier>e</span><span class=special>;</span>
    1283. 

  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. 

  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. 

  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. 

  1286. </pre></blockquote>
    1287. 

  1287.       
    1288. 

  1288.    
    1289. 

  1289.   The full example can be seen in <a href="email_example.html">email_example.cpp</a> </p>
    1290. 

  1290.   <hr>
    1291. 

  1291.   <h2>Examples <a name="examples"></h2>
    1292. 

  1292.   <p>
    1293. 

  1293.   Additional examples can be found in the test files:
    1294. 

  1294.   <ul>
    1295. 

  1295.       <li> <a href="email_example.html">email_example.cpp</a>          
    1296. 

  1296.       <li> <a href="my_vector_example.html">my_vector_example.cpp</a>               
    1297. 

  1297.       <li> <a href="multi_index_container.html">multi_index_container.cpp</a> 
    1298. 

  1298.       <li> <a href="../test/array.cpp">array.cpp</a>      
    1299. 

  1299.       <li> <a href="../test/list_of.cpp">list_of.cpp</a>      
    1300. 

  1300.       <li> <a href="../test/std.cpp">std.cpp</a>      
    1301. 

  1301.       <li> <a href="../test/list_inserter.cpp">list_inserter.cpp</a>      
    1302. 

  1302.       <li> <a href="../test/list_of_workaround.cpp">list_of_work_around.cpp</a>      
    1303. 

  1303. </ul> </p>
    1304. 

  1304.   
    1305. 

  1305.   
    1306. 

  1306.   <hr>
    1307. 

  1307.   <h2><a name="boost_libs">Supported libraries</a></h2> 
    1308. 

  1308.   Here is a list libraries has been tested with Boost.Assign:
    1309. 

  1309.   
    1310. 

  1310.   <ol>
    1311. 

  1311.       <li> <code>boost::<a href="../../array/index.html">array</a></code>
    1312. 

  1312.       <li> <code>boost::<a href="../../multi_index/index.html">multi_index_container</a></code>
    1313. 

  1313.       <li> <code>Boost.<a href="../../ptr_container/index.html">Pointer Container</code> </ol> <p>
    1314. 

  1314. 

  1315.   </p>
    1316. 

  1316.   
    1317. 

  1317.   
    1318. 

  1318.   <hr>
    1319. 

  1319.   <h2><a name="portability">Portability</a></h2>
    1320. 

  1320.   <p>
    1321. 

  1321.     Library has been successfully compiled and tested with
    1322. 

  1322.     MVC++ 7.1, GCC 3.2 (under Cygwin) Comeau 4.3.3
    1323. 

  1323.   </p>
    1324. 

  1324.   <p>
    1325. 

  1325.     There are known limitation on platforms not supporting templated 
    1326. 

  1326.     conversion operators. The solution is to call certain member functions on 
    1327. 

  1327.     the object returned by <code>list_of()</code>: </p>
    1328. 

  1328.  <blockquote>
    1329. 

  1329.      <pre>
    1330. 

  1330. <span class=special>{
    1331. 

  1331.     </span><span class=keyword>using </span><span class=keyword>namespace </span><span class=identifier>std</span><span class=special>;
    1332. 

  1332.     </span><span class=keyword>using </span><span class=keyword>namespace </span><span class=identifier>boost</span><span class=special>;
    1333. 

  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. 

  1334.     
    1335. 

  1335.     </span><span class=keyword></span><span 
    1336. 

  1336. class=identifier>vector</span><span
    1337. 

  1337. class=special>&lt;</span><span class=keyword>int</span><span 
    1338. 

  1338. class=special>&gt;</span>         <span class=identifier>v </span><span 
    1339. 

  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. 

  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. 

  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. 

  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. 

  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. 

  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. 

  1345. <span class=special>}</span>     </pre>
    1346. 

  1346.  </blockquote>
    1347. 

  1347.  <p>
    1348. 

  1348.  Notice how one must supply the functions with an argument so the right
    1349. 

  1349.  return type can be deduced.
    1350. 

  1350.  </p>
    1351. 

  1351.  <p>Some standard libraries are also broken. One problem is that 
    1352. 

  1352. <code>insert()</code> might not work:
    1353. 

  1353. <blockquote>
    1354. 

  1354.     <pre>
    1355. 

  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. 

  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. 

  1357. </blockquote>
    1358. 

  1358. The solution is to use <code>map_list_of()</code> instead:
    1359. 

  1359. <blockquote>
    1360. 

  1360.     <pre>
    1361. 

  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. 

  1362. </p>
    1363. 

  1363.  <hr>
    1364. 

  1364.   <h2><a name="history">History and Acknowledgment</a></h2>
    1365. 

  1365.   <p>
    1366. 

  1366.   The idea for an assignment/initialization library is not new. The 
    1367. 

  1367.   functionality of this
    1368. 

  1368.   library resembles Leor Zolman's STL Container Initialization Library a great 
    1369. 

  1369.   deal, but it does not rely on string parsing to achieve its goals. 
    1370. 

  1370.   </p> 
    1371. 

  1371.   <p>
    1372. 

  1372.   The  
    1373. 

  1373.   library is non-intrusive and puts only a minimum of requirements 
    1374. 

  1374.   on its supported classes.
    1375. 

  1375.  Overloading operator comma is sometimes viewed as a bad practice <a 
    1376. 

  1376. href="#meyers">[1]</A>. However, it has been done
    1377. 

  1377.   with success in eg. the Generative Matrix Computation Library  and Blitz to initialize matrices 
    1378. 

  1378.       (see <a href="#gmcl">[2]</A>) and <a href="#blitz">[3]</A>). The 
    1379. 

  1379. Initialization Library overloads
    1380. 

  1380.       the comma operator in a safe manner by letting free standing functions
    1381. 

  1381.  return an object that is responsible for the initialization. Therefore it takes 
    1382. 

  1382. explicit
    1383. 

  1383.       action from the programmer to begin using the overloaded <code>operator,()</CODE>.
    1384. 

  1384.   </p>
    1385. 

  1385.   <p>
    1386. 

  1386.   There has recently been some discussion about enhancing the language to 
    1387. 

  1387. support better initialization (see <a href="#initializer">[4]</a>).
    1388. 

  1388.   </p>
    1389. 

  1389.   <p>
    1390. 

  1390.   Special thanks goes to 
    1391. 

  1391.   <ul>
    1392. 

  1392.   <li> Leor Zolman for our many discussion that eventually led to this library.
    1393. 

  1393.   <li> Tom Brinkman for being review manager.
    1394. 

  1394.   <li> Joaquín Muñoz for vc6/vc7 portability.
    1395. 

  1395.   <li> Pavel Vozenilek for his countless suggestions, improvements and 
    1396. 

  1396.        portability fixes. 
    1397. 

  1397.   <li> Rene Rivera for Code Warrior portability.     
    1398. 

  1398.        
    1399. 

  1399.        </ul>
    1400. 

  1400.   </p>
    1401. 

  1401.   <hr>
    1402. 

  1402.   <h2><a name="ref">References</a></h2>
    1403. 

  1403.   <p>
    1404. 

  1404.   <ol>
    1405. 

  1405.       <li> <a name="meyers">     Scott. Meyers, "More Effective C++", Item 7, Addison Wesley, 1996       
    1406. 

  1406.       <li> <a name="gmcl">       K. Czarnecki and U.W. Eisenecker, "Generative programming", Addison-Wesley, 2000        
    1407. 

  1407.       <li> <a name="blitz">      <a href="http://www.oonumerics.org/blitz/"> http://www.oonumerics.org/blitz/ </A>     
    1408. 

  1408.       <li> <a name="initializer"> 
    1409. 

  1409.           Gabriel Dos Reis and Bjarne Stroustrup, 
    1410. 

  1410.           <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2003/n1509.pdf"> "Generalized Initializer
    1411. 

  1411.             Lists"</a>, 2003  </a>
    1412. 

  1412.  </OL> 
    1413. 

  1413.  </p>
    1414. 

  1414.   <hr>
    1415. 

  1415.   <p>
    1416. 

  1416.     (C) Copyright Thorsten Ottosen 2003-2006
    1417. 

  1417.   </p>
    1418. 

  1418. 

  1419.   <br>
    1420. 

  1420.   <br>
    1421. 

  1421.   <br>
    1422. 

  1422.   <br>
    1423. 

  1423.   <br>
    1424. 

  1424.   <br>
    1425. 

  1425.   <br>
    1426. 

  1426.   <br>
    1427. 

  1427.   <br>
    1428. 

  1428.   <br>
    1429. 

  1429.   <br>
    1430. 

  1430.   <br>
    1431. 

  1431. </body>
    1432. 

  1432. </html>
    1433.