首頁 探索 說明
註冊 登入
devn00b
/
EQ2EMu
9
3
複刻 0
Files 問題管理 59
目錄樹: 60a9c87312
分支列表 標籤列表
EQ2EMu
/
EQ2
/
source
/
depends
/
boost_1_72_0
/
libs
/
function_types
/
doc
/
html
/
boost_functiontypes
/
use_cases.html

use_cases.html 18 KB
文件歷史 原始文件

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175 
  1. <html>
    2. 

  2. <head>
    3. 

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

  4. <title>Use Cases</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.FunctionTypes 2.5">
    8. 

  8. <link rel="up" href="../index.html" title="Chapter&#160;1.&#160;Boost.FunctionTypes 2.5">
    9. 

  9. <link rel="prev" href="introduction.html" title="Introduction">
    10. 

  10. <link rel="next" href="about_tag_types.html" title="About Tag Types">
    11. 

  11. </head>
    12. 

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

  13. <table cellpadding="2" width="100%"><tr>
    14. 

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

  15. <td align="center"><a href="../../../../../index.html">Home</a></td>
    16. 

  16. <td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
    17. 

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

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

  19. <td align="center"><a href="../../../../../more/index.htm">More</a></td>
    20. 

  20. </tr></table>
    21. 

  21. <hr>
    22. 

  22. <div class="spirit-nav">
    23. 

  23. <a accesskey="p" href="introduction.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="about_tag_types.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
    24. 

  24. </div>
    25. 

  25. <div class="section">
    26. 

  26. <div class="titlepage"><div><div><h2 class="title" style="clear: both">
    27. 

  27. <a name="boost_functiontypes.use_cases"></a><a class="link" href="use_cases.html" title="Use Cases">Use Cases</a>
    28. 

  28. </h2></div></div></div>
    29. 

  29. <p>
    30. 

  30.       Generic libraries that accept callable arguments are common in C++. Accepting
    31. 

  31.       a callable argument of builin type often involves a lot of repetitive code
    32. 

  32.       because the accepting function is overloaded for different function arities.
    33. 

  33.       Further, member functions may have <code class="literal">const</code>/<code class="literal">volatile</code>-qualifiers,
    34. 

  34.       a function may take a variable number of (additional, POD-typed) arguments
    35. 

  35.       (such as <code class="literal">printf</code>) and several C++ implementations encode
    36. 

  36.       a calling convention with each function's type to allow calls across language
    37. 

  37.       or (sub-)system boundaries.
    38. 

  38.     </p>
    39. 

  39. <pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">R</span><span class="special">&gt;</span>
    40. 

  40. <span class="keyword">void</span> <span class="identifier">accept_function</span><span class="special">(</span><span class="identifier">R</span><span class="special">(*</span> <span class="identifier">func</span><span class="special">)());</span>
    41. 

  41. 

  42. <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">R</span><span class="special">&gt;</span>
    43. 

  43. <span class="keyword">void</span> <span class="identifier">accept_function</span><span class="special">(</span><span class="identifier">R</span><span class="special">(&amp;</span> <span class="identifier">func</span><span class="special">)());</span>
    44. 

  44. 

  45. <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">R</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">C</span><span class="special">&gt;</span>
    46. 

  46. <span class="keyword">void</span> <span class="identifier">accept_function</span><span class="special">(</span><span class="identifier">R</span><span class="special">(</span><span class="identifier">C</span><span class="special">::*</span> <span class="identifier">func</span><span class="special">)());</span>
    47. 

  47. 

  48. <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">R</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">C</span><span class="special">&gt;</span>
    49. 

  49. <span class="keyword">void</span> <span class="identifier">accept_function</span><span class="special">(</span><span class="identifier">R</span><span class="special">(</span><span class="identifier">C</span><span class="special">::*</span> <span class="identifier">func</span><span class="special">)()</span> <span class="keyword">const</span><span class="special">);</span>
    50. 

  50. 

  51. <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">R</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">C</span><span class="special">&gt;</span>
    52. 

  52. <span class="keyword">void</span> <span class="identifier">accept_function</span><span class="special">(</span><span class="identifier">R</span><span class="special">(</span><span class="identifier">C</span><span class="special">::*</span> <span class="identifier">func</span><span class="special">)()</span> <span class="keyword">volatile</span><span class="special">);</span>
    53. 

  53. 

  54. <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">R</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">C</span><span class="special">&gt;</span>
    55. 

  55. <span class="keyword">void</span> <span class="identifier">accept_function</span><span class="special">(</span><span class="identifier">R</span><span class="special">(</span><span class="identifier">C</span><span class="special">::*</span> <span class="identifier">func</span><span class="special">)()</span> <span class="keyword">const</span> <span class="keyword">volatile</span><span class="special">);</span>
    56. 

  56. 

  57. <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">R</span><span class="special">&gt;</span>
    58. 

  58. <span class="keyword">void</span> <span class="identifier">accept_function</span><span class="special">(</span><span class="identifier">R</span><span class="special">(*</span> <span class="identifier">func</span><span class="special">)(...));</span>
    59. 

  59. 

  60. <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">R</span><span class="special">&gt;</span>
    61. 

  61. <span class="keyword">void</span> <span class="identifier">accept_function</span><span class="special">(</span><span class="identifier">R</span><span class="special">(&amp;</span> <span class="identifier">func</span><span class="special">)(...));</span>
    62. 

  62. 

  63. <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">R</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">C</span><span class="special">&gt;</span>
    64. 

  64. <span class="keyword">void</span> <span class="identifier">accept_function</span><span class="special">(</span><span class="identifier">R</span><span class="special">(</span><span class="identifier">C</span><span class="special">::*</span> <span class="identifier">func</span><span class="special">)(...));</span>
    65. 

  65. 

  66. <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">R</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">C</span><span class="special">&gt;</span>
    67. 

  67. <span class="keyword">void</span> <span class="identifier">accept_function</span><span class="special">(</span><span class="identifier">R</span><span class="special">(</span><span class="identifier">C</span><span class="special">::*</span> <span class="identifier">func</span><span class="special">)(...)</span> <span class="keyword">const</span><span class="special">);</span>
    68. 

  68. 

  69. <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">R</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">C</span><span class="special">&gt;</span>
    70. 

  70. <span class="keyword">void</span> <span class="identifier">accept_function</span><span class="special">(</span><span class="identifier">R</span><span class="special">(</span><span class="identifier">C</span><span class="special">::*</span> <span class="identifier">func</span><span class="special">)(...)</span> <span class="keyword">volatile</span><span class="special">);</span>
    71. 

  71. 

  72. <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">R</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">C</span><span class="special">&gt;</span>
    73. 

  73. <span class="keyword">void</span> <span class="identifier">accept_function</span><span class="special">(</span><span class="identifier">R</span><span class="special">(</span><span class="identifier">C</span><span class="special">::*</span> <span class="identifier">func</span><span class="special">)(...)</span> <span class="keyword">const</span> <span class="keyword">volatile</span><span class="special">);</span>
    74. 

  74. 

  75. <span class="comment">// ...</span>
    76. 

  76. 

  77. <span class="comment">// needs to be repeated for every additional function parameter</span>
    78. 

  78. <span class="comment">// times the number of possible calling conventions</span>
    79. 

  79. </pre>
    80. 

  80. <p>
    81. 

  81.       The "overloading approach" obviously does not scale well: There might
    82. 

  82.       be several functions that accept callable arguments in one library and client
    83. 

  83.       code might end up using several libraries that use this pattern. On the developer
    84. 

  84.       side, library developers spend their time solving the same problem, working
    85. 

  85.       around the same portability issues, and apply similar optimizations to keep
    86. 

  86.       the compilation time down.
    87. 

  87.     </p>
    88. 

  88. <p>
    89. 

  89.       Using Boost.FunctionTypes it is possible to write a single function template
    90. 

  90.       instead:
    91. 

  91.     </p>
    92. 

  92. <pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">F</span><span class="special">&gt;</span>
    93. 

  93. <span class="keyword">void</span> <span class="identifier">accept_function</span><span class="special">(</span><span class="identifier">F</span> <span class="identifier">f</span><span class="special">)</span>
    94. 

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

  95.   <span class="comment">// ... use Boost.FunctionTypes to analyse F</span>
    96. 

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

  97. </pre>
    98. 

  98. <p>
    99. 

  99.       The combination with a tuples library that provides an invoker component, such
    100. 

  100.       as <a href="../../../../fusion/index.html" target="_top">Boost.Fusion</a>, allows to
    101. 

  101.       build flexible callback facilities that are entirely free of repetitive code
    102. 

  102.       as shown by the <a href="../../../../function_types/example/interpreter.hpp" target="_top">interpreter
    103. 

  103.       example</a>.
    104. 

  104.     </p>
    105. 

  105. <p>
    106. 

  106.       When taking the address of an overloaded function or function template, the
    107. 

  107.       type of the function must be known from the context the expression is used
    108. 

  108.       in. The code below shows three examples for choosing the <code class="literal">float(float)</code>
    109. 

  109.       overload of <code class="literal">std::abs</code>.
    110. 

  110.     </p>
    111. 

  111. <pre class="programlisting"><span class="keyword">float</span> <span class="special">(*</span><span class="identifier">ptr_absf</span><span class="special">)(</span><span class="keyword">float</span><span class="special">)</span> <span class="special">=</span> <span class="special">&amp;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">abs</span><span class="special">;</span>
    112. 

  112. 

  113. 

  114. <span class="keyword">void</span> <span class="identifier">foo</span><span class="special">(</span><span class="keyword">float</span><span class="special">(*</span><span class="identifier">func</span><span class="special">)(</span><span class="keyword">float</span><span class="special">));</span>
    115. 

  115. 

  116. <span class="keyword">void</span> <span class="identifier">bar</span><span class="special">()</span>
    117. 

  117. <span class="special">{</span>
    118. 

  118.   <span class="identifier">foo</span><span class="special">(&amp;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">abs</span><span class="special">);</span>
    119. 

  119. <span class="special">}</span>
    120. 

  120. 

  121. 

  122. <span class="identifier">std</span><span class="special">::</span><span class="identifier">transform</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">e</span><span class="special">,</span> <span class="identifier">o</span><span class="special">,</span> <span class="keyword">static_cast</span><span class="special">&lt;</span><span class="keyword">float</span><span class="special">(*)(</span><span class="keyword">float</span><span class="special">)&gt;(&amp;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">abs</span><span class="special">));</span>
    123. 

  123. </pre>
    124. 

  124. <p>
    125. 

  125.       The library's type synthesis capabilities can be used to automate overload
    126. 

  126.       selection and instantiation of function templates. Given an overloaded function
    127. 

  127.       template
    128. 

  128.     </p>
    129. 

  129. <pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">R</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">T0</span><span class="special">&gt;</span>
    130. 

  130. <span class="identifier">R</span> <span class="identifier">overloaded</span><span class="special">(</span><span class="identifier">T0</span><span class="special">);</span>
    131. 

  131. 

  132. <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">R</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">T0</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">T1</span><span class="special">&gt;</span>
    133. 

  133. <span class="identifier">R</span> <span class="identifier">overloaded</span><span class="special">(</span><span class="identifier">T0</span><span class="special">,</span><span class="identifier">T1</span><span class="special">);</span>
    134. 

  134. 

  135. <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">R</span><span class="special">.</span> <span class="keyword">typename</span> <span class="identifier">T0</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">T2</span><span class="special">&gt;</span>
    136. 

  136. <span class="identifier">R</span> <span class="identifier">overloaded</span><span class="special">(</span><span class="identifier">T0</span><span class="special">,</span><span class="identifier">T1</span><span class="special">,</span><span class="identifier">T2</span><span class="special">);</span>
    137. 

  137. </pre>
    138. 

  138. <p>
    139. 

  139.       we can pick any of the three overloads and instantiate the template with template
    140. 

  140.       arguments from a type sequence in a single expression:
    141. 

  141.     </p>
    142. 

  142. <pre class="programlisting"><span class="keyword">static_cast</span><span class="special">&lt;</span><a class="link" href="reference/synthesis.html#boost_functiontypes.reference.synthesis.function_pointer" title="function_pointer">function_pointer</a><span class="special">&lt;</span><span class="identifier">Seq</span><span class="special">&gt;::</span><span class="identifier">type</span><span class="special">&gt;(&amp;</span> <span class="identifier">overloaded</span><span class="special">)</span>
    143. 

  143. </pre>
    144. 

  144. <p>
    145. 

  145.       This technique can be occasionally more flexible than template argument deduction
    146. 

  146.       from a function call because the exact types from the sequence are used to
    147. 

  147.       specialize the template (including possibly cv-qualified reference types and
    148. 

  148.       the result type). It is applied twice in the <a href="../../../../function_types/example/interface.hpp" target="_top">interface
    149. 

  149.       example</a>.
    150. 

  150.     </p>
    151. 

  151. <p>
    152. 

  152.       Another interersting property of callable, builtin types is that they can be
    153. 

  153.       valid types for non-type template parameters. This way, a function can be pinpointed
    154. 

  154.       at compile time, allowing the compiler to eliminate the call by inlining. The
    155. 

  155.       <a href="../../../../function_types/example/fast_mem_fn.hpp" target="_top">fast_mem_fn example</a>
    156. 

  156.       exploits this characteristic and implements a potentially inlining version
    157. 

  157.       of <a href="../../../../bind/mem_fn.html" target="_top">boost::mem_fn</a> limited to
    158. 

  158.       member functions that are known at compile time.
    159. 

  159.     </p>
    160. 

  160. </div>
    161. 

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

  162. <td align="left"></td>
    163. 

  163. <td align="right"><div class="copyright-footer">Copyright &#169; 2004-2007 Tobias
    164. 

  164.       Schwinger<p>
    165. 

  165.         Distributed under the Boost Software License, Version 1.0. (See accompanying
    166. 

  166.         file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
    167. 

  167.       </p>
    168. 

  168. </div></td>
    169. 

  169. </tr></table>
    170. 

  170. <hr>
    171. 

  171. <div class="spirit-nav">
    172. 

  172. <a accesskey="p" href="introduction.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="about_tag_types.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
    173. 

  173. </div>
    174. 

  174. </body>
    175. 

  175. </html>
    176.