summaryrefslogtreecommitdiff
path: root/libstdc++-v3/doc/html/manual/backwards.html
blob: 2ac6d789e48d9683084744cabb1a4d48f5fba696 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<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;    "/><link rel="home" href="../spine.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. 
  Porting and Maintenance
  
</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
separate GNU project, although reliably paired with GCC. Rumors imply
that it had a working relationship with at least two kinds of
dinosaur.
</p><p>Some background: libg++ was designed and created when there was no
ISO standard to provide guidance.  Classes like linked lists are now
provided for by <code class="classname">list&lt;T&gt;</code> and do not need to be
created by <code class="function">genclass</code>.  (For that matter, templates exist
now and are well-supported, whereas genclass (mostly) predates them.)
</p><p>There are other classes in libg++ that are not specified in the
ISO Standard (e.g., statistical analysis).  While there are a lot of
really useful things that are used by a lot of people, the Standards
Committee couldn't include everything, and so a lot of those
<span class="quote"><span class="quote">obvious</span></span> classes didn't get included.
</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="id503868"/>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>.
</p></div><div class="section" title="No cout in ostream.h, no cin in istream.h"><div class="titlepage"><div><div><h4 class="title"><a id="id503900"/>No <code class="code">cout</code> in <code class="code">ostream.h</code>, no <code class="code">cin</code> in <code class="code">istream.h</code></h4></div></div></div><p>
	In earlier versions of the standard,
	<code class="filename">fstream.h</code>,
	<code class="filename">ostream.h</code>
	and <code class="filename">istream.h</code>
	used to define
	<code class="code">cout</code>, <code class="code">cin</code> and so on. ISO C++ specifies that one needs to include
	<code class="filename">iostream</code>
	explicitly to get the required definitions.
 </p><p> Some include adjustment may be required.</p><p>This project is no longer maintained or supported, and the sources
archived. For the desperate,
the <a class="link" href="http://gcc.gnu.org/extensions.html">GCC extensions
page</a> describes where to find the last libg++ source. The code is
considered replaced and rewritten.
</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>
  The second generation GNU C++ library was called libstdc++, or
  libstdc++-v2. It spans the time between libg++ and pre-ISO C++
  standardization and is usually associated with the following GCC
  releases: egcs 1.x, gcc 2.95, and gcc 2.96.
</p><p>
  The STL portions of this library are based on SGI/HP STL release 3.11.
</p><p>
  This project is no longer maintained or supported, and the sources
  archived.  The code is considered replaced and rewritten.
</p><p>
  Portability notes and known implementation limitations are as follows.
</p><div class="section" title="Namespace std:: not supported"><div class="titlepage"><div><div><h4 class="title"><a id="id504003"/>Namespace <code class="code">std::</code> not supported</h4></div></div></div><p>
    Some care is required to support C++ compiler and or library
    implementation that do not have the standard library in
    <code class="code">namespace std</code>.
  </p><p>
    The following sections list some possible solutions to support compilers
    that cannot ignore <code class="code">std::</code>-qualified names.
  </p><p>
    First, see if the compiler has a flag for this. Namespace
    back-portability-issues are generally not a problem for g++
    compilers that do not have libstdc++ in <code class="code">std::</code>, as the
    compilers use <code class="code">-fno-honor-std</code> (ignore
    <code class="code">std::</code>, <code class="code">:: = std::</code>) by default. That is,
    the responsibility for enabling or disabling <code class="code">std::</code> is
    on the user; the maintainer does not have to care about it. This
    probably applies to some other compilers as well.
  </p><p>
    Second, experiment with a variety of pre-processor tricks.
  </p><p>
    By defining <code class="code">std</code> as a macro, fully-qualified namespace
    calls become global. Volia.
  </p><pre class="programlisting">
#ifdef WICKEDLY_OLD_COMPILER
# define std
#endif
</pre><p>
    Thanks to Juergen Heinzl who posted this solution on gnu.gcc.help.
  </p><p>
    Another pre-processor based approach is to define a macro
    <code class="code">NAMESPACE_STD</code>, which is defined to either
    <span class="quote"><span class="quote"> </span></span> or <span class="quote"><span class="quote">std</span></span> based on a compile-type
    test. On GNU systems, this can be done with autotools by means of
    an autoconf test (see below) for <code class="code">HAVE_NAMESPACE_STD</code>,
    then using that to set a value for the <code class="code">NAMESPACE_STD</code>
    macro.  At that point, one is able to use
    <code class="code">NAMESPACE_STD::string</code>, which will evaluate to
    <code class="code">std::string</code> or <code class="code">::string</code> (i.e., in the
    global namespace on systems that do not put <code class="code">string</code> in
    <code class="code">std::</code>).
  </p><pre class="programlisting">
dnl @synopsis AC_CXX_NAMESPACE_STD
dnl
dnl If the compiler supports namespace std, define
dnl HAVE_NAMESPACE_STD.
dnl
dnl @category Cxx
dnl @author Todd Veldhuizen
dnl @author Luc Maisonobe &lt;luc@spaceroots.org&gt;
dnl @version 2004-02-04
dnl @license AllPermissive
AC_DEFUN([AC_CXX_NAMESPACE_STD], [
  AC_CACHE_CHECK(if g++ supports namespace std,
  ac_cv_cxx_have_std_namespace,
  [AC_LANG_SAVE
  AC_LANG_CPLUSPLUS
  AC_TRY_COMPILE([#include &lt;iostream&gt;
		  std::istream&amp; is = std::cin;],,
  ac_cv_cxx_have_std_namespace=yes, ac_cv_cxx_have_std_namespace=no)
  AC_LANG_RESTORE
  ])
  if test "$ac_cv_cxx_have_std_namespace" = yes; then
    AC_DEFINE(HAVE_NAMESPACE_STD,,[Define if g++ supports namespace std. ])
  fi
])
</pre></div><div class="section" title="Illegal iterator usage"><div class="titlepage"><div><div><h4 class="title"><a id="id504130"/>Illegal iterator usage</h4></div></div></div><p>
  The following illustrate implementation-allowed illegal iterator
  use, and then correct use.
