标准文档 中当前头文件是通用工具库(General utilities library)中的部分内容,为了更好的表述其内容,本手册将其移至语言支持库(Language support library)中的 动态内存管理 主题中。

语言支持库(参考手册) ​语言支持库(标准)

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

  • 指针类别

    unique_ptr C++11 唯一独占对象所有权语义的智能指针(Smart pointer)
    shared_ptr C++11 共享对象所有权语义的智能指针
    weak_ptr C++11 指向由 shared_ptr 管理的对象的弱引用
    auto_ptr 已弃用 严格的对象所有权语义的智能指针

    辅助类

    owner_less  C++11 提供了对共享指针按拥有者(Owner-based)排序所用到的排序规则
    enable_shared_from_this  C++11 允许一个对象可以创建指向自身的 shared_ptr
    bad_weak_ptr  C++11 当访问一个指向已释放对象的 weak_ptr 时所抛出的异常
    default_delete  C++11 unique_ptr 所使用的默认删除器

    内存分配器

    allocator 默认的内存分配器
    allocator_traits C++11 为内存分配器类型提供特征信息
    allocator_arg_t C++11 这是一个空类,用于选择需要内存分配器的构造函数重载,是一个标签类型(Tag type)
    uses_allocator C++11 检测指定类型是否支持带内存分配器构造

    其它

    pointer_safety C++11 这是一个枚举类型,列举 C++ 支持的指针安全性模型
    pointer_traits C++11 为类指针(Pointer-like)类型提供特征信息
    std::hash<std::shared_ptr> C++11 提供了对 shared_ptr 的哈希(Hash)支持
    std::hash<std::unique_ptr> C++11 提供了对 unique_ptr 的哈希支持
  • hash C++11 哈希函数对象
  • allocator_arg C++11 allocator_arg_t 类型的对象
  • 未初始化内存

    uninitialized_copy 拷贝一个范围的对象到一个未初始化内存区域
    uninitialized_copy_n C++11 拷贝指定类目的对象到一个未初始化内存区域
    uninitialized_fill 用一个对象的值填充一个范围的未初始化内存区域
    uninitialized_fill_n 用一个对象的值填充指定数目元素组成的未初始化内存区域
    raw_storage_iterator 这是一个迭代器,标准算法可以通过它将结果存储到未初始化内存区域
    get_temporary_buffer 获得未初始化的临时存储空间
    return_temporary_buffer 返回(即释放)未初始化的临时存储空间

    垃圾回收支持

    declare_reachable C++11 声明一个对象不可以被回收(Recycle)
    undeclare_reachable C++11 声明一个对象可以被回收
    declare_no_pointers C++11 声明一个内存区域内不包含可追踪(Traceable)指针
    undeclare_no_pointers C++11 取消 declare_no_pointers 声明
    pointer_safety C++11 这是一个枚举类型,列举 C++ 支持的指针安全性模型
    get_pointer_safety C++11 获得当前指针安全性模型

    杂项

    addressof C++11 获得一个对象的实际地址,即使 operator& 操作符已被重载
    align C++11 对齐指定缓存中的一个指针

    智能指针的非成员操作

    make_shared C++11 创建一个用来管理新对象的共享指针
    allocate_shared C++11 创建一个用来管理使用内存分配器(Allocator)分配的新对象的共享指针
    static_pointer_cast C++11 提供了共享指针的 static_castdynamic_cast 或 const_cast 类型转换语义
    dynamic_pointer_cast C++11
    const_pointer_cast C++11
    get_deleter C++11 返回指定类型的删除器(Deleter),如果有的话
    operator==
    operator!=
    operator<
    operator<=
    operator>
    operator>=
    shared_ptr 对象同另一个 shared_ptr 对象或同 nullptr 比较
    operator<< 将被管理的指针的值输出到输出流(Output stream)
    std::swap(std::shared_ptr) C++11 std::swap 函数对 shared_ptr 类型所提供的特例化
    std::atomic_is_lock_free(std::shared_ptr) C++11 特例化原子操作
    std::atomic_load(std::shared_ptr) C++11
    std::atomic_load_explicit(std::shared_ptr) C++11
    std::atomic_store(std::shared_ptr) C++11
    std::atomic_store_explicit(std::shared_ptr) C++11
    std::atomic_exchange(std::shared_ptr) C++11
    std::atomic_exchange_explicit(std::shared_ptr) C++11
    std::atomic_compare_exchange_weak(std::shared_ptr) C++11
    std::atomic_compare_exchange_strong(std::shared_ptr) C++11
    std::atomic_compare_exchange_weak_explicit(std::shared_ptr) C++11
    std::atomic_compare_exchange_strong_explicit(std::shared_ptr) C++11
    operator==
    operator!=
    operator<
    operator<=
    operator>
    operator>=
    unique_ptr 对象同另一个 unique_ptr 对象或同 nullptr 比较
    std::swap(std::unique_ptr) C++11 std::swap 函数对 std::unique_ptr 类型所提供的特例化
    std::swap(std::weak_ptr) C++11 std::swap 函数对 std::weak_ptr 类型所提供的特例化

    内存分配器的非成员操作

    operator==
    operator!=
    比较两个内存分配器实例
    operator==
    operator!=
    比较两个多级(Multi-level)内存分配器实例
  • namespace std {
        // pointer traits
        template <class Ptr> struct pointer_traits;
        template <class T> struct pointer_traits<T*>;
     
        // pointer safety
        enum class pointer_safety { relaxed, preferred, strict };
        void declare_reachable(void *p);
        template <class T> T *undeclare_reachable(T *p);
        void declare_no_pointers(char *p, size_t n);
        void undeclare_no_pointers(char *p, size_t n);
        pointer_safety get_pointer_safety() noexcept;
     
        // pointer alignment function
        void *align(std::size_t alignment, std::size_t size,
                    void *&ptr, std::size_t& space);
     
        // allocator argument tag
        struct allocator_arg_t { };
        constexpr allocator_arg_t allocator_arg = allocator_arg_t();
     
        // uses_allocator
        template <class T, class Alloc> struct uses_allocator;
     
        // allocator traits
        template <class Alloc> struct allocator_traits;
     
        // the default allocator:
        template <class T> class allocator;
        template <> class allocator<void>;
        template <class T, class U>
            bool operator==(const allocator<T>&, const allocator<U>&) noexcept;
        template <class T, class U>
            bool operator!=(const allocator<T>&, const allocator<U>&) noexcept;
     
        // raw storage iterator:
        template <class OutputIterator, class T> class raw_storage_iterator;
     
        // temporary buffers:
        template <class T>
            pair<T*,ptrdiff_t> get_temporary_buffer(ptrdiff_t n) noexcept;
        template <class T>
            void return_temporary_buffer(T* p);
     
        // specialized algorithms:
        template <class T> T* addressof(T& r) noexcept;
        template <class InputIterator, class ForwardIterator>
            ForwardIterator uninitialized_copy(InputIterator first, InputIterator last,
                                               ForwardIterator result);
        template <class InputIterator, class Size, class ForwardIterator>
            ForwardIterator uninitialized_copy_n(InputIterator first, Size n,
                                                 ForwardIterator result);
        template <class ForwardIterator, class T>
            void uninitialized_fill(ForwardIterator first, ForwardIterator last,
                                    const T& x);
        template <class ForwardIterator, class Size, class T>
            ForwardIterator uninitialized_fill_n(ForwardIterator first, Size n, const T& x);
        // class template unique_ptr:
        template <class T> class default_delete;
        template <class T> class default_delete<T[]>;
        template <class T, class D = default_delete<T>> class unique_ptr;
        template <class T, class D> class unique_ptr<T[], D>;
     
        template <class T1, class D1, class T2, class D2>
            bool operator==(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
        template <class T1, class D1, class T2, class D2>
            bool operator!=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
        template <class T1, class D1, class T2, class D2>
            bool operator<(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
        template <class T1, class D1, class T2, class D2>
            bool operator<=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
        template <class T1, class D1, class T2, class D2>
            bool operator>(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
        template <class T1, class D1, class T2, class D2>
            bool operator>=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
     
        template <class T, class D>
            bool operator==(const unique_ptr<T, D>& x, nullptr_t) noexcept;
        template <class T, class D>
            bool operator==(nullptr_t, const unique_ptr<T, D>& y) noexcept;
        template <class T, class D>
            bool operator!=(const unique_ptr<T, D>& x, nullptr_t) noexcept;
        template <class T, class D>
            bool operator!=(nullptr_t, const unique_ptr<T, D>& y) noexcept;
     
        template <class T, class D>
            bool operator<(const unique_ptr<T, D>& x, nullptr_t);
        template <class T, class D>
            bool operator<(nullptr_t, const unique_ptr<T, D>& y);
        template <class T, class D>
            bool operator<=(const unique_ptr<T, D>& x, nullptr_t);
        template <class T, class D>
            bool operator<=(nullptr_t, const unique_ptr<T, D>& y);
        template <class T, class D>
            bool operator>(const unique_ptr<T, D>& x, nullptr_t);
        template <class T, class D>
            bool operator>(nullptr_t, const unique_ptr<T, D>& y);
        template <class T, class D>
            bool operator>=(const unique_ptr<T, D>& x, nullptr_t);
        template <class T, class D>
            bool operator>=(nullptr_t, const unique_ptr<T, D>& y);
     
        // class bad_weak_ptr:
        class bad_weak_ptr;
     
        // class template shared_ptr:
        template<class T> class shared_ptr;
     
        // shared_ptr comparisons:
        template<class T, class U>
            bool operator==(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept;
        template<class T, class U>
            bool operator!=(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept;
        template<class T, class U>
            bool operator<(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept;
        template<class T, class U>
            bool operator>(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept;
        template<class T, class U>
            bool operator<=(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept;
        template<class T, class U>
            bool operator>=(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept;
     
        template <class T>
            bool operator==(const shared_ptr<T>& x, nullptr_t) noexcept;
        template <class T>
            bool operator==(nullptr_t, const shared_ptr<T>& y) noexcept;
        template <class T>
            bool operator!=(const shared_ptr<T>& x, nullptr_t) noexcept;
        template <class T>
            bool operator!=(nullptr_t, const shared_ptr<T>& y) noexcept;
        template <class T>
            bool operator<(const shared_ptr<T>& x, nullptr_t) noexcept;
        template <class T>
            bool operator<(nullptr_t, const shared_ptr<T>& y) noexcept;
        template <class T>
            bool operator<=(const shared_ptr<T>& x, nullptr_t) noexcept;
        template <class T>
            bool operator<=(nullptr_t, const shared_ptr<T>& y) noexcept;
        template <class T>
            bool operator>(const shared_ptr<T>& x, nullptr_t) noexcept;
        template <class T>
        bool operator>(nullptr_t, const shared_ptr<T>& y) noexcept;
        template <class T>
            bool operator>=(const shared_ptr<T>& x, nullptr_t) noexcept;
        template <class T>
            bool operator>=(nullptr_t, const shared_ptr<T>& y) noexcept;
     
        // shared_ptr specialized algorithms:
        template<class T> void swap(shared_ptr<T>& a, shared_ptr<T>& b) noexcept;
     
        // shared_ptr casts:
        template<class T, class U>
            shared_ptr<T> static_pointer_cast(shared_ptr<U> const& r) noexcept;
        template<class T, class U>
            shared_ptr<T> dynamic_pointer_cast(shared_ptr<U> const& r) noexcept;
        template<class T, class U>
            shared_ptr<T> const_pointer_cast(shared_ptr<U> const& r) noexcept;
     
        // shared_ptr get_deleter:
        template<class D, class T> D* get_deleter(shared_ptr<T> const& p) noexcept;
     
        // shared_ptr I/O:
        template<class E, class T, class Y>
            basic_ostream<E, T>& operator<< (basic_ostream<E, T>& os, shared_ptr<Y> const& p);
     
        // class template weak_ptr:
        template<class T> class weak_ptr;
     
        // weak_ptr specialized algorithms:
        template<class T> void swap(weak_ptr<T>& a, weak_ptr<T>& b) noexcept;
     
        // class template owner_less:
        template<class T> class owner_less;
     
        // class template enable_shared_from_this:
        template<class T> class enable_shared_from_this;
     
        // shared_ptr atomic access:
        template<class T>
            bool atomic_is_lock_free(const shared_ptr<T>* p);
        template<class T>
            shared_ptr<T> atomic_load(const shared_ptr<T>* p);
        template<class T>
            shared_ptr<T> atomic_load_explicit(const shared_ptr<T>* p, memory_order mo);
        template<class T>
            void atomic_store(shared_ptr<T>* p, shared_ptr<T> r);
        template<class T>
            void atomic_store_explicit(shared_ptr<T>* p, shared_ptr<T> r, memory_order mo);
        template<class T>
            shared_ptr<T> atomic_exchange(shared_ptr<T>* p, shared_ptr<T> r);
        template<class T>
            shared_ptr<T> atomic_exchange_explicit(shared_ptr<T>* p, shared_ptr<T> r,
                                                    memory_order mo);
        template<class T>
            bool atomic_compare_exchange_weak(
                shared_ptr<T>* p, shared_ptr<T>* v, shared_ptr<T>  w);
        template<class T>
            bool atomic_compare_exchange_strong(
                shared_ptr<T>* p, shared_ptr<T>* v, shared_ptr<T>  w);
        template<class T>
            bool atomic_compare_exchange_weak_explicit(
                shared_ptr<T>* p, shared_ptr<T>* v, shared_ptr<T> w,
                memory_order success, memory_order failure);
        template<class T>
            bool atomic_compare_exchange_strong_explicit(
                shared_ptr<T>* p, shared_ptr<T>* v, shared_ptr<T> w,
                memory_order success, memory_order failure);
     
        //  hash support
        template <class T> struct hash;
        template <class T, class D> struct hash<unique_ptr<T, D> >;
        template <class T> struct hash<shared_ptr<T> >;
     
        // auto_ptr (deprecated)
        template <class X> class auto_ptr;
    }