結合shared_ptr、weak_ptr一個例項

         感覺這個例子很好, 結合了很多知識技術。這個例項功能是簡單模擬實現std::vector<std::string> 部分功能。 （只是非常簡單一些操作），當然也可以繼續擴充套件，甚至擴充套件為模板，主要是用於學習。使用兩個類實現，分別是StrBlob、StrBlobPtr。

StrBlob主要使用shared_ptr類物件來管理資源，StrBlobPtr主要使用weak_ptr類物件來管理資源。底層操作資料物件

std::vector<std::string>

學習點： （真心感覺這個例子很棒）

1、StrBlob

跟StrBlobPtr的關係，基本上類似容器和迭代器的關係，很好將他們區分開來。

2、對記憶體資源的管理，非常巧妙。

3、對異常考慮

下面是本例的完整程式碼, 然後再簡單分析一下自己理解。

verStr.h

#ifndef VECSTR_H_INCLUDED
#define VECSTR_H_INCLUDED
#include<memory>
#include<vector>
#include<string>


class StrBlobPtr;

class StrBlob
{
public:
    using size_type = std::vector<std::string>::size_type;

    // in order to access the data member in StrBlobPtr class
    friend class StrBlobPtr;
    //constructor
    StrBlob()
        :data(std::make_shared<std::vector<std::string> >()) {}
    StrBlob(const std::initializer_list<std::string> lisStr)
        : data(std::make_shared<std::vector<std::string> >(lisStr)) {}

    //the operator of size
    size_type size() const{ return data->size();}
    bool empty() const { return data->empty();}

    //add and remove elements
    void push_back(const std::string& str) {data->push_back(str);}
    void pop_back()
    {
        check(0,"pop_back on empty StrBlob");
        data->pop_back();
    }

    //element access
    std::string& front() const
    {
       check(0,"front on empty StrBlob");
       return data->front();
    }
    std::string& back() const
    {
        check(0,"back on empty StrBlob");
        return data->back();
    }

    //return StrBlobPtr to the first and one past the last elements
    StrBlobPtr begin();
    StrBlobPtr end();
private:
    std::shared_ptr<std::vector<std::string> > data;

    // throws msg if data[_size] isn't valid
    void check(size_type _size,const std::string& msg) const
    {
        if(_size>=data->size())
            throw std::runtime_error(msg);
    }
};


class StrBlobPtr
{
public:
    StrBlobPtr() :cur(0){}
    StrBlobPtr(StrBlob& str,std::size_t sz = 0)
        :wptr(str.data),cur(sz)
    {

    }
    // operator of elements
    bool operator!=(const StrBlobPtr& p) { return p.cur!= cur; }
    std::string& deref() const;
    StrBlobPtr& incr(); // prefix version

private:
    std::shared_ptr<std::vector<std::string> >
        check(std::size_t ,const std::string& msg) const;

    //store a weak_ptr, which means the underlying vector might be destroyed
    std::weak_ptr<std::vector<std::string> > wptr;
    std::size_t cur;  // current position within the array
};

std::shared_ptr<std::vector<std::string> >
    StrBlobPtr::check(std::size_t _size,const std::string& msg) const
    {
        auto ret = wptr.lock(); //return the shared_ptr pointer to the object to which wptr points from lock to initialize ret
        if(!ret)
            throw std::runtime_error("unbound StrBlobPtr");
        if(_size>=ret->size())
            throw std::out_of_range(msg);
        return ret;
    }
std::string& StrBlobPtr::deref() const
{
    auto p = check(cur,"dereference past end");
    return (*p)[cur];
}

StrBlobPtr& StrBlobPtr::incr()
{
    check(cur,"increment past end of StrBlobPtr");
    ++cur;
    return *this;
}

StrBlobPtr StrBlob::begin()
{
    return StrBlobPtr(*this);
}
StrBlobPtr StrBlob::end()
{
    auto ret = StrBlobPtr(*this,data->size());
    return ret;
}


#endif // VECSTR_H_INCLUDED
 

以下是一個測試用例，從一個檔案中讀取字串，將其儲存再StrBlob中，再將其打印出來。

