Memory (C++标准库)

智慧型指標

智慧型指標是指當指標物件的生命期結束解構時，同時把指標所指的物件也delete或者參照計數減1。

shared_ptr

shared_ptr是一個類別範本，包裝了使用參照計數的智慧型指標。當shared_ptr在登出其作用域、生命期結束時，解構函式或自動對所指記憶體資料物件的參照計數減去1。如果記憶體資料物件的參照計數為0，則會被自動delete。指向同一資源的shared_ptr共同擁有一個控制塊，其中儲存了shared_ptr的參照計數、指向這一資源的weak_ptr的數目、資源的解構器（deleter ）位址、對該控制塊的可客製化的allocator。
template<class Ty>
   class shared_ptr {public:
    typedef Ty element_type;  //指针基类型//构造函数
    shared_ptr();                      //11 空指针
    shared_ptr(nullptr_t);         //22 空指针
    shared_ptr(const shared_ptr& sp);  //33 拷贝构造
    shared_ptr(shared_ptr&& sp);         //44 右值移动构造
    template<class Other> explicit shared_ptr(Other * ptr); //55 由其他指针初始化，构造失败时自动调用delete ptr
    template<class Other, class D> shared_ptr(Other * ptr, D dtor); //66 由其他指针初始化，dtor是个可调用的函数对象，构造失败时自动调用dtor(ptr)
    template<class D> shared_ptr(nullptr_t, D dtor); //77 空指针，并指定deleter
    template<class Other, class D, class A> shared_ptr(Other *ptr, D dtor, A alloc);//88 alloc管理shared_ptr控制块的内存分配与释放，构造失败时自动调用dtor(ptr)
    template<class D, class A> shared_ptr(nullptr_t, D dtor, A alloc);//99 空指针
    template<class Other> shared_ptr(const shared_ptr<Other>& sp); //0A  拷贝构造+类型转换
    template<class Other> shared_ptr(const shared_ptr<Other>&& sp); //0B 移动构造+类型转换
    template<class Other>  explicit shared_ptr(const weak_ptr<Other>& wp); //0C 由弱指针拷贝构造
    template<class Other>  shared_ptr(auto_ptr<Other>& ap); //0D 由auto_ptr指针拷贝构造
    template<class Other, class D> shared_ptr(unique_ptr<Other, D>&& up); //0E 由unique_ptr移动构造
    template<class Other> shared_ptr(const shared_ptr<Other>& sp, Ty *ptr); //0F 
    template<class Other, class D>shared_ptr(const unique_ptr<Other, D>& up) = delete;//10 禁用const unique_ptr作为移动构造函数
    ~shared_ptr(); // 析构函数
    shared_ptr& operator=(const shared_ptr& sp); //赋值运算符
    template<class Other> shared_ptr& operator=(const shared_ptr<Other>& sp); //类型转换的赋值运算符
    shared_ptr& operator=(shared_ptr&& sp); //右值引用的移动语义
    template<class Other> shared_ptr& operator=(shared_ptr<Other>&& sp); //右值引用+类型转换
    template<class Other> shared_ptr& operator=(auto_ptr< Other >&& ap); //右值引用+auto_ptr类型转换
    template <class Other, class D> shared_ptr& operator=(const unique_ptr< Other, D>& up) = delete; //禁止const型unique_ptr移动赋值给shared_ptr
    template <class Other, class D> shared_ptr& operator=(unique_ptr<Other, D>&& up);//右值引用的移动语义+类型转换
    void swap(shared_ptr& sp); //交换两个指针的内容//reset成员函数，把当前指向的数据对象的引用计数减1，然后指向参数表中新的数据对象
    void reset(); 
    template<class Other> void reset(Other *ptr);
    template<class Other, class D> void reset(Other *ptr, D dtor);
    template<class Other, class D, class A> void reset(Other *ptr, D dtor, A alloc);

    Ty *get() const;                 //返回所指向的数据对象的地址
    Ty& operator*() const;     //返回所指向的数据对象
    Ty *operator->() const;    //返回所指向的数据对象的地址
    long use_count() const;   //返回引用计数值
    bool unique() const;        //判断是否独占引用数据对象
    operator bool() const;     //判断是否指向了一个数据对象

    template<class Other> bool owner_before(shared_ptr<Other> const& ptr) const;
    template<class Other> bool owner_before(weak_ptr<Other> const& ptr) const;
    template<class D, class Ty>  D* get_deleter(shared_ptr<Ty> const& ptr);};

weak_ptr

弱指標weak_ptr用於指向、但不擁有（即不參加參照計數）由shared_ptr管理的資源。弱指標並不直接提供對資源的存取。應該通過shared_ptr來存取資源。當資源的參照計數為0（所有擁有該資源的shared_ptr物件都已被銷毀），該資源將被delete，這時如果仍然有弱指標指向該資源，則該弱指標將變為expired狀態。這實際上避免了資源的迴圈參照計數。對於迴圈的參照計數，如果把其中的一個shared_ptr的指標指向改為weak_ptr的指標指向，即打破了迴圈參照。
template<class Ty> class weak_ptr {public:
    typedef Ty element_type; //指针基类型//构造函数
    weak_ptr();                               //空指针
    weak_ptr(const weak_ptr&);    //拷贝构造
    template<class Other> weak_ptr(const weak_ptr<Other>&); //类型转换的拷贝构造
    template<class Other> weak_ptr(const shared_ptr<Other>&); //从shared_ptr拷贝构造//赋值运算符
    weak_ptr& operator=(const weak_ptr&);
    template<class Other> weak_ptr& operator=(const weak_ptr<Other>&);
    template<class Other> weak_ptr& operator=(shared_ptr<Other>&);

    void swap(weak_ptr&); //交换对象的内容
    void reset();                   //放弃指向资源，当前对象变为空的弱指针

    long use_count() const; //返回资源的引用计数
    bool expired() const;     //判断指向的资源是否还存在（或已经被释放）
    shared_ptr<Ty> lock() const; // 获取对资源的专属拥有
    };

