C++primer 13.2.1节练习

练习13.23

#include <iostream>
#include <string>
#include <memory>

using namespace std;


class HasPtr {
    friend ostream &print(ostream &os, HasPtr &h);
public:
    HasPtr(const string &s = string()) : ps(new string(s)), i(0) {}
    HasPtr(const HasPtr &ptr);
    HasPtr &operator=(const HasPtr &pt);
    ~HasPtr() { }
private:
    string *ps;
    int i;
};

ostream &print(ostream &os, HasPtr &h);

int main()
{
    HasPtr has("hello");
    HasPtr have = has;
    print(cout, have);
    system("pause");
    return 0;
}

HasPtr::HasPtr(const HasPtr & ptr) : ps(new string(*ptr.ps)), i(ptr.i) {}

HasPtr & HasPtr::operator=(const HasPtr & pt)
{
    auto newp = new string(*pt.ps);
    delete ps;
    ps = newp;
    i = pt.i;
    return *this;
    // TODO: 在此处插入 return 语句
}

ostream & print(ostream & os, HasPtr & h)
{
    os << h.ps << h.i << endl;
    return os;
    // TODO: 在此处插入 return 语句
}

练习13.24

1. 如果没有定义析构函数的话，会造成内存泄露。因为，成员变量ps是通过new操作在堆上显式分配出的一段内存，需要使用delete显式的去释放。

2. 如果没有定义拷贝构造函数的话，可能会造成二次释放，或使用悬空指针的情况。因为，在合成的赋值运算符中，让不同实例的ps指向同一段内存的起始位置。当其中有一个实例对内存进行释放或其他操作时，别的实例也会受到印象，如果只是修改值之类的操作，影响并不是很大（不至于崩溃）；但是，当有释放的操作时，程序很可能会发生崩溃。

练习13.25

拷贝构造函数和拷贝赋值运算符需要做的就是分配一个新的内存并赋予其值然后进行拷贝，不需要析构函数是因为智能指针自己有析构函数进行内存的释放；

练习13.26

#include <iostream>
#include <fstream>
#include <string>
#include <sstream>
#include <set>
#include <map>
#include <algorithm>
#include <vector>
#include <algorithm>
#include <iterator>
#include <unordered_map>
#include <memory>

using namespace std;

class strBlobPtr;
class strBlob {
    friend void print(strBlob s);
    friend class strBlobPtr;
public:
    typedef vector<string>::size_type size_type;
    strBlob();
    strBlob(initializer_list<string> il);
    strBlob(const strBlob& str) : data(make_shared<vector<string>>(*str.data)) {}        //拷贝构造函数
    strBlob &operator=(const strBlob &str);                                                //拷贝赋值运算符
    size_type size() const { return data->size(); }
    bool empty() const { return data->empty(); }
    void push_back(const string &t);
    void pop_back();
    const string &front();
    const string &back();
    strBlobPtr begin();
    strBlobPtr end();
private:
    shared_ptr<vector<string>> data;
    void check(size_type i, const string &msg) const;
};

class strBlobPtr {
public:
    strBlobPtr() : curr(0) {}
    strBlobPtr(strBlob &a, size_t sz = 0) : wptr(a.data), curr(sz) {}
    string & deref() const;
    strBlobPtr &incr();
private:
    shared_ptr<vector<string>> check(size_t t, const string &str) const;
    weak_ptr<vector<string>> wptr;
    size_t curr;
};

void print(strBlob s);

int main()
{
    strBlob p1({ "asd", "qew", "jkl" });
    print(p1);
    p1.push_back("dqw");
    print(p1);
    p1.pop_back();
    p1.pop_back();
    print(p1);
    cout << endl;
    cout << p1.front() << endl;
    cout << p1.back() << endl;
    system("pause");
    return 0;
}

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

strBlob & strBlob::operator=(const strBlob & str)
{
    auto str1 = make_shared<vector<string>>(*str.data);
    data = str1;
    return *this;
    // TODO: 在此处插入 return 语句
}

void strBlob::push_back(const string & t)
{
    data->push_back(t);
}
void strBlob::pop_back()
{
    check(0, "pop_back on empty StrBlob");
    data->pop_back();
}
const string & strBlob::front()
{
    check(0, "front on empty StrBlob");
    return data->front();
    // TODO: 在此处插入 return 语句
}
const string & strBlob::back()
{
    check(0, "back on empty StrBlob");
    return data->back();
    // TODO: 在此处插入 return 语句
}

strBlobPtr strBlob::begin()
{
    return strBlobPtr(*this);
}

strBlobPtr strBlob::end()
{
    return strBlobPtr(*this, data->size());
}


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

void print(strBlob s)
{
    for (auto c : *(s.data))
        cout << c << endl;
    cout << endl;
}

string & strBlobPtr::deref() const
{
    auto p = check(curr, "dereference past end");
    return (*p)[curr];
    // TODO: 在此处插入 return 语句
}

strBlobPtr & strBlobPtr::incr()
{
    check(curr, "increment past end of strBlobPtr");
    ++curr;
    return *this;
    // TODO: 在此处插入 return 语句
}

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