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.
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 list<T> and do not need to be
created by genclass. (For that matter, templates exist
now and are well-supported, whereas genclass (mostly) predates them.)
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 “obvious” classes didn't get included.
Known Issues include many of the limitations of its immediate ancestor.
Portability notes and known implementation limitations are as follows.
At least some older implementations don't have std::ios_base, so you should use std::ios::badbit, std::ios::failbit and std::ios::eofbit and std::ios::goodbit.
In earlier versions of the standard,
fstream.h,
ostream.h
and istream.h
used to define
cout, cin and so on. ISO C++ specifies that one needs to include
iostream
explicitly to get the required definitions.
Some include adjustment may be required.
This project is no longer maintained or supported, and the sources archived. For the desperate, the GCC extensions page describes where to find the last libg++ source. The code is considered replaced and rewritten.
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.
The STL portions of this library are based on SGI/HP STL release 3.11.
This project is no longer maintained or supported, and the sources archived. The code is considered replaced and rewritten.
Portability notes and known implementation limitations are as follows.
Some care is required to support C++ compiler and or library
implementation that do not have the standard library in
namespace std.
The following sections list some possible solutions to support compilers
that cannot ignore std::-qualified names.
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 std::, as the
compilers use -fno-honor-std (ignore
std::, :: = std::) by default. That is,
the responsibility for enabling or disabling std:: is
on the user; the maintainer does not have to care about it. This
probably applies to some other compilers as well.
Second, experiment with a variety of pre-processor tricks.
By defining std as a macro, fully-qualified namespace
calls become global. Volia.
#ifdef WICKEDLY_OLD_COMPILER # define std #endif
Thanks to Juergen Heinzl who posted this solution on gnu.gcc.help.
Another pre-processor based approach is to define a macro
NAMESPACE_STD, which is defined to either
“ ” or “std” based on a compile-type
test. On GNU systems, this can be done with autotools by means of
an autoconf test (see below) for HAVE_NAMESPACE_STD,
then using that to set a value for the NAMESPACE_STD
macro. At that point, one is able to use
NAMESPACE_STD::string, which will evaluate to
std::string or ::string (i.e., in the
global namespace on systems that do not put string in
std::).
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 <luc@@spaceroots.org>
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 <iostream>
std::istream& 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
])
The following illustrate implementation-allowed illegal iterator use, and then correct use.
you cannot do ostream::operator<<(iterator)
to print the address of the iterator => use
operator<< &*iterator instead
you cannot clear an iterator's reference (iterator =
0) => use iterator = iterator_type();
if (iterator) won't work any more => use
if (iterator != iterator_type())
Glibc 2.0.x and 2.1.x define ctype.h functionality as macros
(isspace, isalpha etc.).
This implementations of libstdc++, however, keep these functions as macros, and so it is not back-portable to use fully qualified names. For example:
#include <cctype>
int main() { std::isspace('X'); }
Results in something like this:
std:: (__ctype_b[(int) ( ( 'X' ) )] & (unsigned short int) _ISspace ) ;
A solution is to modify a header-file so that the compiler tells
ctype.h to define functions
instead of macros:
// This keeps isalnum, et al from being propagated as macros. #if __linux__ # define __NO_CTYPE 1 #endif
Then, include ctype.h
Another problem arises if you put a using namespace
std; declaration at the top, and include ctype.h. This will result in
ambiguities between the definitions in the global namespace
(ctype.h) and the
definitions in namespace std::
(<cctype>).
One solution is to add an autoconf-test for this:
AC_MSG_CHECKING(for container::at)
AC_TRY_COMPILE(
[
#include <vector>
#include <deque>
#include <string>
using namespace std;
],
[
deque<int> test_deque(3);
test_deque.at(2);
vector<int> test_vector(2);
test_vector.at(1);
string test_string(“test_string”);
test_string.at(3);
],
[AC_MSG_RESULT(yes)
AC_DEFINE(HAVE_CONTAINER_AT)],
[AC_MSG_RESULT(no)])
If you are using other (non-GNU) compilers it might be a good idea
to check for string::at separately.
Use some kind of autoconf test, plus this:
#ifdef HAVE_CHAR_TRAITS #define CPP_EOF std::char_traits<char>::eof() #else #define CPP_EOF EOF #endif
There are two functions for deleting the contents of a string:
clear and erase (the latter returns the
string).
void
clear() { _M_mutate(0, this->size(), 0); }
basic_string&
erase(size_type __pos = 0, size_type __n = npos)
{
return this->replace(_M_check(__pos), _M_fold(__pos, __n),
_M_data(), _M_data());
}
Unfortunately, clear is not implemented in this
version, so you should use erase (which is probably
faster than operator=(charT*)).
These are no longer supported. Please use stringstreams instead.
Although the ISO standard i/ostringstream-classes are
provided, (sstream), for
compatibility with older implementations the pre-ISO
i/ostrstream (strstream) interface is also provided,
with these caveats:
strstream is considered to be deprecated
strstream is limited to char
with ostringstream you don't have to take care of
terminating the string or freeing its memory
istringstream can be re-filled (clear();
str(input);)
You can then use output-stringstreams like this:
#ifdef HAVE_SSTREAM # include <sstream> #else # include <strstream> #endif #ifdef HAVE_SSTREAM std::ostringstream oss; #else std::ostrstream oss; #endif oss << “Name=” << m_name << “, number=” << m_number << std::endl; ... #ifndef HAVE_SSTREAM oss << 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
Input-stringstreams can be used similarly:
std::string input; ... #ifdef HAVE_SSTREAM std::istringstream iss(input); #else std::istrstream iss(input.c_str()); #endif int i; iss >> i;
One (the only?) restriction is that an istrstream cannot be re-filled:
std::istringstream iss(numerator); iss >> m_num; // this is not possible with istrstream iss.clear(); iss.str(denominator); iss >> m_den;
If you don't care about speed, you can put these conversions in a template-function:
template <class X>
void fromString(const string& input, X& any)
{
#ifdef HAVE_SSTREAM
std::istringstream iss(input);
#else
std::istrstream iss(input.c_str());
#endif
X temp;
iss >> temp;
if (iss.fail())
throw runtime_error(..)
any = temp;
}
Another example of using stringstreams is in this howto.
There is additional information in the libstdc++-v2 info files, in particular “info iostream”.
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.
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.
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 fast 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 same definition that SGI 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.
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.
Our threading expert Loren gives a breakdown of the six situations involving threads for the 3.0 release series.
This message inspired a recent updating of issues with threading and the SGI STL library. It also contains some example POSIX-multithreaded STL code.
(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.)
The third generation GNU C++ library is called libstdc++, or libstdc++-v3.
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.
A more formal description of the V3 goals can be found in the official design document.
Portability notes and known implementation limitations are as follows.
The pre-ISO C++ headers
(iostream.h, defalloc.h etc.) are
available, unlike previous libstdc++ versions, but inclusion
generates a warning that you are using deprecated headers.
This compatibility layer is constructed by including the
standard C++ headers, and injecting any items in
std:: into the global namespace.
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 item [27.4].
Some include adjustment may be required. What follows is an
autoconf test that defines PRE_STDCXX_HEADERS when they
exist.
# 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 <new.h>
#include <iterator.h>
#include <alloc.h>
#include <set.h>
#include <hashtable.h>
#include <hash_set.h>
#include <fstream.h>
#include <tempbuf.h>
#include <istream.h>
#include <bvector.h>
#include <stack.h>
#include <rope.h>
#include <complex.h>
#include <ostream.h>
#include <heap.h>
#include <iostream.h>
#include <function.h>
#include <multimap.h>
#include <pair.h>
#include <stream.h>
#include <iomanip.h>
#include <slist.h>
#include <tree.h>
#include <vector.h>
#include <deque.h>
#include <multiset.h>
#include <list.h>
#include <map.h>
#include <algobase.h>
#include <hash_map.h>
#include <algo.h>
#include <queue.h>
#include <streambuf.h>
],,
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
])
Porting between pre-ISO headers and ISO headers is simple: headers
like vector.h can be replaced with vector and a using
directive using namespace std; can be put at the global
scope. This should be enough to get this code compiling, assuming the
other usage is correct.
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.
Header files hash_map and hash_set moved
to ext/hash_map and ext/hash_set,
respectively. At the same time, all types in these files are enclosed
in namespace __gnu_cxx. Later versions move deprecate
these files, and suggest using TR1's unordered_map
and unordered_set instead.
The extensions are no longer in the global or std
namespaces, instead they are declared in the __gnu_cxx
namespace. For maximum portability, consider defining a namespace
alias to use to talk about extensions, e.g.:
#ifdef __GNUC__
#if __GNUC__ < 3
#include <hash_map.h>
namespace extension { using ::hash_map; }; // inherit globals
#else
#include <backward/hash_map>
#if __GNUC__ == 3 && __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<int,int> my_map;
This is a bit cleaner than defining typedefs for all the instantiations you might need.
The following autoconf tests check for working HP/SGI hash containers.
# 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 <ext/hash_map>], [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
])
# 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 <ext/hash_set>], [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
])
The existence of ios::nocreate 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.
For output streams, “nocreate” is probably the default,
unless you specify std::ios::trunc ? 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 app, ate
and trunc (except for app ?).
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.
For a portable solution (among systems which use
file descriptors), you need to implement a subclass of
std::streambuf (or
std::basic_streambuf<..>) which opens a file
given a descriptor, and then pass an instance of this to the
stream-constructor.
An extension is available that implements this.
ext/stdio_filebuf.h contains a derived class called
__gnu_cxx::stdio_filebuf.
This class can be constructed from a C FILE* or a file
descriptor, and provides the fd() function.
For another example of this, refer to fdstream example by Nicolai Josuttis.
Check for complete library coverage of the C++1998/2003 standard.
# 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 <cassert>
#include <cctype>
#include <cerrno>
#include <cfloat>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
],,
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
])
Check for library coverage of the TR1 standard.
# 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 <tr1/array>
#include <tr1/ccomplex>
#include <tr1/cctype>
#include <tr1/cfenv>
#include <tr1/cfloat>
#include <tr1/cinttypes>
#include <tr1/climits>
#include <tr1/cmath>
#include <tr1/complex>
#include <tr1/cstdarg>
#include <tr1/cstdbool>
#include <tr1/cstdint>
#include <tr1/cstdio>
#include <tr1/cstdlib>
#include <tr1/ctgmath>
#include <tr1/ctime>
#include <tr1/cwchar>
#include <tr1/cwctype>
#include <tr1/functional>
#include <tr1/memory>
#include <tr1/random>
#include <tr1/regex>
#include <tr1/tuple>
#include <tr1/type_traits>
#include <tr1/unordered_set>
#include <tr1/unordered_map>
#include <tr1/utility>
],,
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
])
An alternative is to check just for specific TR1 includes, such as <unordered_map> and <unordered_set>.
# 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 <tr1/unordered_map>], [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
])
# 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 <tr1/unordered_set>], [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
])
Check for baseline language coverage in the compiler for the C++0xstandard.
# 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 <typename T>
struct check
{
static_assert(sizeof(int) <= sizeof(T), "not big enough");
};
typedef check<check<bool>> right_angle_brackets;
int a;
decltype(a) b;
typedef check<int> check_type;
check_type c;
check_type&& 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 <typename T>
struct check
{
static_assert(sizeof(int) <= sizeof(T), "not big enough");
};
typedef check<check<bool>> right_angle_brackets;
int a;
decltype(a) b;
typedef check<int> check_type;
check_type c;
check_type&& 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 <typename T>
struct check
{
static_assert(sizeof(int) <= sizeof(T), "not big enough");
};
typedef check<check<bool>> right_angle_brackets;
int a;
decltype(a) b;
typedef check<int> check_type;
check_type c;
check_type&& 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
])
Check for library coverage of the C++0xstandard.
# 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 <cassert>
#include <ccomplex>
#include <cctype>
#include <cerrno>
#include <cfenv>
#include <cfloat>
#include <cinttypes>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstdbool>
#include <cstddef>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctgmath>
#include <ctime>
#include <cwchar>
#include <cwctype>
#include <algorithm>
#include <array>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <random>
#include <regex>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <tuple>
#include <typeinfo>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <valarray>
#include <vector>
],,
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
])
As is the case for TR1 support, these autoconf macros can be made for a finer-grained, per-header-file check. For <unordered_map>
# 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 <unordered_map>], [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
])
# 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 <unordered_set>], [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
])
The first generation GNU C++ library was called libg++. It was a d20 2 a21 2
Known Issues include many of the limitations of its immediate ancestor.
Portability notes and known implementation limitations are as follows.
At least some older implementations don't have std::ios_base, so you should use std::ios::badbit, std::ios::failbit and std::ios::eofbit and std::ios::goodbit.
d23 3
a25 3
<fstream.h>,
<ostream.h>
and <istream.h>
d28 1
a28 1
<iostream>
d32 1
a32 1
the GCC extensions
d35 1
a35 1
d40 1 a40 1
d47 1 a47 1
d54 1 a54 1
d58 1
a58 1
compilers use -fno-honor-std (ignore
d65 1
a65 1
d102 2 a103 2 AC_TRY_COMPILE([#include <iostream> std::istream& is = std::cin;],, d111 1 a111 1
Glibc 2.0.x and 2.1.x define <ctype.h> functionality as macros
d132 3
a134 3
#include <cctype>
int main() { std::isspace('X'); }
d137 3
a139 3
std:: (__ctype_b[(int) ( ( 'X' ) )] & (unsigned short int) _ISspace ) ;
d141 1
a141 1
<ctype.h> to define functions
d144 1
a144 1
// This keeps isalnum, et al from being propagated as macros.
d149 1
a149 1
Then, include <ctype.h>
d152 3
a154 4
std; declaration at the top, and include
<ctype.h>. This will
result in ambiguities between the definitions in the global namespace
(<ctype.h>) and the
d157 1
a157 1
d196 1 a196 1 void d199 1 a199 1 basic_string& d201 1 a201 1 { d203 1 a203 1 _M_data(), _M_data()); d209 1 a209 1
d216 1
a216 1
provided, (<sstream>), for
d218 1
a218 1
i/ostrstream (<strstream>) interface is also provided,
d220 1
a220 1
d222 1 a222 1
d224 1 a224 1
d226 2 a227 2 terminating the string or freeing its memory
d229 1 a229 1 str(input);) d271 1 a271 1 iss >> i; d298 2 a299 2
Another example of using stringstreams is in this howto. d302 1 a302 1
d334 1 a334 1 library (not a general program). We currently use the same d345 2 a346 2
Our threading expert Loren gives a breakdown of the d350 5 a354 5 This message inspired a recent updating of issues with threading and the SGI STL library. It also contains some example POSIX-multithreaded STL code.
d360 1 a360 1
The third generation GNU C++ library is called libstdc++, or d363 2 a364 2 (chapters 23 through 25, mostly) is adapted from the final release of the SGI STL (version 3.3), with extensive changes. d366 3 a368 4 official design document.
Portability notes and known implementation limitations are as follows.
The pre-ISO C++ headers
(<iostream.h>,
<defalloc.h> etc.) are
d376 1
a376 1
Marshall Cline's C++ FAQ Lite has a good explanation in item
d388 1
a388 1
CXXFLAGS="$CXXFLAGS -Wno-deprecated"
d435 1
a435 1
like <vector.h> can be replaced with <vector> and a using
d439 7
a445 9
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 and C++ 2011
are suitable replacements for the non-standard
hash_map and hash_set
containers in the SGI STL.
Header files <hash_map> and <hash_set> moved
to <ext/hash_map> and <ext/hash_set>,
d447 3
a449 3
in namespace __gnu_cxx. Later versions deprecate
these files, and suggest using TR1's <unordered_map>
and <unordered_set> instead.
d451 3
a453 3
namespaces, instead they are declared in the __gnu_cxx
namespace. For maximum portability, consider defining a namespace
alias to use to talk about extensions, e.g.:
d457 2
a458 2
#include <hash_map.h>
namespace extension { using ::hash_map; }; // inherit globals
d460 6
a465 6
#include <backward/hash_map>
#if __GNUC__ == 3 && __GNUC_MINOR__ == 0
namespace extension = std; // GCC 3.0
#else
namespace extension = ::__gnu_cxx; // GCC 3.1 and later
#endif
d468 1
a468 1
namespace extension = std;
d471 1
a471 1
extension::hash_map<int,int> my_map;
d473 1
a473 1
instantiations you might need.
d483 1
a483 1
CXXFLAGS="$CXXFLAGS -Werror"
d501 1
a501 1
CXXFLAGS="$CXXFLAGS -Werror"
d511 1
a511 1
<ext/stdio_filebuf.h> contains a derived class called
__gnu_cxx::stdio_filebuf.
d543 1
a543 1
fdstream example
d545 1
a545 1
Check for baseline language coverage in the compiler for the C++11 standard.
# AC_COMPILE_STDCXX_11
AC_DEFUN([AC_COMPILE_STDCXX_11], [
AC_CACHE_CHECK(if g++ supports C++11 features without additional flags,
ac_cv_cxx_compile_cxx11_native,
d702 1
a702 1
struct check final
d704 1
a704 1
static constexpr T value{ __cplusplus };
d713 3
a715 5
check_type c{};
check_type&& cr = static_cast<check_type&&>(c);
static_assert(check_type::value == 201103L, "C++11 compiler");],,
ac_cv_cxx_compile_cxx11_native=yes, ac_cv_cxx_compile_cxx11_native=no)
d719 2
a720 2
AC_CACHE_CHECK(if g++ supports C++11 features with -std=c++11,
ac_cv_cxx_compile_cxx11_cxx,
d724 1
a724 1
CXXFLAGS="$CXXFLAGS -std=c++11"
d727 1
a727 1
struct check final
d729 1
a729 1
static constexpr T value{ __cplusplus };
d738 3
a740 5
check_type c{};
check_type&& cr = static_cast<check_type&&>(c);
static_assert(check_type::value == 201103L, "C++11 compiler");],,
ac_cv_cxx_compile_cxx11_cxx=yes, ac_cv_cxx_compile_cxx11_cxx=no)
d745 2
a746 2
AC_CACHE_CHECK(if g++ supports C++11 features with -std=gnu++11,
ac_cv_cxx_compile_cxx11_gxx,
d750 1
a750 1
CXXFLAGS="$CXXFLAGS -std=gnu++11"
d753 1
a753 1
struct check final
d755 1
a755 1
static constexpr T value{ __cplusplus };
d764 3
a766 5
check_type c{};
check_type&& cr = static_cast<check_type&&>(c);
static_assert(check_type::value == 201103L, "C++11 compiler");],,
ac_cv_cxx_compile_cxx11_gxx=yes, ac_cv_cxx_compile_cxx11_gxx=no)
d771 4
a774 4
if test "$ac_cv_cxx_compile_cxx11_native" = yes ||
test "$ac_cv_cxx_compile_cxx11_cxx" = yes ||
test "$ac_cv_cxx_compile_cxx11_gxx" = yes; then
AC_DEFINE(HAVE_STDCXX_11,,[Define if g++ supports C++11 features. ])
d777 7
a783 9
Check for library coverage of the C++2011 standard. (Some library headers are commented out in this check, they are not currently provided by libstdc++).
# AC_HEADER_STDCXX_11
AC_DEFUN([AC_HEADER_STDCXX_11], [
AC_CACHE_CHECK(for ISO C++11 include files,
ac_cv_cxx_stdcxx_11,
[AC_REQUIRE([AC_COMPILE_STDCXX_11])
d787 1
a787 1
CXXFLAGS="$CXXFLAGS -std=gnu++11"
a802 1
#include <cstdalign>
a811 1
// #include <cuchar>
a816 1
#include <atomic>
a817 2
#include <chrono>
// #include <codecvt>
a818 1
#include <condition_variable>
a820 1
#include <forward_list>
a822 2
#include <future>
#include <initializer_list>
a833 1
#include <mutex>
a838 1
#include <ratio>
a839 1
#include <scoped_allocator>
a845 2
#include <system_error>
#include <thread>
a846 1
#include <typeindex>
d855 1
a855 1
ac_cv_cxx_stdcxx_11=yes, ac_cv_cxx_stdcxx_11=no)
d859 2
a860 2
if test "$ac_cv_cxx_stdcxx_11" = yes; then
AC_DEFINE(STDCXX_11_HEADERS,,[Define if ISO C++11 header files are present. ])
d863 1
a863 2
As is the case for TR1 support, these autoconf macros can be made for a finer-grained, per-header-file check. For
<unordered_map>
d869 1
a869 1
[AC_REQUIRE([AC_COMPILE_STDCXX_11])
d873 1
a873 1
CXXFLAGS="$CXXFLAGS -std=gnu++11"
d888 1
a888 1
[AC_REQUIRE([AC_COMPILE_STDCXX_11])
d892 1
a892 1
CXXFLAGS="$CXXFLAGS -std=gnu++11"
d902 2
a903 10
Some C++11 features first appeared in GCC 4.3 and could be enabled by
-std=c++0x and -std=gnu++0x for GCC
releases which pre-date the 2011 standard. Those C++11 features and GCC's
support for them were still changing until the 2011 standard was finished,
but the autoconf checks above could be extended to test for incomplete
C++11 support with -std=c++0x and
-std=gnu++0x.
The first generation GNU C++ library was called libg++. It was a d20 2 a21 2
Known Issues include many of the limitations of its immediate ancestor.
Portability notes and known implementation limitations are as follows.
At least some older implementations don't have std::ios_base, so you should use std::ios::badbit, std::ios::failbit and std::ios::eofbit and std::ios::goodbit.
d23 3
a25 3
<fstream.h>,
<ostream.h>
and <istream.h>
d28 1
a28 1
<iostream>
d32 1
a32 1
the GCC extensions
d35 1
a35 1
d40 1 a40 1
d47 1 a47 1
d54 1 a54 1
d58 1
a58 1
compilers use -fno-honor-std (ignore
d65 1
a65 1
d102 2 a103 2 AC_TRY_COMPILE([#include <iostream> std::istream& is = std::cin;],, d111 1 a111 1
Glibc 2.0.x and 2.1.x define <ctype.h> functionality as macros
d132 3
a134 3
#include <cctype>
int main() { std::isspace('X'); }
d137 3
a139 3
std:: (__ctype_b[(int) ( ( 'X' ) )] & (unsigned short int) _ISspace ) ;
d141 1
a141 1
<ctype.h> to define functions
d144 1
a144 1
// This keeps isalnum, et al from being propagated as macros.
d149 1
a149 1
Then, include <ctype.h>
d152 3
a154 4
std; declaration at the top, and include
<ctype.h>. This will
result in ambiguities between the definitions in the global namespace
(<ctype.h>) and the
d157 1
a157 1
d196 1 a196 1 void d199 1 a199 1 basic_string& d201 1 a201 1 { d203 1 a203 1 _M_data(), _M_data()); d209 1 a209 1
d216 1
a216 1
provided, (<sstream>), for
d218 1
a218 1
i/ostrstream (<strstream>) interface is also provided,
d220 1
a220 1
d222 1 a222 1
d224 1 a224 1
d226 2 a227 2 terminating the string or freeing its memory
d229 1 a229 1 str(input);) d271 1 a271 1 iss >> i; d298 2 a299 2
Another example of using stringstreams is in this howto. d302 1 a302 1
d334 1 a334 1 library (not a general program). We currently use the same d345 2 a346 2
Our threading expert Loren gives a breakdown of the d350 5 a354 5 This message inspired a recent updating of issues with threading and the SGI STL library. It also contains some example POSIX-multithreaded STL code.
d360 1 a360 1
The third generation GNU C++ library is called libstdc++, or d363 2 a364 2 (chapters 23 through 25, mostly) is adapted from the final release of the SGI STL (version 3.3), with extensive changes. d366 3 a368 4 official design document.
Portability notes and known implementation limitations are as follows.
The pre-ISO C++ headers
(<iostream.h>,
<defalloc.h> etc.) are
d376 1
a376 1
Marshall Cline's C++ FAQ Lite has a good explanation in item
d388 1
a388 1
CXXFLAGS="$CXXFLAGS -Wno-deprecated"
d435 1
a435 1
like <vector.h> can be replaced with <vector> and a using
d439 7
a445 9
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 and C++ 2011
are suitable replacements for the non-standard
hash_map and hash_set
containers in the SGI STL.
Header files <hash_map> and <hash_set> moved
to <ext/hash_map> and <ext/hash_set>,
d447 3
a449 3
in namespace __gnu_cxx. Later versions deprecate
these files, and suggest using TR1's <unordered_map>
and <unordered_set> instead.
d451 3
a453 3
namespaces, instead they are declared in the __gnu_cxx
namespace. For maximum portability, consider defining a namespace
alias to use to talk about extensions, e.g.:
d457 2
a458 2
#include <hash_map.h>
namespace extension { using ::hash_map; }; // inherit globals
d460 6
a465 6
#include <backward/hash_map>
#if __GNUC__ == 3 && __GNUC_MINOR__ == 0
namespace extension = std; // GCC 3.0
#else
namespace extension = ::__gnu_cxx; // GCC 3.1 and later
#endif
d468 1
a468 1
namespace extension = std;
d471 1
a471 1
extension::hash_map<int,int> my_map;
d473 1
a473 1
instantiations you might need.
d483 1
a483 1
CXXFLAGS="$CXXFLAGS -Werror"
d501 1
a501 1
CXXFLAGS="$CXXFLAGS -Werror"
d511 1
a511 1
<ext/stdio_filebuf.h> contains a derived class called
__gnu_cxx::stdio_filebuf.
d543 1
a543 1
fdstream example
d545 1
a545 1
Check for baseline language coverage in the compiler for the C++11 standard.
# AC_COMPILE_STDCXX_11
AC_DEFUN([AC_COMPILE_STDCXX_11], [
AC_CACHE_CHECK(if g++ supports C++11 features without additional flags,
ac_cv_cxx_compile_cxx11_native,
d702 1
a702 1
struct check final
d704 1
a704 1
static constexpr T value{ __cplusplus };
d713 3
a715 5
check_type c{};
check_type&& cr = static_cast<check_type&&>(c);
static_assert(check_type::value == 201103L, "C++11 compiler");],,
ac_cv_cxx_compile_cxx11_native=yes, ac_cv_cxx_compile_cxx11_native=no)
d719 2
a720 2
AC_CACHE_CHECK(if g++ supports C++11 features with -std=c++11,
ac_cv_cxx_compile_cxx11_cxx,
d724 1
a724 1
CXXFLAGS="$CXXFLAGS -std=c++11"
d727 1
a727 1
struct check final
d729 1
a729 1
static constexpr T value{ __cplusplus };
d738 3
a740 5
check_type c{};
check_type&& cr = static_cast<check_type&&>(c);
static_assert(check_type::value == 201103L, "C++11 compiler");],,
ac_cv_cxx_compile_cxx11_cxx=yes, ac_cv_cxx_compile_cxx11_cxx=no)
d745 2
a746 2
AC_CACHE_CHECK(if g++ supports C++11 features with -std=gnu++11,
ac_cv_cxx_compile_cxx11_gxx,
d750 1
a750 1
CXXFLAGS="$CXXFLAGS -std=gnu++11"
d753 1
a753 1
struct check final
d755 1
a755 1
static constexpr T value{ __cplusplus };
d764 3
a766 5
check_type c{};
check_type&& cr = static_cast<check_type&&>(c);
static_assert(check_type::value == 201103L, "C++11 compiler");],,
ac_cv_cxx_compile_cxx11_gxx=yes, ac_cv_cxx_compile_cxx11_gxx=no)
d771 4
a774 4
if test "$ac_cv_cxx_compile_cxx11_native" = yes ||
test "$ac_cv_cxx_compile_cxx11_cxx" = yes ||
test "$ac_cv_cxx_compile_cxx11_gxx" = yes; then
AC_DEFINE(HAVE_STDCXX_11,,[Define if g++ supports C++11 features. ])
d777 7
a783 9
Check for library coverage of the C++2011 standard. (Some library headers are commented out in this check, they are not currently provided by libstdc++).
# AC_HEADER_STDCXX_11
AC_DEFUN([AC_HEADER_STDCXX_11], [
AC_CACHE_CHECK(for ISO C++11 include files,
ac_cv_cxx_stdcxx_11,
[AC_REQUIRE([AC_COMPILE_STDCXX_11])
d787 1
a787 1
CXXFLAGS="$CXXFLAGS -std=gnu++11"
a802 1
#include <cstdalign>
a811 1
// #include <cuchar>
a816 1
#include <atomic>
a817 2
#include <chrono>
// #include <codecvt>
a818 1
#include <condition_variable>
a820 1
#include <forward_list>
a822 2
#include <future>
#include <initializer_list>
a833 1
#include <mutex>
a838 1
#include <ratio>
a839 1
#include <scoped_allocator>
a845 2
#include <system_error>
#include <thread>
a846 1
#include <typeindex>
d855 1
a855 1
ac_cv_cxx_stdcxx_11=yes, ac_cv_cxx_stdcxx_11=no)
d859 2
a860 2
if test "$ac_cv_cxx_stdcxx_11" = yes; then
AC_DEFINE(STDCXX_11_HEADERS,,[Define if ISO C++11 header files are present. ])
d863 1
a863 2
As is the case for TR1 support, these autoconf macros can be made for a finer-grained, per-header-file check. For
<unordered_map>
d869 1
a869 1
[AC_REQUIRE([AC_COMPILE_STDCXX_11])
d873 1
a873 1
CXXFLAGS="$CXXFLAGS -std=gnu++11"
d888 1
a888 1
[AC_REQUIRE([AC_COMPILE_STDCXX_11])
d892 1
a892 1
CXXFLAGS="$CXXFLAGS -std=gnu++11"
d902 2
a903 10
Some C++11 features first appeared in GCC 4.3 and could be enabled by
-std=c++0x and -std=gnu++0x for GCC
releases which pre-date the 2011 standard. Those C++11 features and GCC's
support for them were still changing until the 2011 standard was finished,
but the autoconf checks above could be extended to test for incomplete
C++11 support with -std=c++0x and
-std=gnu++0x.
The first generation GNU C++ library was called libg++. It was a d20 2 a21 2
Known Issues include many of the limitations of its immediate ancestor.
Portability notes and known implementation limitations are as follows.
At least some older implementations don't have std::ios_base, so you should use std::ios::badbit, std::ios::failbit and std::ios::eofbit and std::ios::goodbit.
d23 3
a25 3
<fstream.h>,
<ostream.h>
and <istream.h>
d28 1
a28 1
<iostream>
d32 1
a32 1
the GCC extensions
d35 1
a35 1
d40 1 a40 1
d47 1 a47 1
d54 1 a54 1
d58 1
a58 1
compilers use -fno-honor-std (ignore
d65 1
a65 1
d102 2 a103 2 AC_TRY_COMPILE([#include <iostream> std::istream& is = std::cin;],, d111 1 a111 1
Glibc 2.0.x and 2.1.x define <ctype.h> functionality as macros
d132 3
a134 3
#include <cctype>
int main() { std::isspace('X'); }
d137 3
a139 3
std:: (__ctype_b[(int) ( ( 'X' ) )] & (unsigned short int) _ISspace ) ;
d141 1
a141 1
<ctype.h> to define functions
d144 1
a144 1
// This keeps isalnum, et al from being propagated as macros.
d149 1
a149 1
Then, include <ctype.h>
d152 3
a154 4
std; declaration at the top, and include
<ctype.h>. This will
result in ambiguities between the definitions in the global namespace
(<ctype.h>) and the
d157 1
a157 1
d196 1 a196 1 void d199 1 a199 1 basic_string& d201 1 a201 1 { d203 1 a203 1 _M_data(), _M_data()); d209 1 a209 1
d216 1
a216 1
provided, (<sstream>), for
d218 1
a218 1
i/ostrstream (<strstream>) interface is also provided,
d220 1
a220 1
d222 1 a222 1
d224 1 a224 1
d226 2 a227 2 terminating the string or freeing its memory
d229 1 a229 1 str(input);) d271 1 a271 1 iss >> i; d298 2 a299 2
Another example of using stringstreams is in this howto. d302 1 a302 1
d334 1 a334 1 library (not a general program). We currently use the same d345 2 a346 2
Our threading expert Loren gives a breakdown of the d350 5 a354 5 This message inspired a recent updating of issues with threading and the SGI STL library. It also contains some example POSIX-multithreaded STL code.
d360 1 a360 1
The third generation GNU C++ library is called libstdc++, or d363 2 a364 2 (chapters 23 through 25, mostly) is adapted from the final release of the SGI STL (version 3.3), with extensive changes. d366 3 a368 4 official design document.
Portability notes and known implementation limitations are as follows.
The pre-ISO C++ headers
(<iostream.h>,
<defalloc.h> etc.) are
d376 1
a376 1
Marshall Cline's C++ FAQ Lite has a good explanation in item
d388 1
a388 1
CXXFLAGS="$CXXFLAGS -Wno-deprecated"
d435 1
a435 1
like <vector.h> can be replaced with <vector> and a using
d439 7
a445 9
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 and C++ 2011
are suitable replacements for the non-standard
hash_map and hash_set
containers in the SGI STL.
Header files <hash_map> and <hash_set> moved
to <ext/hash_map> and <ext/hash_set>,
d447 3
a449 3
in namespace __gnu_cxx. Later versions deprecate
these files, and suggest using TR1's <unordered_map>
and <unordered_set> instead.
d451 3
a453 3
namespaces, instead they are declared in the __gnu_cxx
namespace. For maximum portability, consider defining a namespace
alias to use to talk about extensions, e.g.:
d457 2
a458 2
#include <hash_map.h>
namespace extension { using ::hash_map; }; // inherit globals
d460 6
a465 6
#include <backward/hash_map>
#if __GNUC__ == 3 && __GNUC_MINOR__ == 0
namespace extension = std; // GCC 3.0
#else
namespace extension = ::__gnu_cxx; // GCC 3.1 and later
#endif
d468 1
a468 1
namespace extension = std;
d471 1
a471 1
extension::hash_map<int,int> my_map;
d473 1
a473 1
instantiations you might need.
d483 1
a483 1
CXXFLAGS="$CXXFLAGS -Werror"
d501 1
a501 1
CXXFLAGS="$CXXFLAGS -Werror"
d511 1
a511 1
<ext/stdio_filebuf.h> contains a derived class called
__gnu_cxx::stdio_filebuf.
d543 1
a543 1
fdstream example
d545 1
a545 1
Check for baseline language coverage in the compiler for the C++11 standard.
# AC_COMPILE_STDCXX_11
AC_DEFUN([AC_COMPILE_STDCXX_11], [
AC_CACHE_CHECK(if g++ supports C++11 features without additional flags,
ac_cv_cxx_compile_cxx11_native,
d702 1
a702 1
struct check final
d704 1
a704 1
static constexpr T value{ __cplusplus };
d713 3
a715 5
check_type c{};
check_type&& cr = static_cast<check_type&&>(c);
static_assert(check_type::value == 201103L, "C++11 compiler");],,
ac_cv_cxx_compile_cxx11_native=yes, ac_cv_cxx_compile_cxx11_native=no)
d719 2
a720 2
AC_CACHE_CHECK(if g++ supports C++11 features with -std=c++11,
ac_cv_cxx_compile_cxx11_cxx,
d724 1
a724 1
CXXFLAGS="$CXXFLAGS -std=c++11"
d727 1
a727 1
struct check final
d729 1
a729 1
static constexpr T value{ __cplusplus };
d738 3
a740 5
check_type c{};
check_type&& cr = static_cast<check_type&&>(c);
static_assert(check_type::value == 201103L, "C++11 compiler");],,
ac_cv_cxx_compile_cxx11_cxx=yes, ac_cv_cxx_compile_cxx11_cxx=no)
d745 2
a746 2
AC_CACHE_CHECK(if g++ supports C++11 features with -std=gnu++11,
ac_cv_cxx_compile_cxx11_gxx,
d750 1
a750 1
CXXFLAGS="$CXXFLAGS -std=gnu++11"
d753 1
a753 1
struct check final
d755 1
a755 1
static constexpr T value{ __cplusplus };
d764 3
a766 5
check_type c{};
check_type&& cr = static_cast<check_type&&>(c);
static_assert(check_type::value == 201103L, "C++11 compiler");],,
ac_cv_cxx_compile_cxx11_gxx=yes, ac_cv_cxx_compile_cxx11_gxx=no)
d771 4
a774 4
if test "$ac_cv_cxx_compile_cxx11_native" = yes ||
test "$ac_cv_cxx_compile_cxx11_cxx" = yes ||
test "$ac_cv_cxx_compile_cxx11_gxx" = yes; then
AC_DEFINE(HAVE_STDCXX_11,,[Define if g++ supports C++11 features. ])
d777 7
a783 9
Check for library coverage of the C++2011 standard. (Some library headers are commented out in this check, they are not currently provided by libstdc++).
# AC_HEADER_STDCXX_11
AC_DEFUN([AC_HEADER_STDCXX_11], [
AC_CACHE_CHECK(for ISO C++11 include files,
ac_cv_cxx_stdcxx_11,
[AC_REQUIRE([AC_COMPILE_STDCXX_11])
d787 1
a787 1
CXXFLAGS="$CXXFLAGS -std=gnu++11"
a802 1
#include <cstdalign>
a811 1
// #include <cuchar>
a816 1
#include <atomic>
a817 2
#include <chrono>
// #include <codecvt>
a818 1
#include <condition_variable>
a820 1
#include <forward_list>
a822 2
#include <future>
#include <initializer_list>
a833 1
#include <mutex>
a838 1
#include <ratio>
a839 1
#include <scoped_allocator>
a845 2
#include <system_error>
#include <thread>
a846 1
#include <typeindex>
d855 1
a855 1
ac_cv_cxx_stdcxx_11=yes, ac_cv_cxx_stdcxx_11=no)
d859 2
a860 2
if test "$ac_cv_cxx_stdcxx_11" = yes; then
AC_DEFINE(STDCXX_11_HEADERS,,[Define if ISO C++11 header files are present. ])
d863 1
a863 2
As is the case for TR1 support, these autoconf macros can be made for a finer-grained, per-header-file check. For
<unordered_map>
d869 1
a869 1
[AC_REQUIRE([AC_COMPILE_STDCXX_11])
d873 1
a873 1
CXXFLAGS="$CXXFLAGS -std=gnu++11"
d888 1
a888 1
[AC_REQUIRE([AC_COMPILE_STDCXX_11])
d892 1
a892 1
CXXFLAGS="$CXXFLAGS -std=gnu++11"
d902 2
a903 10
Some C++11 features first appeared in GCC 4.3 and could be enabled by
-std=c++0x and -std=gnu++0x for GCC
releases which pre-date the 2011 standard. Those C++11 features and GCC's
support for them were still changing until the 2011 standard was finished,
but the autoconf checks above could be extended to test for incomplete
C++11 support with -std=c++0x and
-std=gnu++0x.
Historically these flags were used with iostreams to control whether
new files are created or not when opening a file stream, similar to the
O_CREAT and O_EXCL flags for the
open(2) system call. Because iostream modes correspond
to fopen(3) modes these flags are not supported.
For input streams a new file will not be created anyway, so
ios::nocreate is not needed.
For output streams, a new file will be created if it does not exist, which is
consistent with the behaviour of fopen.
When one of these flags is needed a possible alternative is to attempt
to open the file using std::ifstream first to determine whether
the file already exists or not. This may not be reliable however, because
whether the file exists or not could change between opening the
std::istream and re-opening with an output stream. If you need
to check for existence and open a file as a single operation then you will
need to use OS-specific facilities outside the C++ standard library, such
as open(2).
d943 1
a943 1