</p><div class="itemizedlist"><ul class="itemizedlist"><li class="listitem"><p>
      you cannot do <code class="code">ostream::operator&lt;&lt;(iterator)</code>
      to print the address of the iterator =&gt; use
      <code class="code">operator&lt;&lt; &amp;*iterator</code> instead
    </p></li><li class="listitem"><p>
      you cannot clear an iterator's reference (<code class="code">iterator =
      0</code>) =&gt; use <code class="code">iterator = iterator_type();</code>
    </p></li><li class="listitem"><p>
      <code class="code">if (iterator)</code> won't work any more =&gt; use
      <code class="code">if (iterator != iterator_type())</code>
    </p></li></ul></div></div><div class="section" title="isspace from cctype is a macro"><div class="titlepage"><div><div><h4 class="title"><a id="id504191"/><code class="code">isspace</code> from <code class="filename">cctype</code> is a macro
  </h4></div></div></div><p>
    Glibc 2.0.x and 2.1.x define <code class="filename">ctype.h</code> functionality as macros
    (isspace, isalpha etc.).
  </p><p>
    This implementations of libstdc++, however, keep these functions
    as macros, and so it is not back-portable to use fully qualified
    names. For example:
  </p><pre class="programlisting">
#include &lt;cctype&gt;
int main() { std::isspace('X'); }
</pre><p>
  Results in something like this:
</p><pre class="programlisting">
std:: (__ctype_b[(int) ( ( 'X' ) )] &amp; (unsigned short int) _ISspace ) ;
</pre><p>
  A solution is to modify a header-file so that the compiler tells
  <code class="filename">ctype.h</code> to define functions
  instead of macros:
</p><pre class="programlisting">
// This keeps isalnum, et al from being propagated as macros.
#if __linux__
# define __NO_CTYPE 1
#endif
</pre><p>
  Then, include <code class="filename">ctype.h</code>
</p><p>
  Another problem arises if you put a <code class="code">using namespace
  std;</code> declaration at the top, and include <code class="filename">ctype.h</code>. This will result in
  ambiguities between the definitions in the global namespace
  (<code class="filename">ctype.h</code>) and the
  definitions in namespace <code class="code">std::</code>
  (<code class="code">&lt;cctype&gt;</code>).
</p></div><div class="section" title="No vector::at, deque::at, string::at"><div class="titlepage"><div><div><h4 class="title"><a id="id504286"/>No <code class="code">vector::at</code>, <code class="code">deque::at</code>, <code class="code">string::at</code></h4></div></div></div><p>
  One solution is to add an autoconf-test for this:
</p><pre class="programlisting">
AC_MSG_CHECKING(for container::at)
AC_TRY_COMPILE(
[
#include &lt;vector&gt;
#include &lt;deque&gt;
#include &lt;string&gt;

using namespace std;
],
[
deque&lt;int&gt; test_deque(3);
test_deque.at(2);
vector&lt;int&gt; test_vector(2);
test_vector.at(1);
string test_string(<span class="quote"><span class="quote">test_string</span></span>);
test_string.at(3);
],
[AC_MSG_RESULT(yes)
AC_DEFINE(HAVE_CONTAINER_AT)],
[AC_MSG_RESULT(no)])
</pre><p>
  If you are using other (non-GNU) compilers it might be a good idea
  to check for <code class="code">string::at</code> separately.
</p></div><div class="section" title="No std::char_traits&lt;char&gt;::eof"><div class="titlepage"><div><div><h4 class="title"><a id="id504326"/>No <code class="code">std::char_traits&lt;char&gt;::eof</code></h4></div></div></div><p>
  Use some kind of autoconf test, plus this:
</p><pre class="programlisting">
#ifdef HAVE_CHAR_TRAITS
#define CPP_EOF std::char_traits&lt;char&gt;::eof()
#else
#define CPP_EOF EOF
#endif
</pre></div><div class="section" title="No string::clear"><div class="titlepage"><div><div><h4 class="title"><a id="id504344"/>No <code class="code">string::clear</code></h4></div></div></div><p>
  There are two functions for deleting the contents of a string:
  <code class="code">clear</code> and <code class="code">erase</code> (the latter returns the
  string).
</p><pre class="programlisting">
void
clear() { _M_mutate(0, this-&gt;size(), 0); }
</pre><pre class="programlisting">
basic_string&amp;
erase(size_type __pos = 0, size_type __n = npos)
{
  return this-&gt;replace(_M_check(__pos), _M_fold(__pos, __n),
			  _M_data(), _M_data());
}
</pre><p>
  Unfortunately, <code class="code">clear</code> is not implemented in this
  version, so you should use <code class="code">erase</code> (which is probably
  faster than <code class="code">operator=(charT*)</code>).
</p></div><div class="section" title="Removal of ostream::form and istream::scan extensions"><div class="titlepage"><div><div><h4 class="title"><a id="id504390"/>
  Removal of <code class="code">ostream::form</code> and <code class="code">istream::scan</code>
  extensions
</h4></div></div></div><p>
  These are no longer supported. Please use stringstreams instead.
