OSDN Git Service

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