#include <iostream>
#include<fstream>
#include<sstream>
#include<algorithm>
#include"vecStr.h"
const std::string fileName = "input.txt";
int main()
{
    StrBlob str;
    std::ifstream fs(fileName);
    std::string buffer;
    while(getline(fs,buffer))
        str.push_back(buffer);

    for(StrBlobPtr it = str.begin();it!=str.end(); it.incr())
    {
        std::cout<<it.deref()<<std::endl;
    }
    return 0;
}
 

簡單分析：（以下資源是指std::vector<std::string>）

shared_ptr、weak_ptr具體型別如下

std::shared_ptr<std::vector<std::string> > data;
std::weak_ptr<std::vector<std::string> > wptr;

我們知道，我們用StrBlob去顯示初始化StrBlobPtr物件, 主要是使用data去初始化wptr

 StrBlobPtr(StrBlob& str,std::size_t sz = 0)
        :wptr(str.data),cur(sz)
    {

    }

當構造完StrBlobPtr物件，shared_ptr所管理的資源使用者是不會增加的（即資源引用計數不會自增一），weak_ptr只是指向一塊被shared_ptr管理的資源，所擁有的這份資源的管理權在shared_ptr, 這也導致我們在使用weak_ptr所指向的資源的時候，需要檢查一下它所指向的資源是否存在（因為shared_ptr所管理資源可能被刪除）。  在StrBlobPtr中check中函式實現。當weak_ptr所指向的資源不存在時，便丟擲一個異常runtime_error。

std::shared_ptr<std::vector<std::string> >
    StrBlobPtr::check(std::size_t _size,const std::string& msg) const
    {
        auto ret = wptr.lock(); //return the shared_ptr pointer to the object to which wptr points from lock to initialize ret
        if(!ret)
            throw std::runtime_error("unbound StrBlobPtr");
        if(_size>=ret->size())
            throw std::out_of_range(msg);
        return ret;
    }

這裡還有一個地方需要注意，weak_ptr是沒有辦法直接操作它所指向的資源的（一個原因是它所指向的資源有可能被刪除），需要藉助shared_ptr物件，通過呼叫wptr.lock(),當wptr指向非空時，返回一個shared_ptr物件，指向的wptr所指向的資源, 並用這個物件去初始化ret（建立了一個shared_pre物件名ret,這時候weak_ptr所返回的資源管理使用者會增加多一個，即ret這個使用者，資源引用計數增加一個)。如果wptr指向空，那麼這時候lock會返回一個nullptr空指標，程式會丟擲一個異常。

現在問題又來了，ret這個使用者作為check函式的返回值,意味著ret這個使用者並沒有在check函式結束後釋放對它所指向的資源的管理權（資源引用不會減少）那讓我們來跟蹤一個ret這個使用者去哪裡了。 StrBlobPtr類有deref、incr成員呼叫這個函式，如下。

std::string& StrBlobPtr::deref() const
{
    auto p = check(cur,"dereference past end");
    return (*p)[cur];
}

StrBlobPtr& StrBlobPtr::incr()
{
    check(cur,"increment past end of StrBlobPtr");
    ++cur;
    return *this;
}

顯然當這兩個函式分別執行完後，ret將作為函式中區域性物件銷燬了，這時候（資源引用計數遞減1）。 非常巧妙，非常簡單，這樣便保證了資源不會洩漏。

在仔細看看，StrBlobPtr物件是如何解引用獲取StrBlob物件的值，這裡並不是在StrBlobPtr類中過載operator *實現解引用。而是使用了refef成員函式代替（為了方便），

容易看到是通過shared_ptr物件操作下標cur，取得了該資源（vector<string>）所對應的值( 相當於(*data)[cur]).

再來看看如何對StrBlobPtr物件實現遞增，這裡同樣也不是過載operator ++()或者是operator ++(int)  分別對應前置遞增跟後置遞增， 這裡使用incr()函式，結合資料成員

 std::weak_ptr<std::vector<std::string> > wptr;
 std::size_t cur;  // current position within the array

模擬實現前置遞增，很容易看出來。

想想上述物件是否能夠滿足建立const StrBlob 和const StrBlobPtr 物件？？

顯然是不符合我們使用習慣，需要再過載如下函式：

在StrBlob中（以下只提供宣告宣告,實現類似）

 StrBlobPtr begin() const ;
 StrBlobPtr end();  const;

在StrBlobPtr中 

 const std::string& deref() const;

以上分析是個人理解，有不妥歡迎指出來。

參考：