libs/core/doc/html/core/enable_if.html

   1 <html>
   2 <head>
   3 <meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
   4 <title>enable_if</title>
   5 <link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css">
   6 <meta name="generator" content="DocBook XSL Stylesheets V1.78.1">
   7 <link rel="home" href="../index.html" title="Chapter&#160;1.&#160;Boost.Core">
   8 <link rel="up" href="../index.html" title="Chapter&#160;1.&#160;Boost.Core">
   9 <link rel="prev" href="demangle.html" title="demangle">
  10 <link rel="next" href="explicit_operator_bool.html" title="explicit_operator_bool">
  11 </head>
  12 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
  13 <table cellpadding="2" width="100%"><tr>
  14 <td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
  15 <td align="center"><a href="../../../../../index.html">Home</a></td>
  16 <td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
  17 <td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
  18 <td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
  19 <td align="center"><a href="../../../../../more/index.htm">More</a></td>
  20 </tr></table>
  21 <hr>
  22 <div class="spirit-nav">
  23 <a accesskey="p" href="demangle.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="explicit_operator_bool.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
  24 </div>
  25 <div class="section">
  26 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
  27 <a name="core.enable_if"></a><a class="link" href="enable_if.html" title="enable_if">enable_if</a>
  28 </h2></div></div></div>
  29 <div class="toc"><dl class="toc">
  30 <dt><span class="section"><a href="enable_if.html#core.enable_if.introduction">Introduction</a></span></dt>
  31 <dt><span class="section"><a href="enable_if.html#core.enable_if.the_enable_if_templates">The enable_if
  32       templates</a></span></dt>
  33 <dt><span class="section"><a href="enable_if.html#core.enable_if.using_enable_if">Using enable_if</a></span></dt>
  34 <dt><span class="section"><a href="enable_if.html#core.enable_if.acknowledgements">Acknowledgements</a></span></dt>
  35 <dt><span class="section"><a href="enable_if.html#core.enable_if.references">References</a></span></dt>
  36 </dl></div>
  37 <div class="simplesect">
  38 <div class="titlepage"><div><div><h3 class="title">
  39 <a name="idp92547776"></a>Authors</h3></div></div></div>
  40 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
  41 <li class="listitem">
  42           Jaakko J&#228;rvi
  43         </li>
  44 <li class="listitem">
  45           Jeremiah Willcock
  46         </li>
  47 <li class="listitem">
  48           Andrew Lumsdaine
  49         </li>
  50 </ul></div>
  51 </div>
  52 <div class="section">
  53 <div class="titlepage"><div><div><h3 class="title">
  54 <a name="core.enable_if.introduction"></a><a class="link" href="enable_if.html#core.enable_if.introduction" title="Introduction">Introduction</a>
  55 </h3></div></div></div>
  56 <p>
  57         The <code class="computeroutput"><span class="identifier">enable_if</span></code> family of templates
  58         is a set of tools to allow a function template or a class template specialization
  59         to include or exclude itself from a set of matching functions or specializations
  60         based on properties of its template arguments. For example, one can define
  61         function templates that are only enabled for, and thus only match, an arbitrary
  62         set of types defined by a traits class. The <code class="computeroutput"><span class="identifier">enable_if</span></code>
  63         templates can also be applied to enable class template specializations. Applications
  64         of <code class="computeroutput"><span class="identifier">enable_if</span></code> are discussed
  65         in length in <a class="link" href="enable_if.html#REF1">[1]</a> and <a class="link" href="enable_if.html#REF2">[2]</a>.
  66       </p>
  67 <div class="section">
  68 <div class="titlepage"><div><div><h4 class="title">
  69 <a name="core.enable_if.introduction.header_boost_core_enable_if_hpp"></a><a class="link" href="enable_if.html#core.enable_if.introduction.header_boost_core_enable_if_hpp" title="Header &lt;boost/core/enable_if.hpp&gt;">Header
  70         &lt;boost/core/enable_if.hpp&gt;</a>
  71 </h4></div></div></div>
  72 <pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
  73     <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Cond</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">enable_if</span><span class="special">;</span>
  74     <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Cond</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">disable_if</span><span class="special">;</span>
  75     <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Cond</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">lazy_enable_if</span><span class="special">;</span>
  76     <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Cond</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">lazy_disable_if</span><span class="special">;</span>
  77
  78     <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">bool</span> <span class="identifier">B</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">enable_if_c</span><span class="special">;</span>
  79     <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">bool</span> <span class="identifier">B</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">disable_if_c</span><span class="special">;</span>
  80     <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">bool</span> <span class="identifier">B</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">lazy_enable_if_c</span><span class="special">;</span>
  81     <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">bool</span> <span class="identifier">B</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">lazy_disable_if_c</span><span class="special">;</span>
  82 <span class="special">}</span>
  83 </pre>
  84 </div>
  85 <div class="section">
  86 <div class="titlepage"><div><div><h4 class="title">
  87 <a name="core.enable_if.introduction.background"></a><a class="link" href="enable_if.html#core.enable_if.introduction.background" title="Background">Background</a>
  88 </h4></div></div></div>
  89 <p>
  90           Sensible operation of template function overloading in C++ relies on the
  91           <span class="emphasis"><em>SFINAE</em></span> (substitution-failure-is-not-an-error) principle
  92           <a class="link" href="enable_if.html#REF3">[3]</a>: if an invalid argument or return type
  93           is formed during the instantiation of a function template, the instantiation
  94           is removed from the overload resolution set instead of causing a compilation
  95           error. The following example, taken from <a class="link" href="enable_if.html#REF1">[1]</a>,
  96           demonstrates why this is important:
  97         </p>
  98 <pre class="programlisting"><span class="keyword">int</span> <span class="identifier">negate</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="keyword">return</span> <span class="special">-</span><span class="identifier">i</span><span class="special">;</span> <span class="special">}</span>
  99
 100 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">F</span><span class="special">&gt;</span>
 101 <span class="keyword">typename</span> <span class="identifier">F</span><span class="special">::</span><span class="identifier">result_type</span> <span class="identifier">negate</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">F</span><span class="special">&amp;</span> <span class="identifier">f</span><span class="special">)</span> <span class="special">{</span> <span class="keyword">return</span> <span class="special">-</span><span class="identifier">f</span><span class="special">();</span> <span class="special">}</span>
 102 </pre>
 103 <p>
 104           Suppose the compiler encounters the call <code class="computeroutput"><span class="identifier">negate</span><span class="special">(</span><span class="number">1</span><span class="special">)</span></code>.
 105           The first definition is obviously a better match, but the compiler must
 106           nevertheless consider (and instantiate the prototypes) of both definitions
 107           to find this out. Instantiating the latter definition with <code class="computeroutput"><span class="identifier">F</span></code> as <code class="computeroutput"><span class="keyword">int</span></code>
 108           would result in:
 109         </p>
 110 <pre class="programlisting"><span class="keyword">int</span><span class="special">::</span><span class="identifier">result_type</span> <span class="identifier">negate</span><span class="special">(</span><span class="keyword">const</span> <span class="keyword">int</span><span class="special">&amp;);</span>
 111 </pre>
 112 <p>
 113           where the return type is invalid. If this were an error, adding an unrelated
 114           function template (that was never called) could break otherwise valid code.
 115           Due to the SFINAE principle the above example is not, however, erroneous.
 116           The latter definition of <code class="computeroutput"><span class="identifier">negate</span></code>
 117           is simply removed from the overload resolution set.
 118         </p>
 119 <p>
 120           The <code class="computeroutput"><span class="identifier">enable_if</span></code> templates
 121           are tools for controlled creation of the SFINAE conditions.
 122         </p>
 123 </div>
 124 </div>
 125 <div class="section">
 126 <div class="titlepage"><div><div><h3 class="title">
 127 <a name="core.enable_if.the_enable_if_templates"></a><a class="link" href="enable_if.html#core.enable_if.the_enable_if_templates" title="The enable_if templates">The enable_if
 128       templates</a>
 129 </h3></div></div></div>
 130 <p>
 131         The names of the <code class="computeroutput"><span class="identifier">enable_if</span></code>
 132         templates have three parts: an optional <code class="computeroutput"><span class="identifier">lazy_</span></code>
 133         tag, either <code class="computeroutput"><span class="identifier">enable_if</span></code> or
 134         <code class="computeroutput"><span class="identifier">disable_if</span></code>, and an optional
 135         <code class="computeroutput"><span class="identifier">_c</span></code> tag. All eight combinations
 136         of these parts are supported. The meaning of the <code class="computeroutput"><span class="identifier">lazy_</span></code>
 137         tag is described in the section <a class="link" href="enable_if.html#core.enable_if.using_enable_if.enable_if_lazy" title="Lazy enable_if">below</a>.
 138         The second part of the name indicates whether a true condition argument should
 139         enable or disable the current overload. The third part of the name indicates
 140         whether the condition argument is a <code class="computeroutput"><span class="keyword">bool</span></code>
 141         value (<code class="computeroutput"><span class="identifier">_c</span></code> suffix), or a type
 142         containing a static <code class="computeroutput"><span class="keyword">bool</span></code> constant
 143         named <code class="computeroutput"><span class="identifier">value</span></code> (no suffix).
 144         The latter version interoperates with Boost.MPL.
 145       </p>
 146 <p>
 147         The definitions of <code class="computeroutput"><span class="identifier">enable_if_c</span></code>
 148         and <code class="computeroutput"><span class="identifier">enable_if</span></code> are as follows
 149         (we use <code class="computeroutput"><span class="identifier">enable_if</span></code> templates
 150         unqualified but they are in the <code class="computeroutput"><span class="identifier">boost</span></code>
 151         namespace).
 152       </p>
 153 <pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">bool</span> <span class="identifier">B</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">&gt;</span>
 154 <span class="keyword">struct</span> <span class="identifier">enable_if_c</span> <span class="special">{</span>
 155     <span class="keyword">typedef</span> <span class="identifier">T</span> <span class="identifier">type</span><span class="special">;</span>
 156 <span class="special">};</span>
 157
 158 <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>
 159 <span class="keyword">struct</span> <span class="identifier">enable_if_c</span><span class="special">&lt;</span><span class="keyword">false</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="special">{};</span>
 160
 161 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Cond</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">&gt;</span>
 162 <span class="keyword">struct</span> <span class="identifier">enable_if</span> <span class="special">:</span> <span class="keyword">public</span> <span class="identifier">enable_if_c</span><span class="special">&lt;</span><span class="identifier">Cond</span><span class="special">::</span><span class="identifier">value</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="special">{};</span>
 163 </pre>
 164 <p>
 165         An instantiation of the <code class="computeroutput"><span class="identifier">enable_if_c</span></code>
 166         template with the parameter <code class="computeroutput"><span class="identifier">B</span></code>
 167         as <code class="computeroutput"><span class="keyword">true</span></code> contains a member type
 168         <code class="computeroutput"><span class="identifier">type</span></code>, defined to be <code class="computeroutput"><span class="identifier">T</span></code>. If <code class="computeroutput"><span class="identifier">B</span></code>
 169         is <code class="computeroutput"><span class="keyword">false</span></code>, no such member is
 170         defined. Thus <code class="computeroutput"><span class="identifier">enable_if_c</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">,</span>
 171         <span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">type</span></code> is either a valid or an invalid type
 172         expression, depending on the value of <code class="computeroutput"><span class="identifier">B</span></code>.
 173         When valid, <code class="computeroutput"><span class="identifier">enable_if_c</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">type</span></code>
 174         equals <code class="computeroutput"><span class="identifier">T</span></code>. The <code class="computeroutput"><span class="identifier">enable_if_c</span></code> template can thus be used for
 175         controlling when functions are considered for overload resolution and when
 176         they are not. For example, the following function is defined for all arithmetic
 177         types (according to the classification of the Boost <span class="bold"><strong>type_traits</strong></span>
 178         library):
 179       </p>
 180 <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>
 181 <span class="keyword">typename</span> <span class="identifier">enable_if_c</span><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_arithmetic</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">type</span>
 182 <span class="identifier">foo</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">t</span><span class="special">)</span> <span class="special">{</span> <span class="keyword">return</span> <span class="identifier">t</span><span class="special">;</span> <span class="special">}</span>
 183 </pre>
 184 <p>
 185         The <code class="computeroutput"><span class="identifier">disable_if_c</span></code> template
 186         is provided as well, and has the same functionality as <code class="computeroutput"><span class="identifier">enable_if_c</span></code>
 187         except for the negated condition. The following function is enabled for all
 188         non-arithmetic types.
 189       </p>
 190 <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>
 191 <span class="keyword">typename</span> <span class="identifier">disable_if_c</span><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_arithmetic</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">type</span>
 192 <span class="identifier">bar</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">t</span><span class="special">)</span> <span class="special">{</span> <span class="keyword">return</span> <span class="identifier">t</span><span class="special">;</span> <span class="special">}</span>
 193 </pre>
 194 <p>
 195         For easier syntax in some cases and interoperation with Boost.MPL we provide
 196         versions of the <code class="computeroutput"><span class="identifier">enable_if</span></code>
 197         templates taking any type with a <code class="computeroutput"><span class="keyword">bool</span></code>
 198         member constant named <code class="computeroutput"><span class="identifier">value</span></code>
 199         as the condition argument. The MPL <code class="computeroutput"><span class="identifier">bool_</span></code>,
 200         <code class="computeroutput"><span class="identifier">and_</span></code>, <code class="computeroutput"><span class="identifier">or_</span></code>,
 201         and <code class="computeroutput"><span class="identifier">not_</span></code> templates are likely
 202         to be useful for creating such types. Also, the traits classes in the Boost.Type_traits
 203         library follow this convention. For example, the above example function
 204         <code class="computeroutput"><span class="identifier">foo</span></code> can be alternatively
 205         written as:
 206       </p>
 207 <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>
 208 <span class="keyword">typename</span> <span class="identifier">enable_if</span><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_arithmetic</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;,</span> <span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">type</span>
 209 <span class="identifier">foo</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">t</span><span class="special">)</span> <span class="special">{</span> <span class="keyword">return</span> <span class="identifier">t</span><span class="special">;</span> <span class="special">}</span>
 210 </pre>
 211 </div>
 212 <div class="section">
 213 <div class="titlepage"><div><div><h3 class="title">
 214 <a name="core.enable_if.using_enable_if"></a><a class="link" href="enable_if.html#core.enable_if.using_enable_if" title="Using enable_if">Using enable_if</a>
 215 </h3></div></div></div>
 216 <p>
 217         The <code class="computeroutput"><span class="identifier">enable_if</span></code> templates are
 218         defined in <code class="computeroutput"><span class="identifier">boost</span><span class="special">/</span><span class="identifier">utility</span><span class="special">/</span><span class="identifier">enable_if</span><span class="special">.</span><span class="identifier">hpp</span></code>, which is included by <code class="computeroutput"><span class="identifier">boost</span><span class="special">/</span><span class="identifier">utility</span><span class="special">.</span><span class="identifier">hpp</span></code>.
 219       </p>
 220 <p>
 221         With respect to function templates, <code class="computeroutput"><span class="identifier">enable_if</span></code>
 222         can be used in multiple different ways:
 223       </p>
 224 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
 225 <li class="listitem">
 226             As the return type of an instantiatied function
 227           </li>
 228 <li class="listitem">
 229             As an extra parameter of an instantiated function
 230           </li>
 231 <li class="listitem">
 232             As an extra template parameter (useful only in a compiler that supports
 233             C++0x default arguments for function template parameters, see <a class="link" href="enable_if.html#core.enable_if.using_enable_if.enable_if_0x" title="Enabling function templates in C++0x">Enabling
 234             function templates in C++0x</a> for details.
 235           </li>
 236 </ul></div>
 237 <p>
 238         In the previous section, the return type form of <code class="computeroutput"><span class="identifier">enable_if</span></code>
 239         was shown. As an example of using the form of <code class="computeroutput"><span class="identifier">enable_if</span></code>
 240         that works via an extra function parameter, the <code class="computeroutput"><span class="identifier">foo</span></code>
 241         function in the previous section could also be written as:
 242       </p>
 243 <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>
 244 <span class="identifier">T</span> <span class="identifier">foo</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">t</span><span class="special">,</span>
 245     <span class="keyword">typename</span> <span class="identifier">enable_if</span><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_arithmetic</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">type</span><span class="special">*</span> <span class="identifier">dummy</span> <span class="special">=</span> <span class="number">0</span><span class="special">);</span>
 246 </pre>
 247 <p>
 248         Hence, an extra parameter of type <code class="computeroutput"><span class="keyword">void</span><span class="special">*</span></code> is added, but it is given a default value
 249         to keep the parameter hidden from client code. Note that the second template
 250         argument was not given to <code class="computeroutput"><span class="identifier">enable_if</span></code>,
 251         as the default <code class="computeroutput"><span class="keyword">void</span></code> gives the
 252         desired behavior.
 253       </p>
 254 <p>
 255         Which way to write the enabler is largely a matter of taste, but for certain
 256         functions, only a subset of the options is possible:
 257       </p>
 258 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
 259 <li class="listitem">
 260             Many operators have a fixed number of arguments, thus <code class="computeroutput"><span class="identifier">enable_if</span></code>
 261             must be used either in the return type or in an extra template parameter.
 262           </li>
 263 <li class="listitem">
 264             Functions that have a variadic parameter list must use either the return
 265             type form or an extra template parameter.
 266           </li>
 267 <li class="listitem">
 268             Constructors do not have a return type so you must use either an extra
 269             function parameter or an extra template parameter.
 270           </li>
 271 <li class="listitem">
 272             Constructors that have a variadic parameter list must an extra template
 273             parameter.
 274           </li>
 275 <li class="listitem">
 276             Conversion operators can only be written with an extra template parameter.
 277           </li>
 278 </ul></div>
 279 <div class="section">
 280 <div class="titlepage"><div><div><h4 class="title">
 281 <a name="core.enable_if.using_enable_if.enable_if_0x"></a><a class="link" href="enable_if.html#core.enable_if.using_enable_if.enable_if_0x" title="Enabling function templates in C++0x">Enabling
 282         function templates in C++0x</a>
 283 </h4></div></div></div>
 284 <p>
 285           In a compiler which supports C++0x default arguments for function template
 286           parameters, you can enable and disable function templates by adding an
 287           additional template parameter. This approach works in all situations where
 288           you would use either the return type form of <code class="computeroutput"><span class="identifier">enable_if</span></code>
 289           or the function parameter form, including operators, constructors, variadic
 290           function templates, and even overloaded conversion operations.
 291         </p>
 292 <p>
 293           As an example:
 294         </p>
 295 <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">type_traits</span><span class="special">/</span><span class="identifier">is_arithmetic</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 296 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_pointer</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 297 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">utility</span><span class="special">/</span><span class="identifier">enable_if</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 298
 299 <span class="keyword">class</span> <span class="identifier">test</span>
 300 <span class="special">{</span>
 301 <span class="keyword">public</span><span class="special">:</span>
 302     <span class="comment">// A constructor that works for any argument list of size 10</span>
 303     <span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">T</span><span class="special">,</span>
 304         <span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">enable_if_c</span><span class="special">&lt;</span> <span class="keyword">sizeof</span><span class="special">...(</span> <span class="identifier">T</span> <span class="special">)</span> <span class="special">==</span> <span class="number">10</span><span class="special">,</span>
 305             <span class="keyword">int</span> <span class="special">&gt;::</span><span class="identifier">type</span> <span class="special">=</span> <span class="number">0</span><span class="special">&gt;</span>
 306     <span class="identifier">test</span><span class="special">(</span> <span class="identifier">T</span><span class="special">&amp;&amp;...</span> <span class="special">);</span>
 307
 308     <span class="comment">// A conversion operation that can convert to any arithmetic type</span>
 309     <span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span>
 310         <span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">enable_if</span><span class="special">&lt;</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_arithmetic</span><span class="special">&lt;</span> <span class="identifier">T</span> <span class="special">&gt;,</span>
 311             <span class="keyword">int</span> <span class="special">&gt;::</span><span class="identifier">type</span> <span class="special">=</span> <span class="number">0</span><span class="special">&gt;</span>
 312     <span class="keyword">operator</span> <span class="identifier">T</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
 313
 314     <span class="comment">// A conversion operation that can convert to any pointer type</span>
 315     <span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span>
 316         <span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">enable_if</span><span class="special">&lt;</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_pointer</span><span class="special">&lt;</span> <span class="identifier">T</span> <span class="special">&gt;,</span>
 317             <span class="keyword">int</span> <span class="special">&gt;::</span><span class="identifier">type</span> <span class="special">=</span> <span class="number">0</span><span class="special">&gt;</span>
 318     <span class="keyword">operator</span> <span class="identifier">T</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
 319 <span class="special">};</span>
 320
 321 <span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
 322 <span class="special">{</span>
 323     <span class="comment">// Works</span>
 324     <span class="identifier">test</span> <span class="identifier">test_</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="number">10</span> <span class="special">);</span>
 325
 326     <span class="comment">// Fails as expected</span>
 327     <span class="identifier">test</span> <span class="identifier">fail_construction</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>
 328
 329     <span class="comment">// Works by calling the conversion operator enabled for arithmetic types</span>
 330     <span class="keyword">int</span> <span class="identifier">arithmetic_object</span> <span class="special">=</span> <span class="identifier">test_</span><span class="special">;</span>
 331
 332     <span class="comment">// Works by calling the conversion operator enabled for pointer types</span>
 333     <span class="keyword">int</span><span class="special">*</span> <span class="identifier">pointer_object</span> <span class="special">=</span> <span class="identifier">test_</span><span class="special">;</span>
 334
 335     <span class="comment">// Fails as expected</span>
 336     <span class="keyword">struct</span> <span class="special">{}</span> <span class="identifier">fail_conversion</span> <span class="special">=</span> <span class="identifier">test_</span><span class="special">;</span>
 337 <span class="special">}</span>
 338 </pre>
 339 </div>
 340 <div class="section">
 341 <div class="titlepage"><div><div><h4 class="title">
 342 <a name="core.enable_if.using_enable_if.enabling_template_class_speciali"></a><a class="link" href="enable_if.html#core.enable_if.using_enable_if.enabling_template_class_speciali" title="Enabling template class specializations">Enabling
 343         template class specializations</a>
 344 </h4></div></div></div>
 345 <p>
 346           Class template specializations can be enabled or disabled with <code class="computeroutput"><span class="identifier">enable_if</span></code>. One extra template parameter
 347           needs to be added for the enabler expressions. This parameter has the default
 348           value <code class="computeroutput"><span class="keyword">void</span></code>. For example:
 349         </p>
 350 <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">,</span> <span class="keyword">class</span> <span class="identifier">Enable</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">&gt;</span>
 351 <span class="keyword">class</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">...</span> <span class="special">};</span>
 352
 353 <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>
 354 <span class="keyword">class</span> <span class="identifier">A</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">enable_if</span><span class="special">&lt;</span><span class="identifier">is_integral</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">type</span><span class="special">&gt;</span> <span class="special">{</span> <span class="special">...</span> <span class="special">};</span>
 355
 356 <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>
 357 <span class="keyword">class</span> <span class="identifier">A</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">enable_if</span><span class="special">&lt;</span><span class="identifier">is_float</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">type</span><span class="special">&gt;</span> <span class="special">{</span> <span class="special">...</span> <span class="special">};</span>
 358 </pre>
 359 <p>
 360           Instantiating <code class="computeroutput"><span class="identifier">A</span></code> with any
 361           integral type matches the first specialization, whereas any floating point
 362           type matches the second one. All other types match the primary template.
 363           The condition can be any compile-time boolean expression that depends on
 364           the template arguments of the class. Note that again, the second argument
 365           to <code class="computeroutput"><span class="identifier">enable_if</span></code> is not needed;
 366           the default (<code class="computeroutput"><span class="keyword">void</span></code>) is the
 367           correct value.
 368         </p>
 369 </div>
 370 <div class="section">
 371 <div class="titlepage"><div><div><h4 class="title">
 372 <a name="core.enable_if.using_enable_if.overlapping_enabler_conditions"></a><a class="link" href="enable_if.html#core.enable_if.using_enable_if.overlapping_enabler_conditions" title="Overlapping enabler conditions">Overlapping
 373         enabler conditions</a>
 374 </h4></div></div></div>
 375 <p>
 376           Once the compiler has examined the enabling conditions and included the
 377           function into the overload resolution set, normal C++ overload resolution
 378           rules are used to select the best matching function. In particular, there
 379           is no ordering between enabling conditions. Function templates with enabling
 380           conditions that are not mutually exclusive can lead to ambiguities. For
 381           example:
 382         </p>
 383 <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>
 384 <span class="keyword">typename</span> <span class="identifier">enable_if</span><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_integral</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;,</span> <span class="keyword">void</span><span class="special">&gt;::</span><span class="identifier">type</span>
 385 <span class="identifier">foo</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">t</span><span class="special">)</span> <span class="special">{}</span>
 386
 387 <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>
 388 <span class="keyword">typename</span> <span class="identifier">enable_if</span><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_arithmetic</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;,</span> <span class="keyword">void</span><span class="special">&gt;::</span><span class="identifier">type</span>
 389 <span class="identifier">foo</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">t</span><span class="special">)</span> <span class="special">{}</span>
 390 </pre>
 391 <p>
 392           All integral types are also arithmetic. Therefore, say, for the call <code class="computeroutput"><span class="identifier">foo</span><span class="special">(</span><span class="number">1</span><span class="special">)</span></code>, both
 393           conditions are true and both functions are thus in the overload resolution
 394           set. They are both equally good matches and thus ambiguous. Of course,
 395           more than one enabling condition can be simultaneously true as long as
 396           other arguments disambiguate the functions.
 397         </p>
 398 <p>
 399           The above discussion applies to using <code class="computeroutput"><span class="identifier">enable_if</span></code>
 400           in class template partial specializations as well.
 401         </p>
 402 </div>
 403 <div class="section">
 404 <div class="titlepage"><div><div><h4 class="title">
 405 <a name="core.enable_if.using_enable_if.enable_if_lazy"></a><a class="link" href="enable_if.html#core.enable_if.using_enable_if.enable_if_lazy" title="Lazy enable_if">Lazy
 406         enable_if</a>
 407 </h4></div></div></div>
 408 <p>
 409           In some cases it is necessary to avoid instantiating part of a function
 410           signature unless an enabling condition is true. For example:
 411         </p>
 412 <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">,</span> <span class="keyword">class</span> <span class="identifier">U</span><span class="special">&gt;</span> <span class="keyword">class</span> <span class="identifier">mult_traits</span><span class="special">;</span>
 413
 414 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">U</span><span class="special">&gt;</span>
 415 <span class="keyword">typename</span> <span class="identifier">enable_if</span><span class="special">&lt;</span><span class="identifier">is_multipliable</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">U</span><span class="special">&gt;,</span>
 416     <span class="keyword">typename</span> <span class="identifier">mult_traits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">U</span><span class="special">&gt;::</span><span class="identifier">type</span><span class="special">&gt;::</span><span class="identifier">type</span>
 417 <span class="keyword">operator</span><span class="special">*(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">t</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">U</span><span class="special">&amp;</span> <span class="identifier">u</span><span class="special">)</span> <span class="special">{</span> <span class="special">...</span> <span class="special">}</span>
 418 </pre>
 419 <p>
 420           Assume the class template <code class="computeroutput"><span class="identifier">mult_traits</span></code>
 421           is a traits class defining the resulting type of a multiplication operator.
 422           The <code class="computeroutput"><span class="identifier">is_multipliable</span></code> traits
 423           class specifies for which types to enable the operator. Whenever <code class="computeroutput"><span class="identifier">is_multipliable</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">,</span> <span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span></code>
 424           is <code class="computeroutput"><span class="keyword">true</span></code> for some types <code class="computeroutput"><span class="identifier">A</span></code> and <code class="computeroutput"><span class="identifier">B</span></code>,
 425           then <code class="computeroutput"><span class="identifier">mult_traits</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">,</span> <span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">type</span></code>
 426           is defined.
 427         </p>
 428 <p>
 429           Now, trying to invoke (some other overload) of <code class="computeroutput"><span class="keyword">operator</span><span class="special">*</span></code> with, say, operand types <code class="computeroutput"><span class="identifier">C</span></code> and <code class="computeroutput"><span class="identifier">D</span></code>
 430           for which <code class="computeroutput"><span class="identifier">is_multipliable</span><span class="special">&lt;</span><span class="identifier">C</span><span class="special">,</span> <span class="identifier">D</span><span class="special">&gt;::</span><span class="identifier">value</span></code> is <code class="computeroutput"><span class="keyword">false</span></code>
 431           and <code class="computeroutput"><span class="identifier">mult_traits</span><span class="special">&lt;</span><span class="identifier">C</span><span class="special">,</span> <span class="identifier">D</span><span class="special">&gt;::</span><span class="identifier">type</span></code>
 432           is not defined is an error on some compilers. The SFINAE principle is not
 433           applied because the invalid type occurs as an argument to another template.
 434           The <code class="computeroutput"><span class="identifier">lazy_enable_if</span></code> and
 435           <code class="computeroutput"><span class="identifier">lazy_disable_if</span></code> templates
 436           (and their <code class="computeroutput"><span class="identifier">_c</span></code> versions)
 437           can be used in such situations:
 438         </p>
 439 <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">,</span> <span class="keyword">class</span> <span class="identifier">U</span><span class="special">&gt;</span>
 440 <span class="keyword">typename</span> <span class="identifier">lazy_enable_if</span><span class="special">&lt;</span><span class="identifier">is_multipliable</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">U</span><span class="special">&gt;,</span>
 441     <span class="identifier">mult_traits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">U</span><span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">type</span>
 442 <span class="keyword">operator</span><span class="special">*(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">t</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">U</span><span class="special">&amp;</span> <span class="identifier">u</span><span class="special">)</span> <span class="special">{</span> <span class="special">...</span> <span class="special">}</span>
 443 </pre>
 444 <p>
 445           The second argument of <code class="computeroutput"><span class="identifier">lazy_enable_if</span></code>
 446           must be a class type that defines a nested type named <code class="computeroutput"><span class="identifier">type</span></code>
 447           whenever the first parameter (the condition) is true.
 448         </p>
 449 <div class="note"><table border="0" summary="Note">
 450 <tr>
 451 <td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../doc/src/images/note.png"></td>
 452 <th align="left">Note</th>
 453 </tr>
 454 <tr><td align="left" valign="top"><p>
 455             Referring to one member type or static constant in a traits class causes
 456             all of the members (type and static constant) of that specialization
 457             to be instantiated. Therefore, if your traits classes can sometimes contain
 458             invalid types, you should use two distinct templates for describing the
 459             conditions and the type mappings. In the above example, <code class="computeroutput"><span class="identifier">is_multipliable</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">U</span><span class="special">&gt;::</span><span class="identifier">value</span></code> defines when <code class="computeroutput"><span class="identifier">mult_traits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">U</span><span class="special">&gt;::</span><span class="identifier">type</span></code>
 460             is valid.
 461           </p></td></tr>
 462 </table></div>
 463 </div>
 464 <div class="section">
 465 <div class="titlepage"><div><div><h4 class="title">
 466 <a name="core.enable_if.using_enable_if.compiler_workarounds"></a><a class="link" href="enable_if.html#core.enable_if.using_enable_if.compiler_workarounds" title="Compiler workarounds">Compiler
 467         workarounds</a>
 468 </h4></div></div></div>
 469 <p>
 470           Some compilers flag functions as ambiguous if the only distinguishing factor
 471           is a different condition in an enabler (even though the functions could
 472           never be ambiguous). For example, some compilers (e.g. GCC 3.2) diagnose
 473           the following two functions as ambiguous:
 474         </p>
 475 <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>
 476 <span class="keyword">typename</span> <span class="identifier">enable_if</span><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_arithmetic</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;,</span> <span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">type</span>
 477 <span class="identifier">foo</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">t</span><span class="special">);</span>
 478
 479 <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>
 480 <span class="keyword">typename</span> <span class="identifier">disable_if</span><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_arithmetic</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;,</span> <span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">type</span>
 481 <span class="identifier">foo</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">t</span><span class="special">);</span>
 482 </pre>
 483 <p>
 484           Two workarounds can be applied:
 485         </p>
 486 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
 487 <li class="listitem">
 488 <p class="simpara">
 489               Use an extra dummy parameter which disambiguates the functions. Use
 490               a default value for it to hide the parameter from the caller. For example:
 491             </p>
 492 <pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">dummy</span> <span class="special">{</span> <span class="identifier">dummy</span><span class="special">(</span><span class="keyword">int</span><span class="special">)</span> <span class="special">{}</span> <span class="special">};</span>
 493
 494 <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>
 495 <span class="keyword">typename</span> <span class="identifier">enable_if</span><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_arithmetic</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;,</span> <span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">type</span>
 496 <span class="identifier">foo</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">t</span><span class="special">,</span> <span class="identifier">dummy</span><span class="special">&lt;</span><span class="number">0</span><span class="special">&gt;</span> <span class="special">=</span> <span class="number">0</span><span class="special">);</span>
 497
 498 <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>
 499 <span class="keyword">typename</span> <span class="identifier">disable_if</span><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_arithmetic</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;,</span> <span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">type</span>
 500 <span class="identifier">foo</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">t</span><span class="special">,</span> <span class="identifier">dummy</span><span class="special">&lt;</span><span class="number">1</span><span class="special">&gt;</span> <span class="special">=</span> <span class="number">0</span><span class="special">);</span>
 501 </pre>
 502 </li>
 503 <li class="listitem">
 504 <p class="simpara">
 505               Define the functions in different namespaces and bring them into a
 506               common namespace with <code class="computeroutput"><span class="keyword">using</span></code>
 507               declarations:
 508             </p>
 509 <pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">A</span> <span class="special">{</span>
 510     <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>
 511     <span class="keyword">typename</span> <span class="identifier">enable_if</span><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_arithmetic</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;,</span> <span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">type</span>
 512     <span class="identifier">foo</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">t</span><span class="special">);</span>
 513 <span class="special">}</span>
 514
 515 <span class="keyword">namespace</span> <span class="identifier">B</span> <span class="special">{</span>
 516     <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>
 517     <span class="keyword">typename</span> <span class="identifier">disable_if</span><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_arithmetic</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;,</span> <span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">type</span>
 518     <span class="identifier">foo</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">t</span><span class="special">);</span>
 519 <span class="special">}</span>
 520
 521 <span class="keyword">using</span> <span class="identifier">A</span><span class="special">::</span><span class="identifier">foo</span><span class="special">;</span>
 522 <span class="keyword">using</span> <span class="identifier">B</span><span class="special">::</span><span class="identifier">foo</span><span class="special">;</span>
 523 </pre>
 524 <p class="simpara">
 525               Note that the second workaround above cannot be used for member templates.
 526               On the other hand, operators do not accept extra arguments, which makes
 527               the first workaround unusable. As the net effect, neither of the workarounds
 528               are of assistance for templated operators that need to be defined as
 529               member functions (assignment and subscript operators).
 530             </p>
 531 </li>
 532 </ul></div>
 533 </div>
 534 </div>
 535 <div class="section">
 536 <div class="titlepage"><div><div><h3 class="title">
 537 <a name="core.enable_if.acknowledgements"></a><a class="link" href="enable_if.html#core.enable_if.acknowledgements" title="Acknowledgements">Acknowledgements</a>
 538 </h3></div></div></div>
 539 <p>
 540         We are grateful to Howard Hinnant, Jason Shirk, Paul Mensonides, and Richard
 541         Smith whose findings have influenced the library.
 542       </p>
 543 </div>
 544 <div class="section">
 545 <div class="titlepage"><div><div><h3 class="title">
 546 <a name="core.enable_if.references"></a><a class="link" href="enable_if.html#core.enable_if.references" title="References">References</a>
 547 </h3></div></div></div>
 548 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
 549 <li class="listitem">
 550             <a name="REF1"></a>[1] Jaakko J&#228;rvi, Jeremiah Willcock, Howard Hinnant,
 551             and Andrew Lumsdaine. Function overloading based on arbitrary properties
 552             of types. <span class="emphasis"><em>C++ Users Journal</em></span>, 21(6):25--32, June
 553             2003.
 554           </li>
 555 <li class="listitem">
 556             <a name="REF2"></a>[2] Jaakko J&#228;rvi, Jeremiah Willcock, and Andrew
 557             Lumsdaine. Concept-controlled polymorphism. In Frank Pfennig and Yannis
 558             Smaragdakis, editors, <span class="emphasis"><em>Generative Programming and Component
 559             Engineering</em></span>, volume 2830 of <span class="emphasis"><em>LNCS</em></span>, pages
 560             228--244. Springer Verlag, September 2003.
 561           </li>
 562 <li class="listitem">
 563             <a name="REF3"></a>[3] David Vandevoorde and Nicolai M. Josuttis. <span class="emphasis"><em>C++
 564             Templates: The Complete Guide</em></span>. Addison-Wesley, 2002.
 565           </li>
 566 </ul></div>
 567 </div>
 568 </div>
 569 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 570 <td align="left"></td>
 571 <td align="right"><div class="copyright-footer">Copyright &#169; 2014 Peter Dimov<br>Copyright &#169; 2014 Glen Fernandes<br>Copyright &#169; 2014 Andrey Semashev<p>
 572         Distributed under the <a href="http://boost.org/LICENSE_1_0.txt" target="_top">Boost
 573         Software License, Version 1.0</a>.
 574       </p>
 575 </div></td>
 576 </tr></table>
 577 <hr>
 578 <div class="spirit-nav">
 579 <a accesskey="p" href="demangle.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="explicit_operator_bool.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
 580 </div>
 581 </body>
 582 </html>