libstdc++-v3/doc/xml/manual/backwards_compatibility.xml

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