</p></div><div class="section" title="No basic_stringbuf, basic_stringstream"><div class="titlepage"><div><div><h4 class="title"><a id="id504408"/>No <code class="code">basic_stringbuf</code>, <code class="code">basic_stringstream</code></h4></div></div></div><p>
  Although the ISO standard <code class="code">i/ostringstream</code>-classes are
  provided, (<code class="filename">sstream</code>), for
  compatibility with older implementations the pre-ISO
  <code class="code">i/ostrstream</code> (<code class="filename">strstream</code>) interface is also provided,
  with these caveats:
</p><div class="itemizedlist"><ul class="itemizedlist"><li class="listitem"><p>
      <code class="code">strstream</code> is considered to be deprecated
    </p></li><li class="listitem"><p>
      <code class="code">strstream</code> is limited to <code class="code">char</code>
    </p></li><li class="listitem"><p>
      with <code class="code">ostringstream</code> you don't have to take care of
      terminating the string or freeing its memory
    </p></li><li class="listitem"><p>
      <code class="code">istringstream</code> can be re-filled (clear();
      str(input);)
    </p></li></ul></div><p>
  You can then use output-stringstreams like this:
</p><pre class="programlisting">
#ifdef HAVE_SSTREAM
# include &lt;sstream&gt;
#else
# include &lt;strstream&gt;
#endif

#ifdef HAVE_SSTREAM
  std::ostringstream oss;
#else
  std::ostrstream oss;
#endif

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;
...
#ifndef HAVE_SSTREAM
  oss &lt;&lt; std::ends; // terminate the char*-string
#endif

// str() returns char* for ostrstream and a string for ostringstream
// this also causes ostrstream to think that the buffer's memory
// is yours
m_label.set_text(oss.str());
#ifndef HAVE_SSTREAM
  // let the ostrstream take care of freeing the memory
  oss.freeze(false);
#endif
</pre><p>
      Input-stringstreams can be used similarly:
</p><pre class="programlisting">
std::string input;
...
#ifdef HAVE_SSTREAM
std::istringstream iss(input);
#else
std::istrstream iss(input.c_str());
#endif

int i;
iss &gt;&gt; i;
</pre><p> One (the only?) restriction is that an istrstream cannot be re-filled:
</p><pre class="programlisting">
std::istringstream iss(numerator);
iss &gt;&gt; m_num;
// this is not possible with istrstream
iss.clear();
iss.str(denominator);
iss &gt;&gt; m_den;
</pre><p>
If you don't care about speed, you can put these conversions in
      a template-function:
</p><pre class="programlisting">
template &lt;class X&gt;
void fromString(const string&amp; input, X&amp; any)
{
#ifdef HAVE_SSTREAM
std::istringstream iss(input);
#else
std::istrstream iss(input.c_str());
#endif
X temp;
iss &gt;&gt; temp;
if (iss.fail())
throw runtime_error(..)
any = temp;
}
</pre><p>
  Another example of using stringstreams is in <a class="link" href="strings.html#strings.string.shrink" title="Shrink to Fit">this howto</a>.
</p><p> There is additional information in the libstdc++-v2 info files, in
particular <span class="quote"><span class="quote">info iostream</span></span>.
</p></div><div class="section" title="Little or no wide character support"><div class="titlepage"><div><div><h4 class="title"><a id="id504564"/>Little or no wide character support</h4></div></div></div><p>
    Classes <code class="classname">wstring</code> and
    <code class="classname">char_traits&lt;wchar_t&gt;</code> are
    not supported.
  </p></div><div class="section" title="No templatized iostreams"><div class="titlepage"><div><div><h4 class="title"><a id="id504583"/>No templatized iostreams</h4></div></div></div><p>
    Classes <code class="classname">wfilebuf</code> and
    <code class="classname">wstringstream</code> are not supported.
  </p></div><div class="section" title="Thread safety issues"><div class="titlepage"><div><div><h4 class="title"><a id="id504602"/>Thread safety issues</h4></div></div></div><p>
    Earlier GCC releases had a somewhat different approach to
    threading configuration and proper compilation.  Before GCC 3.0,
    configuration of the threading model was dictated by compiler
    command-line options and macros (both of which were somewhat
    thread-implementation and port-specific).  There were no
    guarantees related to being able to link code compiled with one
    set of options and macro setting with another set.
  </p><p>
    For GCC 3.0, configuration of the threading model used with
    libraries and user-code is performed when GCC is configured and
    built using the --enable-threads and --disable-threads options.
    The ABI is stable for symbol name-mangling and limited functional
    compatibility exists between code compiled under different
    threading models.
  </p><p>
     The libstdc++ library has been designed so that it can be used in
     multithreaded applications (with libstdc++-v2 this was only true
     of the STL parts.)  The first problem is finding a
     <span class="emphasis"><em>fast</em></span> method of implementation portable to
     all platforms.  Due to historical reasons, some of the library is
     written against per-CPU-architecture spinlocks and other parts
     against the gthr.h abstraction layer which is provided by gcc.  A
     minor problem that pops up every so often is different
     interpretations of what "thread-safe" means for a
     library (not a general program).  We currently use the <a class="link" href="http://www.sgi.com/tech/stl/thread_safety.html">same
     definition that SGI</a> uses for their STL subset.  However,
     the exception for read-only containers only applies to the STL
     components. This definition is widely-used and something similar
     will be used in the next version of the C++ standard library.
   </p><p>
     Here is a small link farm to threads (no pun) in the mail
     archives that discuss the threading problem.  Each link is to the
     first relevant message in the thread; from there you can use
     "Thread Next" to move down the thread.  This farm is in
     latest-to-oldest order.
   </p><div class="itemizedlist"><ul class="itemizedlist"><li class="listitem"><p>
	    Our threading expert Loren gives a breakdown of <a class="link" href="http://gcc.gnu.org/ml/libstdc++/2001-10/msg00024.html">the
	    six situations involving threads</a> for the 3.0
	    release series.
	  </p></li><li class="listitem"><p>
	    <a class="link" href="http://gcc.gnu.org/ml/libstdc++/2001-05/msg00384.html">
	This message</a> inspired a recent updating of issues with
	threading and the SGI STL library.  It also contains some
	example POSIX-multithreaded STL code.
	  </p></li></ul></div><p>
     (A large selection of links to older messages has been removed;
     many of the messages from 1999 were lost in a disk crash, and the
     few people with access to the backup tapes have been too swamped
     with work to restore them.  Many of the points have been
     superseded anyhow.)
   </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
