checklist

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

T     explicit binary_negate(const Predicate& pred);
V     bool operator()(const typename Predicate::first_argument_type&  x,
          const typename Predicate::second_argument_type& y) const;
    };


   20.3.6  Binders                                          [lib.binders]

   20.3.6.1  Template class binder1st                    [lib.binder.1st]
T   template <class Operation>
    class binder1st
      : public unary_function<typename Operation::second_argument_type,
                              typename Operation::result_type> {
    protected:
T     Operation                      op;
T     typename Operation::first_argument_type value;
    public:
V     binder1st(const Operation& x,
                const typename Operation::first_argument_type& y);
V     typename Operation::result_type
        operator()(const typename Operation::second_argument_type& x) const;
    };

   20.3.6.2  bind1st                                       [lib.bind.1st]

V  template <class Operation, class T>
    binder1st<Operation> bind1st(const Operation& op, const T& x);

   20.3.6.3  Template class binder2nd                    [lib.binder.2nd]
T   template <class Operation>
    class binder2nd
      : public unary_function<typename Operation::first_argument_type,
                              typename Operation::result_type> {
    protected:
T     Operation                       op;
T     typename Operation::second_argument_type value;
    public:
V     binder2nd(const Operation& x,
                const typename Operation::second_argument_type& y);
V     typename Operation::result_type
        operator()(const typename Operation::first_argument_type& x) const;
    };

   20.3.6.4  bind2nd                                       [lib.bind.2nd]

T  template <class Operation, class T>
    binder2nd<Operation> bind2nd(const Operation& op, const T& x);


   20.3.7  Adaptors for pointers to       [lib.function.pointer.adaptors]
       functions

   1 To  allow  pointers to (unary and binary) functions to work with func-
   tion adaptors the library provides:

T   template <class Arg, class Result>
    class pointer_to_unary_function : public unary_function<Arg, Result> {
    public:
T     explicit pointer_to_unary_function(Result (*f)(Arg));
V     Result operator()(Arg x) const;
    };

T  template <class Arg, class Result>
    pointer_to_unary_function<Arg, Result> ptr_fun(Result (*f)(Arg));

T       template <class Arg1, class Arg2, class Result>
        class pointer_to_binary_function :
          public binary_function<Arg1,Arg2,Result> {
        public:
T         explicit pointer_to_binary_function(Result (*f)(Arg1, Arg2));
V         Result operator()(Arg1 x, Arg2 y) const;
        };


   20.3.8  Adaptors for pointers to         [lib.member.pointer.adaptors]
       members

T  template <class S, class T> class mem_fun_t
          : public unary_function<T*, S> {
   public:
T   explicit mem_fun_t(S (T::*p)());
V   S operator()(T* p) const;
   };

T   template <class S, class T, class A> class mem_fun1_t
          : public binary_function<T*, A, S> {
    public:
T     explicit mem_fun1_t(S (T::*p)(A));
V     S operator()(T* p, A x) const;
   };

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));

T   template <class S, class T> class mem_fun_ref_t
          : public unary_function<T, S> {
    public:
T     explicit mem_fun_ref_t(S (T::*p)());
V     S operator()(T& p) const;
   };

T   template <class S, class T, class A> class mem_fun1_ref_t
          : public binary_function<T, A, S> {
    public:
T     explicit mem_fun1_ref_t(S (T::*p)(A));
V     S operator()(T& p, A x) const;
   };

T   template<class S, class T> mem_fun_ref_t<S,T>
       mem_fun_ref(S (T::*f)());

T   template<class S, class T, class A> mem_fun1_ref_t<S,T,A>
       mem_fun_ref(S (T::*f)(A));

T  template <class S, class T> class const_mem_fun_t
        : public unary_function<T*, S> {
   public:
T   explicit const_mem_fun_t(S (T::*p)() const);
V   S operator()(const T* p) const;
   };

T  template <class S, class T, class A> class const_mem_fun1_t
        : public binary_function<T*, A, S> {
   public:
T   explicit const mem_fun1_t(S (T::*p)(A) const);
V   S operator()(const T* p, A x) const;
   };

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);

T   template <class S, class T> class const_mem_fun_ref_t
          : public unary_function<T, S> {
    public:
T     explicit const_mem_fun_ref_t(S (T::*p)() const);
V     S operator()(const T& p) const;
   };

T   template <class S, class T, class A> class const_mem_fun1_ref_t
          : public binary_function<T, A, S> {
    public:
T     explicit const_mem_fun1_ref_t(S (T::*p)(A) const);
V     S operator()(const T& p, A x) const;
   };

T   template<class S, class T> const_mem_fun_ref_t<S,T>
       mem_fun_ref(S (T::*f)() const);

T   template<class S, class T, class A> const_mem_fun1_ref_t<S,T,A>
        mem_fun_ref(S (T::*f)(A) const);

   20.4  Memory                                              [lib.memory]

   Header <memory> synopsis

    // _lib.default.allocator_, the default allocator:
T   template <class T> class allocator;
T   template <> class allocator<void>;
T   template <class T, class U>
      bool operator==(const allocator<T>&, const allocator<U>&) throw();
T   template <class T, class U>
      bool operator!=(const allocator<T>&, const allocator<U>&) throw();
    // _lib.storage.iterator_, raw storage iterator:
T   template <class OutputIterator, class T> class raw_storage_iterator;
    // _lib.temporary.buffer_, temporary buffers:
T   template <class T>
      pair<T*,ptrdiff_t> get_temporary_buffer(ptrdiff_t n);
T   template <class T>
      void return_temporary_buffer(T* p);
    // _lib.specialized.algorithms_, specialized algorithms:
T   template <class InputIterator, class ForwardIterator>
      ForwardIterator
        uninitialized_copy(InputIterator first, InputIterator last,
                           ForwardIterator result);
T   template <class ForwardIterator, class T>
      void uninitialized_fill(ForwardIterator first, ForwardIterator last,
                              const T& x);
T   template <class ForwardIterator, class Size, class T>
      void uninitialized_fill_n(ForwardIterator first, Size n, const T& x);
    // _lib.auto.ptr_, pointers:
X   template<class X> class auto_ptr;
   }

   20.4.1  The default allocator                  [lib.default.allocator]

T   template <class T> class allocator;
    // specialize for void:
T   template <> class allocator<void> {
    public:
T     typedef void*       pointer;
T     typedef const void* const_pointer;
      // reference-to-void members are impossible.
T     typedef void  value_type;
T     template <class U> struct rebind { typedef allocator<U> other; };
    };

T   template <class T> class allocator {
     public:
T     typedef size_t    size_type;
T     typedef ptrdiff_t difference_type;
T     typedef T*        pointer;
T     typedef const T*  const_pointer;
T     typedef T&        reference;
T     typedef const T&  const_reference;
T     typedef T         value_type;
T     template <class U> struct rebind { typedef allocator<U> other; };
T     allocator() throw();
T     allocator(const allocator&) throw();
T     template <class U> allocator(const allocator<U>&) throw();
T    ~allocator() throw();
T     pointer address(reference x) const;
T     const_pointer address(const_reference x) const;
T     pointer allocate(
        size_type, allocator<void>::const_pointer hint = 0);
T     void deallocate(pointer p, size_type n);
T     size_type max_size() const throw();
T     void construct(pointer p, const T& val);
T     void destroy(pointer p);
    };

   20.4.1.2  allocator globals                    [lib.allocator.globals]

T  template <class T1, class T2>
    bool operator==(const allocator<T1>&, const allocator<T2>&) throw();
T  template <class T1, class T2>
    bool operator!=(const allocator<T1>&, const allocator<T2>&) throw();

   20.4.2  Raw storage iterator                    [lib.storage.iterator]

T   template <class OutputIterator, class T>
    class raw_storage_iterator
      : public iterator<output_iterator_tag,void,void,void,void> {
    public:
T     explicit raw_storage_iterator(OutputIterator x);
T     raw_storage_iterator<OutputIterator,T>& operator*();
T     raw_storage_iterator<OutputIterator,T>& operator=(const T& element);
T     raw_storage_iterator<OutputIterator,T>& operator++();
T     raw_storage_iterator<OutputIterator,T>  operator++(int);
    };

   20.4.3  Temporary buffers                       [lib.temporary.buffer]

T  template <class T>
    pair<T*, ptrdiff_t> get_temporary_buffer(ptrdiff_t n);

T  template <class T> void return_temporary_buffer(T* p);

   20.4.4  Specialized algorithms            [lib.specialized.algorithms]

   20.4.4.1  uninitialized_copy                  [lib.uninitialized.copy]

V  template <class InputIterator, class ForwardIterator>
    ForwardIterator
      uninitialized_copy(InputIterator first, InputIterator last,
                         ForwardIterator result);

   20.4.4.2  uninitialized_fill                  [lib.uninitialized.fill]

V  template <class ForwardIterator, class T>
    void uninitialized_fill(ForwardIterator first, ForwardIterator last,
                            const T& x);

   20.4.4.3  uninitialized_fill_n              [lib.uninitialized.fill.n]

V  template <class ForwardIterator, class Size, class T>
    void uninitialized_fill_n(ForwardIterator first, Size n, const T& x);

   20.4.5  Template class auto_ptr                         [lib.auto.ptr]

X   template<class X> class auto_ptr {
      template <class Y> struct auto_ptr_ref {};
    public:
T     typedef X element_type;
      // _lib.auto.ptr.cons_ construct/copy/destroy:
T     explicit auto_ptr(X* p =0) throw();
T     auto_ptr(auto_ptr&) throw();
T     template<class Y> auto_ptr(auto_ptr<Y>&) throw();
T     auto_ptr& operator=(auto_ptr&) throw();
T     template<class Y> auto_ptr& operator=(auto_ptr<Y>&) throw();
T    ~auto_ptr() throw();
      // _lib.auto.ptr.members_ members:
T     X& operator*() const throw();
T     X* operator->() const throw();
T     X* get() const throw();
T     X* release() throw();
T     void reset(X* p =0) throw();

      // _lib.auto.ptr.conv_ conversions:
X     auto_ptr(auto_ptr_ref<X>) throw();
X     template<class Y> operator auto_ptr_ref<Y>() throw();
X     template<class Y> operator auto_ptr<Y>() throw();
    };

   20.4.6  C Library                                       [lib.c.malloc]

                    Table 7--Header <cstdlib> synopsis

X                    Functions:   calloc   malloc
                                  free     realloc


                    Table 8--Header <cstring> synopsis

X                    Macro:       NULL
X                    Type:        size_t
X                    Functions:   memchr    memcmp
X                    memcpy       memmove   memset

                     Table 9--Header <ctime> synopsis

X          Macros:   NULL
X          Types:    size_t   clock_t    time_t
X          Struct:   tm
           Functions:
X          asctime   clock    difftime   localtime   strftime
X          ctime     gmtime   mktime     time

   21.1.1  Character traits requirements        [lib.char.traits.require]

   2 The struct template
T  template<class charT> struct char_traits;
   shall be provided in the header <string> as a basis for  explicit spe-
   cializations.


   21.1.3.1  struct                [lib.char.traits.specializations.char]
       char_traits<char>