C++ shared_ptr

   
 shared_ptr是一个最像指针的“智能指针”,是boost.smart_ptr库中最有价值、最重要的组成部分,也是最有用的。

少奋斗奋斗

                                            晕晕乎乎,其他的再补充

void f(shared_ptr<int>, int);
int g();

void ok()
{
    shared_ptr<int> p( new int(2) );
    f( p, g() );
}

void bad()
{
    f( shared_ptr<int>( new int(2) ), g() );
}

   
 shared_ptr实现的是引用计数的智能指针,可以被自由拷贝和赋值,在任意的地方共享它,当没有代码使用(引用计数为0)它时才删除被包装的动态分配的对象。shared_ptr也可以安全地放到标准容器中。

shared_ptr g(newFoo);// 线程之间共享的 shared_ptr

shared_ptr x;// 线程 A 的局部变量

shared_ptr n(newFoo);// 线程 B 的局部变量

1、shared_ptr 主要是为了方便管理内存而存在的,C++程序中不会再出现new 和
delete,内存的分配和析构全部由shared_ptr进行管理

shared_ptr

示例1:

2、当程序中对某个对象进行复制或者引用的时候,shared_ptr会有一个引用计数这个东西,每当使用一次就+1,用完之后-1,直到减为0的时候再将申请的内存(资源)释放掉

#include <iostream>
#include <memory>
#include <thread>
#include <chrono>
#include <mutex>
using std::cout;
using std::endl;
struct Base
{
    Base() {
        cout << "Base::Base()\n";
    }
    ~Base() {
        cout << "Base::~Base()\n";
    }
};


struct Derived :public Base {
    Derived() {
        cout << "Derived::Derived()" << endl;
    }
    ~Derived() {
        cout << "Dervive::~Derived()" << endl;
    }

};

void thr(std::shared_ptr<Base> p) {
    std::this_thread::sleep_for(std::chrono::seconds(1));
    std::shared_ptr<Base> lp = p;
    {
        static std::mutex io_mutex;
        std::lock_guard<std::mutex> lk(io_mutex);
        std::cout << "local pointer in a thread:\n"
            << "lp.get()" << lp.get()
            << ",lp.use_count()" << lp.use_count() << "\n";
    }

}
int main() {
    std::shared_ptr<Base> p = std::make_shared<Derived>();
    std::cout << "Created a shared Derived (as a pointer to Base)\n"
        << "p.get" << p.get()
        << ",p.use_count()= " << p.use_count() << "\n";
    std::thread t1(thr, p), t2(thr, p), t3(thr, p);
    p.reset(); // release ownership from main
    std::cout << "shared ownership between 3 threads and released\n"
        << "ownership from main:\n"
        << "p.get()" << p.get()
        << ",p.use_count()" << p.use_count() << "\n";
    t1.join(); t2.join(); t3.join();
    std::cout << "All threads completed,the lase one deleted Derived\n";
    system("pause");
    return 0;
}

#include <boost/smart_ptr.hpp>
#include <iostream>
#include <cassert>
using namespace boost;
using namespace std;
int main()
{
shared_ptr<int> sp(new int(10));    
 //一个指向整数的shared_ptr
assert(sp.unique());                
//现在shared_ptr是指针的唯一持有者
shared_ptr<int> sp2 = sp;            
//第二个shared_ptr,拷贝构造函数
assert(sp == sp2 && sp.use_count() == 2);
*sp2 = 100;                 //使用解引用操作符修改被指对象
assert(*sp == 100);
sp.reset();                 //停止shared_ptr的引用
assert(!sp);                //sp不再持有任何指针(空指针)
return 0;
}
示例2:

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

using namespace boost;
using namespace std;

class shared             //一个拥有shared_ptr的类
{
private:
shared_ptr<int> p;
public:
shared(shared_ptr<int> p_) : p(p_) { }  
//构造函数初始化shared_ptr
void print()          //输出shared_ptr的引用计数和指向的值
{
cout << “count: ” << p.use_count()
<< ” v = ” << *p << endl;
}
};

void print_func(shared_ptr<int> p)
{
//同样输出shared_ptr的引用计数和指向的值
cout << “count: ” << p.use_count()
<< ” v = ” << *p << endl;
}

int main()
{
shared_ptr<int> p(new int(110));
shared s1(p), s2(p);       //构造两个自定义的类

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

*p = 20;           //修改shared_ptr所指的值
print_func(p);

s1.print();

return 0;
}
在声明了shared_ptr和两个shared实例后,指针被它们所共享,因此引用计数为3.printf_func函数内部拷贝了一个shared_ptr对象,因此引用计数再增加1,但当退出函数时拷贝自动析构,引用计数又恢复3。

程序运行结果如下:

 count:3 v = 110

count:3 v = 110

count:4 v = 20

count:3 v = 20

发表评论

电子邮件地址不会被公开。 必填项已用*标注