智能指针

智能指针是一个类，用来存储指向动态分配对象的指针，负责自动释放动态分配的对象，防止内存泄漏。动态分配的资源交给一个类对象去管理，当类对象声明周期结束时，自动调用析构函数释放资源。

shared_ptr

采用引用计数器的方法，允许多个智能指针指向同一个对象，每当多一个指针指向该对象时，指向该对象的所有智能指针内部的引用计数加1，每当减少一个智能指针指向对象时，引用计数减1，当计数为0时自动释放动态分配的资源。

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

using namespace std;

int main(int argc, char** argv)
{
    string str = "hello world";
    shared_ptr<string> p1(new string(str));

    shared_ptr<string> p2(p1);

    shared_ptr<string> p3 = p1;             //允许多个指针指向同一个对象

    cout << *p1 << endl;
    cout << *p2 << endl;
    cout << *p3 << endl;

    shared_ptr<string> ps1;

    //从普通指针构造智能指针
    string* str1 = new string("xian");

    //ps1 = str1;                       //隐式转换不可以

    ps1 = shared_ptr<string>(str1);     //显示转换可以

    //shared_ptr<string> ps2 = str1;    //隐式转换不可以

    //shared_ptr<string> ps3(str1);     //显式转换(出现程序崩溃，因为多个智能指针指向了同一块内存，会引起重复释放内存的问题),
    shared_ptr<string> ps3(ps1);        //多个智能指针指向同一块内存，但是使用智能指针是采用引用计数的原理，只有当引用计数为0时，才delete这块内存

    cout << *ps1 << endl;
    cout << *ps3 << endl;

    return 0;

}

auto_ptr

主要是为了解决“有异常抛出时发生内存泄漏”的问题。因为发生异常而无法正常释放内存。auto_ptr有拷贝语义，拷贝后源对象变得无效，程序崩溃，而unique_ptr没有拷贝语义，提供了移动语义（使用std::move）进行转移。所以unique_ptr比auto_ptr更安全。

#include <iostream>

using namespace std;

int main(int argc, char** argv)
{
    string* str1 = new string("hello ");
    auto_ptr<string> p1(str1);

    auto_ptr<string> p2(p1);                //自动将p1的所有权剥夺，导致p1无法访问，不够安全，建议使用unique_ptr

    //cout << *p1 << endl;

    cout << *p2 << endl;

    return 0;
}

unique_ptr

采用独享所有权定义，一个非空的unique_ptr总是拥有它所指向的资源，转移一个unique_ptr会把所有权全部从源指针转移给目标指针，源指针被置空；所以unique_ptr不支持普通的拷贝和赋值操作。

#include <iostream>

using namespace std;

int main(int argc, char** argv)
{
    string* str1 = new string("hello ");
    unique_ptr<string> p1(str1);

    //unique_ptr<string> p2 = p1;       //不允许这样做

    unique_ptr<string> p2 = move(p1);

    //cout << *p1 << endl;              //p1已经丧失了所有权
    cout << *p2 << endl;

    return 0;
}

weak_ptr

弱引用。引用计数有一个问题就是互相引用形成环（环形引用），这样两个指针指向的内存都无法释放。需要使用weak_ptr打破环形应用，是为了配合shared_ptr而引入的一种智能指针，它指向一个由shared_ptr管理的对象而不影响所指对象的生命周期，也就是说它只引用，不计数。

#include <iostream>

using namespace std;

class A;
class B;

class A
{
public:

    //shared_ptr<B> b_ptr;
    weak_ptr<B> b_ptr;                  //修改为若应用即可解决循环引用的问题
};

class B
{
public:

    //shared_ptr<A> a_ptr;
    weak_ptr<A> a_ptr;                  //修改为若应用即可解决循环引用的问题
};

int main(int argc, char** argv)
{

    string* str1 = new string("hell0");

    shared_ptr<string> p(str1);

    //weak_ptr<string> p1(str1);                //出错

    weak_ptr<string> p1(p);                     //可以指向已有的shared_ptr

    //cout << *p1 << endl;                      //不支持*操作
    cout << p1.use_count() << endl;             //查看与自己指向同一个对象的shared_ptr的引用计数，但是自己只引用不会增加或减少计数

    shared_ptr<string> p2 = p1.lock();
    cout << *p2 << endl;                        //借助lock函数返回一个和p1指向同一个对象的shared_ptr类型指针，获取其存储的数据。
    cout << p1.use_count() << endl;

    //**************循环引用******************
    shared_ptr<A> pa(new A);
    shared_ptr<B> pb(new B);

    pa->b_ptr = pb;
    pb->a_ptr = pa;

    //如果不是弱引用，两个的引用计数都为2，这个情况下最后的引用计数不为2，造成两个内存得不到释放，导致内存泄漏
    cout << "pa.use_count=" << pa.use_count() << endl;
    cout << "pb.use_count=" << pb.use_count() << endl;  

    return 0;
}