checklist

gcc-you can use this code to learn something about gcc, and inquire further into linux,

   Completion Checklist for the Standard C++ Library
   Updated: 2003-04-25

   Status Code Legend:
    M - Missing
    S - Present as stub.
    X - Partially implemented, or buggy.
    T - Implemented, pending test/inspection.
    V - Verified to pass all available test suites.
    Q - Qualified by inspection for non-testable correctness.
    P - Portability verified.
    C - Certified.

   Lexical notes:
   Only status codes appear in column 0.  Notes relating to conformance
   issues appear [in brackets].

   Note that this checklist does not (yet) include all emendations
   recommended by the ISO Library Working Group:
   http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/lwg-toc.html

   Detailed explanation of status codes:

    M - Missing:  The name is not visible to programs that include
        the specified header, either at compile or link stage.

    S - Present as stub:  A program can use the name, but no implementation
        is provided.  Programs that use the name link correctly, but
        cannot usefully be run.

    X - Partially implemented, or buggy:  Some implementation has been
        provided, but it is known or believed not to conform fully.
        It may have an incorrect base class, wrong namespace, wrong
        storage class, or simply not fully implement requirements.
        However, it may be sufficiently usable to help test other
        components.

    T - Implemented, pending test/inspection:  Implementation believed
        to be complete, and informal testing suggests it is ready for
        formal verification.

    V - Verified, passes all test suites:  Verified to satisfy all
        generically testable conformance requirements.

    Q - Qualified by inspection for non-testable correctness:
        Inspected, "implementation-defined" documentation accepted,
        local usability criteria satisfied, formally inspected for
        other untestable conformance.  (Untestable requirements
        include exception-safety, thread-safety, worst-case
        complexity, memory cleanliness, usefulness.)

    P - Portability verified:  Qualified on all primary target platforms.

    C - Certified:  Formally certified to have passed all tests,
        inspections, qualifications; approved under "signing authority"
        to be used to satisfy contractual guarantees.

   ----------------------------------------------------------------------
       <algorithm>    <iomanip>    <list>      <ostream>     <streambuf>
       <bitset>       <ios>        <locale>    <queue>       <string>
       <complex>      <iosfwd>     <map>       <set>         <typeinfo>
X      <deque>        <iostream>   <memory>    <sstream>     <utility>
       <exception>    <istream>    <new>       <stack>       <valarray>
       <fstream>      <iterator>   <numeric>   <stdexcept>   <vector>
       <functional>   <limits>

   [C header names must be in std:: to qualify.  Related to shadow/ dir.]
           <cassert> <ciso646> <csetjmp> <cstdio>  <ctime>
           <cctype>  <climits> <csignal> <cstdlib> <cwchar>
X          <cerrno>  <clocale> <cstdarg> <cstring> <cwctype>
           <cfloat>  <cmath>   <cstddef>

    Macro:
X   errno,  declared  or  defined in <cerrno>.

    Macro fn:
X   setjmp(jmp_buf), declared or defined in <csetjmp>
X   va_end(va_list), declared or defined in <cstdarg>

    Types:
X   clock_t, div_t, FILE, fpos_t, lconv, ldiv_t, mbstate_t,
X   ptrdiff_t, sig_atomic_t, size_t,  time_t,  tm,  va_list,
X   wctrans_t, wctype_t, and wint_t.

   1 Which  of  the functions in the C++ Standard Library are not reentrant
    subroutines is implementation-defined.

   18.1  Types                                        [lib.support.types]
X      <cstddef>
X      NULL
X      offsetof
X      ptrdiff_t
X      size_t

   18.2  Implementation properties                   [lib.support.limits]

    <limits>, <climits>, and <cfloat>

   18.2.1  Numeric limits                                    [lib.limits]

X   template<class T> class numeric_limits;

T   enum float_round_style;
T   enum float_denorm_style;

T   template<> class numeric_limits<bool>;

T   template<> class numeric_limits<char>;
T   template<> class numeric_limits<signed char>;
T   template<> class numeric_limits<unsigned char>;
T   template<> class numeric_limits<wchar_t>;

