ceph/src/boost/libs/type_traits/doc/html/boost_typetraits/reference/common_type.html

   1 <html>
   2 <head>
   3 <meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
   4 <title>common_type</title>
   5 <link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
   6 <meta name="generator" content="DocBook XSL Stylesheets V1.77.1">
   7 <link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits">
   8 <link rel="up" href="../reference.html" title="Alphabetical Reference">
   9 <link rel="prev" href="conditional.html" title="conditional">
  10 <link rel="next" href="copy_cv.html" title="copy_cv">
  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="conditional.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.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="copy_cv.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
  24 </div>
  25 <div class="section">
  26 <div class="titlepage"><div><div><h3 class="title">
  27 <a name="boost_typetraits.reference.common_type"></a><a class="link" href="common_type.html" title="common_type">common_type</a>
  28 </h3></div></div></div>
  29 <p>
  30         <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span>
  31         <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">common_type</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
  32         or <code class="computeroutput"> <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">hpp</span><span class="special">&gt;</span></code>
  33       </p>
  34 <pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
  35   <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">&gt;</span> <span class="keyword">struct</span> <span class="identifier">common_type</span><span class="special">;</span>
  36 <span class="special">}</span>
  37 </pre>
  38 <p>
  39         <code class="computeroutput"><span class="identifier">common_type</span></code> is a traits class
  40         used to deduce a type common to a several types, useful as the return type
  41         of functions operating on multiple input types such as in mixed-mode arithmetic..
  42       </p>
  43 <p>
  44         The nested typedef <code class="computeroutput"><span class="special">::</span><span class="identifier">type</span></code>
  45         could be defined as follows:
  46       </p>
  47 <pre class="programlisting"><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">&gt;</span>
  48 <span class="keyword">struct</span> <span class="identifier">common_type</span><span class="special">;</span>
  49
  50 <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">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">V</span><span class="special">&gt;</span>
  51 <span class="keyword">struct</span> <span class="identifier">common_type</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">U</span><span class="special">,</span> <span class="identifier">V</span><span class="special">...&gt;</span> <span class="special">{</span>
  52     <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">common_type</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">common_type</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">,</span> <span class="identifier">V</span><span class="special">...&gt;::</span><span class="identifier">type</span> <span class="identifier">type</span><span class="special">;</span>
  53 <span class="special">};</span>
  54
  55 <span class="keyword">template</span> <span class="special">&lt;&gt;</span>
  56 <span class="keyword">struct</span> <span class="identifier">common_type</span><span class="special">&lt;&gt;</span> <span class="special">{</span>
  57 <span class="special">};</span>
  58
  59 <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>
  60 <span class="keyword">struct</span> <span class="identifier">common_type</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">{</span>
  61     <span class="keyword">typedef</span> <span class="keyword">typename</span> <a class="link" href="decay.html" title="decay">decay</a><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">type</span><span class="special">;</span>
  62 <span class="special">};</span>
  63
  64 <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>
  65 <span class="keyword">struct</span> <span class="identifier">common_type</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">{</span>
  66     <span class="keyword">typedef</span> <span class="keyword">typename</span> <a class="link" href="decay.html" title="decay">decay</a><span class="special">&lt;</span>
  67         <span class="keyword">decltype</span><span class="special">(</span> <a class="link" href="declval.html" title="declval">declval</a><span class="special">&lt;</span><span class="keyword">bool</span><span class="special">&gt;()?</span>
  68             <a class="link" href="declval.html" title="declval">declval</a><span class="special">&lt;</span><span class="keyword">typename</span> <a class="link" href="decay.html" title="decay">decay</a><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">type</span><span class="special">&gt;():</span>
  69             <a class="link" href="declval.html" title="declval">declval</a><span class="special">&lt;</span><span class="keyword">typename</span> <a class="link" href="decay.html" title="decay">decay</a><span class="special">&lt;</span><span class="identifier">U</span><span class="special">&gt;::</span><span class="identifier">type</span><span class="special">&gt;()</span> <span class="special">)</span>
  70     <span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">type</span><span class="special">;</span>
  71 <span class="special">};</span>
  72 </pre>
  73 <p>
  74         All parameter types must be complete. This trait is permitted to be specialized
  75         by a user if at least one template parameter is a user-defined type. <span class="bold"><strong>Note:</strong></span> Such specializations are required when only
  76         explicit conversions are desired among the <code class="computeroutput"><span class="identifier">common_type</span></code>
  77         arguments.
  78       </p>
  79 <p>
  80         Note that when the compiler does not support variadic templates (and the
  81         macro <code class="computeroutput"><span class="identifier">BOOST_NO_CXX11_VARIADIC_TEMPLATES</span></code>
  82         is defined) then the maximum number of template arguments is 9.
  83       </p>
  84 <h5>
  85 <a name="boost_typetraits.reference.common_type.h0"></a>
  86         <span class="phrase"><a name="boost_typetraits.reference.common_type.tutorial"></a></span><a class="link" href="common_type.html#boost_typetraits.reference.common_type.tutorial">Tutorial</a>
  87       </h5>
  88 <p>
  89         In a nutshell, <code class="computeroutput"><span class="identifier">common_type</span></code>
  90         is a trait that takes 1 or more types, and returns a type which all of the
  91         types will convert to. The default definition demands this conversion be
  92         implicit. However the trait can be specialized for user-defined types which
  93         want to limit their inter-type conversions to explicit, and yet still want
  94         to interoperate with the <code class="computeroutput"><span class="identifier">common_type</span></code>
  95         facility.
  96       </p>
  97 <p>
  98         <span class="bold"><strong>Example:</strong></span>
  99       </p>
 100 <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>
 101 <span class="identifier">complex</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">common_type</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>
 102 <span class="keyword">operator</span><span class="special">+(</span><span class="identifier">complex</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;,</span> <span class="identifier">complex</span><span class="special">&lt;</span><span class="identifier">U</span><span class="special">&gt;);</span>
 103 </pre>
 104 <p>
 105         In the above example, "mixed-mode" complex arithmetic is allowed.
 106         The return type is described by <code class="computeroutput"><span class="identifier">common_type</span></code>.
 107         For example the resulting type of adding a <code class="computeroutput"><span class="identifier">complex</span><span class="special">&lt;</span><span class="keyword">float</span><span class="special">&gt;</span></code> and <code class="computeroutput"><span class="identifier">complex</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;</span></code> might be a <code class="computeroutput"><span class="identifier">complex</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;</span></code>.
 108       </p>
 109 <p>
 110         Here is how someone might produce a variadic comparison function:
 111       </p>
 112 <pre class="programlisting"><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">&gt;</span>
 113 <span class="keyword">typename</span> <span class="identifier">common_type</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">...&gt;::</span><span class="identifier">type</span>
 114 <span class="identifier">min</span><span class="special">(</span><span class="identifier">T</span><span class="special">...</span> <span class="identifier">t</span><span class="special">);</span>
 115 </pre>
 116 <p>
 117         This is a very useful and broadly applicable utility.
 118       </p>
 119 <h5>
 120 <a name="boost_typetraits.reference.common_type.h1"></a>
 121         <span class="phrase"><a name="boost_typetraits.reference.common_type.how_to_get_the_common_type_of_types_with_explicit_conversions_"></a></span><a class="link" href="common_type.html#boost_typetraits.reference.common_type.how_to_get_the_common_type_of_types_with_explicit_conversions_">How
 122         to get the common type of types with explicit conversions?</a>
 123       </h5>
 124 <p>
 125         Another choice for the author of the preceding operator could be
 126       </p>
 127 <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>
 128 <span class="keyword">typename</span> <span class="identifier">common_type</span><span class="special">&lt;</span><span class="identifier">complex</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;,</span> <span class="identifier">complex</span><span class="special">&lt;</span><span class="identifier">U</span><span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">type</span>
 129 <span class="keyword">operator</span><span class="special">+(</span><span class="identifier">complex</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;,</span> <span class="identifier">complex</span><span class="special">&lt;</span><span class="identifier">U</span><span class="special">&gt;);</span>
 130 </pre>
 131 <p>
 132         As the default definition of <code class="computeroutput"><span class="identifier">common_type</span></code>
 133         demands the conversion be implicit, we need to specialize the trait for complex
 134         types as follows.
 135       </p>
 136 <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>
 137 <span class="keyword">struct</span> <span class="identifier">common_type</span><span class="special">&lt;</span><span class="identifier">complex</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;,</span> <span class="identifier">complex</span><span class="special">&lt;</span><span class="identifier">U</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="special">{</span>
 138     <span class="keyword">typedef</span> <span class="identifier">complex</span><span class="special">&lt;</span> <span class="identifier">common_type</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><span class="special">;</span>
 139 <span class="special">};</span>
 140 </pre>
 141 <h5>
 142 <a name="boost_typetraits.reference.common_type.h2"></a>
 143         <span class="phrase"><a name="boost_typetraits.reference.common_type.how_important_is_the_order_of_the__code__phrase_role__identifier__common_type__phrase__phrase_role__special___lt__gt___phrase___code__template_arguments_"></a></span><a class="link" href="common_type.html#boost_typetraits.reference.common_type.how_important_is_the_order_of_the__code__phrase_role__identifier__common_type__phrase__phrase_role__special___lt__gt___phrase___code__template_arguments_">How
 144         important is the order of the <code class="computeroutput"><span class="identifier">common_type</span><span class="special">&lt;&gt;</span></code> template arguments?</a>
 145       </h5>
 146 <p>
 147         The order of the template parameters is important.
 148       </p>
 149 <p>
 150         <code class="computeroutput"><span class="identifier">common_type</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">,</span><span class="identifier">B</span><span class="special">,</span><span class="identifier">C</span><span class="special">&gt;::</span><span class="identifier">type</span></code> is not equivalent to <code class="computeroutput"><span class="identifier">common_type</span><span class="special">&lt;</span><span class="identifier">C</span><span class="special">,</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>, but to <code class="computeroutput"><span class="identifier">common_type</span><span class="special">&lt;</span><span class="identifier">common_type</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><span class="special">,</span> <span class="identifier">C</span><span class="special">&gt;::</span><span class="identifier">type</span></code>.
 151       </p>
 152 <p>
 153         Consider
 154       </p>
 155 <pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{};</span>
 156 <span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{};</span>
 157 <span class="keyword">struct</span> <span class="identifier">C</span> <span class="special">{</span>
 158     <span class="identifier">C</span><span class="special">()</span> <span class="special">{}</span>
 159     <span class="identifier">C</span><span class="special">(</span><span class="identifier">A</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="special">{}</span>
 160     <span class="identifier">C</span><span class="special">(</span><span class="identifier">B</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="special">{}</span>
 161     <span class="identifier">C</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="identifier">C</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="special">{</span>
 162         <span class="keyword">return</span> <span class="special">*</span><span class="keyword">this</span><span class="special">;</span>
 163     <span class="special">}</span>
 164 <span class="special">};</span>
 165 </pre>
 166 <p>
 167         The following doesn't compile
 168       </p>
 169 <pre class="programlisting"><span class="keyword">typedef</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">common_type</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">,</span> <span class="identifier">B</span><span class="special">,</span> <span class="identifier">C</span><span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">ABC</span><span class="special">;</span> <span class="comment">// Does not compile</span>
 170 </pre>
 171 <p>
 172         while
 173       </p>
 174 <pre class="programlisting"><span class="keyword">typedef</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">common_type</span><span class="special">&lt;</span><span class="identifier">C</span><span class="special">,</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> <span class="identifier">ABC</span><span class="special">;</span>
 175 </pre>
 176 <p>
 177         compiles.
 178       </p>
 179 <p>
 180         Thus, as <code class="computeroutput"><span class="identifier">common_type</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>
 181         is undefined, <code class="computeroutput"><span class="identifier">common_type</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">,</span><span class="identifier">B</span><span class="special">,</span><span class="identifier">C</span><span class="special">&gt;::</span><span class="identifier">type</span></code>
 182         is also undefined.
 183       </p>
 184 <p>
 185         It is intended that clients who wish for <code class="computeroutput"><span class="identifier">common_type</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">,</span>
 186         <span class="identifier">B</span><span class="special">&gt;</span></code>
 187         to be well defined to define it themselves:
 188       </p>
 189 <pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span>
 190 <span class="special">{</span>
 191
 192 <span class="keyword">template</span> <span class="special">&lt;&gt;</span>
 193 <span class="keyword">struct</span> <span class="identifier">common_type</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="special">{</span><span class="keyword">typedef</span> <span class="identifier">C</span> <span class="identifier">type</span><span class="special">;};</span>
 194
 195 <span class="special">}</span>
 196 </pre>
 197 <p>
 198         Now this client can ask for <code class="computeroutput"><span class="identifier">common_type</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">,</span>
 199         <span class="identifier">B</span><span class="special">,</span> <span class="identifier">C</span><span class="special">&gt;</span></code> (and
 200         get the same answer).
 201       </p>
 202 <p>
 203         Clients wanting to ask <code class="computeroutput"><span class="identifier">common_type</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">,</span>
 204         <span class="identifier">B</span><span class="special">,</span> <span class="identifier">C</span><span class="special">&gt;</span></code> in
 205         any order and get the same result need to add in addition:
 206       </p>
 207 <pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span>
 208 <span class="special">{</span>
 209
 210 <span class="keyword">template</span> <span class="special">&lt;&gt;</span> <span class="keyword">struct</span> <span class="identifier">common_type</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">,</span> <span class="identifier">A</span><span class="special">&gt;</span>
 211 <span class="special">:</span> <span class="keyword">public</span> <span class="identifier">common_type</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="special">{};</span>
 212
 213 <span class="special">}</span>
 214 </pre>
 215 <p>
 216         This is needed as the specialization of <code class="computeroutput"><span class="identifier">common_type</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">,</span>
 217         <span class="identifier">B</span><span class="special">&gt;</span></code>
 218         is not be used implicitly for <code class="computeroutput"><span class="identifier">common_type</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">,</span>
 219         <span class="identifier">A</span><span class="special">&gt;</span></code>.
 220       </p>
 221 <h5>
 222 <a name="boost_typetraits.reference.common_type.h3"></a>
 223         <span class="phrase"><a name="boost_typetraits.reference.common_type.can_the__code__phrase_role__identifier__common_type__phrase___code__of_two_types_be_a_third_type_"></a></span><a class="link" href="common_type.html#boost_typetraits.reference.common_type.can_the__code__phrase_role__identifier__common_type__phrase___code__of_two_types_be_a_third_type_">Can
 224         the <code class="computeroutput"><span class="identifier">common_type</span></code> of two types
 225         be a third type?</a>
 226       </h5>
 227 <p>
 228         Given the preceding example, one might expect <code class="computeroutput"><span class="identifier">common_type</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> to be <code class="computeroutput"><span class="identifier">C</span></code>
 229         without any intervention from the user. But the default <code class="computeroutput"><span class="identifier">common_type</span><span class="special">&lt;&gt;</span></code> implementation doesn't grant that.
 230         It is intended that clients who wish for <code class="computeroutput"><span class="identifier">common_type</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">,</span>
 231         <span class="identifier">B</span><span class="special">&gt;</span></code>
 232         to be well defined to define it themselves:
 233       </p>
 234 <pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span>
 235 <span class="special">{</span>
 236
 237 <span class="keyword">template</span> <span class="special">&lt;&gt;</span>
 238 <span class="keyword">struct</span> <span class="identifier">common_type</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="special">{</span><span class="keyword">typedef</span> <span class="identifier">C</span> <span class="identifier">type</span><span class="special">;};</span>
 239
 240 <span class="keyword">template</span> <span class="special">&lt;&gt;</span> <span class="keyword">struct</span> <span class="identifier">common_type</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">,</span> <span class="identifier">A</span><span class="special">&gt;</span>
 241 <span class="special">:</span> <span class="keyword">public</span> <span class="identifier">common_type</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="special">{};</span>
 242
 243 <span class="special">}</span>
 244 </pre>
 245 <p>
 246         Now this client can ask for <code class="computeroutput"><span class="identifier">common_type</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">,</span>
 247         <span class="identifier">B</span><span class="special">&gt;</span></code>.
 248       </p>
 249 <h5>
 250 <a name="boost_typetraits.reference.common_type.h4"></a>
 251         <span class="phrase"><a name="boost_typetraits.reference.common_type.how_does__code__phrase_role__identifier__common_type__phrase___code__behave_with_pointers_"></a></span><a class="link" href="common_type.html#boost_typetraits.reference.common_type.how_does__code__phrase_role__identifier__common_type__phrase___code__behave_with_pointers_">How
 252         does <code class="computeroutput"><span class="identifier">common_type</span></code> behave with
 253         pointers?</a>
 254       </h5>
 255 <p>
 256         Consider
 257       </p>
 258 <pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">C</span> <span class="special">{</span> <span class="special">}:</span>
 259 <span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">:</span> <span class="identifier">C</span> <span class="special">{</span> <span class="special">};</span>
 260 <span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">:</span> <span class="identifier">C</span> <span class="special">{</span> <span class="special">};</span>
 261 </pre>
 262 <p>
 263         Shouldn't <code class="computeroutput"><span class="identifier">common_type</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>
 264         be <code class="computeroutput"><span class="identifier">C</span><span class="special">*</span></code>?
 265         I would say yes, but the default implementation will make it ill-formed.
 266       </p>
 267 <p>
 268         The library could add a specialization for pointers, as
 269       </p>
 270 <pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span>
 271 <span class="special">{</span>
 272
 273     <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">A</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">B</span><span class="special">&gt;</span>
 274     <span class="keyword">struct</span> <span class="identifier">common_type</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="special">{</span>
 275         <span class="keyword">typedef</span> <span class="identifier">common_type</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><span class="special">;</span>
 276     <span class="special">};</span>
 277 <span class="special">}</span>
 278 </pre>
 279 <p>
 280         But in the absence of a motivating use cases, we prefer not to add more than
 281         the standard specifies.
 282       </p>
 283 <p>
 284         Of course the user can always make this specialization.
 285       </p>
 286 <h5>
 287 <a name="boost_typetraits.reference.common_type.h5"></a>
 288         <span class="phrase"><a name="boost_typetraits.reference.common_type.can_you_explain_the_pros_cons_of__code__phrase_role__identifier__common_type__phrase___code__against_boost_typeof_"></a></span><a class="link" href="common_type.html#boost_typetraits.reference.common_type.can_you_explain_the_pros_cons_of__code__phrase_role__identifier__common_type__phrase___code__against_boost_typeof_">Can
 289         you explain the pros/cons of <code class="computeroutput"><span class="identifier">common_type</span></code>
 290         against Boost.Typeof?</a>
 291       </h5>
 292 <p>
 293         Even if they appear to be close, <code class="computeroutput"><span class="identifier">common_type</span></code>
 294         and <code class="computeroutput"><span class="identifier">typeof</span></code> have different
 295         purposes. You use <code class="computeroutput"><span class="identifier">typeof</span></code>
 296         to get the type of an expression, while you use <code class="computeroutput"><span class="identifier">common_type</span></code>
 297         to set explicitly the type returned of a template function. Both are complementary,
 298         and indeed <code class="computeroutput"><span class="identifier">common_type</span></code> is
 299         approximately equivalent to <code class="computeroutput"><span class="keyword">decltype</span><span class="special">(</span><a class="link" href="declval.html" title="declval">declval</a><span class="special">&lt;</span><span class="keyword">bool</span><span class="special">&gt;()</span>
 300         <span class="special">?</span> <a class="link" href="declval.html" title="declval">declval</a><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;()</span>
 301         <span class="special">:</span> <a class="link" href="declval.html" title="declval">declval</a><span class="special">&lt;</span><span class="identifier">U</span><span class="special">&gt;())</span></code>.
 302       </p>
 303 <p>
 304         <code class="computeroutput"><span class="identifier">common_type</span></code> is also similar
 305         to <code class="computeroutput"><span class="identifier">promote_args</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="special">...</span><span class="identifier">T</span><span class="special">&gt;</span></code> in
 306         <code class="computeroutput"><span class="identifier">boost</span><span class="special">/</span><span class="identifier">math</span><span class="special">/</span><span class="identifier">tools</span><span class="special">/</span><span class="identifier">promotion</span><span class="special">.</span><span class="identifier">hpp</span></code>, though
 307         it is not exactly the same as <code class="computeroutput"><span class="identifier">promote_args</span></code>
 308         either. <code class="computeroutput"><span class="identifier">common_type</span><span class="special">&lt;</span><span class="identifier">T1</span><span class="special">,</span> <span class="identifier">T2</span><span class="special">&gt;::</span><span class="identifier">type</span></code>
 309         simply represents the result of some operation on <code class="computeroutput"><span class="identifier">T1</span></code>
 310         and <code class="computeroutput"><span class="identifier">T2</span></code>, and defaults to the
 311         type obtained by putting <code class="computeroutput"><span class="identifier">T1</span></code>
 312         and <code class="computeroutput"><span class="identifier">T2</span></code> into a conditional
 313         statement.
 314       </p>
 315 <p>
 316         It is meant to be customizable (via specialization) if this default is not
 317         appropriate.
 318       </p>
 319 </div>
 320 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 321 <td align="left"></td>
 322 <td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2011 Adobe Systems Inc, David Abrahams,
 323       Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant,
 324       Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten
 325       Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven
 326       Watanabe<p>
 327         Distributed under the Boost Software License, Version 1.0. (See accompanying
 328         file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
 329       </p>
 330 </div></td>
 331 </tr></table>
 332 <hr>
 333 <div class="spirit-nav">
 334 <a accesskey="p" href="conditional.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.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="copy_cv.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
 335 </div>
 336 </body>
 337 </html>