Home Explore Help
Register Sign In
devn00b
/
EQ2EMu
9
3
Fork 0
Files Issues 63 Pull Requests 0 Wiki
Tree: 37313e0645
Branches Tags
EQ2EMu
/
EQ2
/
source
/
depends
/
boost_1_72_0
/
libs
/
functional
/
factory
/
doc
/
html
/
index.html

index.html 43 KB
History Raw

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721 
  1. <html>
    2. 

  2. <head>
    3. 

  3. <meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
    4. 

  4. <title>Chapter&#160;1.&#160;Boost.Functional/Factory 1.0</title>
    5. 

  5. <link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css">
    6. 

  6. <meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
    7. 

  7. <link rel="home" href="index.html" title="Chapter&#160;1.&#160;Boost.Functional/Factory 1.0">
    8. 

  8. </head>
    9. 

  9. <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
    10. 

  10. <table cellpadding="2" width="100%"><tr>
    11. 

  11. <td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
    12. 

  12. <td align="center"><a href="../../../../../index.html">Home</a></td>
    13. 

  13. <td align="center"><a href="../../../../libraries.htm">Libraries</a></td>
    14. 

  14. <td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
    15. 

  15. <td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
    16. 

  16. <td align="center"><a href="../../../../../more/index.htm">More</a></td>
    17. 

  17. </tr></table>
    18. 

  18. <hr>
    19. 

  19. <div class="spirit-nav"></div>
    20. 

  20. <div class="chapter">
    21. 

  21. <div class="titlepage"><div>
    22. 

  22. <div><h2 class="title">
    23. 

  23. <a name="boost_functional_factory"></a>Chapter&#160;1.&#160;Boost.Functional/Factory 1.0</h2></div>
    24. 

  24. <div><div class="author"><h3 class="author">
    25. 

  25. <span class="firstname">Tobias</span> <span class="surname">Schwinger</span>
    26. 

  26. </h3></div></div>
    27. 

  27. <div><div class="author"><h3 class="author">
    28. 

  28. <span class="firstname">Glen</span> <span class="surname">Fernandes</span>
    29. 

  29. </h3></div></div>
    30. 

  30. <div><p class="copyright">Copyright &#169; 2007, 2008 Tobias Schwinger</p></div>
    31. 

  31. <div><p class="copyright">Copyright &#169; 2019 Glen Joseph Fernandes</p></div>
    32. 

  32. <div><div class="legalnotice">
    33. 

  33. <a name="boost_functional_factory.legal"></a><p>
    34. 

  34.         Distributed under the Boost Software License, Version 1.0.
    35. 

  35.       </p>
    36. 

  36. </div></div>
    37. 

  37. </div></div>
    38. 

  38. <div class="toc">
    39. 

  39. <p><b>Table of Contents</b></p>
    40. 

  40. <dl class="toc">
    41. 

  41. <dt><span class="section"><a href="index.html#boost_functional_factory.brief_description">Brief Description</a></span></dt>
    42. 

  42. <dt><span class="section"><a href="index.html#boost_functional_factory.background">Background</a></span></dt>
    43. 

  43. <dt><span class="section"><a href="index.html#boost_functional_factory.reference">Reference</a></span></dt>
    44. 

  44. <dt><span class="section"><a href="index.html#boost_functional_factory.changes">Changes</a></span></dt>
    45. 

  45. <dt><span class="section"><a href="index.html#boost_functional_factory.acknowledgements">Acknowledgements</a></span></dt>
    46. 

  46. <dt><span class="section"><a href="index.html#boost_functional_factory.references">References</a></span></dt>
    47. 

  47. </dl>
    48. 

  48. </div>
    49. 

  49. <div class="section">
    50. 

  50. <div class="titlepage"><div><div><h2 class="title" style="clear: both">
    51. 

  51. <a name="boost_functional_factory.brief_description"></a><a class="link" href="index.html#boost_functional_factory.brief_description" title="Brief Description">Brief Description</a>
    52. 

  52. </h2></div></div></div>
    53. 

  53. <p>
    54. 

  54.       The template <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">factory</span></code> lets you encapsulate a <code class="computeroutput"><span class="keyword">new</span></code> expression as a function object, <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">value_factory</span></code>
    55. 

  55.       encapsulates a constructor invocation without <code class="computeroutput"><span class="keyword">new</span></code>.
    56. 

  56.     </p>
    57. 

  57. <p>
    58. 

  58. </p>
    59. 

  59. <pre class="programlisting"><code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">factory</span></code><span class="special">&lt;</span><span class="identifier">T</span><span class="special">*&gt;()(</span><span class="identifier">arg1</span><span class="special">,</span><span class="identifier">arg2</span><span class="special">,</span><span class="identifier">arg3</span><span class="special">)</span>
    60. 

  60. <span class="comment">// same as new T(arg1,arg2,arg3)</span>
    61. 

  61. 

  62. <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">value_factory</span></code><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;()(</span><span class="identifier">arg1</span><span class="special">,</span><span class="identifier">arg2</span><span class="special">,</span><span class="identifier">arg3</span><span class="special">)</span>
    63. 

  63. <span class="comment">// same as T(arg1,arg2,arg3)</span>
    64. 

  64. </pre>
    65. 

  65. <p>
    66. 

  66.     </p>
    67. 

  67. <p>
    68. 

  68.       Before C++11 the arguments to the function objects have to be LValues. A factory
    69. 

  69.       that also accepts RValues can be composed using the <a href="http://www.boost.org/libs/functional/forward/doc/index.html" target="_top"><code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">forward_adapter</span></code></a>
    70. 

  70.       or <a href="http://www.boost.org/libs/bind/bind.html" target="_top"><code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">bind</span></code></a>.
    71. 

  71.       In C++11 or higher the arguments can be LValues or RValues.
    72. 

  72.     </p>
    73. 

  73. </div>
    74. 

  74. <div class="section">
    75. 

  75. <div class="titlepage"><div><div><h2 class="title" style="clear: both">
    76. 

  76. <a name="boost_functional_factory.background"></a><a class="link" href="index.html#boost_functional_factory.background" title="Background">Background</a>
    77. 

  77. </h2></div></div></div>
    78. 

  78. <p>
    79. 

  79.       In traditional Object Oriented Programming a Factory is an object implementing
    80. 

  80.       an interface of one or more methods that construct objects conforming to known
    81. 

  81.       interfaces.
    82. 

  82.     </p>
    83. 

  83. <p>
    84. 

  84. </p>
    85. 

  85. <pre class="programlisting"><span class="comment">// assuming a_concrete_class and another_concrete_class are derived</span>
    86. 

  86. <span class="comment">// from an_abstract_class</span>
    87. 

  87. 

  88. <span class="keyword">struct</span> <span class="identifier">a_factory</span> <span class="special">{</span>
    89. 

  89.     <span class="keyword">virtual</span> <span class="identifier">an_abstract_class</span><span class="special">*</span> <span class="identifier">create</span><span class="special">()</span> <span class="keyword">const</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span>
    90. 

  90.     <span class="keyword">virtual</span> <span class="special">~</span><span class="identifier">a_factory</span><span class="special">()</span> <span class="special">{</span> <span class="special">}</span>
    91. 

  91. <span class="special">};</span>
    92. 

  92. 

  93. <span class="keyword">struct</span> <span class="identifier">a_concrete_factory</span>
    94. 

  94.     <span class="special">:</span> <span class="identifier">a_factory</span> <span class="special">{</span>
    95. 

  95.     <span class="identifier">an_abstract_class</span><span class="special">*</span> <span class="identifier">create</span><span class="special">()</span> <span class="keyword">const</span> <span class="special">{</span>
    96. 

  96.         <span class="keyword">return</span> <span class="keyword">new</span> <span class="identifier">a_concrete_class</span><span class="special">();</span>
    97. 

  97.     <span class="special">}</span>
    98. 

  98. <span class="special">};</span>
    99. 

  99. 

  100. <span class="keyword">struct</span> <span class="identifier">another_concrete_factory</span>
    101. 

  101.     <span class="special">:</span> <span class="identifier">a_factory</span> <span class="special">{</span>
    102. 

  102.     <span class="identifier">an_abstract_class</span><span class="special">*</span> <span class="identifier">create</span><span class="special">()</span> <span class="keyword">const</span> <span class="special">{</span>
    103. 

  103.         <span class="keyword">return</span> <span class="keyword">new</span> <span class="identifier">another_concrete_class</span><span class="special">();</span>
    104. 

  104.     <span class="special">}</span>
    105. 

  105. <span class="special">};</span>
    106. 

  106. 

  107. <span class="comment">// [...]</span>
    108. 

  108. 

  109. <span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
    110. 

  110. <span class="special">{</span>
    111. 

  111.     <span class="identifier">boost</span><span class="special">::</span><span class="identifier">ptr_map</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">,</span> <span class="identifier">a_factory</span><span class="special">&gt;</span> <span class="identifier">factories</span><span class="special">;</span>
    112. 

  112. 

  113.     <span class="comment">// [...]</span>
    114. 

  114. 

  115.     <span class="identifier">factories</span><span class="special">.</span><span class="identifier">insert</span><span class="special">(</span><span class="string">"a_name"</span><span class="special">,</span>
    116. 

  116.         <span class="identifier">std</span><span class="special">::</span><span class="identifier">unique_ptr</span><span class="special">&lt;</span><span class="identifier">a_factory</span><span class="special">&gt;(</span><span class="keyword">new</span> <span class="identifier">a_concrete_factory</span><span class="special">));</span>
    117. 

  117.     <span class="identifier">factories</span><span class="special">.</span><span class="identifier">insert</span><span class="special">(</span><span class="string">"another_name"</span><span class="special">,</span>
    118. 

  118.         <span class="identifier">std</span><span class="special">::</span><span class="identifier">unique_ptr</span><span class="special">&lt;</span><span class="identifier">a_factory</span><span class="special">&gt;(</span><span class="keyword">new</span> <span class="identifier">another_concrete_factory</span><span class="special">));</span>
    119. 

  119. 

  120.     <span class="comment">// [...]</span>
    121. 

  121. 

  122.     <span class="identifier">std</span><span class="special">::</span><span class="identifier">unique_ptr</span><span class="special">&lt;</span><span class="identifier">an_abstract_class</span><span class="special">&gt;</span> <span class="identifier">x</span><span class="special">(</span><span class="identifier">factories</span><span class="special">.</span><span class="identifier">at</span><span class="special">(</span><span class="identifier">some_name</span><span class="special">).</span><span class="identifier">create</span><span class="special">());</span>
    123. 

  123. 

  124.     <span class="comment">// [...]</span>
    125. 

  125. <span class="special">}</span>
    126. 

  126. </pre>
    127. 

  127. <p>
    128. 

  128.     </p>
    129. 

  129. <p>
    130. 

  130.       This approach has several drawbacks. The most obvious one is that there is
    131. 

  131.       lots of boilerplate code. In other words there is too much code to express
    132. 

  132.       a rather simple intention. We could use templates to get rid of some of it
    133. 

  133.       but the approach remains inflexible:
    134. 

  134.     </p>
    135. 

  135. <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
    136. 

  136. <li class="listitem">
    137. 

  137.           We may want a factory that takes some arguments that are forwarded to the
    138. 

  138.           constructor,
    139. 

  139.         </li>
    140. 

  140. <li class="listitem">
    141. 

  141.           we will probably want to use smart pointers,
    142. 

  142.         </li>
    143. 

  143. <li class="listitem">
    144. 

  144.           we may want several member functions to create different kinds of objects,
    145. 

  145.         </li>
    146. 

  146. <li class="listitem">
    147. 

  147.           we might not necessarily need a polymorphic base class for the objects,
    148. 

  148.         </li>
    149. 

  149. <li class="listitem">
    150. 

  150.           as we will see, we do not need a factory base class at all,
    151. 

  151.         </li>
    152. 

  152. <li class="listitem">
    153. 

  153.           we might want to just call the constructor - without <code class="computeroutput"><span class="keyword">new</span></code>
    154. 

  154.           to create an object on the stack, and
    155. 

  155.         </li>
    156. 

  156. <li class="listitem">
    157. 

  157.           finally we might want to use customized memory management.
    158. 

  158.         </li>
    159. 

  159. </ul></div>
    160. 

  160. <p>
    161. 

  161.       Experience has shown that using function objects and generic Boost components
    162. 

  162.       for their composition, Design Patterns that describe callback mechanisms (typically
    163. 

  163.       requiring a high percentage of boilerplate code with pure Object Oriented methodology)
    164. 

  164.       become implementable with just few code lines and without extra classes.
    165. 

  165.     </p>
    166. 

  166. <p>
    167. 

  167.       Factories are callback mechanisms for constructors, so we provide two class
    168. 

  168.       templates, <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">value_factory</span></code> and <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">factory</span></code>,
    169. 

  169.       that encapsulate object construction via direct application of the constructor
    170. 

  170.       and the <code class="computeroutput"><span class="keyword">new</span></code> operator, respectively.
    171. 

  171.     </p>
    172. 

  172. <p>
    173. 

  173.       We let the function objects forward their arguments to the construction expressions
    174. 

  174.       they encapsulate. Over this <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">factory</span></code>
    175. 

  175.       optionally allows the use of smart pointers and <a href="https://www.boost.org/sgi/stl/Allocators.html" target="_top">Allocators</a>.
    176. 

  176.     </p>
    177. 

  177. <p>
    178. 

  178.       Compile-time polymorphism can be used where appropriate,
    179. 

  179.     </p>
    180. 

  180. <p>
    181. 

  181. </p>
    182. 

  182. <pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
    183. 

  183. <span class="keyword">void</span> <span class="identifier">do_something</span><span class="special">()</span>
    184. 

  184. <span class="special">{</span>
    185. 

  185.     <span class="comment">// [...]</span>
    186. 

  186.     <span class="identifier">T</span> <span class="identifier">x</span> <span class="special">=</span> <span class="identifier">T</span><span class="special">(</span><span class="identifier">a</span><span class="special">,</span> <span class="identifier">b</span><span class="special">);</span>
    187. 

  187. 

  188.     <span class="comment">// for conceptually similar objects x we neither need virtual</span>
    189. 

  189.     <span class="comment">// functions nor a common base class in this context.</span>
    190. 

  190.     <span class="comment">// [...]</span>
    191. 

  191. <span class="special">}</span>
    192. 

  192. </pre>
    193. 

  193. <p>
    194. 

  194.     </p>
    195. 

  195. <p>
    196. 

  196.       Now, to allow inhomogeneous signatures for the constructors of the types passed
    197. 

  197.       in for <code class="computeroutput"><span class="identifier">T</span></code> we can use <code class="computeroutput"><span class="identifier">value_factory</span></code> and <a href="http://www.boost.org/libs/bind/bind.html" target="_top"><code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">bind</span></code></a>
    198. 

  198.       to normalize between them.
    199. 

  199.     </p>
    200. 

  200. <p>
    201. 

  201. </p>
    202. 

  202. <pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">ValueFactory</span><span class="special">&gt;</span>
    203. 

  203. <span class="keyword">void</span> <span class="identifier">do_something</span><span class="special">(</span><span class="identifier">ValueFactory</span> <span class="identifier">make_obj</span> <span class="special">=</span> <span class="identifier">ValueFactory</span><span class="special">())</span>
    204. 

  204. <span class="special">{</span>
    205. 

  205.     <span class="comment">// [...]</span>
    206. 

  206.     <span class="keyword">typename</span> <span class="identifier">ValueFactory</span><span class="special">::</span><span class="identifier">result_type</span> <span class="identifier">x</span> <span class="special">=</span> <span class="identifier">make_obj</span><span class="special">(</span><span class="identifier">a</span><span class="special">,</span> <span class="identifier">b</span><span class="special">);</span>
    207. 

  207. 

  208.     <span class="comment">// for conceptually similar objects x we neither need virtual</span>
    209. 

  209.     <span class="comment">// functions nor a common base class in this context.</span>
    210. 

  210.     <span class="comment">// [...]</span>
    211. 

  211. <span class="special">}</span>
    212. 

  212. 

  213. <span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
    214. 

  214. <span class="special">{</span>
    215. 

  215.     <span class="comment">// [...]</span>
    216. 

  216. 

  217.     <span class="identifier">do_something</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">value_factory</span><span class="special">&lt;</span><span class="identifier">X</span><span class="special">&gt;());</span>
    218. 

  218.     <span class="identifier">do_something</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">bind</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">value_factory</span><span class="special">&lt;</span><span class="identifier">Y</span><span class="special">&gt;(),</span> <span class="identifier">_1</span><span class="special">,</span> <span class="number">5</span><span class="special">,</span> <span class="identifier">_2</span><span class="special">));</span>
    219. 

  219.     <span class="comment">// construct X(a, b) and Y(a, 5, b), respectively.</span>
    220. 

  220. 

  221.     <span class="comment">// [...]</span>
    222. 

  222. <span class="special">}</span>
    223. 

  223. </pre>
    224. 

  224. <p>
    225. 

  225.     </p>
    226. 

  226. <p>
    227. 

  227.       Maybe we want our objects to outlive the function's scope, in this case we
    228. 

  228.       have to use dynamic allocation;
    229. 

  229.     </p>
    230. 

  230. <p>
    231. 

  231. </p>
    232. 

  232. <pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Factory</span><span class="special">&gt;</span>
    233. 

  233. <span class="identifier">whatever</span> <span class="identifier">do_something</span><span class="special">(</span><span class="identifier">Factory</span> <span class="identifier">new_obj</span> <span class="special">=</span> <span class="identifier">Factory</span><span class="special">())</span>
    234. 

  234. <span class="special">{</span>
    235. 

  235.     <span class="keyword">typename</span> <span class="identifier">Factory</span><span class="special">::</span><span class="identifier">result_type</span> <span class="identifier">ptr</span> <span class="special">=</span> <span class="identifier">new_obj</span><span class="special">(</span><span class="identifier">a</span><span class="special">,</span> <span class="identifier">b</span><span class="special">);</span>
    236. 

  236. 

  237.     <span class="comment">// again, no common base class or virtual functions needed,</span>
    238. 

  238.     <span class="comment">// we could enforce a polymorphic base by writing e.g.</span>
    239. 

  239.     <span class="comment">//     boost::shared_ptr&lt;base&gt;</span>
    240. 

  240.     <span class="comment">// instead of</span>
    241. 

  241.     <span class="comment">//     typename Factory::result_type</span>
    242. 

  242.     <span class="comment">// above.</span>
    243. 

  243.     <span class="comment">// Note that we are also free to have the type erasure happen</span>
    244. 

  244.     <span class="comment">// somewhere else (e.g. in the constructor of this function's</span>
    245. 

  245.     <span class="comment">// result type).</span>
    246. 

  246. 

  247.     <span class="comment">// [...]</span>
    248. 

  248. <span class="special">}</span>
    249. 

  249. 

  250. <span class="comment">// [... call do_something like above but with boost::factory instead</span>
    251. 

  251. <span class="comment">// of boost::value_factory]</span>
    252. 

  252. </pre>
    253. 

  253. <p>
    254. 

  254.     </p>
    255. 

  255. <p>
    256. 

  256.       Although we might have created polymorphic objects in the previous example,
    257. 

  257.       we have used compile time polymorphism for the factory. If we want to erase
    258. 

  258.       the type of the factory and thus allow polymorphism at run time, we can use
    259. 

  259.       <a href="http://www.boost.org/doc/html/function.html" target="_top">Boost.Function</a>
    260. 

  260.       to do so. The first example can be rewritten as follows.
    261. 

  261.     </p>
    262. 

  262. <p>
    263. 

  263. </p>
    264. 

  264. <pre class="programlisting"><span class="keyword">typedef</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">function</span><span class="special">&lt;</span><span class="identifier">an_abstract_class</span><span class="special">*()&gt;</span> <span class="identifier">a_factory</span><span class="special">;</span>
    265. 

  265. 

  266. <span class="comment">// [...]</span>
    267. 

  267. 

  268. <span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
    269. 

  269. <span class="special">{</span>
    270. 

  270.     <span class="identifier">std</span><span class="special">::</span><span class="identifier">map</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">,</span> <span class="identifier">a_factory</span><span class="special">&gt;</span> <span class="identifier">factories</span><span class="special">;</span>
    271. 

  271. 

  272.     <span class="comment">// [...]</span>
    273. 

  273. 

  274.     <span class="identifier">factories</span><span class="special">[</span><span class="string">"a_name"</span><span class="special">]</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">factory</span><span class="special">&lt;</span><span class="identifier">a_concrete_class</span><span class="special">*&gt;();</span>
    275. 

  275.     <span class="identifier">factories</span><span class="special">[</span><span class="string">"another_name"</span><span class="special">]</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">factory</span><span class="special">&lt;</span><span class="identifier">another_concrete_class</span><span class="special">*&gt;();</span>
    276. 

  276. 

  277.     <span class="comment">// [...]</span>
    278. 

  278. <span class="special">}</span>
    279. 

  279. </pre>
    280. 

  280. <p>
    281. 

  281.     </p>
    282. 

  282. <p>
    283. 

  283.       Of course we can just as easy create factories that take arguments and/or return
    284. 

  284.       <a href="http://www.boost.org/libs/smart_ptr/index.html" target="_top">Smart Pointers</a>.
    285. 

  285.     </p>
    286. 

  286. </div>
    287. 

  287. <div class="section">
    288. 

  288. <div class="titlepage"><div><div><h2 class="title" style="clear: both">
    289. 

  289. <a name="boost_functional_factory.reference"></a><a class="link" href="index.html#boost_functional_factory.reference" title="Reference">Reference</a>
    290. 

  290. </h2></div></div></div>
    291. 

  291. <div class="toc"><dl class="toc">
    292. 

  292. <dt><span class="section"><a href="index.html#boost_functional_factory.reference.value_factory">value_factory</a></span></dt>
    293. 

  293. <dt><span class="section"><a href="index.html#boost_functional_factory.reference.factory">factory</a></span></dt>
    294. 

  294. </dl></div>
    295. 

  295. <div class="section">
    296. 

  296. <div class="titlepage"><div><div><h3 class="title">
    297. 

  297. <a name="boost_functional_factory.reference.value_factory"></a><a class="link" href="index.html#boost_functional_factory.reference.value_factory" title="value_factory">value_factory</a>
    298. 

  298. </h3></div></div></div>
    299. 

  299. <h5>
    300. 

  300. <a name="boost_functional_factory.reference.value_factory.h0"></a>
    301. 

  301.         <span class="phrase"><a name="boost_functional_factory.reference.value_factory.description"></a></span><a class="link" href="index.html#boost_functional_factory.reference.value_factory.description">Description</a>
    302. 

  302.       </h5>
    303. 

  303. <p>
    304. 

  304.         Function object template that invokes the constructor of the type <code class="computeroutput"><span class="identifier">T</span></code>.
    305. 

  305.       </p>
    306. 

  306. <h5>
    307. 

  307. <a name="boost_functional_factory.reference.value_factory.h1"></a>
    308. 

  308.         <span class="phrase"><a name="boost_functional_factory.reference.value_factory.header"></a></span><a class="link" href="index.html#boost_functional_factory.reference.value_factory.header">Header</a>
    309. 

  309.       </h5>
    310. 

  310. <p>
    311. 

  311. </p>
    312. 

  312. <pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">functional</span><span class="special">/</span><span class="identifier">value_factory</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
    313. 

  313. </pre>
    314. 

  314. <p>
    315. 

  315.       </p>
    316. 

  316. <h5>
    317. 

  317. <a name="boost_functional_factory.reference.value_factory.h2"></a>
    318. 

  318.         <span class="phrase"><a name="boost_functional_factory.reference.value_factory.synopsis"></a></span><a class="link" href="index.html#boost_functional_factory.reference.value_factory.synopsis">Synopsis</a>
    319. 

  319.       </h5>
    320. 

  320. <p>
    321. 

  321. </p>
    322. 

  322. <pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
    323. 

  323. 

  324. <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
    325. 

  325. <span class="keyword">class</span> <span class="identifier">value_factory</span><span class="special">;</span>
    326. 

  326. 

  327. <span class="special">}</span> <span class="comment">// boost</span>
    328. 

  328. </pre>
    329. 

  329. <p>
    330. 

  330.       </p>
    331. 

  331. <div class="variablelist">
    332. 

  332. <p class="title"><b>Notation</b></p>
    333. 

  333. <dl class="variablelist">
    334. 

  334. <dt><span class="term"><code class="computeroutput"><span class="identifier">T</span></code></span></dt>
    335. 

  335. <dd><p>
    336. 

  336.               an arbitrary type with at least one public constructor
    337. 

  337.             </p></dd>
    338. 

  338. <dt><span class="term"><code class="computeroutput"><span class="identifier">a0</span></code>...<code class="computeroutput"><span class="identifier">aN</span></code></span></dt>
    339. 

  339. <dd><p>
    340. 

  340.               argument values to a constructor of <code class="computeroutput"><span class="identifier">T</span></code>
    341. 

  341.             </p></dd>
    342. 

  342. <dt><span class="term"><code class="computeroutput"><span class="identifier">F</span></code></span></dt>
    343. 

  343. <dd><p>
    344. 

  344.               the type <code class="computeroutput"><span class="identifier">value_factory</span><span class="special">&lt;</span><span class="identifier">F</span><span class="special">&gt;</span></code>
    345. 

  345.             </p></dd>
    346. 

  346. <dt><span class="term"><code class="computeroutput"><span class="identifier">f</span></code></span></dt>
    347. 

  347. <dd><p>
    348. 

  348.               an instance object of <code class="computeroutput"><span class="identifier">F</span></code>
    349. 

  349.             </p></dd>
    350. 

  350. </dl>
    351. 

  351. </div>
    352. 

  352. <h5>
    353. 

  353. <a name="boost_functional_factory.reference.value_factory.h3"></a>
    354. 

  354.         <span class="phrase"><a name="boost_functional_factory.reference.value_factory.expression_semantics"></a></span><a class="link" href="index.html#boost_functional_factory.reference.value_factory.expression_semantics">Expression
    355. 

  355.         Semantics</a>
    356. 

  356.       </h5>
    357. 

  357. <div class="informaltable"><table class="table">
    358. 

  358. <colgroup>
    359. 

  359. <col>
    360. 

  360. <col>
    361. 

  361. </colgroup>
    362. 

  362. <thead><tr>
    363. 

  363. <th>
    364. 

  364.                 <p>
    365. 

  365.                   Expression
    366. 

  366.                 </p>
    367. 

  367.               </th>
    368. 

  368. <th>
    369. 

  369.                 <p>
    370. 

  370.                   Semantics
    371. 

  371.                 </p>
    372. 

  372.               </th>
    373. 

  373. </tr></thead>
    374. 

  374. <tbody>
    375. 

  375. <tr>
    376. 

  376. <td>
    377. 

  377.                 <p>
    378. 

  378.                   <code class="computeroutput"><span class="identifier">F</span><span class="special">()</span></code>
    379. 

  379.                 </p>
    380. 

  380.               </td>
    381. 

  381. <td>
    382. 

  382.                 <p>
    383. 

  383.                   creates an object of type <code class="computeroutput"><span class="identifier">F</span></code>.
    384. 

  384.                 </p>
    385. 

  385.               </td>
    386. 

  386. </tr>
    387. 

  387. <tr>
    388. 

  388. <td>
    389. 

  389.                 <p>
    390. 

  390.                   <code class="computeroutput"><span class="identifier">F</span><span class="special">(</span><span class="identifier">f</span><span class="special">)</span></code>
    391. 

  391.                 </p>
    392. 

  392.               </td>
    393. 

  393. <td>
    394. 

  394.                 <p>
    395. 

  395.                   creates an object of type <code class="computeroutput"><span class="identifier">F</span></code>.
    396. 

  396.                 </p>
    397. 

  397.               </td>
    398. 

  398. </tr>
    399. 

  399. <tr>
    400. 

  400. <td>
    401. 

  401.                 <p>
    402. 

  402.                   <code class="computeroutput"><span class="identifier">f</span><span class="special">(</span><span class="identifier">a0</span></code>...<code class="computeroutput"><span class="identifier">aN</span><span class="special">)</span></code>
    403. 

  403.                 </p>
    404. 

  404.               </td>
    405. 

  405. <td>
    406. 

  406.                 <p>
    407. 

  407.                   returns <code class="computeroutput"><span class="identifier">T</span><span class="special">(</span><span class="identifier">a0</span></code>...<code class="computeroutput"><span class="identifier">aN</span><span class="special">)</span></code>.
    408. 

  408.                 </p>
    409. 

  409.               </td>
    410. 

  410. </tr>
    411. 

  411. <tr>
    412. 

  412. <td>
    413. 

  413.                 <p>
    414. 

  414.                   <code class="computeroutput"><span class="identifier">F</span><span class="special">::</span><span class="identifier">result_type</span></code>
    415. 

  415.                 </p>
    416. 

  416.               </td>
    417. 

  417. <td>
    418. 

  418.                 <p>
    419. 

  419.                   is the type <code class="computeroutput"><span class="identifier">T</span></code>.
    420. 

  420.                 </p>
    421. 

  421.               </td>
    422. 

  422. </tr>
    423. 

  423. </tbody>
    424. 

  424. </table></div>
    425. 

  425. <h5>
    426. 

  426. <a name="boost_functional_factory.reference.value_factory.h4"></a>
    427. 

  427.         <span class="phrase"><a name="boost_functional_factory.reference.value_factory.limits"></a></span><a class="link" href="index.html#boost_functional_factory.reference.value_factory.limits">Limits</a>
    428. 

  428.       </h5>
    429. 

  429. <p>
    430. 

  430.         Before C++11, the maximum number of arguments supported is 10. Since C++11
    431. 

  431.         an arbitrary number of arguments is supported.
    432. 

  432.       </p>
    433. 

  433. </div>
    434. 

  434. <div class="section">
    435. 

  435. <div class="titlepage"><div><div><h3 class="title">
    436. 

  436. <a name="boost_functional_factory.reference.factory"></a><a class="link" href="index.html#boost_functional_factory.reference.factory" title="factory">factory</a>
    437. 

  437. </h3></div></div></div>
    438. 

  438. <h5>
    439. 

  439. <a name="boost_functional_factory.reference.factory.h0"></a>
    440. 

  440.         <span class="phrase"><a name="boost_functional_factory.reference.factory.description"></a></span><a class="link" href="index.html#boost_functional_factory.reference.factory.description">Description</a>
    441. 

  441.       </h5>
    442. 

  442. <p>
    443. 

  443.         Function object template that dynamically constructs a pointee object for
    444. 

  444.         the type of pointer given as template argument. Smart pointers may be used
    445. 

  445.         for the template argument, given that <code class="computeroutput"><span class="identifier">pointer_traits</span><span class="special">&lt;</span><span class="identifier">Pointer</span><span class="special">&gt;::</span><span class="identifier">element_type</span></code>
    446. 

  446.         yields the pointee type.
    447. 

  447.       </p>
    448. 

  448. <p>
    449. 

  449.         If an <a href="https://www.boost.org/sgi/stl/Allocators.html" target="_top">Allocator</a>
    450. 

  450.         is given, it is used for memory allocation and the placement form of the
    451. 

  451.         <code class="computeroutput"><span class="keyword">new</span></code> operator is used to construct
    452. 

  452.         the object. A function object that calls the destructor and deallocates the
    453. 

  453.         memory with a copy of the Allocator is used for the second constructor argument
    454. 

  454.         of <code class="computeroutput"><span class="identifier">Pointer</span></code> (thus it must
    455. 

  455.         be a <a href="http://www.boost.org/libs/smart_ptr/index.html" target="_top">Smart Pointer</a>
    456. 

  456.         that provides a suitable constructor, such as <a href="http://www.boost.org/libs/smart_ptr/shared_ptr.htm" target="_top"><code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">shared_ptr</span></code></a>).
    457. 

  457.       </p>
    458. 

  458. <p>
    459. 

  459.         If a third template argument is <code class="computeroutput"><span class="identifier">factory_passes_alloc_to_smart_pointer</span></code>,
    460. 

  460.         the allocator itself is used for the third constructor argument of <code class="computeroutput"><span class="identifier">Pointer</span></code> ( <a href="http://www.boost.org/libs/smart_ptr/shared_ptr.htm" target="_top"><code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">shared_ptr</span></code></a> then uses the allocator
    461. 

  461.         to manage the memory of its separately allocated reference counter).
    462. 

  462.       </p>
    463. 

  463. <h5>
    464. 

  464. <a name="boost_functional_factory.reference.factory.h1"></a>
    465. 

  465.         <span class="phrase"><a name="boost_functional_factory.reference.factory.header"></a></span><a class="link" href="index.html#boost_functional_factory.reference.factory.header">Header</a>
    466. 

  466.       </h5>
    467. 

  467. <p>
    468. 

  468. </p>
    469. 

  469. <pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">functional</span><span class="special">/</span><span class="identifier">factory</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
    470. 

  470. </pre>
    471. 

  471. <p>
    472. 

  472.       </p>
    473. 

  473. <h5>
    474. 

  474. <a name="boost_functional_factory.reference.factory.h2"></a>
    475. 

  475.         <span class="phrase"><a name="boost_functional_factory.reference.factory.synopsis"></a></span><a class="link" href="index.html#boost_functional_factory.reference.factory.synopsis">Synopsis</a>
    476. 

  476.       </h5>
    477. 

  477. <p>
    478. 

  478. </p>
    479. 

  479. <pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
    480. 

  480. 

  481. <span class="keyword">enum</span> <span class="identifier">factory_alloc_propagation</span> <span class="special">{</span>
    482. 

  482.     <span class="identifier">factory_alloc_for_pointee_and_deleter</span><span class="special">,</span>
    483. 

  483.     <span class="identifier">factory_passes_alloc_to_smart_pointer</span>
    484. 

  484. <span class="special">};</span>
    485. 

  485. 

  486. <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Pointer</span><span class="special">,</span>
    487. 

  487.     <span class="keyword">class</span> <span class="identifier">Allocator</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">,</span>
    488. 

  488.     <span class="identifier">factory_alloc_propagation</span> <span class="identifier">Policy</span> <span class="special">=</span> <span class="identifier">factory_alloc_for_pointee_and_deleter</span><span class="special">&gt;</span>
    489. 

  489. <span class="keyword">class</span> <span class="identifier">factory</span><span class="special">;</span>
    490. 

  490. 

  491. <span class="special">}</span> <span class="comment">// boost</span>
    492. 

  492. </pre>
    493. 

  493. <p>
    494. 

  494.       </p>
    495. 

  495. <div class="variablelist">
    496. 

  496. <p class="title"><b>Notation</b></p>
    497. 

  497. <dl class="variablelist">
    498. 

  498. <dt><span class="term"><code class="computeroutput"><span class="identifier">T</span></code></span></dt>
    499. 

  499. <dd><p>
    500. 

  500.               an arbitrary type with at least one public constructor
    501. 

  501.             </p></dd>
    502. 

  502. <dt><span class="term"><code class="computeroutput"><span class="identifier">P</span></code></span></dt>
    503. 

  503. <dd><p>
    504. 

  504.               pointer or smart pointer to <code class="computeroutput"><span class="identifier">T</span></code>
    505. 

  505.             </p></dd>
    506. 

  506. <dt><span class="term"><code class="computeroutput"><span class="identifier">a0</span></code>...<code class="computeroutput"><span class="identifier">aN</span></code></span></dt>
    507. 

  507. <dd><p>
    508. 

  508.               argument values to a constructor of <code class="computeroutput"><span class="identifier">T</span></code>
    509. 

  509.             </p></dd>
    510. 

  510. <dt><span class="term"><code class="computeroutput"><span class="identifier">F</span></code></span></dt>
    511. 

  511. <dd><p>
    512. 

  512.               the type <code class="computeroutput"><span class="identifier">factory</span><span class="special">&lt;</span><span class="identifier">P</span><span class="special">&gt;</span></code>
    513. 

  513.             </p></dd>
    514. 

  514. <dt><span class="term"><code class="computeroutput"><span class="identifier">f</span></code></span></dt>
    515. 

  515. <dd><p>
    516. 

  516.               an instance object of <code class="computeroutput"><span class="identifier">F</span></code>
    517. 

  517.             </p></dd>
    518. 

  518. </dl>
    519. 

  519. </div>
    520. 

  520. <h5>
    521. 

  521. <a name="boost_functional_factory.reference.factory.h3"></a>
    522. 

  522.         <span class="phrase"><a name="boost_functional_factory.reference.factory.expression_semantics"></a></span><a class="link" href="index.html#boost_functional_factory.reference.factory.expression_semantics">Expression
    523. 

  523.         Semantics</a>
    524. 

  524.       </h5>
    525. 

  525. <div class="informaltable"><table class="table">
    526. 

  526. <colgroup>
    527. 

  527. <col>
    528. 

  528. <col>
    529. 

  529. </colgroup>
    530. 

  530. <thead><tr>
    531. 

  531. <th>
    532. 

  532.                 <p>
    533. 

  533.                   Expression
    534. 

  534.                 </p>
    535. 

  535.               </th>
    536. 

  536. <th>
    537. 

  537.                 <p>
    538. 

  538.                   Semantics
    539. 

  539.                 </p>
    540. 

  540.               </th>
    541. 

  541. </tr></thead>
    542. 

  542. <tbody>
    543. 

  543. <tr>
    544. 

  544. <td>
    545. 

  545.                 <p>
    546. 

  546.                   <code class="computeroutput"><span class="identifier">F</span><span class="special">()</span></code>
    547. 

  547.                 </p>
    548. 

  548.               </td>
    549. 

  549. <td>
    550. 

  550.                 <p>
    551. 

  551.                   creates an object of type <code class="computeroutput"><span class="identifier">F</span></code>.
    552. 

  552.                 </p>
    553. 

  553.               </td>
    554. 

  554. </tr>
    555. 

  555. <tr>
    556. 

  556. <td>
    557. 

  557.                 <p>
    558. 

  558.                   <code class="computeroutput"><span class="identifier">F</span><span class="special">(</span><span class="identifier">f</span><span class="special">)</span></code>
    559. 

  559.                 </p>
    560. 

  560.               </td>
    561. 

  561. <td>
    562. 

  562.                 <p>
    563. 

  563.                   creates an object of type <code class="computeroutput"><span class="identifier">F</span></code>.
    564. 

  564.                 </p>
    565. 

  565.               </td>
    566. 

  566. </tr>
    567. 

  567. <tr>
    568. 

  568. <td>
    569. 

  569.                 <p>
    570. 

  570.                   <code class="computeroutput"><span class="identifier">f</span><span class="special">(</span><span class="identifier">a0</span></code>...<code class="computeroutput"><span class="identifier">aN</span><span class="special">)</span></code>
    571. 

  571.                 </p>
    572. 

  572.               </td>
    573. 

  573. <td>
    574. 

  574.                 <p>
    575. 

  575.                   dynamically creates an object of type <code class="computeroutput"><span class="identifier">T</span></code>
    576. 

  576.                   using <code class="computeroutput"><span class="identifier">a0</span></code>...<code class="computeroutput"><span class="identifier">aN</span></code> as arguments for the constructor
    577. 

  577.                   invocation.
    578. 

  578.                 </p>
    579. 

  579.               </td>
    580. 

  580. </tr>
    581. 

  581. <tr>
    582. 

  582. <td>
    583. 

  583.                 <p>
    584. 

  584.                   <code class="computeroutput"><span class="identifier">F</span><span class="special">::</span><span class="identifier">result_type</span></code>
    585. 

  585.                 </p>
    586. 

  586.               </td>
    587. 

  587. <td>
    588. 

  588.                 <p>
    589. 

  589.                   is the type <code class="computeroutput"><span class="identifier">P</span></code> with
    590. 

  590.                   top-level cv-qualifiers removed.
    591. 

  591.                 </p>
    592. 

  592.               </td>
    593. 

  593. </tr>
    594. 

  594. </tbody>
    595. 

  595. </table></div>
    596. 

  596. <h5>
    597. 

  597. <a name="boost_functional_factory.reference.factory.h4"></a>
    598. 

  598.         <span class="phrase"><a name="boost_functional_factory.reference.factory.limits"></a></span><a class="link" href="index.html#boost_functional_factory.reference.factory.limits">Limits</a>
    599. 

  599.       </h5>
    600. 

  600. <p>
    601. 

  601.         Before C++11, the maximum number of arguments supported is 10. Since C++11
    602. 

  602.         an arbitrary number of arguments is supported.
    603. 

  603.       </p>
    604. 

  604. </div>
    605. 

  605. </div>
    606. 

  606. <div class="section">
    607. 

  607. <div class="titlepage"><div><div><h2 class="title" style="clear: both">
    608. 

  608. <a name="boost_functional_factory.changes"></a><a class="link" href="index.html#boost_functional_factory.changes" title="Changes">Changes</a>
    609. 

  609. </h2></div></div></div>
    610. 

  610. <h4>
    611. 

  611. <a name="boost_functional_factory.changes.h0"></a>
    612. 

  612.       <span class="phrase"><a name="boost_functional_factory.changes.boost_1_72_0"></a></span><a class="link" href="index.html#boost_functional_factory.changes.boost_1_72_0">Boost
    613. 

  613.       1.72.0</a>
    614. 

  614.     </h4>
    615. 

  615. <p>
    616. 

  616.       Glen Fernandes rewrote the implementations of <code class="computeroutput"><span class="identifier">factory</span></code>
    617. 

  617.       and <code class="computeroutput"><span class="identifier">value_factory</span></code> to provide
    618. 

  618.       the following features:
    619. 

  619.     </p>
    620. 

  620. <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
    621. 

  621. <li class="listitem">
    622. 

  622.           Support r-value arguments when available
    623. 

  623.         </li>
    624. 

  624. <li class="listitem">
    625. 

  625.           Support arbitrary number of arguments via variadic templates when available
    626. 

  626.         </li>
    627. 

  627. <li class="listitem">
    628. 

  628.           Support allocators that are final
    629. 

  629.         </li>
    630. 

  630. <li class="listitem">
    631. 

  631.           Support allocators that use fancy pointers
    632. 

  632.         </li>
    633. 

  633. <li class="listitem">
    634. 

  634.           Support for disabled exceptions (<code class="computeroutput"><span class="identifier">BOOST_NO_EXCEPTIONS</span></code>)
    635. 

  635.         </li>
    636. 

  636. <li class="listitem">
    637. 

  637.           Improved compilation times
    638. 

  638.         </li>
    639. 

  639. </ul></div>
    640. 

  640. <p>
    641. 

  641.       The following features have been removed:
    642. 

  642.     </p>
    643. 

  643. <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
    644. 

  644. <li class="listitem">
    645. 

  645.           Increasing limits for C++03 compilers through <code class="computeroutput"><span class="identifier">BOOST_FUNCTIONAL_VALUE_FACTORY_MAX_ARITY</span></code>
    646. 

  646.         </li>
    647. 

  647. <li class="listitem">
    648. 

  648.           Using <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">none_t</span></code> in place of <code class="computeroutput"><span class="keyword">void</span></code>
    649. 

  649.           through <code class="computeroutput"><span class="identifier">BOOST_FUNCTIONAL_FACTORY_SUPPORT_NONE_T</span></code>
    650. 

  650.         </li>
    651. 

  651. </ul></div>
    652. 

  652. <h4>
    653. 

  653. <a name="boost_functional_factory.changes.h1"></a>
    654. 

  654.       <span class="phrase"><a name="boost_functional_factory.changes.boost_1_58_0"></a></span><a class="link" href="index.html#boost_functional_factory.changes.boost_1_58_0">Boost
    655. 

  655.       1.58.0</a>
    656. 

  656.     </h4>
    657. 

  657. <p>
    658. 

  658.       In order to remove the dependency on Boost.Optional, the default parameter
    659. 

  659.       for allocators has been changed from <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">none_t</span></code>
    660. 

  660.       to <code class="computeroutput"><span class="keyword">void</span></code>. If you have code that
    661. 

  661.       has stopped working because it uses <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">none_t</span></code>,
    662. 

  662.       a quick fix is to define <code class="computeroutput"><span class="identifier">BOOST_FUNCTIONAL_FACTORY_SUPPORT_NONE_T</span></code>,
    663. 

  663.       which will restore support, but this will be removed in a future release. It
    664. 

  664.       should be be relatively easy to fix this properly.
    665. 

  665.     </p>
    666. 

  666. </div>
    667. 

  667. <div class="section">
    668. 

  668. <div class="titlepage"><div><div><h2 class="title" style="clear: both">
    669. 

  669. <a name="boost_functional_factory.acknowledgements"></a><a class="link" href="index.html#boost_functional_factory.acknowledgements" title="Acknowledgements">Acknowledgements</a>
    670. 

  670. </h2></div></div></div>
    671. 

  671. <p>
    672. 

  672.       Tobias Schwinger for creating this library.
    673. 

  673.     </p>
    674. 

  674. <p>
    675. 

  675.       Eric Niebler requested a function to invoke a type's constructor (with the
    676. 

  676.       arguments supplied as a Tuple) as a Fusion feature. These Factory utilities
    677. 

  677.       are a factored-out generalization of this idea.
    678. 

  678.     </p>
    679. 

  679. <p>
    680. 

  680.       Dave Abrahams suggested Smart Pointer support for exception safety, providing
    681. 

  681.       useful hints for the implementation.
    682. 

  682.     </p>
    683. 

  683. <p>
    684. 

  684.       Joel de Guzman's documentation style was copied from Fusion.
    685. 

  685.     </p>
    686. 

  686. <p>
    687. 

  687.       Peter Dimov for sharing his insights on language details and their evolution.
    688. 

  688.     </p>
    689. 

  689. </div>
    690. 

  690. <div class="section">
    691. 

  691. <div class="titlepage"><div><div><h2 class="title" style="clear: both">
    692. 

  692. <a name="boost_functional_factory.references"></a><a class="link" href="index.html#boost_functional_factory.references" title="References">References</a>
    693. 

  693. </h2></div></div></div>
    694. 

  694. <div class="orderedlist"><ol class="orderedlist" type="1">
    695. 

  695. <li class="listitem">
    696. 

  696.           <a href="http://en.wikipedia.org/wiki/Design_Patterns" target="_top">Design Patterns</a>,
    697. 

  697.           Gamma et al. - Addison Wesley Publishing, 1995
    698. 

  698.         </li>
    699. 

  699. <li class="listitem">
    700. 

  700.           <a href="https://boost.org/sgi/stl/" target="_top">Standard Template Library Programmer's
    701. 

  701.           Guide</a>, Hewlett-Packard Company, 1994
    702. 

  702.         </li>
    703. 

  703. <li class="listitem">
    704. 

  704.           <a href="http://www.boost.org/libs/bind/bind.html" target="_top">Boost.Bind</a>,
    705. 

  705.           Peter Dimov, 2001-2005
    706. 

  706.         </li>
    707. 

  707. <li class="listitem">
    708. 

  708.           <a href="http://www.boost.org/doc/html/function.html" target="_top">Boost.Function</a>,
    709. 

  709.           Douglas Gregor, 2001-2004
    710. 

  710.         </li>
    711. 

  711. </ol></div>
    712. 

  712. </div>
    713. 

  713. </div>
    714. 

  714. <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
    715. 

  715. <td align="left"><p><small>Last revised: December 10, 2019 at 00:23:31 GMT</small></p></td>
    716. 

  716. <td align="right"><div class="copyright-footer"></div></td>
    717. 

  717. </tr></table>
    718. 

  718. <hr>
    719. 

  719. <div class="spirit-nav"></div>
    720. 

  720. </body>
    721. 

  721. </html>
    722.