libstdc++-v3.
</p><p>The subset commonly known as the Standard Template Library
	 (chapters 23 through 25, mostly) is adapted from the final release
	 of the SGI STL (version 3.3), with extensive changes.
      </p><p>A more formal description of the V3 goals can be found in the
	 official <a class="link" href="source_design_notes.html" title="Design Notes">design document</a>.
      </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="id504726"/>Pre-ISO headers moved to backwards or removed</h4></div></div></div><p> The pre-ISO C++ headers
      (<code class="code">iostream.h</code>, <code class="code">defalloc.h</code> etc.) are
      available, unlike previous libstdc++ versions, but inclusion
      generates a warning that you are using deprecated headers.
</p><p>This compatibility layer is constructed by including the
    standard C++ headers, and injecting any items in
    <code class="code">std::</code> into the global namespace.
   </p><p>For those of you new to ISO C++ (welcome, time travelers!), no,
      that isn't a typo. Yes, the headers really have new names.
      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
      [27.4]</a>.
   </p><p> Some include adjustment may be required. What follows is an
autoconf test that defines <code class="code">PRE_STDCXX_HEADERS</code> when they
exist.</p><pre class="programlisting">
# AC_HEADER_PRE_STDCXX
AC_DEFUN([AC_HEADER_PRE_STDCXX], [
  AC_CACHE_CHECK(for pre-ISO C++ include files,
  ac_cv_cxx_pre_stdcxx,
  [AC_LANG_SAVE
  AC_LANG_CPLUSPLUS
  ac_save_CXXFLAGS="$CXXFLAGS"
  CXXFLAGS="$CXXFLAGS -Wno-deprecated"

  # Omit defalloc.h, as compilation with newer compilers is problematic.
  AC_TRY_COMPILE([
  #include &lt;new.h&gt;
  #include &lt;iterator.h&gt;
  #include &lt;alloc.h&gt;
  #include &lt;set.h&gt;
  #include &lt;hashtable.h&gt;
  #include &lt;hash_set.h&gt;
  #include &lt;fstream.h&gt;
  #include &lt;tempbuf.h&gt;
  #include &lt;istream.h&gt;
  #include &lt;bvector.h&gt;
  #include &lt;stack.h&gt;
  #include &lt;rope.h&gt;
  #include &lt;complex.h&gt;
  #include &lt;ostream.h&gt;
  #include &lt;heap.h&gt;
  #include &lt;iostream.h&gt;
  #include &lt;function.h&gt;
  #include &lt;multimap.h&gt;
  #include &lt;pair.h&gt;
  #include &lt;stream.h&gt;
  #include &lt;iomanip.h&gt;
  #include &lt;slist.h&gt;
  #include &lt;tree.h&gt;
  #include &lt;vector.h&gt;
  #include &lt;deque.h&gt;
  #include &lt;multiset.h&gt;
  #include &lt;list.h&gt;
  #include &lt;map.h&gt;
  #include &lt;algobase.h&gt;
  #include &lt;hash_map.h&gt;
  #include &lt;algo.h&gt;
  #include &lt;queue.h&gt;
  #include &lt;streambuf.h&gt;
  ],,
  ac_cv_cxx_pre_stdcxx=yes, ac_cv_cxx_pre_stdcxx=no)
  CXXFLAGS="$ac_save_CXXFLAGS"
  AC_LANG_RESTORE
  ])
  if test "$ac_cv_cxx_pre_stdcxx" = yes; then
    AC_DEFINE(PRE_STDCXX_HEADERS,,[Define if pre-ISO C++ header files are present. ])
  fi
])
</pre><p>Porting between pre-ISO headers and ISO headers is simple: headers
like <code class="filename">vector.h</code> can be replaced with <code class="filename">vector</code> and a using
directive <code class="code">using namespace std;</code> can be put at the global
scope. This should be enough to get this code compiling, assuming the
other usage is correct.
</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="id504811"/>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
	 replaced by standardized libraries.
	 In particular, the unordered_map and unordered_set containers of TR1
	 are suitable replacement for the non-standard hash_map and hash_set
	 containers in the SGI STL.
      </p><p> Header files <code class="filename">hash_map</code> and <code class="filename">hash_set</code> moved
to <code class="filename">ext/hash_map</code> and  <code class="filename">ext/hash_set</code>,
respectively. At the same time, all types in these files are enclosed
in <code class="code">namespace __gnu_cxx</code>. Later versions move deprecate
these files, and suggest using TR1's  <code class="filename">unordered_map</code>
and  <code class="filename">unordered_set</code> instead.
</p><p>The extensions are no longer in the global or <code class="code">std</code>
	 namespaces, instead they are declared in the <code class="code">__gnu_cxx</code>
	 namespace. For maximum portability, consider defining a namespace
	 alias to use to talk about extensions, e.g.:
      </p><pre class="programlisting">
      #ifdef __GNUC__
      #if __GNUC__ &lt; 3
	#include &lt;hash_map.h&gt;
	namespace extension { using ::hash_map; }; // inherit globals
      #else
	#include &lt;backward/hash_map&gt;
	#if __GNUC__ == 3 &amp;&amp; __GNUC_MINOR__ == 0
	  namespace extension = std;               // GCC 3.0
	#else
	  namespace extension = ::__gnu_cxx;       // GCC 3.1 and later
	#endif
      #endif
      #else      // ...  there are other compilers, right?
	namespace extension = std;
      #endif

      extension::hash_map&lt;int,int&gt; my_map;
      </pre><p>This is a bit cleaner than defining typedefs for all the
	 instantiations you might need.
      </p><p>The following autoconf tests check for working HP/SGI hash containers.
