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