auto_ptr

auto_ptr，即自動指標，在C++11標準是過時的類別範本。

allocator

allocator是STL中非常常用的類別範本，用於客製化記憶體的分配、釋放、管理。目的是封裝STL容器在記憶體管理上的低層細節，所以用戶程式不應該直接呼叫allocator去管理記憶體，除非是正在客製化容器。allocator將記憶體的分配與物件的構造初始化解耦，分別用allocate、construct兩個成員函式完成；同樣將記憶體的釋放與物件的解構銷毀解耦，分別用deallocat、destroy兩個成員函式完成。自訂的allocator的實現，必須滿足C++11標準的17.6.3.5節中的「Table 28 —— Allocator requirements」，簡單說就是要在類中定義若干類型名、模板成員名、成員函式、運算子函式。<memory>中定義的allocator類別範本做一些使用全局malloc/free函式運算式的記憶體的分配、釋放的平常操作：
template<class _Ty> class  allocator : public _Allocator_base<_Ty>
{ 
public:/*类型定义。容器类常常直接从它的allocator提取这些类型——  */typedef _Allocator_base<_Ty> _Mybase;                  //基类型
typedef typename _Mybase::value_type value_type;//值类型
typedef value_type _FARQ *pointer;                         //指针类型
typedef value_type _FARQ& reference;                    //引用类型
typedef const value_type _FARQ *const_pointer;     //常量指针类型
typedef const value_type _FARQ& const_reference;//常量引用类型
typedef size_t size_type;                                            //size类型
typedef ptrdiff_t difference_type;                                 //地址差值类型/*类型操作函数：  */ 
template<class _Other>
struct rebind //用于'''重绑定'''的成员模板： convert this type to allocator<_Other>。
                     //因为容器类需要动态申请内存的往往不是value_type，而是诸如List Node这样的其他类型
{
typedef allocator<_Other> other;
};

pointer address(reference _Val) const
{// 把mutuable引用变换为地址返回
return ((pointer) &(char&)_Val);
}

const_pointer address(const_reference _Val) const
{//把只读引用变换为只读地址返回
return ((const_pointer) &(char&)_Val);
}/*构造函数：*/   
allocator() throw( )
{ //缺省构造，不抛出异常
}

allocator(const allocator<_Ty>&) throw()
{// 空的拷贝构造
}

template<class _Other>
allocator(const allocator<_Other>&) throw()
{//从相关的allocator做拷贝构造，内容为空
}

template<class _Other>
allocator<_Ty>& operator=(const allocator<_Other>&)
{//从相关的allocator做拷贝赋值运算符，内容为空
return (*this);
}/*以下为业务函数： */
void deallocate(pointer _Ptr, size_type) //释放内存，并不析构对象。第二个参数为元素的项数
{// deallocate object at _Ptr, ignore size 
::operator delete(_Ptr);
}

pointer allocate(size_type _Count) //获取内存资源，并不调用对象的构造函数
{// allocate array of _Count elements
return (_Allocate(_Count, (pointer)0)); 
 }

pointer allocate(size_type _Count, const void _FARQ *)
{// allocate array of _Count elements, ignore hint 为高性能而设计的allocator可能会利用第二个参数的提示
return (allocate(_Count));
}

void construct(pointer _Ptr, const _Ty& _Val) // construct object at _Ptr with value _Val 
{//实际上调用了“带位置的new运算符表达式”，实现在特定位置上调用构造函数。 
_Construct(_Ptr, _Val);
}

void construct(pointer _Ptr, _Ty&& _Val) //construct object at _Ptr with right-value _Val
{ 实际上调用了“带位置的new运算符表达式”，以及右值完美转发，实现在特定位置上调用构造函数。
::new ((void _FARQ *)_Ptr) _Ty(_STD forward<_Ty>(_Val));
}

template<class _Other>
void construct(pointer _Ptr, _Other&& _Val) // construct object at _Ptr with value _Val， 带类型转换
{
::new ((void _FARQ *)_Ptr) _Ty(_STD forward<_Other>(_Val));
}

void destroy(pointer _Ptr)
{// 摧毁在地址 _Ptr的对象，但不释放内存
_Destroy(_Ptr);
}

_SIZT max_size() const _THROW0()
{// 估计allocator能分配的数据对象的最大可能数目
_SIZT _Count = (_SIZT)(-1) / sizeof (_Ty);
return (0 < _Count ? _Count : 1);
}};

allocator_traits

allocator_traits是對allocator的包裝。

bad_weak_ptr

bad_weak_ptr是個異常類。在用弱指標拷貝構造共用指標時，如果弱指標是expired，那麼拷貝建構函式丟擲bad_weak_ptr異常。

raw_storage_iterator

raw_storage_iterator是個類別範本，用於表示指向記憶體的一個前向疊代器。其設定運算子在當前所指向記憶體上呼叫值類型的建構函式，生成一個物件。