checklist

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

                    Table 7--Header <csetjmp> synopsis

                          Macro:      setjmp |
X                         Type:       jmp_buf
                          Function:   longjmp

                     Table 8--Header <ctime> synopsis

                      Macros:      CLOCKS_PER_SEC
X                     Types:       clock_t
                      Functions:   clock

                    Table 9--Header <csignal> synopsis

X        Macros:      SIGABRT        SIGILL   SIGSEGV   SIG_DFL
         SIG_IGN      SIGFPE         SIGINT   SIGTERM   SIG_ERR
         Type:        sig_atomic_t
         Functions:   raise          signal

                   Table 10--Header <cstdlib> synopsis

X                     Functions:   getenv   system

   19.1  Exception classes                           [lib.std.exceptions]

   Header <stdexcept> synopsis

T     class logic_error;
T     class domain_error;
T     class invalid_argument;
T     class length_error;
T     class out_of_range;
T     class runtime_error;
T     class range_error;
T     class overflow_error;
T     class underflow_error;

   19.1.1  Class logic_error                            [lib.logic.error]
T   class logic_error : public exception {
    public:
T     explicit logic_error(const string& what_arg);
    };

   19.1.2  Class domain_error                          [lib.domain.error]

T   class domain_error : public logic_error {
    public:
T     explicit domain_error(const string& what_arg);
    };

   19.1.3  Class invalid_argument                  [lib.invalid.argument]

T   class invalid_argument : public logic_error {
    public:
T     explicit invalid_argument(const string& what_arg);
    };

   19.1.4  Class length_error                          [lib.length.error]

T   class length_error : public logic_error {
    public:
T     explicit length_error(const string& what_arg);
    };

   19.1.5  Class out_of_range                          [lib.out.of.range]

T   class out_of_range : public logic_error {
    public:
T     explicit out_of_range(const string& what_arg);
    };


   19.1.6  Class runtime_error                        [lib.runtime.error]

T   class runtime_error : public exception {
    public:
T     explicit runtime_error(const string& what_arg);
    };


   19.1.7  Class range_error                            [lib.range.error]

T   class range_error : public runtime_error {
    public:
T     explicit range_error(const string& what_arg);
    };

   19.1.8  Class overflow_error                      [lib.overflow.error]

T   class overflow_error : public runtime_error {
    public:
T     explicit overflow_error(const string& what_arg);
    };


   19.1.9  Class underflow_error                    [lib.underflow.error]

T   class underflow_error : public runtime_error {
    public:
T     explicit underflow_error(const string& what_arg);
    };


   19.2  Assertions                                      [lib.assertions]

                    Table 2--Header <cassert> synopsis

X                         Macro:   assert

   19.3  Error numbers                                        [lib.errno]

                    Table 3--Header <cerrno> synopsis

X                    |Macros:   EDOM   ERANGE   errno |


   20.2  Utility components                                 [lib.utility]

   Header <utility> synopsis

    // _lib.operators_, operators:
T    namespace rel_ops {
T      template<class T> bool operator!=(const T&, const T&);
T      template<class T> bool operator> (const T&, const T&);
T      template<class T> bool operator<=(const T&, const T&);
T      template<class T> bool operator>=(const T&, const T&);
    }
    // _lib.pairs_, pairs:
T   template <class T1, class T2> struct pair;
T   template <class T1, class T2>
      bool operator==(const pair<T1,T2>&, const pair<T1,T2>&);
T   template <class T1, class T2>
      bool operator< (const pair<T1,T2>&, const pair<T1,T2>&);
T   template <class T1, class T2>
      bool operator!=(const pair<T1,T2>&, const pair<T1,T2>&);
T   template <class T1, class T2>
      bool operator> (const pair<T1,T2>&, const pair<T1,T2>&);
T   template <class T1, class T2>
      bool operator>=(const pair<T1,T2>&, const pair<T1,T2>&);
T   template <class T1, class T2>
      bool operator<=(const pair<T1,T2>&, const pair<T1,T2>&);
T   template <class T1, class T2> pair<T1,T2> make_pair(const T1&, const T2&);


   20.2.2  Pairs                                              [lib.pairs]

T  template <class T1, class T2>
   struct pair {
T    typedef T1 first_type;
T    typedef T2 second_type;

T    T1 first;
T    T2 second;
T    pair();
T    pair(const T1& x, const T2& y);
T    template<class U, class V> pair(const pair<U, V> &p);
   };

   20.3  Function objects                          [lib.function.objects]

   Header <functional> synopsis

    // _lib.base_, base:
V   template <class Arg, class Result> struct unary_function;
V   template <class Arg1, class Arg2, class Result> struct binary_function;

    // _lib.arithmetic.operations_, arithmetic operations:
V   template <class T> struct plus;
V   template <class T> struct minus;
V   template <class T> struct multiplies;
V   template <class T> struct divides;
V   template <class T> struct modulus;
V   template <class T> struct negate;
    // _lib.comparisons_, comparisons:
V   template <class T> struct equal_to;
V   template <class T> struct not_equal_to;
V   template <class T> struct greater;
V   template <class T> struct less;
V   template <class T> struct greater_equal;
V   template <class T> struct less_equal;
    // _lib.logical.operations_, logical operations:
V   template <class T> struct logical_and;
V   template <class T> struct logical_or;
V   template <class T> struct logical_not;
    // _lib.negators_, negators:
    template <class Predicate> struct unary_negate;
