OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libstdc++-v3/] [doc/] [html/] [manual/] [backwards.html] - Blame information for rev 742

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 742 jeremybenn 
<?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>

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.