c++primer练习13.22-13.38

练习13.22

假定我们希望HasPtr的行为像一个值。即，对于对象所指向的string成员，每个对象都有一份自己的拷贝。编写拷贝构造函数，拷贝赋值函数

class HasPtr{
    public::
    HasPtr(HasPtr&b):ptr(new std::string(*b.ptr)),cur(b.cur){    }
    HasPtr &operator=(const HasPtr&a){delete ptr;ptr=new std::string(*a.ptr);cur=a.cur;}
    private::
    std::string*ptr;
    int cur;
    
}; 

练习13.23

理解上一题和本节代码之间的差异

：：上一题代码不够全面，没有设计析构函数，由于new的ptr不能默认删除，得在析构函数里delete，并且拷贝赋值函数应该用临时值拷贝，防止自赋值的未定义行为，类值的行为表明每一个对象都拥有自己独一份的拷贝

练习13.24

如果本节未定义析构函数，会发生什么？如果为定义构造函数，将会发生什么？

::未定义析构函数，动态内存将不会回收，未定义构造函数，析构函数的delete将引起错误，删除非动态内存

练习13.25

假定希望定义StrBlob的类值版本，而且希望继续使用shared_ptr，这样我们的StrBlob类就仍能使用指向vector的weak_ptr了。你修改后的类将需要一个拷贝构造函数和一个拷贝赋值运算符，但不需要析构函数。解释为什么需要拷贝构造和赋值运算符，和为什么不用析构

：：为了达到类值的效果，shared_ptr必须是值初始化的，而不是拷贝初始化，拥有独一份的值，赋值同理，shared_ptr指针可以自己管理内存，无需手动delete，默认析构即可

练习13.26

编写StrBlob类

class StrBlob{
        friend class StrBlobPtr;
    public:
        StrBlob(StrBlob&a):data(make_shared<vector<string>>(*a.data); )
        StrBlob &operator=(const StrBlob&a){auto d=a.data;data=d;return *this;        }
    
    
    private:
    std::shared_ptr<std::vector<std::string> > data; 
   
    void check(size_type i, const std::string &msg) const;
}; 

练习13.27

定义你自己的使用引用计数版本的HasPtr

class HasPtr{
    public:
    HasPtr(const string&s ):ptr(new string(s)),i(0),use(new size_t(1)){    }
    HasPtr(HasPtr&b):ptr(b.ptr),i(b.i),use(b.use){++*use;    }
    HasPtr &operator=(const HasPtr&a);
    ~HasPtr();
    private:
    std::string*ptr;
    int i;
    size_t*use;
    
}; 
HasPtr&
HasPtr::operator=(const HasPtr&a)
{
    ++*a.use;
    if(--use==0)
    {delete ptr;
    delete use;
    }
    ptr=a.ptr;
    use=a.use;
    i=a.i;
    return *this;
}
HasPtr::~HasPtr()
{
    if(--*use==0)
    {
        delete ptr;
        delete use;
    }
}

练习13.28

给定下面的类，为其实现一个默认构造函数和必要的拷贝控制成员

class TreeNode {
public:
    TreeNode():value(string()),count(1),left(new TreeNode),right(new TreeNode){    }
    TreeNode(const string&s):value(s),count(1),left(new TreeNode),right(new TreeNode){    }
    TreeNode (const TreeNode a):value(a.value),count(a.count),left(a.left),right(a.right){    }
    TreeNode &operator=(const TreeNode&a);
    ~TreeNode();
    
private:

std::string value；

int count;

TreeNode *left;

TreeNode *right;

}；
    TreeNode &TreeNode::operator=(const TreeNode&a)
{
    value(a.value);
    count(a.count);
    left(a.left);
    right(a.right);
    return *this;
}

class BinStrTree{
        friend class TreeNode;
    public:
        BinStrTree():root(new TreeNode){        }
        BinStrTree(const TreeNode&a):root(&a){        }            
        BinStrTree(const BinStrTree&a):root(a.root){++a->count;        }
        BinStrTree &operator=(const BinStrTree&a);
        ~BinStrTree();
        
        
    private:
        TreeNode*root;
        
};
BinStrTree&operator=(const BinStrTree&a)
{
    ++a->count;
    if(--*this.count==0)
    {
        delete root;
    }
    root=a;
}
BinStrTree::~BinStrTree()
{
    if(--*this.count==0)
    {
        delete root;
    }
}

练习13.29

解释（HasPtr&,HasPtr&）中对swap的调用不会导致递归循环

：：参数可以区别开标准库和类swap

练习13.30

为你的类值版本的HasPtr编写swap函数，并测试它。为你的swap函数添加打印语句，指出函数什么时候会执行