V   template <class Predicate>
      unary_negate<Predicate>  not1(const Predicate&);
V   template <class Predicate> struct binary_negate;
V   template <class Predicate>
      binary_negate<Predicate> not2(const Predicate&);
    // _lib.binders_, binders:
V   template <class Operation>  class binder1st;
V   template <class Operation, class T>
      binder1st<Operation> bind1st(const Operation&, const T&);
V   template <class Operation> class binder2nd;
V   template <class Operation, class T>
      binder2nd<Operation> bind2nd(const Operation&, const T&);
    // _lib.function.pointer.adaptors_, adaptors:
V   template <class Arg, class Result> class pointer_to_unary_function;
V   template <class Arg, class Result>
      pointer_to_unary_function<Arg,Result> ptr_fun(Result (*)(Arg));
V   template <class Arg1, class Arg2, class Result>
      class pointer_to_binary_function;
V   template <class Arg1, class Arg2, class Result>
      pointer_to_binary_function<Arg1,Arg2,Result>
        ptr_fun(Result (*)(Arg1,Arg2));

    // _lib.member.pointer.adaptors_, adaptors:
V   template<class S, class T> class mem_fun_t;
V   template<class S, class T, class A> class mem_fun1_t;
V   template<class S, class T>
        mem_fun_t<S,T> mem_fun(S (T::*f)());
V   template<class S, class T, class A>
        mem_fun1_t<S,T,A> mem_fun(S (T::*f)(A));
V   template<class S, class T> class mem_fun_ref_t;
V   template<class S, class T, class A> class mem_fun1_ref_t;
V   template<class S, class T>
        mem_fun_ref_t<S,T> mem_fun_ref(S (T::*f)());
V   template<class S, class T, class A>
        mem_fun1_ref_t<S,T,A> mem_fun_ref(S (T::*f)(A));

V   template <class S, class T> class const_mem_fun_t;
V   template <class S, class T, class A> class const_mem_fun1_t;
V   template <class S, class T>
      const_mem_fun_t<S,T> mem_fun(S (T::*f)() const);
V   template <class S, class T, class A>
      const_mem_fun1_t<S,T,A> mem_fun(S (T::*f)(A) const);
V   template <class S, class T> class const_mem_fun_ref_t;
V   template <class S, class T, class A> class const_mem_fun1_ref_t;
V   template <class S, class T>
      const_mem_fun_ref_t<S,T> mem_fun_ref(S (T::*f)() const);
V   template <class S, class T, class A>
      const_mem_fun1_ref_t<S,T,A> mem_fun_ref(S (T::*f)(A) const);
   }

   20.3.1  Base                                                [lib.base]

V   template <class Arg, class Result>
    struct unary_function {
V     typedef Arg    argument_type;
V     typedef Result result_type;
    };
V   template <class Arg1, class Arg2, class Result>
    struct binary_function {
V     typedef Arg1   first_argument_type;
V     typedef Arg2   second_argument_type;
V     typedef Result result_type;
    };

   20.3.2  Arithmetic operations              [lib.arithmetic.operations]

T  template <class T> struct plus : binary_function<T,T,T> {
V   T operator()(const T& x, const T& y) const;
   };

T  template <class T> struct minus : binary_function<T,T,T> {
V   T operator()(const T& x, const T& y) const;
   };

T  template <class T> struct multiplies : binary_function<T,T,T> {
V   T operator()(const T& x, const T& y) const;
   };

T  template <class T> struct divides : binary_function<T,T,T> {
V   T operator()(const T& x, const T& y) const;
   };

T  template <class T> struct modulus : binary_function<T,T,T> {
V   T operator()(const T& x, const T& y) const;
   };

T  template <class T> struct negate : unary_function<T,T> {
V   T operator()(const T& x) const;
   };

   20.3.3  Comparisons                                  [lib.comparisons]

T  template <class T> struct equal_to : binary_function<T,T,bool> {
V   bool operator()(const T& x, const T& y) const;
   };

T  template <class T> struct not_equal_to : binary_function<T,T,bool> {
V   bool operator()(const T& x, const T& y) const;
   };

T  template <class T> struct greater : binary_function<T,T,bool> {
V   bool operator()(const T& x, const T& y) const;
   };

T  template <class T> struct less : binary_function<T,T,bool> {
V   bool operator()(const T& x, const T& y) const;
   };

T  template <class T> struct greater_equal : binary_function<T,T,bool> {
V   bool operator()(const T& x, const T& y) const;
   };

T  template <class T> struct less_equal : binary_function<T,T,bool> {
V   bool operator()(const T& x, const T& y) const;
   };

   20.3.4  Logical operations                    [lib.logical.operations]

T  template <class T> struct logical_and : binary_function<T,T,bool> {
V   bool operator()(const T& x, const T& y) const;
   };

T  template <class T> struct logical_or : binary_function<T,T,bool> {
V   bool operator()(const T& x, const T& y) const;
   };

T  template <class T> struct logical_not : unary_function<T,bool> {
V   bool operator()(const T& x) const;
   };

   20.3.5  Negators                                        [lib.negators]

T  template <class Predicate>
    class unary_negate
      : public unary_function<typename Predicate::argument_type,bool> {
   public:
T   explicit unary_negate(const Predicate& pred);
V   bool operator()(const typename Predicate::argument_type& x) const;
   };

T  template <class Predicate>
    class binary_negate
      : public binary_function<typename Predicate::first_argument_type,
          typename Predicate::second_argument_type, bool> {
    public: