当前头文件是通用工具库(Diagnostics library)中的部分内容。

​通用工具库(参考手册) ​通用工具库(标准)

  • std::rel_ops::operator!=,>,<=,>= 通过用户自定义的 operator== 及 operator< 操作符,自动生成的其它比较操作符
  • swap 交换两个对象的值
    forward C++11 传递一个函数参数
    move C++11 获得右值引用(Rvalue reference)
    move_if_noexcept C++11 如果移动构造函数(Move constructor)不会抛出异常,则获得右值引用
    declval C++11 该函数模板用于 decltype 表达式,可以将任意类型转化成一个引用类型(Reference type),再使用其成员函数以猜测类型,不管该类型是否支持默认构造函数(Default constructor)
    make_pair 创建由参数的类型定义的二元组(Pair)对象
    operator==
    operator!=
    operator<
    operator<=
    operator>
    operator>=
    pair 对象中的值进行字典序(Lexicographically)比较 
    std::swap(std::pair) C++11 std::swap 函数对 std::pair 的特例化
    std::get(std::pair) C++11 访问一个二元组对象中的一个元素
  • pair 实现了二元组
    tuple C++11 实现了多元组,这是一个编译期就确定大小(Implements fixed)的容器,可以容纳不同类型的元素
    piecewise_construct C++11 这是一个空对象,是 piecewise_construct 的一个实例,专用于重载 pair 的构造函数,使得可以将两个 tuple 参数中的成员按正确的顺序(In place)传递给对应的构造函数,即 pair 内部构造 tuple 对象时不是以另一整个 tuple 为参数(拷贝构造),而是将另一个 tuple 内所有元素拆分开来再传递进构造函数(Piecewise)
    piecewise_construct_t C++11 piecewise_construct 常量的类型,是一个空结构体
  • #include <initializer_list>
     
    namespace std {
        // operators:
        namespace rel_ops {
            template<class T> bool operator!=(const T&, const T&);
            template<class T> bool operator> (const T&, const T&);
            template<class T> bool operator<=(const T&, const T&);
            template<class T> bool operator>=(const T&, const T&);
        }
     
        // swap:
        template<class T> void swap(T& a, T& b) noexcept(noexcept(a.swap(b));
        template <class T, size_t N> 
            void swap(T (&a)[N], T (&b)[N]) noexcept(noexcept(swap(*a, *b)));
     
        // forward/move:
        template <class T> T&& forward(typename remove_reference<T>::type& t) noexcept;
        template <class T> T&& forward(typename remove_reference<T>::type&& t) noexcept;
        template <class T> typename remove_reference<T>::type&& move(T&&) noexcept;
        template <class T> typename conditional<
            !is_nothrow_move_constructible<T>::value && is_copy_constructible<T>::value,
            const T&, T&&>::type move_if_noexcept(T& x) noexcept;
     
        // declval, as unevaluated operand:
        template <class T>
            typename add_rvalue_reference<T>::type declval() noexcept; 
     
        // pairs:
        template <class T1, class T2> struct pair;
     
        // pair specialized algorithms:
        template <class T1, class T2>
            bool operator==(const pair<T1,T2>&, const
        template <class T1, class T2>
            bool operator< (const pair<T1,T2>&, const pair<T1,T2>&);
        template <class T1, class T2>
            bool operator!=(const pair<T1,T2>&, const pair<T1,T2>&);
        template <class T1, class T2>
            bool operator> (const pair<T1,T2>&, const pair<T1,T2>&);
        template <class T1, class T2>
            bool operator>=(const pair<T1,T2>&, const pair<T1,T2>&);
        template <class T1, class T2>
            bool operator<=(const pair<T1,T2>&, const pair<T1,T2>&);
        template <class T1, class T2>
            void swap(pair<T1,T2>& x, pair<T1,T2>& y) noexcept(noexcept(x.swap(y)));
        template <class T1, class T2>
            pair<V1,V2> make_pair(T1&&, T2&&);
     
        //tuple-like access to pair:
        template <class T> class tuple_size;
        template <size_t I, class T> class tuple_element;
     
        template <class T1, class T2> struct tuple_size<std::pair<T1, T2> >;
        template <class T1, class T2> struct tuple_element<0, std::pair<T1, T2> >;
        template <class T1, class T2> struct tuple_element<1, std::pair<T1, T2> >;
     
        template<size_t I, class T1, class T2>
            typename tuple_element<I, std::pair<T1, T2> >::type& 
            get(std::pair<T1, T2>&) noexcept;
        template<size_t I, class T1, class T2>
            typename tuple_element<I, std::pair<T1, T2> >::type&& 
            get(std::pair<T1, T2>&&) noexcept;
        template<size_t I, class T1, class T2>
            const typename tuple_element<I, std::pair<T1, T2> >::type&
                get(const std::pair<T1, T2>&) noexcept;
     
        // pair piecewise construction
        struct piecewise_construct_t { };
        constexpr piecewise_construct_t piecewise_construct = piecewise_construct_t();
     
        template <class... Types> class tuple; // defined in <tuple>
    }
  • template <class T1, class T2>
    struct pair {
        typedef T1 first_type;
        typedef T2 second_type;
     
        T1 first;
        T2 second;
        pair(const pair&) = default;
        pair(pair&&) = default;
     
        constexpr pair();
        pair(const T1& x, const T2& y);
        template<class U, class V> pair(U&& x, V&& y);
        template<class U, class V> pair(const pair<U, V>& p);
        template<class U, class V> pair(pair<U, V>&& p);
        template <class... Args1, class... Args2>
            pair(piecewise_construct_t,
                 tuple<Args1...> first_args, tuple<Args2...> second_args);
     
        pair& operator=(const pair& p);
        template<class U, class V> pair& operator=(const pair<U, V>& p);
        pair& operator=(pair&& p) noexcept(see below);
        template<class U, class V> pair& operator=(pair<U, V>&& p);
     
        void swap(pair& p) noexcept( noexcept(swap(first, p.first)) &&
                                     noexcept(swap(second, p.second)) );
    };