#include <string>
#include <iostream>
#include <algorithm>
using std::string;
class HasPtr{
    friend void swap(HasPtr&,HasPtr&);
    public:
    HasPtr(const string&s ):ptr(new string(s)),i(0),use(new size_t(1)){    }
    HasPtr(HasPtr&b):ptr(b.ptr),i(b.i),use(b.use){++*use;    }
    HasPtr &operator=(const HasPtr&a);
    ~HasPtr();
    string* called(){return ptr;}
    private:
    std::string*ptr;
    int i;
    size_t*use;
    
}; 
HasPtr&
HasPtr::operator=(const HasPtr&a)
{
    ++*a.use;
    if(--use==0)
    {delete ptr;
    delete use;
    }
    ptr=a.ptr;
    use=a.use;
    i=a.i;
    return *this;
}
HasPtr::~HasPtr()
{
    if(--*use==0)
    {
        delete ptr;
        delete use;
    }
}
inline void swap(HasPtr &a,HasPtr &b)
{
    using std::swap;
    swap(a.ptr,b.ptr);
    swap(a.i,b.i);
    std::cout<<"done"<<std::endl;
}
int main()
{

    HasPtr a("beauty"),b("day");
　　swap(a,b);

    std::cout<<*a.called()<<std::endl;
}

函数只在调用交换HasPtr类对象时执行，函数内部的仍是标准库

练习13.31

为你的HasPtr类定义一个<运算符，并定义一个HasPtr的vector，为这个vector添加一些元素，并对它执行sort。注意何时会调用swap。

#include <string>
#include <iostream>
#include <algorithm>
#include <vector>
using std::string;
class HasPtr{
    friend void swap(HasPtr&,HasPtr&);
    friend bool operator<(const HasPtr&a,const HasPtr &b);
    public:
    HasPtr(const string&s ):ptr(new string(s)),i(0),use(new size_t(1)){    }
    HasPtr(const HasPtr&b):ptr(b.ptr),i(b.i),use(b.use){++*use;    }
    HasPtr &operator=(const HasPtr&a);
    ~HasPtr();
    string* called(){return ptr;}
//    bool operator<(HasPtr &a);
    private:
    std::string*ptr;
    int i;
    size_t*use;
    
}; 
HasPtr&
HasPtr::operator=(const HasPtr&a)
{
    ++*a.use;
    if(--use==0)
    {delete ptr;
    delete use;
    }
    ptr=a.ptr;
    use=a.use;
    i=a.i;
    return *this;
}
bool operator<(const HasPtr&a,const HasPtr &b)
{
    std::cout<<"do<"<<std::endl;
    return *a.ptr<*b.ptr;
}
HasPtr::~HasPtr()
{
    if(--*use==0)
    {
        delete ptr;
        delete use;
    }
}
inline void swap(HasPtr &a,HasPtr &b)
{
    using std::swap;
    swap(a.ptr,b.ptr);
    swap(a.i,b.i);
    std::cout<<"done"<<std::endl;
}
int main()
{

    HasPtr a("beauty"),b("day"),c("oh");
    std::vector<HasPtr> line{a,b,c};
    std::sort(line.begin(),line.end());
    std::cout<<*line.begin()->called()<<std::endl;    
}

元素多的时候会用自己定义的swap

练习13.32

类指针的HasPtr版本会从swap函数收益吗？如果会，得到了什么益处，如果不会，为什么

：：不会收益，默认的swap就能交换指向，无需多此一举

练习13.33

为什么Message的成员save和remove的参数是一个Folder&?为什么我们不将参数定义为Folder或者const Folder&

：：为了包含该message对象的Folder能删除或添加该指针

练习13.34

编写本节所描述的Message

class Message{
    friend class Folder;
    public:
        Message(const string&s=" "):content(s){        }
        Message(const Message&a):content(a.content),folders(a.folders){add_to_Folders(a);    }
        Message& operator=(const Message &a){remove_from_Folders();content=a.content;folders=a.folders;
        add_to_Folders(a);return *this;
        }
    
        void save(Folder&f)
        {
            folders.insert(&f);
            f.addMsg(this);    
        }
        void remove(Folder&f)
        {
            folders.erase(&f);
            f.remMsg(this);
        }
    
    
    private:
    string content;
    set<Folder*> folders;
    
    void add_to_Folders(const Message &m)
    {
        for(auto d:m.folders)
        d->addMsg(this);
    }
    void remove_from_Folders()
    {
        for(auto d:folders)
        d->remMsg(this);
    }
};

练习13.35

如果Message使用合成的拷贝控制成员，将会发生什么？

：：Message的folders和Folder的Msg就没有意义了

练习13.36

设计并实现对应的Folder类。此类应该保存一个指向Folder中包含的Message的set

class Folder{
    friend class Message;
    public:
        void addMsg(Message*a){Msg.insert(a);}
        void remMsg(Message*a){Msg.erase(a);    }
    
        
    private:
        set<Message*> Msg;    
    
};

练习13.37

为Message添加成员，实现向folders添加删除

：：看13.34

练习13.38

我们并未使用拷贝并交换方式来设计Message的赋值运算符，你认为其原因是什么？

：：没有什么益处