doc/html/boost_typeindex/examples.html

   1 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
   2 <html>
   3 <head>
   4 <meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
   5 <title>Examples</title>
   6 <link rel="stylesheet" href="../../../doc/src/boostbook.css" type="text/css">
   7 <meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
   8 <link rel="home" href="../index.html" title="The Boost C++ Libraries BoostBook Documentation Subset">
   9 <link rel="up" href="../boost_typeindex.html" title="Chapter&#160;41.&#160;Boost.TypeIndex 4.1">
  10 <link rel="prev" href="how_it_works.html" title="How it works">
  11 <link rel="next" href="../boost_typeindex_header_reference.html" title="Boost.TypeIndex Header Reference">
  12 </head>
  13 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
  14 <table cellpadding="2" width="100%"><tr>
  15 <td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../boost.png"></td>
  16 <td align="center"><a href="../../../index.html">Home</a></td>
  17 <td align="center"><a href="../../../libs/libraries.htm">Libraries</a></td>
  18 <td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
  19 <td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
  20 <td align="center"><a href="../../../more/index.htm">More</a></td>
  21 </tr></table>
  22 <hr>
  23 <div class="spirit-nav">
  24 <a accesskey="p" href="how_it_works.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../boost_typeindex.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="../boost_typeindex_header_reference.html"><img src="../../../doc/src/images/next.png" alt="Next"></a>
  25 </div>
  26 <div class="section">
  27 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
  28 <a name="boost_typeindex.examples"></a><a class="link" href="examples.html" title="Examples">Examples</a>
  29 </h2></div></div></div>
  30 <div class="toc"><dl class="toc">
  31 <dt><span class="section"><a href="examples.html#boost_typeindex.examples.getting_human_readable_and_mangl">Getting
  32       human readable and mangled type names</a></span></dt>
  33 <dt><span class="section"><a href="examples.html#boost_typeindex.examples.storing_information_about_a_type">Storing
  34       information about a type in container </a></span></dt>
  35 <dt><span class="section"><a href="examples.html#boost_typeindex.examples.getting_through_the_inheritance_">Getting
  36       through the inheritance to receive a real type name </a></span></dt>
  37 <dt><span class="section"><a href="examples.html#boost_typeindex.examples.using_runtime_cast_where_rtti_is">Using
  38       runtime_cast where RTTI is unavailable or undesirable </a></span></dt>
  39 <dt><span class="section"><a href="examples.html#boost_typeindex.examples.exact_type_matching_storing_type">Exact
  40       type matching: storing type with const, volatile and reference qualifiers</a></span></dt>
  41 <dt><span class="section"><a href="examples.html#boost_typeindex.examples.table_of_raw_name_and_pretty_nam">Table
  42       of raw_name() and pretty_name() outputs with and without RTTI </a></span></dt>
  43 <dt><span class="section"><a href="examples.html#boost_typeindex.examples.c_14_checking_namespace_at_compi">C++14:
  44       Checking namespace at compile time </a></span></dt>
  45 <dt><span class="section"><a href="examples.html#boost_typeindex.examples.c_14_checking_lexigraphical_orde">C++14:
  46       Checking lexigraphical order of provided types </a></span></dt>
  47 </dl></div>
  48 <div class="section">
  49 <div class="titlepage"><div><div><h3 class="title">
  50 <a name="boost_typeindex.examples.getting_human_readable_and_mangl"></a><a class="link" href="examples.html#boost_typeindex.examples.getting_human_readable_and_mangl" title="Getting human readable and mangled type names">Getting
  51       human readable and mangled type names</a>
  52 </h3></div></div></div>
  53 <p>
  54         The following example shows how short (mangled) and human readable type names
  55         could be obtained from a type. Works with and without RTTI.
  56       </p>
  57 <pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_index</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
  58 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</span>
  59
  60 <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>
  61 <span class="keyword">void</span> <span class="identifier">foo</span><span class="special">(</span><span class="identifier">T</span><span class="special">)</span> <span class="special">{</span>
  62     <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"\n Short name: "</span> <span class="special">&lt;&lt;</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">typeindex</span><span class="special">::</span><span class="identifier">type_id</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;().</span><span class="identifier">raw_name</span><span class="special">();</span>
  63     <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"\n Readable name: "</span> <span class="special">&lt;&lt;</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">typeindex</span><span class="special">::</span><span class="identifier">type_id</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;().</span><span class="identifier">pretty_name</span><span class="special">();</span>
  64 <span class="special">}</span>
  65
  66 <span class="keyword">struct</span> <span class="identifier">user_defined_type</span><span class="special">{};</span>
  67
  68 <span class="keyword">namespace</span> <span class="identifier">ns1</span> <span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">ns2</span> <span class="special">{</span>
  69     <span class="keyword">struct</span> <span class="identifier">user_defined_type</span><span class="special">{};</span>
  70 <span class="special">}}</span> <span class="comment">// namespace ns1::ns2</span>
  71
  72 <span class="keyword">namespace</span> <span class="special">{</span>
  73     <span class="keyword">struct</span> <span class="identifier">in_anon_type</span><span class="special">{};</span>
  74 <span class="special">}</span> <span class="comment">// anonymous namespace</span>
  75
  76 <span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span>
  77     <span class="comment">// Call to</span>
  78     <span class="identifier">foo</span><span class="special">(</span><span class="number">1</span><span class="special">);</span>
  79     <span class="comment">// will output something like this:</span>
  80     <span class="comment">//</span>
  81     <span class="comment">// (RTTI on)                                            (RTTI off)</span>
  82     <span class="comment">// Short name: i                                        Short name: int]</span>
  83     <span class="comment">// Readable name: int                                   Readable name: int</span>
  84
  85     <span class="identifier">user_defined_type</span> <span class="identifier">t</span><span class="special">;</span>
  86     <span class="identifier">foo</span><span class="special">(</span><span class="identifier">t</span><span class="special">);</span>
  87     <span class="comment">// Will output:</span>
  88     <span class="comment">//</span>
  89     <span class="comment">// (RTTI on)                                            (RTTI off)</span>
  90     <span class="comment">// Short name: 17user_defined_type                      user_defined_type]</span>
  91     <span class="comment">// Readable name: user_defined_type                     user_defined_type</span>
  92
  93     <span class="identifier">ns1</span><span class="special">::</span><span class="identifier">ns2</span><span class="special">::</span><span class="identifier">user_defined_type</span> <span class="identifier">t_in_ns</span><span class="special">;</span>
  94     <span class="identifier">foo</span><span class="special">(</span><span class="identifier">t_in_ns</span><span class="special">);</span>
  95     <span class="comment">// Will output:</span>
  96     <span class="comment">//</span>
  97     <span class="comment">// (RTTI on)                                            (RTTI off)</span>
  98     <span class="comment">// Short name: N3ns13ns217user_defined_typeE            ns1::ns2::user_defined_type]</span>
  99     <span class="comment">// Readable name: ns1::ns2::user_defined_type           ns1::ns2::user_defined_type</span>
 100
 101     <span class="identifier">in_anon_type</span> <span class="identifier">anon_t</span><span class="special">;</span>
 102     <span class="identifier">foo</span><span class="special">(</span><span class="identifier">anon_t</span><span class="special">);</span>
 103     <span class="comment">// Will output:</span>
 104     <span class="comment">//</span>
 105     <span class="comment">// (RTTI on)                                            (RTTI off)</span>
 106     <span class="comment">// Short name: N12_GLOBAL__N_112in_anon_typeE           {anonymous}::in_anon_type]</span>
 107     <span class="comment">// Readable name: (anonymous namespace)::in_anon_type   {anonymous}::in_anon_type</span>
 108 <span class="special">}</span>
 109 </pre>
 110 <p>
 111         Short names are very compiler dependant: some compiler will output <code class="computeroutput"><span class="special">.</span><span class="identifier">H</span></code>, others
 112         <code class="computeroutput"><span class="identifier">i</span></code>.
 113       </p>
 114 <p>
 115         Readable names may also differ between compilers: <code class="computeroutput"><span class="keyword">struct</span>
 116         <span class="identifier">user_defined_type</span></code>, <code class="computeroutput"><span class="identifier">user_defined_type</span></code>.
 117       </p>
 118 <div class="warning"><table border="0" summary="Warning">
 119 <tr>
 120 <td rowspan="2" align="center" valign="top" width="25"><img alt="[Warning]" src="../../../doc/src/images/warning.png"></td>
 121 <th align="left">Warning</th>
 122 </tr>
 123 <tr><td align="left" valign="top"><p>
 124           With RTTI off different classes with same names in anonymous namespace
 125           may collapse. See 'RTTI emulation limitations'.
 126         </p></td></tr>
 127 </table></div>
 128 </div>
 129 <div class="section">
 130 <div class="titlepage"><div><div><h3 class="title">
 131 <a name="boost_typeindex.examples.storing_information_about_a_type"></a><a class="link" href="examples.html#boost_typeindex.examples.storing_information_about_a_type" title="Storing information about a type in container">Storing
 132       information about a type in container </a>
 133 </h3></div></div></div>
 134 <p>
 135         The following example shows how an information about a type could be stored.
 136         Example works with and without RTTI.
 137       </p>
 138 <pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_index</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 139 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">unordered_set</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 140 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">functional</span><span class="special">/</span><span class="identifier">hash</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 141 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">cassert</span><span class="special">&gt;</span>
 142
 143 <span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span>
 144     <span class="identifier">boost</span><span class="special">::</span><span class="identifier">unordered_set</span><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">typeindex</span><span class="special">::</span><span class="identifier">type_index</span><span class="special">&gt;</span> <span class="identifier">types</span><span class="special">;</span>
 145
 146     <span class="comment">// Storing some `boost::type_info`s</span>
 147     <span class="identifier">types</span><span class="special">.</span><span class="identifier">insert</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">typeindex</span><span class="special">::</span><span class="identifier">type_id</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;());</span>
 148     <span class="identifier">types</span><span class="special">.</span><span class="identifier">insert</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">typeindex</span><span class="special">::</span><span class="identifier">type_id</span><span class="special">&lt;</span><span class="keyword">float</span><span class="special">&gt;());</span>
 149
 150     <span class="comment">// `types` variable contains two `boost::type_index`es:</span>
 151     <span class="identifier">assert</span><span class="special">(</span><span class="identifier">types</span><span class="special">.</span><span class="identifier">size</span><span class="special">()</span> <span class="special">==</span> <span class="number">2</span><span class="special">);</span>
 152
 153     <span class="comment">// Const, volatile and reference will be striped from the type:</span>
 154     <span class="keyword">bool</span> <span class="identifier">is_inserted</span> <span class="special">=</span> <span class="identifier">types</span><span class="special">.</span><span class="identifier">insert</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">typeindex</span><span class="special">::</span><span class="identifier">type_id</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="keyword">int</span><span class="special">&gt;()).</span><span class="identifier">second</span><span class="special">;</span>
 155     <span class="identifier">assert</span><span class="special">(!</span><span class="identifier">is_inserted</span><span class="special">);</span>
 156     <span class="identifier">assert</span><span class="special">(</span><span class="identifier">types</span><span class="special">.</span><span class="identifier">erase</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">typeindex</span><span class="special">::</span><span class="identifier">type_id</span><span class="special">&lt;</span><span class="keyword">float</span><span class="special">&amp;&gt;())</span> <span class="special">==</span> <span class="number">1</span><span class="special">);</span>
 157
 158     <span class="comment">// We have erased the `float` type, only `int` remains</span>
 159     <span class="identifier">assert</span><span class="special">(*</span><span class="identifier">types</span><span class="special">.</span><span class="identifier">begin</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">typeindex</span><span class="special">::</span><span class="identifier">type_id</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;());</span>
 160 <span class="special">}</span>
 161 </pre>
 162 </div>
 163 <div class="section">
 164 <div class="titlepage"><div><div><h3 class="title">
 165 <a name="boost_typeindex.examples.getting_through_the_inheritance_"></a><a class="link" href="examples.html#boost_typeindex.examples.getting_through_the_inheritance_" title="Getting through the inheritance to receive a real type name">Getting
 166       through the inheritance to receive a real type name </a>
 167 </h3></div></div></div>
 168 <p>
 169         The following example shows that <code class="computeroutput"><span class="identifier">type_info</span></code>
 170         is able to store the real type, successfully getting through all the inheritances.
 171       </p>
 172 <p>
 173         Example works with and without RTTI."
 174       </p>
 175 <pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_index</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 176 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_index</span><span class="special">/</span><span class="identifier">runtime_cast</span><span class="special">/</span><span class="identifier">register_runtime_class</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 177 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</span>
 178
 179 <span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span>
 180     <span class="identifier">BOOST_TYPE_INDEX_REGISTER_CLASS</span>
 181     <span class="keyword">virtual</span> <span class="special">~</span><span class="identifier">A</span><span class="special">(){}</span>
 182 <span class="special">};</span>
 183 <span class="keyword">struct</span> <span class="identifier">B</span><span class="special">:</span> <span class="keyword">public</span> <span class="identifier">A</span> <span class="special">{</span> <span class="identifier">BOOST_TYPE_INDEX_REGISTER_CLASS</span> <span class="special">};</span>
 184 <span class="keyword">struct</span> <span class="identifier">C</span><span class="special">:</span> <span class="keyword">public</span> <span class="identifier">B</span> <span class="special">{</span> <span class="identifier">BOOST_TYPE_INDEX_REGISTER_CLASS</span> <span class="special">};</span>
 185 <span class="keyword">struct</span> <span class="identifier">D</span><span class="special">:</span> <span class="keyword">public</span> <span class="identifier">C</span> <span class="special">{</span> <span class="identifier">BOOST_TYPE_INDEX_REGISTER_RUNTIME_CLASS</span><span class="special">(</span><span class="identifier">BOOST_TYPE_INDEX_NO_BASE_CLASS</span><span class="special">)</span> <span class="special">};</span>
 186
 187 <span class="keyword">void</span> <span class="identifier">print_real_type</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">)</span> <span class="special">{</span>
 188     <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">typeindex</span><span class="special">::</span><span class="identifier">type_id_runtime</span><span class="special">(</span><span class="identifier">a</span><span class="special">).</span><span class="identifier">pretty_name</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="char">'\n'</span><span class="special">;</span>
 189 <span class="special">}</span>
 190
 191 <span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span>
 192     <span class="identifier">C</span> <span class="identifier">c</span><span class="special">;</span>
 193     <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;</span> <span class="identifier">c_as_a</span> <span class="special">=</span> <span class="identifier">c</span><span class="special">;</span>
 194     <span class="identifier">print_real_type</span><span class="special">(</span><span class="identifier">c_as_a</span><span class="special">);</span>    <span class="comment">// Outputs `struct C`</span>
 195     <span class="identifier">print_real_type</span><span class="special">(</span><span class="identifier">B</span><span class="special">());</span>       <span class="comment">// Outputs `struct B`</span>
 196 </pre>
 197 <p>
 198         It's also possible to use type_id_runtime with the BOOST_TYPE_INDEX_REGISTER_RUNTIME_CLASS,
 199         which adds additional information for runtime_cast to work.
 200       </p>
 201 <pre class="programlisting">    <span class="identifier">D</span> <span class="identifier">d</span><span class="special">;</span>
 202     <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;</span> <span class="identifier">d_as_a</span> <span class="special">=</span> <span class="identifier">d</span><span class="special">;</span>
 203     <span class="identifier">print_real_type</span><span class="special">(</span><span class="identifier">d_as_a</span><span class="special">);</span>    <span class="comment">// Outputs `struct D`</span>
 204
 205 <span class="special">}</span>
 206 </pre>
 207 </div>
 208 <div class="section">
 209 <div class="titlepage"><div><div><h3 class="title">
 210 <a name="boost_typeindex.examples.using_runtime_cast_where_rtti_is"></a><a class="link" href="examples.html#boost_typeindex.examples.using_runtime_cast_where_rtti_is" title="Using runtime_cast where RTTI is unavailable or undesirable">Using
 211       runtime_cast where RTTI is unavailable or undesirable </a>
 212 </h3></div></div></div>
 213 <p>
 214         The following example shows that <code class="computeroutput"><span class="identifier">runtime_cast</span></code>
 215         is able to find a valid pointer in various class hierarchies regardless of
 216         inheritance or type relation.
 217       </p>
 218 <p>
 219         Example works with and without RTTI."
 220       </p>
 221 <pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_index</span><span class="special">/</span><span class="identifier">runtime_cast</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 222 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</span>
 223
 224 <span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span>
 225     <span class="identifier">BOOST_TYPE_INDEX_REGISTER_RUNTIME_CLASS</span><span class="special">(</span><span class="identifier">BOOST_TYPE_INDEX_NO_BASE_CLASS</span><span class="special">)</span>
 226     <span class="keyword">virtual</span> <span class="special">~</span><span class="identifier">A</span><span class="special">()</span>
 227     <span class="special">{}</span>
 228 <span class="special">};</span>
 229
 230 <span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span>
 231     <span class="identifier">BOOST_TYPE_INDEX_REGISTER_RUNTIME_CLASS</span><span class="special">(</span><span class="identifier">BOOST_TYPE_INDEX_NO_BASE_CLASS</span><span class="special">)</span>
 232     <span class="keyword">virtual</span> <span class="special">~</span><span class="identifier">B</span><span class="special">()</span>
 233     <span class="special">{}</span>
 234 <span class="special">};</span>
 235
 236 <span class="keyword">struct</span> <span class="identifier">C</span> <span class="special">:</span> <span class="identifier">A</span> <span class="special">{</span>
 237     <span class="identifier">BOOST_TYPE_INDEX_REGISTER_RUNTIME_CLASS</span><span class="special">((</span><span class="identifier">A</span><span class="special">))</span>
 238 <span class="special">};</span>
 239
 240 <span class="keyword">struct</span> <span class="identifier">D</span> <span class="special">:</span> <span class="identifier">B</span> <span class="special">{</span>
 241     <span class="identifier">BOOST_TYPE_INDEX_REGISTER_RUNTIME_CLASS</span><span class="special">((</span><span class="identifier">B</span><span class="special">))</span>
 242 <span class="special">};</span>
 243
 244 <span class="keyword">struct</span> <span class="identifier">E</span> <span class="special">:</span> <span class="identifier">C</span><span class="special">,</span> <span class="identifier">D</span> <span class="special">{</span>
 245     <span class="identifier">BOOST_TYPE_INDEX_REGISTER_RUNTIME_CLASS</span><span class="special">((</span><span class="identifier">C</span><span class="special">)(</span><span class="identifier">D</span><span class="special">))</span>
 246 <span class="special">};</span>
 247
 248 <span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span>
 249     <span class="identifier">C</span> <span class="identifier">c</span><span class="special">;</span>
 250     <span class="identifier">A</span><span class="special">*</span> <span class="identifier">a</span> <span class="special">=</span> <span class="special">&amp;</span><span class="identifier">c</span><span class="special">;</span>
 251
 252     <span class="keyword">if</span><span class="special">(</span><span class="identifier">C</span><span class="special">*</span> <span class="identifier">cp</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">typeindex</span><span class="special">::</span><span class="identifier">runtime_cast</span><span class="special">&lt;</span><span class="identifier">C</span><span class="special">*&gt;(</span><span class="identifier">a</span><span class="special">))</span> <span class="special">{</span>
 253         <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Yes, a points to a C: "</span>
 254                   <span class="special">&lt;&lt;</span> <span class="identifier">a</span> <span class="special">&lt;&lt;</span> <span class="string">"-&gt;"</span> <span class="special">&lt;&lt;</span> <span class="identifier">cp</span> <span class="special">&lt;&lt;</span> <span class="char">'\n'</span><span class="special">;</span>
 255     <span class="special">}</span>
 256     <span class="keyword">else</span> <span class="special">{</span>
 257         <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Error: Expected a to point to a C"</span> <span class="special">&lt;&lt;</span> <span class="char">'\n'</span><span class="special">;</span>
 258     <span class="special">}</span>
 259
 260     <span class="keyword">if</span><span class="special">(</span><span class="identifier">E</span><span class="special">*</span> <span class="identifier">ce</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">typeindex</span><span class="special">::</span><span class="identifier">runtime_cast</span><span class="special">&lt;</span><span class="identifier">E</span><span class="special">*&gt;(</span><span class="identifier">a</span><span class="special">))</span> <span class="special">{</span>
 261         <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Error: Expected a to not points to an E: "</span>
 262                   <span class="special">&lt;&lt;</span> <span class="identifier">a</span> <span class="special">&lt;&lt;</span> <span class="string">"-&gt;"</span> <span class="special">&lt;&lt;</span> <span class="identifier">ce</span> <span class="special">&lt;&lt;</span> <span class="char">'\n'</span><span class="special">;</span>
 263     <span class="special">}</span>
 264     <span class="keyword">else</span> <span class="special">{</span>
 265         <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"But, a does not point to an E"</span> <span class="special">&lt;&lt;</span> <span class="char">'\n'</span><span class="special">;</span>
 266     <span class="special">}</span>
 267
 268     <span class="identifier">E</span> <span class="identifier">e</span><span class="special">;</span>
 269     <span class="identifier">C</span><span class="special">*</span> <span class="identifier">cp2</span> <span class="special">=</span> <span class="special">&amp;</span><span class="identifier">e</span><span class="special">;</span>
 270     <span class="keyword">if</span><span class="special">(</span><span class="identifier">D</span><span class="special">*</span> <span class="identifier">dp</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">typeindex</span><span class="special">::</span><span class="identifier">runtime_cast</span><span class="special">&lt;</span><span class="identifier">D</span><span class="special">*&gt;(</span><span class="identifier">cp2</span><span class="special">))</span> <span class="special">{</span>
 271         <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Yes, we can cross-cast from a C* to a D* when we actually have an E: "</span>
 272                   <span class="special">&lt;&lt;</span> <span class="identifier">cp2</span> <span class="special">&lt;&lt;</span> <span class="string">"-&gt;"</span> <span class="special">&lt;&lt;</span> <span class="identifier">dp</span> <span class="special">&lt;&lt;</span> <span class="char">'\n'</span><span class="special">;</span>
 273     <span class="special">}</span>
 274     <span class="keyword">else</span> <span class="special">{</span>
 275         <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Error: Expected cp to point to a D"</span> <span class="special">&lt;&lt;</span> <span class="char">'\n'</span><span class="special">;</span>
 276     <span class="special">}</span>
 277 </pre>
 278 <p>
 279         Alternatively, we can use runtime_pointer_cast so we don't need to specity
 280         the target as a pointer. This works for smart_ptr types too.
 281       </p>
 282 <pre class="programlisting">    <span class="identifier">A</span><span class="special">*</span> <span class="identifier">ap</span> <span class="special">=</span> <span class="special">&amp;</span><span class="identifier">e</span><span class="special">;</span>
 283     <span class="keyword">if</span><span class="special">(</span><span class="identifier">B</span><span class="special">*</span> <span class="identifier">bp</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">typeindex</span><span class="special">::</span><span class="identifier">runtime_pointer_cast</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;(</span><span class="identifier">ap</span><span class="special">))</span> <span class="special">{</span>
 284         <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Yes, we can cross-cast and up-cast at the same time."</span>
 285                   <span class="special">&lt;&lt;</span> <span class="identifier">ap</span> <span class="special">&lt;&lt;</span> <span class="string">"-&gt;"</span> <span class="special">&lt;&lt;</span> <span class="identifier">bp</span> <span class="special">&lt;&lt;</span> <span class="char">'\n'</span><span class="special">;</span>
 286     <span class="special">}</span>
 287     <span class="keyword">else</span> <span class="special">{</span>
 288         <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Error: Expected ap to point to a B"</span> <span class="special">&lt;&lt;</span> <span class="char">'\n'</span><span class="special">;</span>
 289     <span class="special">}</span>
 290
 291     <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
 292 <span class="special">}</span>
 293 </pre>
 294 </div>
 295 <div class="section">
 296 <div class="titlepage"><div><div><h3 class="title">
 297 <a name="boost_typeindex.examples.exact_type_matching_storing_type"></a><a class="link" href="examples.html#boost_typeindex.examples.exact_type_matching_storing_type" title="Exact type matching: storing type with const, volatile and reference qualifiers">Exact
 298       type matching: storing type with const, volatile and reference qualifiers</a>
 299 </h3></div></div></div>
 300 <p>
 301         The following example shows that <code class="computeroutput"><span class="identifier">type_index</span></code>
 302         (and <code class="computeroutput"><span class="identifier">type_info</span></code>) is able to
 303         store the exact type, without stripping const, volatile and references. Example
 304         works with and without RTTI.
 305       </p>
 306 <p>
 307         In this example we'll create a class that stores a pointer to function and
 308         remembers the exact type of the parameter the function accepts. When the
 309         call to the bound function is made, he actual input parameter type is checked
 310         against the stored parameter type and an exception is thrown in case of mismatch.
 311       </p>
 312 <pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_index</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 313 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</span>
 314 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">stdexcept</span><span class="special">&gt;</span>
 315 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">cstdlib</span><span class="special">&gt;</span>
 316
 317 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">cassert</span><span class="special">&gt;</span>
 318
 319 <span class="keyword">class</span> <span class="identifier">type_erased_unary_function</span> <span class="special">{</span>
 320     <span class="keyword">void</span><span class="special">*</span>                           <span class="identifier">function_ptr_</span><span class="special">;</span>
 321     <span class="identifier">boost</span><span class="special">::</span><span class="identifier">typeindex</span><span class="special">::</span><span class="identifier">type_index</span>    <span class="identifier">exact_param_t_</span><span class="special">;</span>
 322
 323 <span class="keyword">public</span><span class="special">:</span>
 324     <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">ParamT</span><span class="special">&gt;</span>
 325     <span class="identifier">type_erased_unary_function</span><span class="special">(</span><span class="keyword">void</span><span class="special">(*</span><span class="identifier">ptr</span><span class="special">)(</span><span class="identifier">ParamT</span><span class="special">))</span>
 326         <span class="special">:</span> <span class="identifier">function_ptr_</span><span class="special">(</span><span class="keyword">reinterpret_cast</span><span class="special">&lt;</span><span class="keyword">void</span><span class="special">*&gt;(</span><span class="identifier">ptr</span><span class="special">))</span> <span class="comment">// ptr - is a pointer to function returning `void` and accepting parameter of type `ParamT`</span>
 327         <span class="special">,</span> <span class="identifier">exact_param_t_</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">typeindex</span><span class="special">::</span><span class="identifier">type_id_with_cvr</span><span class="special">&lt;</span><span class="identifier">ParamT</span><span class="special">&gt;())</span>
 328     <span class="special">{}</span>
 329
 330     <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">ParamT</span><span class="special">&gt;</span>
 331     <span class="keyword">void</span> <span class="identifier">call</span><span class="special">(</span><span class="identifier">ParamT</span> <span class="identifier">v</span><span class="special">)</span> <span class="special">{</span>
 332         <span class="keyword">if</span> <span class="special">(</span><span class="identifier">exact_param_t_</span> <span class="special">!=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">typeindex</span><span class="special">::</span><span class="identifier">type_id_with_cvr</span><span class="special">&lt;</span><span class="identifier">ParamT</span><span class="special">&gt;())</span> <span class="special">{</span>
 333             <span class="keyword">throw</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">runtime_error</span><span class="special">(</span><span class="string">"Incorrect `ParamT`"</span><span class="special">);</span>
 334         <span class="special">}</span>
 335
 336         <span class="keyword">return</span> <span class="special">(</span><span class="keyword">reinterpret_cast</span><span class="special">&lt;</span><span class="keyword">void</span><span class="special">(*)(</span><span class="identifier">ParamT</span><span class="special">)&gt;(</span><span class="identifier">function_ptr_</span><span class="special">))(</span><span class="identifier">v</span><span class="special">);</span>
 337     <span class="special">}</span>
 338 <span class="special">};</span>
 339
 340 <span class="keyword">void</span> <span class="identifier">foo</span><span class="special">(</span><span class="keyword">int</span><span class="special">){}</span>
 341
 342 <span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span>
 343     <span class="identifier">type_erased_unary_function</span> <span class="identifier">func</span><span class="special">(&amp;</span><span class="identifier">foo</span><span class="special">);</span>
 344     <span class="identifier">func</span><span class="special">.</span><span class="identifier">call</span><span class="special">(</span><span class="number">100</span><span class="special">);</span> <span class="comment">// OK, `100` has type `int`</span>
 345
 346     <span class="keyword">try</span> <span class="special">{</span>
 347         <span class="keyword">int</span> <span class="identifier">i</span> <span class="special">=</span> <span class="number">100</span><span class="special">;</span>
 348
 349         <span class="comment">// An attempt to convert stored function to a function accepting reference</span>
 350         <span class="identifier">func</span><span class="special">.</span><span class="identifier">call</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&amp;&gt;(</span><span class="identifier">i</span><span class="special">);</span> <span class="comment">// Will throw, because types `int&amp;` and `int` mismatch</span>
 351
 352         <span class="identifier">assert</span><span class="special">(</span><span class="keyword">false</span><span class="special">);</span>
 353     <span class="special">}</span> <span class="keyword">catch</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">runtime_error</span><span class="special">&amp;</span> <span class="comment">/*e*/</span><span class="special">)</span> <span class="special">{}</span>
 354 <span class="special">}</span>
 355 </pre>
 356 </div>
 357 <div class="section">
 358 <div class="titlepage"><div><div><h3 class="title">
 359 <a name="boost_typeindex.examples.table_of_raw_name_and_pretty_nam"></a><a class="link" href="examples.html#boost_typeindex.examples.table_of_raw_name_and_pretty_nam" title="Table of raw_name() and pretty_name() outputs with and without RTTI">Table
 360       of raw_name() and pretty_name() outputs with and without RTTI </a>
 361 </h3></div></div></div>
 362 <p>
 363         The following example shows how different type names look when we explicitly
 364         use classes for RTTI and RTT off.
 365       </p>
 366 <p>
 367         This example requires RTTI. For a more portable example see 'Getting human
 368         readable and mangled type names':
 369       </p>
 370 <pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_index</span><span class="special">/</span><span class="identifier">stl_type_index</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 371 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_index</span><span class="special">/</span><span class="identifier">ctti_type_index</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 372 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</span>
 373
 374 <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>
 375 <span class="keyword">void</span> <span class="identifier">print</span><span class="special">(</span><span class="keyword">const</span> <span class="keyword">char</span><span class="special">*</span> <span class="identifier">name</span><span class="special">)</span> <span class="special">{</span>
 376     <span class="identifier">boost</span><span class="special">::</span><span class="identifier">typeindex</span><span class="special">::</span><span class="identifier">stl_type_index</span> <span class="identifier">sti</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">typeindex</span><span class="special">::</span><span class="identifier">stl_type_index</span><span class="special">::</span><span class="identifier">type_id</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;();</span>
 377     <span class="identifier">boost</span><span class="special">::</span><span class="identifier">typeindex</span><span class="special">::</span><span class="identifier">ctti_type_index</span> <span class="identifier">cti</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">typeindex</span><span class="special">::</span><span class="identifier">ctti_type_index</span><span class="special">::</span><span class="identifier">type_id</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;();</span>
 378     <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"\t["</span> <span class="comment">/* start of the row */</span>
 379         <span class="special">&lt;&lt;</span> <span class="string">"["</span> <span class="special">&lt;&lt;</span> <span class="identifier">name</span> <span class="special">&lt;&lt;</span> <span class="string">"]"</span>
 380         <span class="special">&lt;&lt;</span> <span class="string">"[`"</span> <span class="special">&lt;&lt;</span> <span class="identifier">sti</span><span class="special">.</span><span class="identifier">raw_name</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="string">"`] "</span>
 381         <span class="special">&lt;&lt;</span> <span class="string">"[`"</span> <span class="special">&lt;&lt;</span> <span class="identifier">sti</span><span class="special">.</span><span class="identifier">pretty_name</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="string">"`] "</span>
 382         <span class="special">&lt;&lt;</span> <span class="string">"[`"</span> <span class="special">&lt;&lt;</span> <span class="identifier">cti</span><span class="special">.</span><span class="identifier">raw_name</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="string">"`] "</span>
 383     <span class="special">&lt;&lt;</span> <span class="string">"]\n"</span> <span class="comment">/* end of the row */</span> <span class="special">;</span>
 384 <span class="special">}</span>
 385
 386 <span class="keyword">struct</span> <span class="identifier">user_defined_type</span><span class="special">{};</span>
 387
 388 <span class="keyword">namespace</span> <span class="identifier">ns1</span> <span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">ns2</span> <span class="special">{</span>
 389     <span class="keyword">struct</span> <span class="identifier">user_defined_type</span><span class="special">{};</span>
 390 <span class="special">}}</span> <span class="comment">// namespace ns1::ns2</span>
 391
 392 <span class="keyword">namespace</span> <span class="special">{</span>
 393     <span class="keyword">struct</span> <span class="identifier">in_anon_type</span><span class="special">{};</span>
 394 <span class="special">}</span> <span class="comment">// anonymous namespace</span>
 395
 396 <span class="keyword">namespace</span> <span class="identifier">ns3</span> <span class="special">{</span> <span class="keyword">namespace</span> <span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">ns4</span> <span class="special">{</span>
 397     <span class="keyword">struct</span> <span class="identifier">in_anon_type</span><span class="special">{};</span>
 398 <span class="special">}}}</span> <span class="comment">// namespace ns3::{anonymous}::ns4</span>
 399
 400
 401 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T0</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T1</span><span class="special">&gt;</span>
 402 <span class="keyword">class</span> <span class="identifier">templ</span> <span class="special">{};</span>
 403
 404 <span class="keyword">template</span> <span class="special">&lt;&gt;</span>
 405 <span class="keyword">class</span> <span class="identifier">templ</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">&gt;</span> <span class="special">{};</span>
 406
 407 <span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span>
 408     <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"[table:id Table of names\n"</span><span class="special">;</span>
 409     <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"\t[[Type] [RTTI &amp; raw_name] [RTTI &amp; pretty_name] [noRTTI &amp; raw_name]]\n"</span><span class="special">;</span>
 410
 411     <span class="identifier">print</span><span class="special">&lt;</span><span class="identifier">user_defined_type</span><span class="special">&gt;(</span><span class="string">"User defined type"</span><span class="special">);</span>
 412     <span class="identifier">print</span><span class="special">&lt;</span><span class="identifier">in_anon_type</span><span class="special">&gt;(</span><span class="string">"In anonymous namespace"</span><span class="special">);</span>
 413     <span class="identifier">print</span><span class="special">&lt;</span><span class="identifier">ns3</span><span class="special">::</span><span class="identifier">ns4</span><span class="special">::</span><span class="identifier">in_anon_type</span><span class="special">&gt;(</span><span class="string">"In ns3::{anonymous}::ns4 namespace"</span><span class="special">);</span>
 414     <span class="identifier">print</span><span class="special">&lt;</span><span class="identifier">templ</span><span class="special">&lt;</span><span class="keyword">short</span><span class="special">,</span> <span class="keyword">int</span><span class="special">&gt;</span> <span class="special">&gt;(</span><span class="string">"Template class"</span><span class="special">);</span>
 415     <span class="identifier">print</span><span class="special">&lt;</span><span class="identifier">templ</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">&gt;</span> <span class="special">&gt;(</span><span class="string">"Template class (full specialization)"</span><span class="special">);</span>
 416     <span class="identifier">print</span><span class="special">&lt;</span><span class="identifier">templ</span><span class="special">&lt;</span>
 417         <span class="identifier">templ</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">,</span> <span class="keyword">signed</span> <span class="keyword">char</span><span class="special">&gt;,</span>
 418         <span class="identifier">templ</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="identifier">user_defined_type</span><span class="special">&gt;</span>
 419     <span class="special">&gt;</span> <span class="special">&gt;(</span><span class="string">"Template class with templae classes"</span><span class="special">);</span>
 420
 421
 422     <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"]\n"</span><span class="special">;</span>
 423 <span class="special">}</span>
 424 </pre>
 425 <p>
 426         Code from the example will produce the following table:
 427       </p>
 428 <div class="table">
 429 <a name="boost_typeindex.examples.table_of_raw_name_and_pretty_nam.id"></a><p class="title"><b>Table&#160;41.2.&#160;Table of names</b></p>
 430 <div class="table-contents"><table class="table" summary="Table of names">
 431 <colgroup>
 432 <col>
 433 <col>
 434 <col>
 435 <col>
 436 </colgroup>
 437 <thead><tr>
 438 <th>
 439                 <p>
 440                   Type
 441                 </p>
 442               </th>
 443 <th>
 444                 <p>
 445                   RTTI &amp; raw_name
 446                 </p>
 447               </th>
 448 <th>
 449                 <p>
 450                   RTTI &amp; pretty_name
 451                 </p>
 452               </th>
 453 <th>
 454                 <p>
 455                   noRTTI &amp; raw_name
 456                 </p>
 457               </th>
 458 </tr></thead>
 459 <tbody>
 460 <tr>
 461 <td>
 462                 <p>
 463                   User defined type
 464                 </p>
 465               </td>
 466 <td>
 467                 <p>
 468                   <code class="computeroutput"><span class="number">17u</span><span class="identifier">ser_defined_type</span></code>
 469                 </p>
 470               </td>
 471 <td>
 472                 <p>
 473                   <code class="computeroutput"><span class="identifier">user_defined_type</span></code>
 474                 </p>
 475               </td>
 476 <td>
 477                 <p>
 478                   <code class="computeroutput"><span class="identifier">user_defined_type</span><span class="special">]</span></code>
 479                 </p>
 480               </td>
 481 </tr>
 482 <tr>
 483 <td>
 484                 <p>
 485                   In anonymous namespace
 486                 </p>
 487               </td>
 488 <td>
 489                 <p>
 490                   <code class="computeroutput"><span class="identifier">N12_GLOBAL__N_112in_anon_typeE</span></code>
 491                 </p>
 492               </td>
 493 <td>
 494                 <p>
 495                   <code class="computeroutput"><span class="special">(</span><span class="identifier">anonymous</span>
 496                   <span class="keyword">namespace</span><span class="special">)::</span><span class="identifier">in_anon_type</span></code>
 497                 </p>
 498               </td>
 499 <td>
 500                 <p>
 501                   <code class="computeroutput"><span class="special">{</span><span class="identifier">anonymous</span><span class="special">}::</span><span class="identifier">in_anon_type</span><span class="special">]</span></code>
 502                 </p>
 503               </td>
 504 </tr>
 505 <tr>
 506 <td>
 507                 <p>
 508                   In ns3::{anonymous}::ns4 namespace
 509                 </p>
 510               </td>
 511 <td>
 512                 <p>
 513                   <code class="computeroutput"><span class="identifier">N3ns312_GLOBAL__N_13ns412in_anon_typeE</span></code>
 514                 </p>
 515               </td>
 516 <td>
 517                 <p>
 518                   <code class="computeroutput"><span class="identifier">ns3</span><span class="special">::(</span><span class="identifier">anonymous</span> <span class="keyword">namespace</span><span class="special">)::</span><span class="identifier">ns4</span><span class="special">::</span><span class="identifier">in_anon_type</span></code>
 519                 </p>
 520               </td>
 521 <td>
 522                 <p>
 523                   <code class="computeroutput"><span class="identifier">ns3</span><span class="special">::{</span><span class="identifier">anonymous</span><span class="special">}::</span><span class="identifier">ns4</span><span class="special">::</span><span class="identifier">in_anon_type</span><span class="special">]</span></code>
 524                 </p>
 525               </td>
 526 </tr>
 527 <tr>
 528 <td>
 529                 <p>
 530                   Template class
 531                 </p>
 532               </td>
 533 <td>
 534                 <p>
 535                   <code class="computeroutput"><span class="number">5</span><span class="identifier">templIsiE</span></code>
 536                 </p>
 537               </td>
 538 <td>
 539                 <p>
 540                   <code class="computeroutput"><span class="identifier">templ</span><span class="special">&lt;</span><span class="keyword">short</span><span class="special">,</span>
 541                   <span class="keyword">int</span><span class="special">&gt;</span></code>
 542                 </p>
 543               </td>
 544 <td>
 545                 <p>
 546                   <code class="computeroutput"><span class="identifier">templ</span><span class="special">&lt;</span><span class="keyword">short</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">&gt;]</span></code>
 547                 </p>
 548               </td>
 549 </tr>
 550 <tr>
 551 <td>
 552                 <p>
 553                   Template class (full specialization)
 554                 </p>
 555               </td>
 556 <td>
 557                 <p>
 558                   <code class="computeroutput"><span class="number">5</span><span class="identifier">templIiiE</span></code>
 559                 </p>
 560               </td>
 561 <td>
 562                 <p>
 563                   <code class="computeroutput"><span class="identifier">templ</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">&gt;</span></code>
 564                 </p>
 565               </td>
 566 <td>
 567                 <p>
 568                   <code class="computeroutput"><span class="identifier">templ</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">&gt;]</span></code>
 569                 </p>
 570               </td>
 571 </tr>
 572 <tr>
 573 <td>
 574                 <p>
 575                   Template class with template classes
 576                 </p>
 577               </td>
 578 <td>
 579                 <p>
 580                   <code class="computeroutput"><span class="number">5</span><span class="identifier">templIS_IcaES_Ii17user_defined_typeEE</span></code>
 581                 </p>
 582               </td>
 583 <td>
 584                 <p>
 585                   <code class="computeroutput"><span class="identifier">templ</span><span class="special">&lt;</span><span class="identifier">templ</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">,</span>
 586                   <span class="keyword">signed</span> <span class="keyword">char</span><span class="special">&gt;,</span> <span class="identifier">templ</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="identifier">user_defined_type</span><span class="special">&gt;</span> <span class="special">&gt;</span></code>
 587                 </p>
 588               </td>
 589 <td>
 590                 <p>
 591                   <code class="computeroutput"><span class="identifier">templ</span><span class="special">&lt;</span><span class="identifier">templ</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">,</span>
 592                   <span class="keyword">signed</span> <span class="keyword">char</span><span class="special">&gt;,</span> <span class="identifier">templ</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="identifier">user_defined_type</span><span class="special">&gt;</span> <span class="special">&gt;]</span></code>
 593                 </p>
 594               </td>
 595 </tr>
 596 </tbody>
 597 </table></div>
 598 </div>
 599 <br class="table-break"><p>
 600         We have not show the "noRTTI &amp; pretty_name" column in the table
 601         because it is almost equal to "noRTTI &amp; raw_name" column.
 602       </p>
 603 <div class="warning"><table border="0" summary="Warning">
 604 <tr>
 605 <td rowspan="2" align="center" valign="top" width="25"><img alt="[Warning]" src="../../../doc/src/images/warning.png"></td>
 606 <th align="left">Warning</th>
 607 </tr>
 608 <tr><td align="left" valign="top"><p>
 609           With RTTI off different classes with same names in anonymous namespace
 610           may collapse. See 'RTTI emulation limitations'.
 611         </p></td></tr>
 612 </table></div>
 613 </div>
 614 <div class="section">
 615 <div class="titlepage"><div><div><h3 class="title">
 616 <a name="boost_typeindex.examples.c_14_checking_namespace_at_compi"></a><a class="link" href="examples.html#boost_typeindex.examples.c_14_checking_namespace_at_compi" title="C++14: Checking namespace at compile time">C++14:
 617       Checking namespace at compile time </a>
 618 </h3></div></div></div>
 619 <p>
 620         The following example shows that <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">typeindex</span><span class="special">::</span><span class="identifier">ctti_type_index</span></code>
 621         is usable at compile time on a C++14 compatible compilers.
 622       </p>
 623 <p>
 624         In this example we'll create and use a constexpr function that checks namespace
 625         of the provided type.
 626       </p>
 627 <pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_index</span><span class="special">/</span><span class="identifier">ctti_type_index</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 628
 629 <span class="comment">// Helper function that returns true if `name` starts with `substr`</span>
 630 <span class="keyword">template</span> <span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">N</span><span class="special">&gt;</span>
 631 <span class="keyword">constexpr</span> <span class="keyword">bool</span> <span class="identifier">starts_with</span><span class="special">(</span><span class="keyword">const</span> <span class="keyword">char</span><span class="special">*</span> <span class="identifier">name</span><span class="special">,</span> <span class="keyword">const</span> <span class="keyword">char</span> <span class="special">(&amp;</span><span class="identifier">substr</span><span class="special">)[</span><span class="identifier">N</span><span class="special">])</span> <span class="keyword">noexcept</span><span class="special">;</span>
 632
 633
 634 <span class="comment">// Function that returns true if `T` declared in namespace `ns`</span>
 635 <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="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">N</span><span class="special">&gt;</span>
 636 <span class="keyword">constexpr</span> <span class="keyword">bool</span> <span class="identifier">in_namespace</span><span class="special">(</span><span class="keyword">const</span> <span class="keyword">char</span> <span class="special">(&amp;</span><span class="identifier">ns</span><span class="special">)[</span><span class="identifier">N</span><span class="special">])</span> <span class="keyword">noexcept</span> <span class="special">{</span>
 637     <span class="keyword">const</span> <span class="keyword">char</span><span class="special">*</span> <span class="identifier">name</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">typeindex</span><span class="special">::</span><span class="identifier">ctti_type_index</span><span class="special">::</span><span class="identifier">type_id</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;().</span><span class="identifier">raw_name</span><span class="special">();</span>
 638
 639     <span class="comment">// Some compilers add `class ` or `struct ` before the namespace, so we need to skip those words first</span>
 640     <span class="keyword">if</span> <span class="special">(</span><span class="identifier">starts_with</span><span class="special">(</span><span class="identifier">name</span><span class="special">,</span> <span class="string">"class "</span><span class="special">))</span> <span class="special">{</span>
 641         <span class="identifier">name</span> <span class="special">+=</span> <span class="keyword">sizeof</span><span class="special">(</span><span class="string">"class "</span><span class="special">)</span> <span class="special">-</span> <span class="number">1</span><span class="special">;</span>
 642     <span class="special">}</span> <span class="keyword">else</span> <span class="keyword">if</span> <span class="special">(</span><span class="identifier">starts_with</span><span class="special">(</span><span class="identifier">name</span><span class="special">,</span> <span class="string">"struct "</span><span class="special">))</span> <span class="special">{</span>
 643         <span class="identifier">name</span> <span class="special">+=</span> <span class="keyword">sizeof</span><span class="special">(</span><span class="string">"struct "</span><span class="special">)</span> <span class="special">-</span> <span class="number">1</span><span class="special">;</span>
 644     <span class="special">}</span>
 645
 646     <span class="keyword">return</span> <span class="identifier">starts_with</span><span class="special">(</span><span class="identifier">name</span><span class="special">,</span> <span class="identifier">ns</span><span class="special">)</span> <span class="special">&amp;&amp;</span> <span class="identifier">starts_with</span><span class="special">(</span><span class="identifier">name</span> <span class="special">+</span> <span class="identifier">N</span> <span class="special">-</span> <span class="number">1</span><span class="special">,</span> <span class="string">"::"</span><span class="special">);</span>
 647 <span class="special">}</span>
 648 </pre>
 649 <p>
 650         Now when we have that wonderfull function, we can do static assertions and
 651         other compile-time validations:
 652       </p>
 653 <pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">my_project</span> <span class="special">{</span>
 654     <span class="keyword">struct</span> <span class="identifier">serializer</span> <span class="special">{</span>
 655         <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>
 656         <span class="keyword">void</span> <span class="identifier">serialize</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">value</span><span class="special">)</span> <span class="special">{</span>
 657             <span class="keyword">static_assert</span><span class="special">(</span>
 658                 <span class="identifier">in_namespace</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;(</span><span class="string">"my_project::types"</span><span class="special">)</span> <span class="special">||</span> <span class="identifier">in_namespace</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;(</span><span class="string">"my_project::types_ext"</span><span class="special">),</span>
 659                 <span class="string">"Only types from namespaces `my_project::types` and `my_project::types_ext` are allowed to be serialized using `my_project::serializer`"</span>
 660             <span class="special">);</span>
 661
 662             <span class="comment">// Actual implementation of the serialization goes below</span>
 663             <span class="comment">// ...</span>
 664         <span class="special">}</span>
 665     <span class="special">};</span>
 666
 667     <span class="keyword">namespace</span> <span class="identifier">types</span> <span class="special">{</span>
 668         <span class="keyword">struct</span> <span class="identifier">foo</span><span class="special">{};</span>
 669         <span class="keyword">struct</span> <span class="identifier">bar</span><span class="special">{};</span>
 670     <span class="special">}</span>
 671 <span class="special">}</span> <span class="comment">// namespace my_project</span>
 672
 673 <span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span>
 674     <span class="identifier">my_project</span><span class="special">::</span><span class="identifier">serializer</span> <span class="identifier">s</span><span class="special">;</span>
 675     <span class="identifier">my_project</span><span class="special">::</span><span class="identifier">types</span><span class="special">::</span><span class="identifier">foo</span> <span class="identifier">f</span><span class="special">;</span>
 676     <span class="identifier">my_project</span><span class="special">::</span><span class="identifier">types</span><span class="special">::</span><span class="identifier">bar</span> <span class="identifier">b</span><span class="special">;</span>
 677
 678     <span class="identifier">s</span><span class="special">.</span><span class="identifier">serialize</span><span class="special">(</span><span class="identifier">f</span><span class="special">);</span>
 679     <span class="identifier">s</span><span class="special">.</span><span class="identifier">serialize</span><span class="special">(</span><span class="identifier">b</span><span class="special">);</span>
 680
 681     <span class="comment">// short sh = 0;</span>
 682     <span class="comment">// s.serialize(sh); // Fails the static_assert!</span>
 683 <span class="special">}</span>
 684 </pre>
 685 </div>
 686 <div class="section">
 687 <div class="titlepage"><div><div><h3 class="title">
 688 <a name="boost_typeindex.examples.c_14_checking_lexigraphical_orde"></a><a class="link" href="examples.html#boost_typeindex.examples.c_14_checking_lexigraphical_orde" title="C++14: Checking lexigraphical order of provided types">C++14:
 689       Checking lexigraphical order of provided types </a>
 690 </h3></div></div></div>
 691 <p>
 692         The following example shows that <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">typeindex</span><span class="special">::</span><span class="identifier">ctti_type_index</span></code>
 693         is usable at compile time on a C++14 compatible compilers to check order
 694         of template parameters.
 695       </p>
 696 <p>
 697         Consider the situation when we have a function that accepts std::tuple, boost::variant
 698         or some other class that uses variadic templates:
 699       </p>
 700 <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> <span class="keyword">class</span> <span class="identifier">types</span><span class="special">{};</span>
 701
 702 <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>
 703 <span class="keyword">void</span> <span class="identifier">do_something</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">types</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">...&gt;&amp;</span> <span class="identifier">t</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
 704 </pre>
 705 <p>
 706         Such functions may be very usefull, however they may significantly increase
 707         the size of the resulting program. Each instantionation of such function
 708         with different templates order consumes space in the resulting program:
 709       </p>
 710 <pre class="programlisting"><span class="comment">// Types are same, but different order leads to new instantionation of do_something function.</span>
 711 <span class="identifier">types</span><span class="special">&lt;</span><span class="keyword">bool</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">int</span><span class="special">&gt;</span>
 712 <span class="identifier">types</span><span class="special">&lt;</span><span class="keyword">bool</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">&gt;</span>
 713 <span class="identifier">types</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">,</span> <span class="keyword">double</span><span class="special">&gt;</span>
 714 <span class="identifier">types</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">&gt;</span>
 715 <span class="identifier">types</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">&gt;</span>
 716 <span class="identifier">types</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">,</span> <span class="keyword">int</span><span class="special">&gt;</span>
 717 </pre>
 718 <p>
 719         One of the ways to reduce instantinations count is to force the types to
 720         have some order:
 721       </p>
 722 <pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_index</span><span class="special">/</span><span class="identifier">ctti_type_index</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 723
 724 <span class="comment">// Implementing type trait that returns true if the types are sorted lexographicaly</span>
 725 <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>
 726 <span class="keyword">constexpr</span> <span class="keyword">bool</span> <span class="identifier">is_asc_sorted</span><span class="special">(</span><span class="identifier">types</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">...&gt;)</span> <span class="keyword">noexcept</span> <span class="special">{</span>
 727     <span class="keyword">return</span> <span class="keyword">true</span><span class="special">;</span>
 728 <span class="special">}</span>
 729
 730 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Lhs</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">TN</span><span class="special">&gt;</span>
 731 <span class="keyword">constexpr</span> <span class="keyword">bool</span> <span class="identifier">is_asc_sorted</span><span class="special">(</span><span class="identifier">types</span><span class="special">&lt;</span><span class="identifier">Lhs</span><span class="special">,</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">TN</span><span class="special">...&gt;)</span> <span class="keyword">noexcept</span> <span class="special">{</span>
 732     <span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">typeindex</span><span class="special">;</span>
 733     <span class="keyword">return</span> <span class="identifier">ctti_type_index</span><span class="special">::</span><span class="identifier">type_id</span><span class="special">&lt;</span><span class="identifier">Lhs</span><span class="special">&gt;()</span> <span class="special">&lt;=</span> <span class="identifier">ctti_type_index</span><span class="special">::</span><span class="identifier">type_id</span><span class="special">&lt;</span><span class="identifier">Rhs</span><span class="special">&gt;()</span>
 734         <span class="special">&amp;&amp;</span> <span class="identifier">is_asc_sorted</span><span class="special">(</span><span class="identifier">types</span><span class="special">&lt;</span><span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">TN</span><span class="special">...&gt;());</span>
 735 <span class="special">}</span>
 736
 737
 738 <span class="comment">// Using the newly created `is_asc_sorted` trait:</span>
 739 <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>
 740 <span class="keyword">void</span> <span class="identifier">do_something</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">types</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">...&gt;&amp;</span> <span class="identifier">t</span><span class="special">)</span> <span class="keyword">noexcept</span> <span class="special">{</span>
 741     <span class="keyword">static_assert</span><span class="special">(</span>
 742         <span class="identifier">is_asc_sorted</span><span class="special">(</span> <span class="identifier">types</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">...&gt;()</span> <span class="special">),</span>
 743         <span class="string">"T... for do_something(const types&lt;T...&gt;&amp; t) must be sorted ascending"</span>
 744     <span class="special">);</span>
 745 <span class="special">}</span>
 746
 747 <span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span>
 748     <span class="identifier">do_something</span><span class="special">(</span> <span class="identifier">types</span><span class="special">&lt;</span><span class="keyword">bool</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">int</span><span class="special">&gt;()</span> <span class="special">);</span>
 749     <span class="comment">// do_something( types&lt;bool, int, double&gt;() ); // Fails the static_assert!</span>
 750 <span class="special">}</span>
 751 </pre>
 752 </div>
 753 </div>
 754 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 755 <td align="left"></td>
 756 <td align="right"><div class="copyright-footer">Copyright &#169; 2012-2016 Antony Polukhin<p>
 757         Distributed under the Boost Software License, Version 1.0. (See accompanying
 758         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>)
 759       </p>
 760 </div></td>
 761 </tr></table>
 762 <hr>
 763 <div class="spirit-nav">
 764 <a accesskey="p" href="how_it_works.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../boost_typeindex.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="../boost_typeindex_header_reference.html"><img src="../../../doc/src/images/next.png" alt="Next"></a>
 765 </div>
 766 </body>
 767 </html>