Smart Pointer 智能指针

P76

参考：http://www.cnblogs.com/lanxuezaipiao/p/4132096.html

　　http://blog.csdn.net/hackbuteer1/article/details/7561235

简介

智能指针是存储指向动态分类（堆）对象的指针的类，用于生存期控制，确保在离开指针作用域时，自动正确销毁动态分配的对象。

通过引用计数的技术来实现，每使用它一次，内部的引用计数就加1，每析构一次，引用计数减1，减到0时就销毁对象，回收内存。

头文件 #include <memory>

分类

三种智能指针：

• std::shared_ptr　　实现共享式拥有，多个指针可以指向相同的对象，该对象和相关资源会在最后一个reference被销毁时释放
• std::unique_ptr　　实现独占式拥有，保证同一时间内只有一个指针可以指向该对象
• std::weak_ptr　　  持有被shared_ptr所管理对象的引用，但是不会改变引用计数值。允许共享但不拥有某对象

另一方面，auto_ptr已经被废弃，C98，之前和std::unique_ptr一个意思

使用

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

class report
{
private:
    std::string str;
public:
 report(const std::string s) : str(s) {
  std::cout << "Object created.
";
 }
 ~report() {
  std::cout << "Object deleted.
";
 }
 void comment() const {
  std::cout << str << "
";
 }
};

int main() {
 {
  std::auto_ptr<report> ps(new report("using auto ptr"));
  ps->comment();
 }

 {
  std::shared_ptr<report> ps(new report("using shared ptr"));
  ps->comment();
 }

 {
  std::unique_ptr<report> ps(new report("using unique ptr"));
  ps->comment();
 }
 return 0;
}

注意：智能指针的初始化必须使用复制初始化而不能采用赋值初始化，因为智能指针类的构造函数是explicit，只能够显示的调用构造函数

str_ptr<string> p1 = new string("hello")    //error，赋值初始化隐式调用构造函数

str_ptr<string> p2(new string("world"))    //OK

unique_ptr注意拥有权必须用move

    unique_ptr<string> p2(new string("hello"));
    unique_ptr<string> p3;
    p3 = std::move(p2);

p2失去拥有权不能在被调用了

unique_ptr比auto_ptr的好处在于如果p3 = p2，unique_ptr在编译时就能发现错误，auto_ptr要在运行时才能发现错误

shared_ptr实现

参考：http://www.jianshu.com/p/0300b2d833af

分析：

成员，一个模板指针T *p，一个引用计数的int *count；

成员函数：

构造函数：接受T *参数初始化成员p，初始化count为1，注意count需要new，p就不用了，p是在使用过程中new的

复制构造函数：注意形参不要用const类型，是引用类型的smart_point类，让count等于形参.count++，让p等于形参.p

析构函数：首先先对*count自减，不是0就算了，是0的话delete   p和count

然后写重载几个运算符*，->和=

*是返回T&类型，返回*p

->返回T*类型也就是指针，返回的是p

=首先将*count加一，然后为了防止自己=自己要判断count自减后是不是0，最后用对count和p进行赋值操作

#include <string>
#include <iostream>
using namespace std;

template <typename T>
class smart_ptrs {

public:
    smart_ptrs(T*); //用普通指针初始化智能指针
    smart_ptrs(smart_ptrs&);

    T* operator->(); //自定义指针运算符
    T& operator*(); //自定义解引用运算符
    smart_ptrs& operator=(smart_ptrs&); //自定义赋值运算符

    ~smart_ptrs(); //自定义析构函数

private:
    int *count; //引用计数
    T *p; //智能指针底层保管的指针
};

template <typename T>
smart_ptrs<T>::smart_ptrs(T *p) : count(new int(1)), p(p) {
    cout << "创建对象" << *p << "，引用计数:" << *count << endl;
}

template <typename T>
//对普通指针进行拷贝，同时引用计数器加1，因为需要对参数进行修改，所以没有将参数声明为const
smart_ptrs<T>::smart_ptrs(smart_ptrs &sp) : count(&(++*sp.count)), p(sp.p)  {
    cout << "调用复制构造函数，拷贝：" << *sp.p << "，引用计数:" << *count << endl;
}

template <typename T>
T* smart_ptrs<T>::operator->() {
    return p;
}

template <typename T>
T& smart_ptrs<T>::operator*() {
    return *p;
}

template <typename T>
smart_ptrs<T>& smart_ptrs<T>::operator=(smart_ptrs& sp) {
    ++*sp.count;
    if (--*count == 0) { //自我赋值同样能保持正确
        delete count;
        delete p;
    }
    this->p = sp.p;
    this->count = sp.count;
    cout << "赋值操作，" << *this->p << "引用计数变为" << *this->count << endl;
    return *this;
}

template <typename T>
smart_ptrs<T>::~smart_ptrs() {
    if (--*count == 0) {
        delete count;
        delete p;
    }
}

int main()
{
    smart_ptrs<string> pstr(new string("abc"));
    smart_ptrs<string> pstr2(pstr);
    smart_ptrs<string> pstr3(new string("bcd"));
    pstr3 = pstr2;

    system("pause");
}