gcc-4_9-branch/libstdc++-v3/doc/html/manual/backwards.html

   1 <?xml version="1.0" encoding="UTF-8" standalone="no"?>
   2 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /><title>Backwards Compatibility</title><meta name="generator" content="DocBook XSL-NS Stylesheets V1.78.1" /><meta name="keywords" content="ISO C++, backwards" /><meta name="keywords" content="ISO C++, library" /><meta name="keywords" content="ISO C++, runtime, library" /><link rel="home" href="../index.html" title="The GNU C++ Library" /><link rel="up" href="appendix_porting.html" title="Appendix B.  Porting and Maintenance" /><link rel="prev" href="api.html" title="API Evolution and Deprecation History" /><link rel="next" href="appendix_free.html" title="Appendix C.  Free Software Needs Free Documentation" /></head><body><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">Backwards Compatibility</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="api.html">Prev</a> </td><th width="60%" align="center">Appendix B.
   3   Porting and Maintenance
   4
   5 </th><td width="20%" align="right"> <a accesskey="n" href="appendix_free.html">Next</a></td></tr></table><hr /></div><div class="section"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a id="manual.appendix.porting.backwards"></a>Backwards Compatibility</h2></div></div></div><div class="section"><div class="titlepage"><div><div><h3 class="title"><a id="backwards.first"></a>First</h3></div></div></div><p>The first generation GNU C++ library was called libg++.  It was a
   6 separate GNU project, although reliably paired with GCC. Rumors imply
   7 that it had a working relationship with at least two kinds of
   8 dinosaur.
   9 </p><p>Some background: libg++ was designed and created when there was no
  10 ISO standard to provide guidance.  Classes like linked lists are now
  11 provided for by <code class="classname">list&lt;T&gt;</code> and do not need to be
  12 created by <code class="function">genclass</code>.  (For that matter, templates exist
  13 now and are well-supported, whereas genclass (mostly) predates them.)
  14 </p><p>There are other classes in libg++ that are not specified in the
  15 ISO Standard (e.g., statistical analysis).  While there are a lot of
  16 really useful things that are used by a lot of people, the Standards
  17 Committee couldn't include everything, and so a lot of those
  18 <span class="quote">“<span class="quote">obvious</span>”</span> classes didn't get included.
  19 </p><p>Known Issues include many of the limitations of its immediate ancestor.</p><p>Portability notes and known implementation limitations are as follows.</p><div class="section"><div class="titlepage"><div><div><h4 class="title"><a id="backwards.first.ios_base"></a>No <code class="code">ios_base</code></h4></div></div></div><p> At least some older implementations don't have <code class="code">std::ios_base</code>, so you should use <code class="code">std::ios::badbit</code>, <code class="code">std::ios::failbit</code> and <code class="code">std::ios::eofbit</code> and <code class="code">std::ios::goodbit</code>.
  20 </p></div><div class="section"><div class="titlepage"><div><div><h4 class="title"><a id="backwards.first.cout_cin"></a>No <code class="code">cout</code> in <code class="filename">&lt;ostream.h&gt;</code>, no <code class="code">cin</code> in <code class="filename">&lt;istream.h&gt;</code></h4></div></div></div><p>
  21         In earlier versions of the standard,
  22         <code class="filename">&lt;fstream.h&gt;</code>,
  23         <code class="filename">&lt;ostream.h&gt;</code>
  24         and <code class="filename">&lt;istream.h&gt;</code>
  25         used to define
  26         <code class="code">cout</code>, <code class="code">cin</code> and so on. ISO C++ specifies that one needs to include
  27         <code class="filename">&lt;iostream&gt;</code>
  28         explicitly to get the required definitions.
  29  </p><p> Some include adjustment may be required.</p><p>This project is no longer maintained or supported, and the sources
  30 archived. For the desperate,
  31 the <a class="link" href="http://gcc.gnu.org/extensions.html" target="_top">GCC extensions
  32 page</a> describes where to find the last libg++ source. The code is
  33 considered replaced and rewritten.
  34 </p></div></div><div class="section"><div class="titlepage"><div><div><h3 class="title"><a id="backwards.second"></a>Second</h3></div></div></div><p>
  35   The second generation GNU C++ library was called libstdc++, or
  36   libstdc++-v2. It spans the time between libg++ and pre-ISO C++
  37   standardization and is usually associated with the following GCC
  38   releases: egcs 1.x, gcc 2.95, and gcc 2.96.
  39 </p><p>
  40   The STL portions of this library are based on SGI/HP STL release 3.11.
  41 </p><p>
  42   This project is no longer maintained or supported, and the sources
  43   archived.  The code is considered replaced and rewritten.
  44 </p><p>
  45   Portability notes and known implementation limitations are as follows.
  46 </p><div class="section"><div class="titlepage"><div><div><h4 class="title"><a id="backwards.second.std"></a>Namespace <code class="code">std::</code> not supported</h4></div></div></div><p>
  47     Some care is required to support C++ compiler and or library
  48     implementation that do not have the standard library in
  49     <code class="code">namespace std</code>.
  50   </p><p>
  51     The following sections list some possible solutions to support compilers
  52     that cannot ignore <code class="code">std::</code>-qualified names.
  53   </p><p>
  54     First, see if the compiler has a flag for this. Namespace
  55     back-portability-issues are generally not a problem for g++
  56     compilers that do not have libstdc++ in <code class="code">std::</code>, as the
  57     compilers use <code class="option">-fno-honor-std</code> (ignore
  58     <code class="code">std::</code>, <code class="code">:: = std::</code>) by default. That is,
  59     the responsibility for enabling or disabling <code class="code">std::</code> is
  60     on the user; the maintainer does not have to care about it. This
  61     probably applies to some other compilers as well.
  62   </p><p>
  63     Second, experiment with a variety of pre-processor tricks.
  64   </p><p>
  65     By defining <code class="code">std</code> as a macro, fully-qualified namespace
  66     calls become global. Volia.
  67   </p><pre class="programlisting">
  68 #ifdef WICKEDLY_OLD_COMPILER
  69 # define std
  70 #endif
  71 </pre><p>
  72     Thanks to Juergen Heinzl who posted this solution on gnu.gcc.help.
  73   </p><p>
  74     Another pre-processor based approach is to define a macro
  75     <code class="code">NAMESPACE_STD</code>, which is defined to either
  76     <span class="quote">“<span class="quote"> </span>”</span> or <span class="quote">“<span class="quote">std</span>”</span> based on a compile-type
  77     test. On GNU systems, this can be done with autotools by means of
  78     an autoconf test (see below) for <code class="code">HAVE_NAMESPACE_STD</code>,
  79     then using that to set a value for the <code class="code">NAMESPACE_STD</code>
  80     macro.  At that point, one is able to use
  81     <code class="code">NAMESPACE_STD::string</code>, which will evaluate to
  82     <code class="code">std::string</code> or <code class="code">::string</code> (i.e., in the
  83     global namespace on systems that do not put <code class="code">string</code> in
  84     <code class="code">std::</code>).
  85   </p><pre class="programlisting">
  86 dnl @synopsis AC_CXX_NAMESPACE_STD
  87 dnl
  88 dnl If the compiler supports namespace std, define
  89 dnl HAVE_NAMESPACE_STD.
  90 dnl
  91 dnl @category Cxx
  92 dnl @author Todd Veldhuizen
  93 dnl @author Luc Maisonobe &lt;luc@spaceroots.org&gt;
  94 dnl @version 2004-02-04
  95 dnl @license AllPermissive
  96 AC_DEFUN([AC_CXX_NAMESPACE_STD], [
  97   AC_CACHE_CHECK(if g++ supports namespace std,
  98   ac_cv_cxx_have_std_namespace,
  99   [AC_LANG_SAVE
 100   AC_LANG_CPLUSPLUS
 101   AC_TRY_COMPILE([#include &lt;iostream&gt;
 102                   std::istream&amp; is = std::cin;],,
 103   ac_cv_cxx_have_std_namespace=yes, ac_cv_cxx_have_std_namespace=no)
 104   AC_LANG_RESTORE
 105   ])
 106   if test "$ac_cv_cxx_have_std_namespace" = yes; then
 107     AC_DEFINE(HAVE_NAMESPACE_STD,,[Define if g++ supports namespace std. ])
 108   fi
 109 ])
 110 </pre></div><div class="section"><div class="titlepage"><div><div><h4 class="title"><a id="backwards.second.iterators"></a>Illegal iterator usage</h4></div></div></div><p>
 111   The following illustrate implementation-allowed illegal iterator
 112   use, and then correct use.
 113 </p><div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem"><p>
 114       you cannot do <code class="code">ostream::operator&lt;&lt;(iterator)</code>
 115       to print the address of the iterator =&gt; use
 116       <code class="code">operator&lt;&lt; &amp;*iterator</code> instead
 117     </p></li><li class="listitem"><p>
 118       you cannot clear an iterator's reference (<code class="code">iterator =
 119       0</code>) =&gt; use <code class="code">iterator = iterator_type();</code>
 120     </p></li><li class="listitem"><p>
 121       <code class="code">if (iterator)</code> won't work any more =&gt; use
 122       <code class="code">if (iterator != iterator_type())</code>
 123     </p></li></ul></div></div><div class="section"><div class="titlepage"><div><div><h4 class="title"><a id="backwards.second.isspace"></a><code class="code">isspace</code> from <code class="filename">&lt;cctype&gt;</code> is a macro
 124   </h4></div></div></div><p>
 125     Glibc 2.0.x and 2.1.x define <code class="filename">&lt;ctype.h&gt;</code> functionality as macros
 126     (isspace, isalpha etc.).
 127   </p><p>
 128     This implementations of libstdc++, however, keep these functions
 129     as macros, and so it is not back-portable to use fully qualified
 130     names. For example:
 131   </p><pre class="programlisting">
 132 #include &lt;cctype&gt;
 133 int main() { std::isspace('X'); }
 134 </pre><p>
 135   Results in something like this:
 136 </p><pre class="programlisting">
 137 std:: (__ctype_b[(int) ( ( 'X' ) )] &amp; (unsigned short int) _ISspace ) ;
 138 </pre><p>
 139   A solution is to modify a header-file so that the compiler tells
 140   <code class="filename">&lt;ctype.h&gt;</code> to define functions
 141   instead of macros:
 142 </p><pre class="programlisting">
 143 // This keeps isalnum, et al from being propagated as macros.
 144 #if __linux__
 145 # define __NO_CTYPE 1
 146 #endif
 147 </pre><p>
 148   Then, include <code class="filename">&lt;ctype.h&gt;</code>
 149 </p><p>
 150   Another problem arises if you put a <code class="code">using namespace
 151   std;</code> declaration at the top, and include
 152   <code class="filename">&lt;ctype.h&gt;</code>. This will
 153   result in ambiguities between the definitions in the global namespace
 154   (<code class="filename">&lt;ctype.h&gt;</code>) and the
 155   definitions in namespace <code class="code">std::</code>
 156   (<code class="code">&lt;cctype&gt;</code>).
 157 </p></div><div class="section"><div class="titlepage"><div><div><h4 class="title"><a id="backwards.second.at"></a>No <code class="code">vector::at</code>, <code class="code">deque::at</code>, <code class="code">string::at</code></h4></div></div></div><p>
 158   One solution is to add an autoconf-test for this:
 159 </p><pre class="programlisting">
 160 AC_MSG_CHECKING(for container::at)
 161 AC_TRY_COMPILE(
 162 [
 163 #include &lt;vector&gt;
 164 #include &lt;deque&gt;
 165 #include &lt;string&gt;
 166
 167 using namespace std;
 168 ],
 169 [
 170 deque&lt;int&gt; test_deque(3);
 171 test_deque.at(2);
 172 vector&lt;int&gt; test_vector(2);
 173 test_vector.at(1);
 174 string test_string(<span class="quote">“<span class="quote">test_string</span>”</span>);
 175 test_string.at(3);
 176 ],
 177 [AC_MSG_RESULT(yes)
 178 AC_DEFINE(HAVE_CONTAINER_AT)],
 179 [AC_MSG_RESULT(no)])
 180 </pre><p>
 181   If you are using other (non-GNU) compilers it might be a good idea
 182   to check for <code class="code">string::at</code> separately.
 183 </p></div><div class="section"><div class="titlepage"><div><div><h4 class="title"><a id="backwards.second.eof"></a>No <code class="code">std::char_traits&lt;char&gt;::eof</code></h4></div></div></div><p>
 184   Use some kind of autoconf test, plus this:
 185 </p><pre class="programlisting">
 186 #ifdef HAVE_CHAR_TRAITS
 187 #define CPP_EOF std::char_traits&lt;char&gt;::eof()
 188 #else
 189 #define CPP_EOF EOF
 190 #endif
 191 </pre></div><div class="section"><div class="titlepage"><div><div><h4 class="title"><a id="backwards.second.stringclear"></a>No <code class="code">string::clear</code></h4></div></div></div><p>
 192   There are two functions for deleting the contents of a string:
 193   <code class="code">clear</code> and <code class="code">erase</code> (the latter returns the
 194   string).
 195 </p><pre class="programlisting">
 196 void
 197 clear() { _M_mutate(0, this-&gt;size(), 0); }
 198 </pre><pre class="programlisting">
 199 basic_string&amp;
 200 erase(size_type __pos = 0, size_type __n = npos)
 201 {
 202   return this-&gt;replace(_M_check(__pos), _M_fold(__pos, __n),
 203                           _M_data(), _M_data());
 204 }
 205 </pre><p>
 206   Unfortunately, <code class="code">clear</code> is not implemented in this
 207   version, so you should use <code class="code">erase</code> (which is probably
 208   faster than <code class="code">operator=(charT*)</code>).
 209 </p></div><div class="section"><div class="titlepage"><div><div><h4 class="title"><a id="backwards.second.ostreamform_istreamscan"></a>
 210   Removal of <code class="code">ostream::form</code> and <code class="code">istream::scan</code>
 211   extensions
 212 </h4></div></div></div><p>
 213   These are no longer supported. Please use stringstreams instead.
 214 </p></div><div class="section"><div class="titlepage"><div><div><h4 class="title"><a id="backwards.second.stringstreams"></a>No <code class="code">basic_stringbuf</code>, <code class="code">basic_stringstream</code></h4></div></div></div><p>
 215   Although the ISO standard <code class="code">i/ostringstream</code>-classes are
 216   provided, (<code class="filename">&lt;sstream&gt;</code>), for
 217   compatibility with older implementations the pre-ISO
 218   <code class="code">i/ostrstream</code> (<code class="filename">&lt;strstream&gt;</code>) interface is also provided,
 219   with these caveats:
 220 </p><div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem"><p>
 221       <code class="code">strstream</code> is considered to be deprecated
 222     </p></li><li class="listitem"><p>
 223       <code class="code">strstream</code> is limited to <code class="code">char</code>
 224     </p></li><li class="listitem"><p>
 225       with <code class="code">ostringstream</code> you don't have to take care of
 226       terminating the string or freeing its memory
 227     </p></li><li class="listitem"><p>
 228       <code class="code">istringstream</code> can be re-filled (clear();
 229       str(input);)
 230     </p></li></ul></div><p>
 231   You can then use output-stringstreams like this:
 232 </p><pre class="programlisting">
 233 #ifdef HAVE_SSTREAM
 234 # include &lt;sstream&gt;
 235 #else
 236 # include &lt;strstream&gt;
 237 #endif
 238
 239 #ifdef HAVE_SSTREAM
 240   std::ostringstream oss;
 241 #else
 242   std::ostrstream oss;
 243 #endif
 244
 245 oss &lt;&lt; <span class="quote">“<span class="quote">Name=</span>”</span> &lt;&lt; m_name &lt;&lt; <span class="quote">“<span class="quote">, number=</span>”</span> &lt;&lt; m_number &lt;&lt; std::endl;
 246 ...
 247 #ifndef HAVE_SSTREAM
 248   oss &lt;&lt; std::ends; // terminate the char*-string
 249 #endif
 250
 251 // str() returns char* for ostrstream and a string for ostringstream
 252 // this also causes ostrstream to think that the buffer's memory
 253 // is yours
 254 m_label.set_text(oss.str());
 255 #ifndef HAVE_SSTREAM
 256   // let the ostrstream take care of freeing the memory
 257   oss.freeze(false);
 258 #endif
 259 </pre><p>
 260       Input-stringstreams can be used similarly:
 261 </p><pre class="programlisting">
 262 std::string input;
 263 ...
 264 #ifdef HAVE_SSTREAM
 265 std::istringstream iss(input);
 266 #else
 267 std::istrstream iss(input.c_str());
 268 #endif
 269
 270 int i;
 271 iss &gt;&gt; i;
 272 </pre><p> One (the only?) restriction is that an istrstream cannot be re-filled:
 273 </p><pre class="programlisting">
 274 std::istringstream iss(numerator);
 275 iss &gt;&gt; m_num;
 276 // this is not possible with istrstream
 277 iss.clear();
 278 iss.str(denominator);
 279 iss &gt;&gt; m_den;
 280 </pre><p>
 281 If you don't care about speed, you can put these conversions in
 282       a template-function:
 283 </p><pre class="programlisting">
 284 template &lt;class X&gt;
 285 void fromString(const string&amp; input, X&amp; any)
 286 {
 287 #ifdef HAVE_SSTREAM
 288 std::istringstream iss(input);
 289 #else
 290 std::istrstream iss(input.c_str());
 291 #endif
 292 X temp;
 293 iss &gt;&gt; temp;
 294 if (iss.fail())
 295 throw runtime_error(..)
 296 any = temp;
 297 }
 298 </pre><p>
 299   Another example of using stringstreams is in <a class="link" href="strings.html#strings.string.shrink" title="Shrink to Fit">this howto</a>.
 300 </p><p> There is additional information in the libstdc++-v2 info files, in
 301 particular <span class="quote">“<span class="quote">info iostream</span>”</span>.
 302 </p></div><div class="section"><div class="titlepage"><div><div><h4 class="title"><a id="backwards.second.wchar"></a>Little or no wide character support</h4></div></div></div><p>
 303     Classes <code class="classname">wstring</code> and
 304     <code class="classname">char_traits&lt;wchar_t&gt;</code> are
 305     not supported.
 306   </p></div><div class="section"><div class="titlepage"><div><div><h4 class="title"><a id="backwards.second.iostream_templates"></a>No templatized iostreams</h4></div></div></div><p>
 307     Classes <code class="classname">wfilebuf</code> and
 308     <code class="classname">wstringstream</code> are not supported.
 309   </p></div><div class="section"><div class="titlepage"><div><div><h4 class="title"><a id="backwards.second.thread_safety"></a>Thread safety issues</h4></div></div></div><p>
 310     Earlier GCC releases had a somewhat different approach to
 311     threading configuration and proper compilation.  Before GCC 3.0,
 312     configuration of the threading model was dictated by compiler
 313     command-line options and macros (both of which were somewhat
 314     thread-implementation and port-specific).  There were no
 315     guarantees related to being able to link code compiled with one
 316     set of options and macro setting with another set.
 317   </p><p>
 318     For GCC 3.0, configuration of the threading model used with
 319     libraries and user-code is performed when GCC is configured and
 320     built using the --enable-threads and --disable-threads options.
 321     The ABI is stable for symbol name-mangling and limited functional
 322     compatibility exists between code compiled under different
 323     threading models.
 324   </p><p>
 325      The libstdc++ library has been designed so that it can be used in
 326      multithreaded applications (with libstdc++-v2 this was only true
 327      of the STL parts.)  The first problem is finding a
 328      <span class="emphasis"><em>fast</em></span> method of implementation portable to
 329      all platforms.  Due to historical reasons, some of the library is
 330      written against per-CPU-architecture spinlocks and other parts
 331      against the gthr.h abstraction layer which is provided by gcc.  A
 332      minor problem that pops up every so often is different
 333      interpretations of what "thread-safe" means for a
 334      library (not a general program).  We currently use the <a class="link" href="http://www.sgi.com/tech/stl/thread_safety.html" target="_top">same
 335      definition that SGI</a> uses for their STL subset.  However,
 336      the exception for read-only containers only applies to the STL
 337      components. This definition is widely-used and something similar
 338      will be used in the next version of the C++ standard library.
 339    </p><p>
 340      Here is a small link farm to threads (no pun) in the mail
 341      archives that discuss the threading problem.  Each link is to the
 342      first relevant message in the thread; from there you can use
 343      "Thread Next" to move down the thread.  This farm is in
 344      latest-to-oldest order.
 345    </p><div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem"><p>
 346             Our threading expert Loren gives a breakdown of <a class="link" href="http://gcc.gnu.org/ml/libstdc++/2001-10/msg00024.html" target="_top">the
 347             six situations involving threads</a> for the 3.0
 348             release series.
 349           </p></li><li class="listitem"><p>
 350             <a class="link" href="http://gcc.gnu.org/ml/libstdc++/2001-05/msg00384.html" target="_top">
 351         This message</a> inspired a recent updating of issues with
 352         threading and the SGI STL library.  It also contains some
 353         example POSIX-multithreaded STL code.
 354           </p></li></ul></div><p>
 355      (A large selection of links to older messages has been removed;
 356      many of the messages from 1999 were lost in a disk crash, and the
 357      few people with access to the backup tapes have been too swamped
 358      with work to restore them.  Many of the points have been
 359      superseded anyhow.)
 360    </p></div></div><div class="section"><div class="titlepage"><div><div><h3 class="title"><a id="backwards.third"></a>Third</h3></div></div></div><p> The third generation GNU C++ library is called libstdc++, or
 361 libstdc++-v3.
 362 </p><p>The subset commonly known as the Standard Template Library
 363          (clauses 23 through 25, mostly) is adapted from the final release
 364          of the SGI STL (version 3.3), with extensive changes.
 365       </p><p>A more formal description of the V3 goals can be found in the
 366          official <a class="link" href="source_design_notes.html" title="Design Notes">design document</a>.
 367       </p><p>Portability notes and known implementation limitations are as follows.</p><div class="section"><div class="titlepage"><div><div><h4 class="title"><a id="backwards.third.headers"></a>Pre-ISO headers moved to backwards or removed</h4></div></div></div><p> The pre-ISO C++ headers
 368       (<code class="filename">&lt;iostream.h&gt;</code>,
 369       <code class="filename">&lt;defalloc.h&gt;</code> etc.) are
 370       available, unlike previous libstdc++ versions, but inclusion
 371       generates a warning that you are using deprecated headers.
 372 </p><p>This compatibility layer is constructed by including the
 373     standard C++ headers, and injecting any items in
 374     <code class="code">std::</code> into the global namespace.
 375    </p><p>For those of you new to ISO C++ (welcome, time travelers!), no,
 376       that isn't a typo. Yes, the headers really have new names.
 377       Marshall Cline's C++ FAQ Lite has a good explanation in <a class="link" href="http://www.parashift.com/c++-faq-lite/std-headers.html" target="_top">What's
 378       the difference between &lt;xxx&gt; and &lt;xxx.h&gt; headers?</a>.
 379    </p><p> Some include adjustment may be required. What follows is an
 380 autoconf test that defines <code class="code">PRE_STDCXX_HEADERS</code> when they
 381 exist.</p><pre class="programlisting">
 382 # AC_HEADER_PRE_STDCXX
 383 AC_DEFUN([AC_HEADER_PRE_STDCXX], [
 384   AC_CACHE_CHECK(for pre-ISO C++ include files,
 385   ac_cv_cxx_pre_stdcxx,
 386   [AC_LANG_SAVE
 387   AC_LANG_CPLUSPLUS
 388   ac_save_CXXFLAGS="$CXXFLAGS"
 389   CXXFLAGS="$CXXFLAGS -Wno-deprecated"
 390
 391   # Omit defalloc.h, as compilation with newer compilers is problematic.
 392   AC_TRY_COMPILE([
 393   #include &lt;new.h&gt;
 394   #include &lt;iterator.h&gt;
 395   #include &lt;alloc.h&gt;
 396   #include &lt;set.h&gt;
 397   #include &lt;hashtable.h&gt;
 398   #include &lt;hash_set.h&gt;
 399   #include &lt;fstream.h&gt;
 400   #include &lt;tempbuf.h&gt;
 401   #include &lt;istream.h&gt;
 402   #include &lt;bvector.h&gt;
 403   #include &lt;stack.h&gt;
 404   #include &lt;rope.h&gt;
 405   #include &lt;complex.h&gt;
 406   #include &lt;ostream.h&gt;
 407   #include &lt;heap.h&gt;
 408   #include &lt;iostream.h&gt;
 409   #include &lt;function.h&gt;
 410   #include &lt;multimap.h&gt;
 411   #include &lt;pair.h&gt;
 412   #include &lt;stream.h&gt;
 413   #include &lt;iomanip.h&gt;
 414   #include &lt;slist.h&gt;
 415   #include &lt;tree.h&gt;
 416   #include &lt;vector.h&gt;
 417   #include &lt;deque.h&gt;
 418   #include &lt;multiset.h&gt;
 419   #include &lt;list.h&gt;
 420   #include &lt;map.h&gt;
 421   #include &lt;algobase.h&gt;
 422   #include &lt;hash_map.h&gt;
 423   #include &lt;algo.h&gt;
 424   #include &lt;queue.h&gt;
 425   #include &lt;streambuf.h&gt;
 426   ],,
 427   ac_cv_cxx_pre_stdcxx=yes, ac_cv_cxx_pre_stdcxx=no)
 428   CXXFLAGS="$ac_save_CXXFLAGS"
 429   AC_LANG_RESTORE
 430   ])
 431   if test "$ac_cv_cxx_pre_stdcxx" = yes; then
 432     AC_DEFINE(PRE_STDCXX_HEADERS,,[Define if pre-ISO C++ header files are present. ])
 433   fi
 434 ])
 435 </pre><p>Porting between pre-ISO headers and ISO headers is simple: headers
 436 like <code class="filename">&lt;vector.h&gt;</code> can be replaced with <code class="filename">&lt;vector&gt;</code> and a using
 437 directive <code class="code">using namespace std;</code> can be put at the global
 438 scope. This should be enough to get this code compiling, assuming the
 439 other usage is correct.
 440 </p></div><div class="section"><div class="titlepage"><div><div><h4 class="title"><a id="backwards.third.hash"></a>Extension headers hash_map, hash_set moved to ext or backwards</h4></div></div></div><p>At this time most of the features of the SGI STL extension have been
 441          replaced by standardized libraries.
 442          In particular, the <code class="classname">unordered_map</code> and
 443          <code class="classname">unordered_set</code> containers of TR1 and C++ 2011
 444          are suitable replacements for the non-standard
 445          <code class="classname">hash_map</code> and <code class="classname">hash_set</code>
 446          containers in the SGI STL.
 447       </p><p> Header files <code class="filename">&lt;hash_map&gt;</code> and <code class="filename">&lt;hash_set&gt;</code> moved
 448 to <code class="filename">&lt;ext/hash_map&gt;</code> and  <code class="filename">&lt;ext/hash_set&gt;</code>,
 449 respectively. At the same time, all types in these files are enclosed
 450 in <code class="code">namespace __gnu_cxx</code>. Later versions deprecate
 451 these files, and suggest using TR1's  <code class="filename">&lt;unordered_map&gt;</code>
 452 and  <code class="filename">&lt;unordered_set&gt;</code> instead.
 453 </p><p>The extensions are no longer in the global or <code class="code">std</code>
 454          namespaces, instead they are declared in the <code class="code">__gnu_cxx</code>
 455          namespace. For maximum portability, consider defining a namespace
 456          alias to use to talk about extensions, e.g.:
 457       </p><pre class="programlisting">
 458       #ifdef __GNUC__
 459       #if __GNUC__ &lt; 3
 460         #include &lt;hash_map.h&gt;
 461         namespace extension { using ::hash_map; }; // inherit globals
 462       #else
 463         #include &lt;backward/hash_map&gt;
 464         #if __GNUC__ == 3 &amp;&amp; __GNUC_MINOR__ == 0
 465           namespace extension = std;               // GCC 3.0
 466         #else
 467           namespace extension = ::__gnu_cxx;       // GCC 3.1 and later
 468         #endif
 469       #endif
 470       #else      // ...  there are other compilers, right?
 471         namespace extension = std;
 472       #endif
 473
 474       extension::hash_map&lt;int,int&gt; my_map;
 475       </pre><p>This is a bit cleaner than defining typedefs for all the
 476          instantiations you might need.
 477       </p><p>The following autoconf tests check for working HP/SGI hash containers.
 478 </p><pre class="programlisting">
 479 # AC_HEADER_EXT_HASH_MAP
 480 AC_DEFUN([AC_HEADER_EXT_HASH_MAP], [
 481   AC_CACHE_CHECK(for ext/hash_map,
 482   ac_cv_cxx_ext_hash_map,
 483   [AC_LANG_SAVE
 484   AC_LANG_CPLUSPLUS
 485   ac_save_CXXFLAGS="$CXXFLAGS"
 486   CXXFLAGS="$CXXFLAGS -Werror"
 487   AC_TRY_COMPILE([#include &lt;ext/hash_map&gt;], [using __gnu_cxx::hash_map;],
 488   ac_cv_cxx_ext_hash_map=yes, ac_cv_cxx_ext_hash_map=no)
 489   CXXFLAGS="$ac_save_CXXFLAGS"
 490   AC_LANG_RESTORE
 491   ])
 492   if test "$ac_cv_cxx_ext_hash_map" = yes; then
 493     AC_DEFINE(HAVE_EXT_HASH_MAP,,[Define if ext/hash_map is present. ])
 494   fi
 495 ])
 496 </pre><pre class="programlisting">
 497 # AC_HEADER_EXT_HASH_SET
 498 AC_DEFUN([AC_HEADER_EXT_HASH_SET], [
 499   AC_CACHE_CHECK(for ext/hash_set,
 500   ac_cv_cxx_ext_hash_set,
 501   [AC_LANG_SAVE
 502   AC_LANG_CPLUSPLUS
 503   ac_save_CXXFLAGS="$CXXFLAGS"
 504   CXXFLAGS="$CXXFLAGS -Werror"
 505   AC_TRY_COMPILE([#include &lt;ext/hash_set&gt;], [using __gnu_cxx::hash_set;],
 506   ac_cv_cxx_ext_hash_set=yes, ac_cv_cxx_ext_hash_set=no)
 507   CXXFLAGS="$ac_save_CXXFLAGS"
 508   AC_LANG_RESTORE
 509   ])
 510   if test "$ac_cv_cxx_ext_hash_set" = yes; then
 511     AC_DEFINE(HAVE_EXT_HASH_SET,,[Define if ext/hash_set is present. ])
 512   fi
 513 ])
 514 </pre></div><div class="section"><div class="titlepage"><div><div><h4 class="title"><a id="backwards.third.nocreate_noreplace"></a>No <code class="code">ios::nocreate/ios::noreplace</code>.
 515 </h4></div></div></div><p>Historically these flags were used with iostreams to control whether
 516 new files are created or not when opening a file stream, similar to the
 517 <code class="code">O_CREAT</code> and <code class="code">O_EXCL</code> flags for the
 518 <code class="function">open(2)</code> system call. Because iostream modes correspond
 519 to <code class="function">fopen(3)</code> modes these flags are not supported.
 520 For input streams a new file will not be created anyway, so
 521 <code class="code">ios::nocreate</code> is not needed.
 522 For output streams, a new file will be created if it does not exist, which is
 523 consistent with the behaviour of <code class="function">fopen</code>.
 524 </p><p>When one of these flags is needed a possible alternative is to attempt
 525 to open the file using <span class="type">std::ifstream</span> first to determine whether
 526 the file already exists or not. This may not be reliable however, because
 527 whether the file exists or not could change between opening the
 528 <span class="type">std::istream</span> and re-opening with an output stream. If you need
 529 to check for existence and open a file as a single operation then you will
 530 need to use OS-specific facilities outside the C++ standard library, such
 531 as <code class="function">open(2)</code>.
 532 </p></div><div class="section"><div class="titlepage"><div><div><h4 class="title"><a id="backwards.third.streamattach"></a>
 533 No <code class="code">stream::attach(int fd)</code>
 534 </h4></div></div></div><p>
 535       Phil Edwards writes: It was considered and rejected for the ISO
 536       standard.  Not all environments use file descriptors.  Of those
 537       that do, not all of them use integers to represent them.
 538     </p><p>
 539       For a portable solution (among systems which use
 540       file descriptors), you need to implement a subclass of
 541       <code class="code">std::streambuf</code> (or
 542       <code class="code">std::basic_streambuf&lt;..&gt;</code>) which opens a file
 543       given a descriptor, and then pass an instance of this to the
 544       stream-constructor.
 545     </p><p>
 546       An extension is available that implements this.
 547       <code class="filename">&lt;ext/stdio_filebuf.h&gt;</code> contains a derived class called
 548       <a class="link" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a00074.html" target="_top"><code class="code">__gnu_cxx::stdio_filebuf</code></a>.
 549       This class can be constructed from a C <code class="code">FILE*</code> or a file
 550       descriptor, and provides the <code class="code">fd()</code> function.
 551     </p><p>
 552  For another example of this, refer to
 553       <a class="link" href="http://www.josuttis.com/cppcode/fdstream.html" target="_top">fdstream example</a>
 554       by Nicolai Josuttis.
 555 </p></div><div class="section"><div class="titlepage"><div><div><h4 class="title"><a id="backwards.third.support_cxx98"></a>
 556 Support for C++98 dialect.
 557 </h4></div></div></div><p>Check for complete library coverage of the C++1998/2003 standard.
 558 </p><pre class="programlisting">
 559 # AC_HEADER_STDCXX_98
 560 AC_DEFUN([AC_HEADER_STDCXX_98], [
 561   AC_CACHE_CHECK(for ISO C++ 98 include files,
 562   ac_cv_cxx_stdcxx_98,
 563   [AC_LANG_SAVE
 564   AC_LANG_CPLUSPLUS
 565   AC_TRY_COMPILE([
 566     #include &lt;cassert&gt;
 567     #include &lt;cctype&gt;
 568     #include &lt;cerrno&gt;
 569     #include &lt;cfloat&gt;
 570     #include &lt;ciso646&gt;
 571     #include &lt;climits&gt;
 572     #include &lt;clocale&gt;
 573     #include &lt;cmath&gt;
 574     #include &lt;csetjmp&gt;
 575     #include &lt;csignal&gt;
 576     #include &lt;cstdarg&gt;
 577     #include &lt;cstddef&gt;
 578     #include &lt;cstdio&gt;
 579     #include &lt;cstdlib&gt;
 580     #include &lt;cstring&gt;
 581     #include &lt;ctime&gt;
 582
 583     #include &lt;algorithm&gt;
 584     #include &lt;bitset&gt;
 585     #include &lt;complex&gt;
 586     #include &lt;deque&gt;
 587     #include &lt;exception&gt;
 588     #include &lt;fstream&gt;
 589     #include &lt;functional&gt;
 590     #include &lt;iomanip&gt;
 591     #include &lt;ios&gt;
 592     #include &lt;iosfwd&gt;
 593     #include &lt;iostream&gt;
 594     #include &lt;istream&gt;
 595     #include &lt;iterator&gt;
 596     #include &lt;limits&gt;
 597     #include &lt;list&gt;
 598     #include &lt;locale&gt;
 599     #include &lt;map&gt;
 600     #include &lt;memory&gt;
 601     #include &lt;new&gt;
 602     #include &lt;numeric&gt;
 603     #include &lt;ostream&gt;
 604     #include &lt;queue&gt;
 605     #include &lt;set&gt;
 606     #include &lt;sstream&gt;
 607     #include &lt;stack&gt;
 608     #include &lt;stdexcept&gt;
 609     #include &lt;streambuf&gt;
 610     #include &lt;string&gt;
 611     #include &lt;typeinfo&gt;
 612     #include &lt;utility&gt;
 613     #include &lt;valarray&gt;
 614     #include &lt;vector&gt;
 615   ],,
 616   ac_cv_cxx_stdcxx_98=yes, ac_cv_cxx_stdcxx_98=no)
 617   AC_LANG_RESTORE
 618   ])
 619   if test "$ac_cv_cxx_stdcxx_98" = yes; then
 620     AC_DEFINE(STDCXX_98_HEADERS,,[Define if ISO C++ 1998 header files are present. ])
 621   fi
 622 ])
 623 </pre></div><div class="section"><div class="titlepage"><div><div><h4 class="title"><a id="backwards.third.support_tr1"></a>
 624 Support for C++TR1 dialect.
 625 </h4></div></div></div><p>Check for library coverage of the TR1 standard.
 626 </p><pre class="programlisting">
 627 # AC_HEADER_STDCXX_TR1
 628 AC_DEFUN([AC_HEADER_STDCXX_TR1], [
 629   AC_CACHE_CHECK(for ISO C++ TR1 include files,
 630   ac_cv_cxx_stdcxx_tr1,
 631   [AC_LANG_SAVE
 632   AC_LANG_CPLUSPLUS
 633   AC_TRY_COMPILE([
 634   #include &lt;tr1/array&gt;
 635   #include &lt;tr1/ccomplex&gt;
 636   #include &lt;tr1/cctype&gt;
 637   #include &lt;tr1/cfenv&gt;
 638   #include &lt;tr1/cfloat&gt;
 639   #include &lt;tr1/cinttypes&gt;
 640   #include &lt;tr1/climits&gt;
 641   #include &lt;tr1/cmath&gt;
 642   #include &lt;tr1/complex&gt;
 643   #include &lt;tr1/cstdarg&gt;
 644   #include &lt;tr1/cstdbool&gt;
 645   #include &lt;tr1/cstdint&gt;
 646   #include &lt;tr1/cstdio&gt;
 647   #include &lt;tr1/cstdlib&gt;
 648   #include &lt;tr1/ctgmath&gt;
 649   #include &lt;tr1/ctime&gt;
 650   #include &lt;tr1/cwchar&gt;
 651   #include &lt;tr1/cwctype&gt;
 652   #include &lt;tr1/functional&gt;
 653   #include &lt;tr1/memory&gt;
 654   #include &lt;tr1/random&gt;
 655   #include &lt;tr1/regex&gt;
 656   #include &lt;tr1/tuple&gt;
 657   #include &lt;tr1/type_traits&gt;
 658   #include &lt;tr1/unordered_set&gt;
 659   #include &lt;tr1/unordered_map&gt;
 660   #include &lt;tr1/utility&gt;
 661   ],,
 662   ac_cv_cxx_stdcxx_tr1=yes, ac_cv_cxx_stdcxx_tr1=no)
 663   AC_LANG_RESTORE
 664   ])
 665   if test "$ac_cv_cxx_stdcxx_tr1" = yes; then
 666     AC_DEFINE(STDCXX_TR1_HEADERS,,[Define if ISO C++ TR1 header files are present. ])
 667   fi
 668 ])
 669 </pre><p>An alternative is to check just for specific TR1 includes, such as &lt;unordered_map&gt; and &lt;unordered_set&gt;.
 670 </p><pre class="programlisting">
 671 # AC_HEADER_TR1_UNORDERED_MAP
 672 AC_DEFUN([AC_HEADER_TR1_UNORDERED_MAP], [
 673   AC_CACHE_CHECK(for tr1/unordered_map,
 674   ac_cv_cxx_tr1_unordered_map,
 675   [AC_LANG_SAVE
 676   AC_LANG_CPLUSPLUS
 677   AC_TRY_COMPILE([#include &lt;tr1/unordered_map&gt;], [using std::tr1::unordered_map;],
 678   ac_cv_cxx_tr1_unordered_map=yes, ac_cv_cxx_tr1_unordered_map=no)
 679   AC_LANG_RESTORE
 680   ])
 681   if test "$ac_cv_cxx_tr1_unordered_map" = yes; then
 682     AC_DEFINE(HAVE_TR1_UNORDERED_MAP,,[Define if tr1/unordered_map is present. ])
 683   fi
 684 ])
 685 </pre><pre class="programlisting">
 686 # AC_HEADER_TR1_UNORDERED_SET
 687 AC_DEFUN([AC_HEADER_TR1_UNORDERED_SET], [
 688   AC_CACHE_CHECK(for tr1/unordered_set,
 689   ac_cv_cxx_tr1_unordered_set,
 690   [AC_LANG_SAVE
 691   AC_LANG_CPLUSPLUS
 692   AC_TRY_COMPILE([#include &lt;tr1/unordered_set&gt;], [using std::tr1::unordered_set;],
 693   ac_cv_cxx_tr1_unordered_set=yes, ac_cv_cxx_tr1_unordered_set=no)
 694   AC_LANG_RESTORE
 695   ])
 696   if test "$ac_cv_cxx_tr1_unordered_set" = yes; then
 697     AC_DEFINE(HAVE_TR1_UNORDERED_SET,,[Define if tr1/unordered_set is present. ])
 698   fi
 699 ])
 700 </pre></div><div class="section"><div class="titlepage"><div><div><h4 class="title"><a id="backwards.third.support_cxx11"></a>
 701 Support for C++11 dialect.
 702 </h4></div></div></div><p>Check for baseline language coverage in the compiler for the C++11 standard.
 703 </p><pre class="programlisting">
 704 # AC_COMPILE_STDCXX_11
 705 AC_DEFUN([AC_COMPILE_STDCXX_11], [
 706   AC_CACHE_CHECK(if g++ supports C++11 features without additional flags,
 707   ac_cv_cxx_compile_cxx11_native,
 708   [AC_LANG_SAVE
 709   AC_LANG_CPLUSPLUS
 710   AC_TRY_COMPILE([
 711   template &lt;typename T&gt;
 712     struct check final
 713     {
 714       static constexpr T value{ __cplusplus };
 715     };
 716
 717     typedef check&lt;check&lt;bool&gt;&gt; right_angle_brackets;
 718
 719     int a;
 720     decltype(a) b;
 721
 722     typedef check&lt;int&gt; check_type;
 723     check_type c{};
 724     check_type&amp;&amp; cr = static_cast&lt;check_type&amp;&amp;&gt;(c);
 725
 726     static_assert(check_type::value == 201103L, "C++11 compiler");],,
 727   ac_cv_cxx_compile_cxx11_native=yes, ac_cv_cxx_compile_cxx11_native=no)
 728   AC_LANG_RESTORE
 729   ])
 730
 731   AC_CACHE_CHECK(if g++ supports C++11 features with -std=c++11,
 732   ac_cv_cxx_compile_cxx11_cxx,
 733   [AC_LANG_SAVE
 734   AC_LANG_CPLUSPLUS
 735   ac_save_CXXFLAGS="$CXXFLAGS"
 736   CXXFLAGS="$CXXFLAGS -std=c++11"
 737   AC_TRY_COMPILE([
 738   template &lt;typename T&gt;
 739     struct check final
 740     {
 741       static constexpr T value{ __cplusplus };
 742     };
 743
 744     typedef check&lt;check&lt;bool&gt;&gt; right_angle_brackets;
 745
 746     int a;
 747     decltype(a) b;
 748
 749     typedef check&lt;int&gt; check_type;
 750     check_type c{};
 751     check_type&amp;&amp; cr = static_cast&lt;check_type&amp;&amp;&gt;(c);
 752
 753     static_assert(check_type::value == 201103L, "C++11 compiler");],,
 754   ac_cv_cxx_compile_cxx11_cxx=yes, ac_cv_cxx_compile_cxx11_cxx=no)
 755   CXXFLAGS="$ac_save_CXXFLAGS"
 756   AC_LANG_RESTORE
 757   ])
 758
 759   AC_CACHE_CHECK(if g++ supports C++11 features with -std=gnu++11,
 760   ac_cv_cxx_compile_cxx11_gxx,
 761   [AC_LANG_SAVE
 762   AC_LANG_CPLUSPLUS
 763   ac_save_CXXFLAGS="$CXXFLAGS"
 764   CXXFLAGS="$CXXFLAGS -std=gnu++11"
 765   AC_TRY_COMPILE([
 766   template &lt;typename T&gt;
 767     struct check final
 768     {
 769       static constexpr T value{ __cplusplus };
 770     };
 771
 772     typedef check&lt;check&lt;bool&gt;&gt; right_angle_brackets;
 773
 774     int a;
 775     decltype(a) b;
 776
 777     typedef check&lt;int&gt; check_type;
 778     check_type c{};
 779     check_type&amp;&amp; cr = static_cast&lt;check_type&amp;&amp;&gt;(c);
 780
 781     static_assert(check_type::value == 201103L, "C++11 compiler");],,
 782   ac_cv_cxx_compile_cxx11_gxx=yes, ac_cv_cxx_compile_cxx11_gxx=no)
 783   CXXFLAGS="$ac_save_CXXFLAGS"
 784   AC_LANG_RESTORE
 785   ])
 786
 787   if test "$ac_cv_cxx_compile_cxx11_native" = yes ||
 788      test "$ac_cv_cxx_compile_cxx11_cxx" = yes ||
 789      test "$ac_cv_cxx_compile_cxx11_gxx" = yes; then
 790     AC_DEFINE(HAVE_STDCXX_11,,[Define if g++ supports C++11 features. ])
 791   fi
 792 ])
 793 </pre><p>Check for library coverage of the C++2011 standard.
 794   (Some library headers are commented out in this check, they are
 795   not currently provided by libstdc++).
 796 </p><pre class="programlisting">
 797 # AC_HEADER_STDCXX_11
 798 AC_DEFUN([AC_HEADER_STDCXX_11], [
 799   AC_CACHE_CHECK(for ISO C++11 include files,
 800   ac_cv_cxx_stdcxx_11,
 801   [AC_REQUIRE([AC_COMPILE_STDCXX_11])
 802   AC_LANG_SAVE
 803   AC_LANG_CPLUSPLUS
 804   ac_save_CXXFLAGS="$CXXFLAGS"
 805   CXXFLAGS="$CXXFLAGS -std=gnu++11"
 806
 807   AC_TRY_COMPILE([
 808     #include &lt;cassert&gt;
 809     #include &lt;ccomplex&gt;
 810     #include &lt;cctype&gt;
 811     #include &lt;cerrno&gt;
 812     #include &lt;cfenv&gt;
 813     #include &lt;cfloat&gt;
 814     #include &lt;cinttypes&gt;
 815     #include &lt;ciso646&gt;
 816     #include &lt;climits&gt;
 817     #include &lt;clocale&gt;
 818     #include &lt;cmath&gt;
 819     #include &lt;csetjmp&gt;
 820     #include &lt;csignal&gt;
 821     #include &lt;cstdalign&gt;
 822     #include &lt;cstdarg&gt;
 823     #include &lt;cstdbool&gt;
 824     #include &lt;cstddef&gt;
 825     #include &lt;cstdint&gt;
 826     #include &lt;cstdio&gt;
 827     #include &lt;cstdlib&gt;
 828     #include &lt;cstring&gt;
 829     #include &lt;ctgmath&gt;
 830     #include &lt;ctime&gt;
 831     // #include &lt;cuchar&gt;
 832     #include &lt;cwchar&gt;
 833     #include &lt;cwctype&gt;
 834
 835     #include &lt;algorithm&gt;
 836     #include &lt;array&gt;
 837     #include &lt;atomic&gt;
 838     #include &lt;bitset&gt;
 839     #include &lt;chrono&gt;
 840     // #include &lt;codecvt&gt;
 841     #include &lt;complex&gt;
 842     #include &lt;condition_variable&gt;
 843     #include &lt;deque&gt;
 844     #include &lt;exception&gt;
 845     #include &lt;forward_list&gt;
 846     #include &lt;fstream&gt;
 847     #include &lt;functional&gt;
 848     #include &lt;future&gt;
 849     #include &lt;initializer_list&gt;
 850     #include &lt;iomanip&gt;
 851     #include &lt;ios&gt;
 852     #include &lt;iosfwd&gt;
 853     #include &lt;iostream&gt;
 854     #include &lt;istream&gt;
 855     #include &lt;iterator&gt;
 856     #include &lt;limits&gt;
 857     #include &lt;list&gt;
 858     #include &lt;locale&gt;
 859     #include &lt;map&gt;
 860     #include &lt;memory&gt;
 861     #include &lt;mutex&gt;
 862     #include &lt;new&gt;
 863     #include &lt;numeric&gt;
 864     #include &lt;ostream&gt;
 865     #include &lt;queue&gt;
 866     #include &lt;random&gt;
 867     #include &lt;ratio&gt;
 868     #include &lt;regex&gt;
 869     #include &lt;scoped_allocator&gt;
 870     #include &lt;set&gt;
 871     #include &lt;sstream&gt;
 872     #include &lt;stack&gt;
 873     #include &lt;stdexcept&gt;
 874     #include &lt;streambuf&gt;
 875     #include &lt;string&gt;
 876     #include &lt;system_error&gt;
 877     #include &lt;thread&gt;
 878     #include &lt;tuple&gt;
 879     #include &lt;typeindex&gt;
 880     #include &lt;typeinfo&gt;
 881     #include &lt;type_traits&gt;
 882     #include &lt;unordered_map&gt;
 883     #include &lt;unordered_set&gt;
 884     #include &lt;utility&gt;
 885     #include &lt;valarray&gt;
 886     #include &lt;vector&gt;
 887   ],,
 888   ac_cv_cxx_stdcxx_11=yes, ac_cv_cxx_stdcxx_11=no)
 889   AC_LANG_RESTORE
 890   CXXFLAGS="$ac_save_CXXFLAGS"
 891   ])
 892   if test "$ac_cv_cxx_stdcxx_11" = yes; then
 893     AC_DEFINE(STDCXX_11_HEADERS,,[Define if ISO C++11 header files are present. ])
 894   fi
 895 ])
 896 </pre><p>As is the case for TR1 support, these autoconf macros can be made for a finer-grained, per-header-file check. For
 897 <code class="filename">&lt;unordered_map&gt;</code>
 898 </p><pre class="programlisting">
 899 # AC_HEADER_UNORDERED_MAP
 900 AC_DEFUN([AC_HEADER_UNORDERED_MAP], [
 901   AC_CACHE_CHECK(for unordered_map,
 902   ac_cv_cxx_unordered_map,
 903   [AC_REQUIRE([AC_COMPILE_STDCXX_11])
 904   AC_LANG_SAVE
 905   AC_LANG_CPLUSPLUS
 906   ac_save_CXXFLAGS="$CXXFLAGS"
 907   CXXFLAGS="$CXXFLAGS -std=gnu++11"
 908   AC_TRY_COMPILE([#include &lt;unordered_map&gt;], [using std::unordered_map;],
 909   ac_cv_cxx_unordered_map=yes, ac_cv_cxx_unordered_map=no)
 910   CXXFLAGS="$ac_save_CXXFLAGS"
 911   AC_LANG_RESTORE
 912   ])
 913   if test "$ac_cv_cxx_unordered_map" = yes; then
 914     AC_DEFINE(HAVE_UNORDERED_MAP,,[Define if unordered_map is present. ])
 915   fi
 916 ])
 917 </pre><pre class="programlisting">
 918 # AC_HEADER_UNORDERED_SET
 919 AC_DEFUN([AC_HEADER_UNORDERED_SET], [
 920   AC_CACHE_CHECK(for unordered_set,
 921   ac_cv_cxx_unordered_set,
 922   [AC_REQUIRE([AC_COMPILE_STDCXX_11])
 923   AC_LANG_SAVE
 924   AC_LANG_CPLUSPLUS
 925   ac_save_CXXFLAGS="$CXXFLAGS"
 926   CXXFLAGS="$CXXFLAGS -std=gnu++11"
 927   AC_TRY_COMPILE([#include &lt;unordered_set&gt;], [using std::unordered_set;],
 928   ac_cv_cxx_unordered_set=yes, ac_cv_cxx_unordered_set=no)
 929   CXXFLAGS="$ac_save_CXXFLAGS"
 930   AC_LANG_RESTORE
 931   ])
 932   if test "$ac_cv_cxx_unordered_set" = yes; then
 933     AC_DEFINE(HAVE_UNORDERED_SET,,[Define if unordered_set is present. ])
 934   fi
 935 ])
 936 </pre><p>
 937   Some C++11 features first appeared in GCC 4.3 and could be enabled by
 938   <code class="option">-std=c++0x</code> and <code class="option">-std=gnu++0x</code> for GCC
 939   releases which pre-date the 2011 standard. Those C++11 features and GCC's
 940   support for them were still changing until the 2011 standard was finished,
 941   but the autoconf checks above could be extended to test for incomplete
 942   C++11 support with <code class="option">-std=c++0x</code> and
 943   <code class="option">-std=gnu++0x</code>.
 944 </p></div><div class="section"><div class="titlepage"><div><div><h4 class="title"><a id="backwards.third.iterator_type"></a>
 945   <code class="code">Container::iterator_type</code> is not necessarily <code class="code">Container::value_type*</code>
 946 </h4></div></div></div><p>
 947   This is a change in behavior from older versions. Now, most
 948   <span class="type">iterator_type</span> typedefs in container classes are POD
 949   objects, not <span class="type">value_type</span> pointers.
 950 </p></div></div><div class="bibliography"><div class="titlepage"><div><div><h3 class="title"><a id="backwards.biblio"></a>Bibliography</h3></div></div></div><div class="biblioentry"><a id="idm270856837440"></a><p><span class="title"><em>
 951         <a class="link" href="http://www.kegel.com/gcc/gcc4.html" target="_top">
 952       Migrating to GCC 4.1
 953         </a>
 954       </em>. </span><span class="author"><span class="firstname">Dan</span> <span class="surname">Kegel</span>. </span></p></div><div class="biblioentry"><a id="idm270856834656"></a><p><span class="title"><em>
 955         <a class="link" href="http://lists.debian.org/debian-gcc/2006/03/msg00405.html" target="_top">
 956       Building the Whole Debian Archive with GCC 4.1: A Summary
 957         </a>
 958       </em>. </span><span class="author"><span class="firstname">Martin</span> <span class="surname">Michlmayr</span>. </span></p></div><div class="biblioentry"><a id="idm270856831808"></a><p><span class="title"><em>
 959         <a class="link" href="http://annwm.lbl.gov/~leggett/Atlas/gcc-3.2.html" target="_top">
 960       Migration guide for GCC-3.2
 961         </a>
 962       </em>. </span></p></div></div></div><div class="navfooter"><hr /><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="api.html">Prev</a> </td><td width="20%" align="center"><a accesskey="u" href="appendix_porting.html">Up</a></td><td width="40%" align="right"> <a accesskey="n" href="appendix_free.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">API Evolution and Deprecation History </td><td width="20%" align="center"><a accesskey="h" href="../index.html">Home</a></td><td width="40%" align="right" valign="top"> Appendix C.
 963   Free Software Needs Free Documentation
 964
 965 </td></tr></table></div></body></html>