1<html> 2<head> 3<meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> 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.79.1"> 7<link rel="home" href="../index.html" title="Chapter 1. Boost.Core"> 8<link rel="up" href="../index.html" title="Chapter 1. Boost.Core"> 9<link rel="prev" href="empty_value.html" title="empty_value"> 10<link rel="next" href="exchange.html" title="exchange"> 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="empty_value.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="exchange.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="idm45312829399232"></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ä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 <boost/core/enable_if.hpp>">Header 70 <boost/core/enable_if.hpp></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"><</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">></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"><</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">></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"><</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">struct</span> <span class="identifier">lazy_enable_if</span><span class="special">;</span> 76 <span class="keyword">template</span> <span class="special"><</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">struct</span> <span class="identifier">lazy_disable_if</span><span class="special">;</span> 77 78 <span class="keyword">template</span> <span class="special"><</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">></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"><</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">></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"><</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">struct</span> <span class="identifier">lazy_enable_if_c</span><span class="special">;</span> 81 <span class="keyword">template</span> <span class="special"><</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">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"><</span><span class="keyword">class</span> <span class="identifier">F</span><span class="special">></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">&</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">&);</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"><</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">></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"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> 159<span class="keyword">struct</span> <span class="identifier">enable_if_c</span><span class="special"><</span><span class="keyword">false</span><span class="special">,</span> <span class="identifier">T</span><span class="special">></span> <span class="special">{};</span> 160 161<span class="keyword">template</span> <span class="special"><</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">></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"><</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">></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"><</span><span class="identifier">B</span><span class="special">,</span> 171 <span class="identifier">T</span><span class="special">>::</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"><</span><span class="identifier">B</span><span class="special">,</span> <span class="identifier">T</span><span class="special">>::</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"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> 181<span class="keyword">typename</span> <span class="identifier">enable_if_c</span><span class="special"><</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_arithmetic</span><span class="special"><</span><span class="identifier">T</span><span class="special">>::</span><span class="identifier">value</span><span class="special">,</span> <span class="identifier">T</span><span class="special">>::</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"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> 191<span class="keyword">typename</span> <span class="identifier">disable_if_c</span><span class="special"><</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_arithmetic</span><span class="special"><</span><span class="identifier">T</span><span class="special">>::</span><span class="identifier">value</span><span class="special">,</span> <span class="identifier">T</span><span class="special">>::</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"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> 208<span class="keyword">typename</span> <span class="identifier">enable_if</span><span class="special"><</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_arithmetic</span><span class="special"><</span><span class="identifier">T</span><span class="special">>,</span> <span class="identifier">T</span><span class="special">>::</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"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></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"><</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_arithmetic</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">>::</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"><</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">></span> 296<span class="preprocessor">#include</span> <span class="special"><</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">></span> 297<span class="preprocessor">#include</span> <span class="special"><</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">></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"><</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"><</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">>::</span><span class="identifier">type</span> <span class="special">=</span> <span class="number">0</span><span class="special">></span> 306 <span class="identifier">test</span><span class="special">(</span> <span class="identifier">T</span><span class="special">&&...</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"><</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"><</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_arithmetic</span><span class="special"><</span> <span class="identifier">T</span> <span class="special">>,</span> 311 <span class="keyword">int</span> <span class="special">>::</span><span class="identifier">type</span> <span class="special">=</span> <span class="number">0</span><span class="special">></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"><</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"><</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_pointer</span><span class="special"><</span> <span class="identifier">T</span> <span class="special">>,</span> 317 <span class="keyword">int</span> <span class="special">>::</span><span class="identifier">type</span> <span class="special">=</span> <span class="number">0</span><span class="special">></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"><</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">></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"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> 354<span class="keyword">class</span> <span class="identifier">A</span><span class="special"><</span><span class="identifier">T</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">enable_if</span><span class="special"><</span><span class="identifier">is_integral</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">>::</span><span class="identifier">type</span><span class="special">></span> <span class="special">{</span> <span class="special">...</span> <span class="special">};</span> 355 356<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> 357<span class="keyword">class</span> <span class="identifier">A</span><span class="special"><</span><span class="identifier">T</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">enable_if</span><span class="special"><</span><span class="identifier">is_float</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">>::</span><span class="identifier">type</span><span class="special">></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<p> 370 The <code class="computeroutput"><span class="identifier">enable_if_has_type</span></code> 371 template is usable this scenario but instead of using a type traits to 372 enable or disable a specialization, it use a SFINAE context to check for 373 the existence of a dependent type inside its parameter. For example, the 374 following structure extracts a dependent <code class="computeroutput"><span class="identifier">value_type</span></code> 375 from T if and only if <code class="computeroutput"><span class="identifier">T</span><span class="special">::</span><span class="identifier">value_type</span></code> 376 exists. 377 </p> 378<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Enable</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">></span> 379<span class="keyword">class</span> <span class="identifier">value_type_from</span> 380<span class="special">{</span> 381 <span class="keyword">typedef</span> <span class="identifier">T</span> <span class="identifier">type</span><span class="special">;</span> 382<span class="special">};</span> 383 384<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> 385<span class="keyword">class</span> <span class="identifier">value_type_from</span><span class="special"><</span><span class="identifier">T</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">enable_if_has_type</span><span class="special"><</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">::</span><span class="identifier">value_type</span><span class="special">>::</span><span class="identifier">type</span><span class="special">></span> 386<span class="special">{</span> 387 <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">T</span><span class="special">::</span><span class="identifier">value_type</span> <span class="identifier">type</span><span class="special">;</span> 388<span class="special">};</span> 389</pre> 390</div> 391<div class="section"> 392<div class="titlepage"><div><div><h4 class="title"> 393<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 394 enabler conditions</a> 395</h4></div></div></div> 396<p> 397 Once the compiler has examined the enabling conditions and included the 398 function into the overload resolution set, normal C++ overload resolution 399 rules are used to select the best matching function. In particular, there 400 is no ordering between enabling conditions. Function templates with enabling 401 conditions that are not mutually exclusive can lead to ambiguities. For 402 example: 403 </p> 404<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> 405<span class="keyword">typename</span> <span class="identifier">enable_if</span><span class="special"><</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_integral</span><span class="special"><</span><span class="identifier">T</span><span class="special">>,</span> <span class="keyword">void</span><span class="special">>::</span><span class="identifier">type</span> 406<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> 407 408<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> 409<span class="keyword">typename</span> <span class="identifier">enable_if</span><span class="special"><</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_arithmetic</span><span class="special"><</span><span class="identifier">T</span><span class="special">>,</span> <span class="keyword">void</span><span class="special">>::</span><span class="identifier">type</span> 410<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> 411</pre> 412<p> 413 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 414 conditions are true and both functions are thus in the overload resolution 415 set. They are both equally good matches and thus ambiguous. Of course, 416 more than one enabling condition can be simultaneously true as long as 417 other arguments disambiguate the functions. 418 </p> 419<p> 420 The above discussion applies to using <code class="computeroutput"><span class="identifier">enable_if</span></code> 421 in class template partial specializations as well. 422 </p> 423</div> 424<div class="section"> 425<div class="titlepage"><div><div><h4 class="title"> 426<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 427 enable_if</a> 428</h4></div></div></div> 429<p> 430 In some cases it is necessary to avoid instantiating part of a function 431 signature unless an enabling condition is true. For example: 432 </p> 433<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">U</span><span class="special">></span> <span class="keyword">class</span> <span class="identifier">mult_traits</span><span class="special">;</span> 434 435<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">U</span><span class="special">></span> 436<span class="keyword">typename</span> <span class="identifier">enable_if</span><span class="special"><</span><span class="identifier">is_multipliable</span><span class="special"><</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">U</span><span class="special">>,</span> 437 <span class="keyword">typename</span> <span class="identifier">mult_traits</span><span class="special"><</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">U</span><span class="special">>::</span><span class="identifier">type</span><span class="special">>::</span><span class="identifier">type</span> 438<span class="keyword">operator</span><span class="special">*(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&</span> <span class="identifier">t</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">U</span><span class="special">&</span> <span class="identifier">u</span><span class="special">)</span> <span class="special">{</span> <span class="special">...</span> <span class="special">}</span> 439</pre> 440<p> 441 Assume the class template <code class="computeroutput"><span class="identifier">mult_traits</span></code> 442 is a traits class defining the resulting type of a multiplication operator. 443 The <code class="computeroutput"><span class="identifier">is_multipliable</span></code> traits 444 class specifies for which types to enable the operator. Whenever <code class="computeroutput"><span class="identifier">is_multipliable</span><span class="special"><</span><span class="identifier">A</span><span class="special">,</span> <span class="identifier">B</span><span class="special">>::</span><span class="identifier">value</span></code> 445 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>, 446 then <code class="computeroutput"><span class="identifier">mult_traits</span><span class="special"><</span><span class="identifier">A</span><span class="special">,</span> <span class="identifier">B</span><span class="special">>::</span><span class="identifier">type</span></code> 447 is defined. 448 </p> 449<p> 450 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> 451 for which <code class="computeroutput"><span class="identifier">is_multipliable</span><span class="special"><</span><span class="identifier">C</span><span class="special">,</span> <span class="identifier">D</span><span class="special">>::</span><span class="identifier">value</span></code> is <code class="computeroutput"><span class="keyword">false</span></code> 452 and <code class="computeroutput"><span class="identifier">mult_traits</span><span class="special"><</span><span class="identifier">C</span><span class="special">,</span> <span class="identifier">D</span><span class="special">>::</span><span class="identifier">type</span></code> 453 is not defined is an error on some compilers. The SFINAE principle is not 454 applied because the invalid type occurs as an argument to another template. 455 The <code class="computeroutput"><span class="identifier">lazy_enable_if</span></code> and 456 <code class="computeroutput"><span class="identifier">lazy_disable_if</span></code> templates 457 (and their <code class="computeroutput"><span class="identifier">_c</span></code> versions) 458 can be used in such situations: 459 </p> 460<pre class="programlisting"><span class="keyword">template</span><span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">U</span><span class="special">></span> 461<span class="keyword">typename</span> <span class="identifier">lazy_enable_if</span><span class="special"><</span><span class="identifier">is_multipliable</span><span class="special"><</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">U</span><span class="special">>,</span> 462 <span class="identifier">mult_traits</span><span class="special"><</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">U</span><span class="special">></span> <span class="special">>::</span><span class="identifier">type</span> 463<span class="keyword">operator</span><span class="special">*(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&</span> <span class="identifier">t</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">U</span><span class="special">&</span> <span class="identifier">u</span><span class="special">)</span> <span class="special">{</span> <span class="special">...</span> <span class="special">}</span> 464</pre> 465<p> 466 The second argument of <code class="computeroutput"><span class="identifier">lazy_enable_if</span></code> 467 must be a class type that defines a nested type named <code class="computeroutput"><span class="identifier">type</span></code> 468 whenever the first parameter (the condition) is true. 469 </p> 470<div class="note"><table border="0" summary="Note"> 471<tr> 472<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../doc/src/images/note.png"></td> 473<th align="left">Note</th> 474</tr> 475<tr><td align="left" valign="top"><p> 476 Referring to one member type or static constant in a traits class causes 477 all of the members (type and static constant) of that specialization 478 to be instantiated. Therefore, if your traits classes can sometimes contain 479 invalid types, you should use two distinct templates for describing the 480 conditions and the type mappings. In the above example, <code class="computeroutput"><span class="identifier">is_multipliable</span><span class="special"><</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">U</span><span class="special">>::</span><span class="identifier">value</span></code> defines when <code class="computeroutput"><span class="identifier">mult_traits</span><span class="special"><</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">U</span><span class="special">>::</span><span class="identifier">type</span></code> 481 is valid. 482 </p></td></tr> 483</table></div> 484</div> 485<div class="section"> 486<div class="titlepage"><div><div><h4 class="title"> 487<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 488 workarounds</a> 489</h4></div></div></div> 490<p> 491 Some compilers flag functions as ambiguous if the only distinguishing factor 492 is a different condition in an enabler (even though the functions could 493 never be ambiguous). For example, some compilers (e.g. GCC 3.2) diagnose 494 the following two functions as ambiguous: 495 </p> 496<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> 497<span class="keyword">typename</span> <span class="identifier">enable_if</span><span class="special"><</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_arithmetic</span><span class="special"><</span><span class="identifier">T</span><span class="special">>,</span> <span class="identifier">T</span><span class="special">>::</span><span class="identifier">type</span> 498<span class="identifier">foo</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">t</span><span class="special">);</span> 499 500<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> 501<span class="keyword">typename</span> <span class="identifier">disable_if</span><span class="special"><</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_arithmetic</span><span class="special"><</span><span class="identifier">T</span><span class="special">>,</span> <span class="identifier">T</span><span class="special">>::</span><span class="identifier">type</span> 502<span class="identifier">foo</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">t</span><span class="special">);</span> 503</pre> 504<p> 505 Two workarounds can be applied: 506 </p> 507<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "> 508<li class="listitem"> 509<p class="simpara"> 510 Use an extra dummy parameter which disambiguates the functions. Use 511 a default value for it to hide the parameter from the caller. For example: 512 </p> 513<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">int</span><span class="special">></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> 514 515<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> 516<span class="keyword">typename</span> <span class="identifier">enable_if</span><span class="special"><</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_arithmetic</span><span class="special"><</span><span class="identifier">T</span><span class="special">>,</span> <span class="identifier">T</span><span class="special">>::</span><span class="identifier">type</span> 517<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"><</span><span class="number">0</span><span class="special">></span> <span class="special">=</span> <span class="number">0</span><span class="special">);</span> 518 519<span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> 520<span class="keyword">typename</span> <span class="identifier">disable_if</span><span class="special"><</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_arithmetic</span><span class="special"><</span><span class="identifier">T</span><span class="special">>,</span> <span class="identifier">T</span><span class="special">>::</span><span class="identifier">type</span> 521<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"><</span><span class="number">1</span><span class="special">></span> <span class="special">=</span> <span class="number">0</span><span class="special">);</span> 522</pre> 523</li> 524<li class="listitem"> 525<p class="simpara"> 526 Define the functions in different namespaces and bring them into a 527 common namespace with <code class="computeroutput"><span class="keyword">using</span></code> 528 declarations: 529 </p> 530<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">A</span> <span class="special">{</span> 531 <span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> 532 <span class="keyword">typename</span> <span class="identifier">enable_if</span><span class="special"><</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_arithmetic</span><span class="special"><</span><span class="identifier">T</span><span class="special">>,</span> <span class="identifier">T</span><span class="special">>::</span><span class="identifier">type</span> 533 <span class="identifier">foo</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">t</span><span class="special">);</span> 534<span class="special">}</span> 535 536<span class="keyword">namespace</span> <span class="identifier">B</span> <span class="special">{</span> 537 <span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> 538 <span class="keyword">typename</span> <span class="identifier">disable_if</span><span class="special"><</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_arithmetic</span><span class="special"><</span><span class="identifier">T</span><span class="special">>,</span> <span class="identifier">T</span><span class="special">>::</span><span class="identifier">type</span> 539 <span class="identifier">foo</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">t</span><span class="special">);</span> 540<span class="special">}</span> 541 542<span class="keyword">using</span> <span class="identifier">A</span><span class="special">::</span><span class="identifier">foo</span><span class="special">;</span> 543<span class="keyword">using</span> <span class="identifier">B</span><span class="special">::</span><span class="identifier">foo</span><span class="special">;</span> 544</pre> 545<p class="simpara"> 546 Note that the second workaround above cannot be used for member templates. 547 On the other hand, operators do not accept extra arguments, which makes 548 the first workaround unusable. As the net effect, neither of the workarounds 549 are of assistance for templated operators that need to be defined as 550 member functions (assignment and subscript operators). 551 </p> 552</li> 553</ul></div> 554</div> 555</div> 556<div class="section"> 557<div class="titlepage"><div><div><h3 class="title"> 558<a name="core.enable_if.acknowledgements"></a><a class="link" href="enable_if.html#core.enable_if.acknowledgements" title="Acknowledgements">Acknowledgements</a> 559</h3></div></div></div> 560<p> 561 We are grateful to Howard Hinnant, Jason Shirk, Paul Mensonides, and Richard 562 Smith whose findings have influenced the library. 563 </p> 564</div> 565<div class="section"> 566<div class="titlepage"><div><div><h3 class="title"> 567<a name="core.enable_if.references"></a><a class="link" href="enable_if.html#core.enable_if.references" title="References">References</a> 568</h3></div></div></div> 569<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "> 570<li class="listitem"> 571 <a name="REF1"></a>[1] Jaakko Järvi, Jeremiah Willcock, Howard Hinnant, 572 and Andrew Lumsdaine. Function overloading based on arbitrary properties 573 of types. <span class="emphasis"><em>C++ Users Journal</em></span>, 21(6):25--32, June 574 2003. 575 </li> 576<li class="listitem"> 577 <a name="REF2"></a>[2] Jaakko Järvi, Jeremiah Willcock, and Andrew 578 Lumsdaine. Concept-controlled polymorphism. In Frank Pfennig and Yannis 579 Smaragdakis, editors, <span class="emphasis"><em>Generative Programming and Component 580 Engineering</em></span>, volume 2830 of <span class="emphasis"><em>LNCS</em></span>, pages 581 228--244. Springer Verlag, September 2003. 582 </li> 583<li class="listitem"> 584 <a name="REF3"></a>[3] David Vandevoorde and Nicolai M. Josuttis. <span class="emphasis"><em>C++ 585 Templates: The Complete Guide</em></span>. Addison-Wesley, 2002. 586 </li> 587</ul></div> 588</div> 589</div> 590<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> 591<td align="left"></td> 592<td align="right"><div class="copyright-footer">Copyright © 2014 Peter Dimov<br>Copyright © 2014 Glen Fernandes<br>Copyright © 2014 Andrey Semashev<p> 593 Distributed under the <a href="http://boost.org/LICENSE_1_0.txt" target="_top">Boost 594 Software License, Version 1.0</a>. 595 </p> 596</div></td> 597</tr></table> 598<hr> 599<div class="spirit-nav"> 600<a accesskey="p" href="empty_value.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="exchange.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a> 601</div> 602</body> 603</html> 604
