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