#include <boost/smart_ptr.hpp>  
#include <iostream>   

using namespace std;
using namespace boost;


int main()
{
    //shared_ptr 引用计数型的智能指针
    //自由，允许拷贝 赋值，共享
    //可放置在容器中，stl容器中存储指针的最标准解法
    //类似scoped_ptr,重载了* ->  bool判断有效性，get()得到原始指针，没有指针算数操作
    //不可管理new[]产生的动态数组指针，unique_ptr《》  可以

    boost::shared_ptr<int> spi(new int);
    assert(spi); //此时值为内存随机的数；
    cout << "is unique ? " << spi.unique() << endl; //此时为1
    cout << "*spi   (0)" << *spi << endl;
    cout << "value of use_count " << spi.use_count() << endl;
    *spi = 10;
    cout << "is unique() ? " << spi.unique() << endl;
    cout << "*spi   (1)" << *spi << endl;
    cout << "value of use_count " << spi.use_count() << endl;
    //此时引用计数为1，当为0时，就会自动删除；

    boost::shared_ptr<int>   sp2(spi);
    assert(spi == sp2);  //支持比较操作
    cout << "value of use_count " << sp2.use_count() << endl;
    cout << "is unique ? " << spi.unique() << endl; // 此时为0

    sp2.reset();
    cout << "spi" << spi.use_count() << endl;
    cout << "sp2" << sp2.use_count() << endl;
    //sp2 为0，spi 为1
    //reset的作用：将引用计数减为0，停止对指针的共享
    cout << "___" << endl;

    boost::shared_ptr<int>  sp3(spi);
    cout << "sp3" << sp3.use_count() << endl;
    cout << "spi" << spi.use_count() << endl; //此时use_count（） 都是2
    //spi 0； sp3 1;
    spi.reset();

    cout << "sp3" << sp3.use_count() << endl;
    cout << "spi" << spi.use_count() << endl;
    system("pause");
    return 0;
}

结果：

is unique ? 1
*spi   (0)-842150451
value of use_count 1
is unique() ? 1
*spi   (1)10
value of use_count 1
value of use_count 2
is unique ? 0
spi1
sp20
___
sp32
spi2
sp31
spi0

一个简单例子：

#include <boost/smart_ptr.hpp>  
#include <iostream>   

using namespace std;
using namespace boost;

class shared
{
private:
    boost::shared_ptr<int> p;
public:
    shared(boost::shared_ptr<int> p_) :p(p_) 
    {
        //cout << "construct  use_count: " << p.use_count() << endl;
    }
    void print()
    {
        cout << "count : " << p.use_count() << "v:=" << *p << endl;
    }

};

void print_func(boost::shared_ptr<int> p) //参数是指针拷贝的方式传参，
{
    cout << "count : " << p.use_count() << "v:=" << *p << endl;
}
int main()
{
    boost::shared_ptr<int> p(new int(10));

    shared s1(p), s2(p);

    s1.print();
    s2.print();

    print_func(p);
    *p = 20;
    print_func(p);
    s1.print();
    system("pause");

    return 0;
}

结果

#include <boost/smart_ptr.hpp>  
#include <iostream>   

using namespace std;
using namespace boost;

class shared
{
private:
    boost::shared_ptr<int> p;
public:
    shared(boost::shared_ptr<int> p_) :p(p_) 
    {
        //cout << "construct  use_count: " << p.use_count() << endl;
    }
    void print()
    {
        cout << "count : " << p.use_count() << "v:=" << *p << endl;
    }

};

void print_func(boost::shared_ptr<int> p) //参数是指针拷贝的方式传参，
{
    cout << "count : " << p.use_count() << "v:=" << *p << endl;
}
int main()
{
    boost::shared_ptr<int> p(new int(10));

    shared s1(p), s2(p);

    s1.print();
    s2.print();

    print_func(p);
    *p = 20;
    print_func(p);
    s1.print();
    system("pause");

    return 0;
}

结果为：

count : 3v:=10
count : 3v:=10
count : 4v:=10
count : 4v:=20
count : 3v:=20

工厂函数make_share<> () ,来避免使用new；

#include <boost/smart_ptr.hpp>  
#include <vector>
#include <iostream>   

using namespace std;
using namespace boost;


int main()
{
    auto sp = boost::make_shared<string>("Leeman");
    auto spv = boost::make_shared<vector<int>>(10, 2);
    assert(spv->size() == 10);
    cout << spv->at(0) << endl;

    system("pause");

    return 0;
}

#include <boost/smart_ptr.hpp>  
#include <vector>
#include <iostream>   

using namespace std;
using namespace boost;


int main()
{
    //shared_ptr 应用于标准容器有两种方式
    //1.将容器作为shared_ptr管理的对象，如shared_ptr<vector<int>>
    //2.将shared_ptr作为容器的元素，scoped_ptr 就不行，没法拷贝和赋值
    typedef vector<boost::shared_ptr<int>>  vs;
    vs v(10);
    int i = 0;
    for (auto pos = v.begin(); pos < v.end(); pos++)
    {
        (*pos) = boost::make_shared<int>(++i);
        cout << **pos << ", ";
    }
    cout << endl;
    boost::shared_ptr<int> p = v[9];
    cout << *v[9] << endl;
    cout << *v[0] << endl;  system("pause");

    return 0;
}

结果为：
指针指向的都是一个对象i，并且不断++，为何最终列表 还是可以生成1 - 10；地址变成10个了？？？

1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
10
1

#include <boost/smart_ptr.hpp>  
#include <vector>
#include <iostream>   

using namespace std;
using namespace boost;


int main()
{
    int *p = new int[100];
    shared_array<int> sa(p);

    assert(sa.unique());

    shared_array<int> sb(sa);
    assert(sb.use_count() == 2);

    sa[0] = 10;
    assert(sb[0] == 10);
    system("pause");
    return 0;
}