</p><pre class="programlisting">
# AC_HEADER_EXT_HASH_MAP
AC_DEFUN([AC_HEADER_EXT_HASH_MAP], [
  AC_CACHE_CHECK(for ext/hash_map,
  ac_cv_cxx_ext_hash_map,
  [AC_LANG_SAVE
  AC_LANG_CPLUSPLUS
  ac_save_CXXFLAGS="$CXXFLAGS"
  CXXFLAGS="$CXXFLAGS -Werror"
  AC_TRY_COMPILE([#include &lt;ext/hash_map&gt;], [using __gnu_cxx::hash_map;],
  ac_cv_cxx_ext_hash_map=yes, ac_cv_cxx_ext_hash_map=no)
  CXXFLAGS="$ac_save_CXXFLAGS"
  AC_LANG_RESTORE
  ])
  if test "$ac_cv_cxx_ext_hash_map" = yes; then
    AC_DEFINE(HAVE_EXT_HASH_MAP,,[Define if ext/hash_map is present. ])
  fi
])
</pre><pre class="programlisting">
# AC_HEADER_EXT_HASH_SET
AC_DEFUN([AC_HEADER_EXT_HASH_SET], [
  AC_CACHE_CHECK(for ext/hash_set,
  ac_cv_cxx_ext_hash_set,
  [AC_LANG_SAVE
  AC_LANG_CPLUSPLUS
  ac_save_CXXFLAGS="$CXXFLAGS"
  CXXFLAGS="$CXXFLAGS -Werror"
  AC_TRY_COMPILE([#include &lt;ext/hash_set&gt;], [using __gnu_cxx::hash_set;],
  ac_cv_cxx_ext_hash_set=yes, ac_cv_cxx_ext_hash_set=no)
  CXXFLAGS="$ac_save_CXXFLAGS"
  AC_LANG_RESTORE
  ])
  if test "$ac_cv_cxx_ext_hash_set" = yes; then
    AC_DEFINE(HAVE_EXT_HASH_SET,,[Define if ext/hash_set is present. ])
  fi
])
</pre></div><div class="section" title="No ios::nocreate/ios::noreplace."><div class="titlepage"><div><div><h4 class="title"><a id="id504914"/>No <code class="code">ios::nocreate/ios::noreplace</code>.
</h4></div></div></div><p> The existence of <code class="code">ios::nocreate</code> being used for
input-streams has been confirmed, most probably because the author
thought it would be more correct to specify nocreate explicitly.  So
it can be left out for input-streams.
</p><p>For output streams, <span class="quote"><span class="quote">nocreate</span></span> is probably the default,
unless you specify <code class="code">std::ios::trunc</code> ? To be safe, you can
open the file for reading, check if it has been opened, and then
decide whether you want to create/replace or not. To my knowledge,
even older implementations support <code class="code">app</code>, <code class="code">ate</code>
and <code class="code">trunc</code> (except for <code class="code">app</code> ?).
</p></div><div class="section" title="No stream::attach(int fd)"><div class="titlepage"><div><div><h4 class="title"><a id="id504962"/>
No <code class="code">stream::attach(int fd)</code>
</h4></div></div></div><p>
      Phil Edwards writes: It was considered and rejected for the ISO
      standard.  Not all environments use file descriptors.  Of those
      that do, not all of them use integers to represent them.
    </p><p>
      For a portable solution (among systems which use
      file descriptors), you need to implement a subclass of
      <code class="code">std::streambuf</code> (or
      <code class="code">std::basic_streambuf&lt;..&gt;</code>) which opens a file
      given a descriptor, and then pass an instance of this to the
      stream-constructor.
    </p><p>
      An extension is available that implements this.
      <code class="filename">ext/stdio_filebuf.h</code> contains a derived class called
      <a class="link" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a00074.html"><code class="code">__gnu_cxx::stdio_filebuf</code></a>.
      This class can be constructed from a C <code class="code">FILE*</code> or a file
      descriptor, and provides the <code class="code">fd()</code> function.
    </p><p>
 For another example of this, refer to
      <a class="link" href="http://www.josuttis.com/cppcode/fdstream.html">fdstream example</a>
      by Nicolai Josuttis.
</p></div><div class="section" title="Support for C++98 dialect."><div class="titlepage"><div><div><h4 class="title"><a id="id505030"/>
Support for C++98 dialect.
</h4></div></div></div><p>Check for complete library coverage of the C++1998/2003 standard.
</p><pre class="programlisting">
# AC_HEADER_STDCXX_98
AC_DEFUN([AC_HEADER_STDCXX_98], [
  AC_CACHE_CHECK(for ISO C++ 98 include files,
  ac_cv_cxx_stdcxx_98,
  [AC_LANG_SAVE
  AC_LANG_CPLUSPLUS
  AC_TRY_COMPILE([
    #include &lt;cassert&gt;
    #include &lt;cctype&gt;
    #include &lt;cerrno&gt;
    #include &lt;cfloat&gt;
    #include &lt;ciso646&gt;
    #include &lt;climits&gt;
    #include &lt;clocale&gt;
    #include &lt;cmath&gt;
    #include &lt;csetjmp&gt;
    #include &lt;csignal&gt;
    #include &lt;cstdarg&gt;
    #include &lt;cstddef&gt;
    #include &lt;cstdio&gt;
    #include &lt;cstdlib&gt;
    #include &lt;cstring&gt;
    #include &lt;ctime&gt;

    #include &lt;algorithm&gt;
    #include &lt;bitset&gt;
    #include &lt;complex&gt;
    #include &lt;deque&gt;
    #include &lt;exception&gt;
    #include &lt;fstream&gt;
    #include &lt;functional&gt;
    #include &lt;iomanip&gt;
    #include &lt;ios&gt;
    #include &lt;iosfwd&gt;
    #include &lt;iostream&gt;
    #include &lt;istream&gt;
    #include &lt;iterator&gt;
    #include &lt;limits&gt;
    #include &lt;list&gt;
    #include &lt;locale&gt;
    #include &lt;map&gt;
    #include &lt;memory&gt;
    #include &lt;new&gt;
    #include &lt;numeric&gt;
    #include &lt;ostream&gt;
    #include &lt;queue&gt;
    #include &lt;set&gt;
    #include &lt;sstream&gt;
    #include &lt;stack&gt;
    #include &lt;stdexcept&gt;
    #include &lt;streambuf&gt;
    #include &lt;string&gt;
    #include &lt;typeinfo&gt;
    #include &lt;utility&gt;
    #include &lt;valarray&gt;
    #include &lt;vector&gt;
  ],,
  ac_cv_cxx_stdcxx_98=yes, ac_cv_cxx_stdcxx_98=no)
  AC_LANG_RESTORE
  ])
  if test "$ac_cv_cxx_stdcxx_98" = yes; then
    AC_DEFINE(STDCXX_98_HEADERS,,[Define if ISO C++ 1998 header files are present. ])
  fi
])
</pre></div><div class="section" title="Support for C++TR1 dialect."><div class="titlepage"><div><div><h4 class="title"><a id="id505057"/>
Support for C++TR1 dialect.
</h4></div></div></div><p>Check for library coverage of the TR1 standard.
</p><pre class="programlisting">
# AC_HEADER_STDCXX_TR1
AC_DEFUN([AC_HEADER_STDCXX_TR1], [
  AC_CACHE_CHECK(for ISO C++ TR1 include files,
  ac_cv_cxx_stdcxx_tr1,
  [AC_LANG_SAVE
  AC_LANG_CPLUSPLUS
  AC_TRY_COMPILE([
  #include &lt;tr1/array&gt;
  #include &lt;tr1/ccomplex&gt;
  #include &lt;tr1/cctype&gt;
  #include &lt;tr1/cfenv&gt;
  #include &lt;tr1/cfloat&gt;
  #include &lt;tr1/cinttypes&gt;
  #include &lt;tr1/climits&gt;
  #include &lt;tr1/cmath&gt;
  #include &lt;tr1/complex&gt;
  #include &lt;tr1/cstdarg&gt;
  #include &lt;tr1/cstdbool&gt;
  #include &lt;tr1/cstdint&gt;
  #include &lt;tr1/cstdio&gt;
  #include &lt;tr1/cstdlib&gt;
  #include &lt;tr1/ctgmath&gt;
  #include &lt;tr1/ctime&gt;
  #include &lt;tr1/cwchar&gt;
  #include &lt;tr1/cwctype&gt;
  #include &lt;tr1/functional&gt;
  #include &lt;tr1/memory&gt;
  #include &lt;tr1/random&gt;
  #include &lt;tr1/regex&gt;
  #include &lt;tr1/tuple&gt;
  #include &lt;tr1/type_traits&gt;
  #include &lt;tr1/unordered_set&gt;
  #include &lt;tr1/unordered_map&gt;
  #include &lt;tr1/utility&gt;
  ],,
  ac_cv_cxx_stdcxx_tr1=yes, ac_cv_cxx_stdcxx_tr1=no)
  AC_LANG_RESTORE
  ])
  if test "$ac_cv_cxx_stdcxx_tr1" = yes; then
    AC_DEFINE(STDCXX_TR1_HEADERS,,[Define if ISO C++ TR1 header files are present. ])
  fi
])
</pre><p>An alternative is to check just for specific TR1 includes, such as &lt;unordered_map&gt; and &lt;unordered_set&gt;.
</p><pre class="programlisting">
# AC_HEADER_TR1_UNORDERED_MAP
AC_DEFUN([AC_HEADER_TR1_UNORDERED_MAP], [
  AC_CACHE_CHECK(for tr1/unordered_map,
  ac_cv_cxx_tr1_unordered_map,
  [AC_LANG_SAVE
  AC_LANG_CPLUSPLUS
  AC_TRY_COMPILE([#include &lt;tr1/unordered_map&gt;], [using std::tr1::unordered_map;],
  ac_cv_cxx_tr1_unordered_map=yes, ac_cv_cxx_tr1_unordered_map=no)
  AC_LANG_RESTORE
  ])
  if test "$ac_cv_cxx_tr1_unordered_map" = yes; then
    AC_DEFINE(HAVE_TR1_UNORDERED_MAP,,[Define if tr1/unordered_map is present. ])
  fi
])
</pre><pre class="programlisting">
# AC_HEADER_TR1_UNORDERED_SET
AC_DEFUN([AC_HEADER_TR1_UNORDERED_SET], [
  AC_CACHE_CHECK(for tr1/unordered_set,
  ac_cv_cxx_tr1_unordered_set,
  [AC_LANG_SAVE
  AC_LANG_CPLUSPLUS
  AC_TRY_COMPILE([#include &lt;tr1/unordered_set&gt;], [using std::tr1::unordered_set;],
  ac_cv_cxx_tr1_unordered_set=yes, ac_cv_cxx_tr1_unordered_set=no)
  AC_LANG_RESTORE
  ])
  if test "$ac_cv_cxx_tr1_unordered_set" = yes; then
    AC_DEFINE(HAVE_TR1_UNORDERED_SET,,[Define if tr1/unordered_set is present. ])
  fi
])
</pre></div><div class="section" title="Support for C++0x dialect."><div class="titlepage"><div><div><h4 class="title"><a id="id505101"/>
Support for C++0x dialect.
</h4></div></div></div><p>Check for baseline language coverage in the compiler for the C++0xstandard.
</p><pre class="programlisting">
# AC_COMPILE_STDCXX_OX
AC_DEFUN([AC_COMPILE_STDCXX_0X], [
  AC_CACHE_CHECK(if g++ supports C++0x features without additional flags,
  ac_cv_cxx_compile_cxx0x_native,
  [AC_LANG_SAVE
  AC_LANG_CPLUSPLUS
  AC_TRY_COMPILE([
  template &lt;typename T&gt;
    struct check
    {
      static_assert(sizeof(int) &lt;= sizeof(T), "not big enough");
    };

    typedef check&lt;check&lt;bool&gt;&gt; right_angle_brackets;

    int a;
    decltype(a) b;

    typedef check&lt;int&gt; check_type;
    check_type c;
    check_type&amp;&amp; cr = c;],,
  ac_cv_cxx_compile_cxx0x_native=yes, ac_cv_cxx_compile_cxx0x_native=no)
  AC_LANG_RESTORE
  ])

  AC_CACHE_CHECK(if g++ supports C++0x features with -std=c++0x,
  ac_cv_cxx_compile_cxx0x_cxx,
  [AC_LANG_SAVE
  AC_LANG_CPLUSPLUS
  ac_save_CXXFLAGS="$CXXFLAGS"
  CXXFLAGS="$CXXFLAGS -std=c++0x"
  AC_TRY_COMPILE([
  template &lt;typename T&gt;
    struct check
    {
      static_assert(sizeof(int) &lt;= sizeof(T), "not big enough");
    };

    typedef check&lt;check&lt;bool&gt;&gt; right_angle_brackets;

    int a;
    decltype(a) b;

    typedef check&lt;int&gt; check_type;
    check_type c;
    check_type&amp;&amp; cr = c;],,
  ac_cv_cxx_compile_cxx0x_cxx=yes, ac_cv_cxx_compile_cxx0x_cxx=no)
  CXXFLAGS="$ac_save_CXXFLAGS"
  AC_LANG_RESTORE
  ])

  AC_CACHE_CHECK(if g++ supports C++0x features with -std=gnu++0x,
  ac_cv_cxx_compile_cxx0x_gxx,
  [AC_LANG_SAVE
  AC_LANG_CPLUSPLUS
  ac_save_CXXFLAGS="$CXXFLAGS"
  CXXFLAGS="$CXXFLAGS -std=gnu++0x"
  AC_TRY_COMPILE([
  template &lt;typename T&gt;
    struct check
    {
      static_assert(sizeof(int) &lt;= sizeof(T), "not big enough");
    };

    typedef check&lt;check&lt;bool&gt;&gt; right_angle_brackets;

    int a;
    decltype(a) b;

    typedef check&lt;int&gt; check_type;
    check_type c;
    check_type&amp;&amp; cr = c;],,
  ac_cv_cxx_compile_cxx0x_gxx=yes, ac_cv_cxx_compile_cxx0x_gxx=no)
  CXXFLAGS="$ac_save_CXXFLAGS"
  AC_LANG_RESTORE
  ])

  if test "$ac_cv_cxx_compile_cxx0x_native" = yes ||
     test "$ac_cv_cxx_compile_cxx0x_cxx" = yes ||
     test "$ac_cv_cxx_compile_cxx0x_gxx" = yes; then
    AC_DEFINE(HAVE_STDCXX_0X,,[Define if g++ supports C++0x features. ])
  fi
])
</pre><p>Check for library coverage of the C++0xstandard.
</p><pre class="programlisting">
# AC_HEADER_STDCXX_0X
AC_DEFUN([AC_HEADER_STDCXX_0X], [
  AC_CACHE_CHECK(for ISO C++ 0x include files,
  ac_cv_cxx_stdcxx_0x,
  [AC_REQUIRE([AC_COMPILE_STDCXX_0X])
  AC_LANG_SAVE
  AC_LANG_CPLUSPLUS
  ac_save_CXXFLAGS="$CXXFLAGS"
  CXXFLAGS="$CXXFLAGS -std=gnu++0x"

  AC_TRY_COMPILE([
    #include &lt;cassert&gt;
    #include &lt;ccomplex&gt;
    #include &lt;cctype&gt;
    #include &lt;cerrno&gt;
    #include &lt;cfenv&gt;
    #include &lt;cfloat&gt;
    #include &lt;cinttypes&gt;
    #include &lt;ciso646&gt;
    #include &lt;climits&gt;
    #include &lt;clocale&gt;
    #include &lt;cmath&gt;
    #include &lt;csetjmp&gt;
    #include &lt;csignal&gt;
    #include &lt;cstdarg&gt;
    #include &lt;cstdbool&gt;
    #include &lt;cstddef&gt;
    #include &lt;cstdint&gt;
    #include &lt;cstdio&gt;
    #include &lt;cstdlib&gt;
    #include &lt;cstring&gt;
    #include &lt;ctgmath&gt;
    #include &lt;ctime&gt;
    #include &lt;cwchar&gt;
    #include &lt;cwctype&gt;

    #include &lt;algorithm&gt;
    #include &lt;array&gt;
    #include &lt;bitset&gt;
    #include &lt;complex&gt;
    #include &lt;deque&gt;
    #include &lt;exception&gt;
    #include &lt;fstream&gt;
    #include &lt;functional&gt;
    #include &lt;iomanip&gt;
    #include &lt;ios&gt;
    #include &lt;iosfwd&gt;
    #include &lt;iostream&gt;
    #include &lt;istream&gt;
    #include &lt;iterator&gt;
    #include &lt;limits&gt;
    #include &lt;list&gt;
    #include &lt;locale&gt;
    #include &lt;map&gt;
    #include &lt;memory&gt;
    #include &lt;new&gt;
    #include &lt;numeric&gt;
    #include &lt;ostream&gt;
    #include &lt;queue&gt;
    #include &lt;random&gt;
    #include &lt;regex&gt;
    #include &lt;set&gt;
    #include &lt;sstream&gt;
    #include &lt;stack&gt;
    #include &lt;stdexcept&gt;
    #include &lt;streambuf&gt;
    #include &lt;string&gt;
    #include &lt;tuple&gt;
    #include &lt;typeinfo&gt;
    #include &lt;type_traits&gt;
    #include &lt;unordered_map&gt;
    #include &lt;unordered_set&gt;
    #include &lt;utility&gt;
    #include &lt;valarray&gt;
    #include &lt;vector&gt;
  ],,
  ac_cv_cxx_stdcxx_0x=yes, ac_cv_cxx_stdcxx_0x=no)
  AC_LANG_RESTORE
  CXXFLAGS="$ac_save_CXXFLAGS"
  ])
  if test "$ac_cv_cxx_stdcxx_0x" = yes; then
    AC_DEFINE(STDCXX_0X_HEADERS,,[Define if ISO C++ 0x header files are present. ])
  fi
])
</pre><p>As is the case for TR1 support, these autoconf macros can be made for a finer-grained, per-header-file check. For &lt;unordered_map&gt;
</p><pre class="programlisting">
# AC_HEADER_UNORDERED_MAP
AC_DEFUN([AC_HEADER_UNORDERED_MAP], [
  AC_CACHE_CHECK(for unordered_map,
  ac_cv_cxx_unordered_map,
  [AC_REQUIRE([AC_COMPILE_STDCXX_0X])
  AC_LANG_SAVE
  AC_LANG_CPLUSPLUS
  ac_save_CXXFLAGS="$CXXFLAGS"
  CXXFLAGS="$CXXFLAGS -std=gnu++0x"
  AC_TRY_COMPILE([#include &lt;unordered_map&gt;], [using std::unordered_map;],
  ac_cv_cxx_unordered_map=yes, ac_cv_cxx_unordered_map=no)
  CXXFLAGS="$ac_save_CXXFLAGS"
  AC_LANG_RESTORE
  ])
  if test "$ac_cv_cxx_unordered_map" = yes; then
    AC_DEFINE(HAVE_UNORDERED_MAP,,[Define if unordered_map is present. ])
  fi
])
</pre><pre class="programlisting">
# AC_HEADER_UNORDERED_SET
AC_DEFUN([AC_HEADER_UNORDERED_SET], [
  AC_CACHE_CHECK(for unordered_set,
  ac_cv_cxx_unordered_set,
  [AC_REQUIRE([AC_COMPILE_STDCXX_0X])
  AC_LANG_SAVE
  AC_LANG_CPLUSPLUS
  ac_save_CXXFLAGS="$CXXFLAGS"
  CXXFLAGS="$CXXFLAGS -std=gnu++0x"
  AC_TRY_COMPILE([#include &lt;unordered_set&gt;], [using std::unordered_set;],
  ac_cv_cxx_unordered_set=yes, ac_cv_cxx_unordered_set=no)
  CXXFLAGS="$ac_save_CXXFLAGS"
  AC_LANG_RESTORE
  ])
  if test "$ac_cv_cxx_unordered_set" = yes; then
    AC_DEFINE(HAVE_UNORDERED_SET,,[Define if unordered_set is present. ])
  fi
])
</pre></div><div class="section" title="Container::iterator_type is not necessarily Container::value_type*"><div class="titlepage"><div><div><h4 class="title"><a id="id505180"/>
  Container::iterator_type is not necessarily Container::value_type*
</h4></div></div></div><p>
  This is a change in behavior from the previous version. Now, most
  <span class="type">iterator_type</span> typedefs in container classes are POD
  objects, not <span class="type">value_type</span> pointers.
</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"><a id="id505210"/><p><span class="biblioid">
    . </span><span class="citetitle"><em class="citetitle">
      Migrating to GCC 4.1
    </em>. </span><span class="author"><span class="firstname">Dan</span> <span class="surname">Kegel</span>. </span></p></div><div class="biblioentry"><a id="id505235"/><p><span class="biblioid">
    . </span><span class="citetitle"><em class="citetitle">
      Building the Whole Debian Archive with GCC 4.1: A Summary
    </em>. </span><span class="author"><span class="firstname">Martin</span> <span class="surname">Michlmayr</span>. </span></p></div><div class="biblioentry"><a id="id505261"/><p><span class="biblioid">
    . </span><span class="citetitle"><em class="citetitle">
      Migration guide for GCC-3.2
    </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="../spine.html">Home</a></td><td align="right" valign="top"> Appendix C. 
  Free Software Needs Free Documentation
  
</td></tr></table></div></body></html>