libstdc++-v3/doc/html/manual/backwards.html

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