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