C++ primer StrBlobPtr和StrBlobPtr

#include <iostream>
#include <stdio.h>
#include <string>
#include <memory>
#include <algorithm>
#include <initializer_list>
#include <memory>
#include <vector>
#include <stdexcept>
#include <fstream>
#include <sstream>
using namespace std;

#ifndef STRBLOB_H_
#define STRBLOB_H_

class StrBlobPtr;

class StrBlob
{
public:
    friend class StrBlobPtr;
    friend void inp(StrBlob& str, ifstream& input);
    typedef std::vector<std::string>::size_type size_type;
    StrBlob();
    StrBlob(std::initializer_list<std::string> il);
    size_type size() const { return data->size(); }
    bool empty() const { return data->empty(); }
    void push_back(const std::string& t) { data->push_back(t); }
    void pop_back();
    std::string& front();
    std::string& back();
    const std::string& front() const;
    const std::string& back() const;
    StrBlobPtr begin();
    StrBlobPtr end();
private:
    std::shared_ptr<std::vector<std::string>> data;
    void check(size_type i, const std::string& msg) const;
};

class StrBlobPtr
{
public:
    friend void inp(StrBlob& str, ifstream& input);
    StrBlobPtr() : curr(0) {};
    StrBlobPtr(StrBlob& a, size_t sz = 0) : wptr(a.data), curr(sz) {}
    std::string& deref() const;
    StrBlobPtr& incr();
    friend bool eq(const StrBlobPtr& lhs, const StrBlobPtr& rhs);
private:
    std::shared_ptr<std::vector<std::string>> check(std::size_t, const std::string&) const;
    std::weak_ptr<std::vector<std::string>> wptr;
    std::size_t curr;
};

std::shared_ptr<std::vector<std::string>> StrBlobPtr::check(std::size_t i, const std::string& msg) const
{
    auto ret = wptr.lock();
    if (!ret)
        throw std::runtime_error("unbound StrBlobPtr");
    if (i >= ret->size())
        throw std::out_of_range(msg);
    return ret;
}

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

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

StrBlob::StrBlob() : data(std::make_shared<std::vector<std::string>>()) {}
StrBlob::StrBlob(std::initializer_list<std::string> il) : data(std::make_shared<std::vector<std::string>>(il)) {}

void StrBlob::check(size_type i, const std::string& msg) const
{
    if (i >= data->size())
        throw std::out_of_range(msg);
}

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

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

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

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

void StrBlob::pop_back()
{
    check(0, "pop_back on empty StrBlob");
    data->pop_back();
}

StrBlobPtr StrBlob::begin() { return StrBlobPtr(*this); }

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

#endif

bool eq(const StrBlobPtr& lhs, const StrBlobPtr& rhs) {
    auto lp = lhs.wptr.lock(), rp = rhs.wptr.lock();
    if (lp == rp) {
        return (!lp || lhs.curr == rhs.curr);
    }
    else {
        return false;
    }
}

void inp(StrBlob &str, ifstream &input)
{
    //存入类中
    string text;
    while (getline(input, text))
    {
        istringstream stream(text);
        string word;
        while (stream >> word)
        {
            str.push_back(word);
        }
    }
    //打印类中元素
    for (StrBlobPtr cur = str.begin(); !eq(cur,str.end()); cur.incr())
    {
        string out = cur.deref();
        cout << out << "";
    }
    
}