T   template<> class numeric_limits<short>;
T   template<> class numeric_limits<int>;
T   template<> class numeric_limits<long>;
T   template<> class numeric_limits<unsigned short>;
T   template<> class numeric_limits<unsigned int>;
T   template<> class numeric_limits<unsigned long>;

X   template<> class numeric_limits<float>;
X   template<> class numeric_limits<double>;
X   template<> class numeric_limits<long double>;

   18.2.1.1  Template class numeric_limits           [lib.numeric.limits]
T   template<class T> class numeric_limits {
    public:
T     static const bool is_specialized = false;
T     static T min() throw();
T     static T max() throw();
T     static const int  digits = 0;
T     static const int  digits10 = 0;
T     static const bool is_signed = false;
T     static const bool is_integer = false;
T     static const bool is_exact = false;
T     static const int  radix = 0;
T     static T epsilon() throw();
T     static T round_error() throw();

T     static const int  min_exponent = 0;
T     static const int  min_exponent10 = 0;
T     static const int  max_exponent = 0;
T     static const int  max_exponent10 = 0;

T     static const bool has_infinity = false;
T     static const bool has_quiet_NaN = false;
T     static const bool has_signaling_NaN = false;
T     static const float_denorm_style has_denorm = denorm_absent;
T     static const bool has_denorm_loss = false;
T     static T infinity() throw();
T     static T quiet_NaN() throw();
T     static T signaling_NaN() throw();
T     static T denorm_min() throw();

T     static const bool is_iec559 = false;
T     static const bool is_bounded = false;
T     static const bool is_modulo = false;

T     static const bool traps = false;
T     static const bool tinyness_before = false;
T     static const float_round_style round_style = round_toward_zero;
    };

   18.2.1.3  Type float_round_style                     [lib.round.style]

T   enum float_round_style {
T     round_indeterminate       = -1,
T     round_toward_zero         =  0,
T     round_to_nearest          =  1,
T     round_toward_infinity     =  2,
T     round_toward_neg_infinity =  3
    };

   18.2.1.4  Type float_denorm_style                   [lib.denorm.style]

T   enum float_denorm_style {
T     denorm_indeterminate = -1;
T     denorm_absent = 0;
T     denorm present = 1;
    };

   18.2.1.5  numeric_limits specializations         [lib.numeric.special]
   
   [Note: see Note at 18.2.1.  ]

   18.2.2  C Library                                       [lib.c.limits]

   1 Header <climits> (Table 3):
      CHAR_BIT   INT_MAX    LONG_MIN     SCHAR_MIN   UCHAR_MAX   USHRT_MAX
X     CHAR_MAX   INT_MIN    MB_LEN_MAX   SHRT_MAX    UINT_MAX
      CHAR_MIN   LONG_MAX   SCHAR_MAX    SHRT_MIN    ULONG_MAX

   3 Header <cfloat> (Table 4):

    DBL_DIG          DBL_MIN_EXP      FLT_MIN_10_EXP   LDBL_MAX_10_EXP
    DBL_EPSILON      FLT_DIG          FLT_MIN_EXP      LDBL_MAX_EXP
    DBL_MANT_DIG     FLT_EPSILON      FLT_RADIX        LDBL_MIN
X   DBL_MAX          FLT_MANT_DIG     FLT_ROUNDS       LDBL_MIN_10_EXP
    DBL_MAX_10_EXP   FLT_MAX          LDBL_DIG         LDBL_MIN_EXP
    DBL_MAX_EXP      FLT_MAX_10_EXP   LDBL_EPSILON
    DBL_MIN          FLT_MAX_EXP      LDBL_MANT_DIG
    DBL_MIN_10_EXP   FLT_MIN          LDBL_MAX


        1 Header <cstdlib> (partial), Table 5:
X             EXIT_FAILURE     EXIT_SUCCESS
              abort   atexit   exit

S    abort(void)
S    extern "C" int atexit(void (*f)(void))
S    extern "C++" int atexit(void (*f)(void))
S    exit(int status)

   18.4  Dynamic memory management                  [lib.support.dynamic]

   Header <new> synopsis

T    class bad_alloc;
T    struct nothrow_t {};
T    extern const nothrow_t nothrow;
T    typedef void (*new_handler)();
T    new_handler set_new_handler(new_handler new_p) throw();

T    void* operator new(std::size_t size) throw(std::bad_alloc);
T    void* operator new(std::size_t size, const std::nothrow_t&) throw();
T    void  operator delete(void* ptr) throw();
T    void  operator delete(void* ptr, const std::nothrow_t&) throw();
T    void* operator new[](std::size_t size) throw(std::bad_alloc);
T    void* operator new[](std::size_t size, const std::nothrow_t&) throw();
T    void  operator delete[](void* ptr) throw();
T    void  operator delete[](void* ptr, const std::nothrow_t&) throw();
T    void* operator new  (std::size_t size, void* ptr) throw();
T    void* operator new[](std::size_t size, void* ptr) throw();
T    void  operator delete  (void* ptr, void*) throw();
T    void  operator delete[](void* ptr, void*) throw();

   18.4.2.1  Class bad_alloc                              [lib.bad.alloc]

T   class bad_alloc : public exception {
    public:
T     bad_alloc() throw();
T     bad_alloc(const bad_alloc&) throw();
T     bad_alloc& operator=(const bad_alloc&) throw();
T     virtual ~bad_alloc() throw();
T     virtual const char* what() const throw();



T  new_handler set_new_handler(new_handler new_p) throw();


     Header <typeinfo> synopsis

T    class type_info;
T    class bad_cast;
T    class bad_typeid;

   18.5.1 - Class type_info [lib.type.info]

T    class type_info {
    public:
T      virtual ~type_info();
T      bool operator==(const type_info& rhs) const;
T      bool operator!=(const type_info& rhs) const;
T      bool before(const type_info& rhs) const;
T      const char* name() const;
    private:
T      type_info(const type_info& rhs);
T      type_info& operator=(const type_info& rhs);
    };

   18.5.2 - Class bad_cast [lib.bad.cast]

T  bad_cast() throw();
T  virtual const char* bad_cast::what() const throw();

   18.5.3  Class bad_typeid                              [lib.bad.typeid]

T    class bad_typeid : public exception {
    public:
T      bad_typeid() throw();
T      bad_typeid(const bad_typeid&) throw();
T      bad_typeid& operator=(const bad_typeid&) throw();
T      virtual ~bad_typeid() throw();
T      virtual const char* what() const throw();
    };

   18.6  Exception handling                       [lib.support.exception]

T      Header <exception> synopsis

T    class exception;
T    class bad_exception;

T    typedef void (*unexpected_handler)();
T    unexpected_handler set_unexpected(unexpected_handler f) throw();
T    void unexpected();
T    typedef void (*terminate_handler)();
T    terminate_handler set_terminate(terminate_handler f) throw();
T    void terminate();
T    bool uncaught_exception();

   18.6.1  Class exception                                [lib.exception]

T    class exception {
     public:
T      exception() throw();
T      exception(const exception&) throw();
T      exception& operator=(const exception&) throw();
T      virtual ~exception() throw();
T      virtual const char* what() const throw();
    };

   18.6.2.1  Class bad_exception                      [lib.bad.exception]
T    class bad_exception : public exception {
    public:
T      bad_exception() throw();
T      bad_exception(const bad_exception&) throw();
T      bad_exception& operator=(const bad_exception&) throw();
T      virtual ~bad_exception() throw();
T      virtual const char* what() const throw();
    };

   18.7  Other runtime support                      [lib.support.runtime]

   1 Headers <cstdarg> (variable arguments),  <csetjmp>  (nonlocal  jumps),
    <ctime>  (system  clock clock(), time()), <csignal> (signal handling),
    and <cstdlib> (runtime environment getenv(), system()).

                    Table 6--Header <cstdarg> synopsis
                 Macros:   va_arg    va_end   va_start
X                Type:     va_list