C++标准库笔记 -- 智能指针之shared_ptr

智能指针的行为类似于常规指针，重要的区别是它负责自动释放所指向的对象。

1、shared_ptr允许多个指针指向同一个对象

2、unique_ptr则独占所指向的对象

3、weak_ptr，他是一种弱引用，指向shared_ptr所管理的对象

这三种类型都定义在memory头文件中

 

shared_ptr初始化

#include 
#include 
using namespace std;
int main()
{
    shared_ptr p1;
    if(!p1)
        cout<<"p1==NULL"< p2(new string);
    if(p2&&p2->empty())
     {
        *p2="helloworld";
        cout<<*p2< pa = new string("normal usage!");//！错误:不允许以暴露裸漏的指针进行赋值操作。　　
    shared_ptr pa(new string("normal usage!"));
    cout<<*pa< pint1 = make_shared("safe uage!");
    cout<<*pint1<

get()函数

get函数返回一个内置指针，指向智能指针的管理的对象。

1、此函数设置的初衷是当我们向不能使用智能指针的代码传递一个内置指针。使用get返回指针的代码不能delete此指针。

2、get用来将指针的访问权限传递给代码，只有在确定代码不会delete指针的情况下，才能使用get。特别是，永远不要用get初始化另一个智能指针或者为另一个智能指针赋值

#include 
#include 
using namespace std;

void useShared_ptr(int *p)
{
    cout<<*p< p1 = make_shared(32);
//    shared_ptrp2(p1.get());  //!错误的用法：但是p1、p2各自保留了对一段内存的引用计数，其中有一个引用计数耗尽，资源也就释放了。
    useShared_ptr(p1.get());
//    delePointer(p1.get());        //!error:
}

shared_ptr的拷贝和赋值

　　当进行拷贝或者赋值操作时，每个shared_ptr都会记录有多少个其他的shared_ptr指向相同的对象：

#include 
#include 
using namespace std;

int main()
{
    auto p = make_shared(42); //!p指向的对象只有p一个引用者。
    cout<

shared_ptr作返回值：

#include 
#include 
using namespace std;

shared_ptr factory(const char* p){
    return make_shared(p);
}

void use_factory()
{
    shared_ptr p = factory("helloworld");
    cout<<*p< return_share_ptr()
{
    shared_ptr p = factory("helloworld");
    cout<<*p<

引用计数

#include 
#include 
using namespace std;

int main()
{
    auto p = make_shared(42); //指向的对象只有p一个引用者。
    cout<(56);//指向的对象只有q一个引用者。
    cout<

 

于一块内存，shared_ptr类保证只要有任何shared_ptr对象引用它，他就不会被释放掉，要释放掉用erease

#include 
#include 
#include 

using namespace std;
int main()
{
    list>pstrList;
    pstrList.push_back(make_shared("1111"));
    pstrList.push_back(make_shared("2222"));
    pstrList.push_back(make_shared("3333"));
    pstrList.push_back(make_shared("4444"));

    for(auto p:pstrList)
    {
        if(*p == "3333");
        {
            /*do some thing!*/
        }
        cout<<*p<>::iterator itr = pstrList.begin();
    for(;itr!=pstrList.end();++itr)
    {
        if(**itr == "3333")
        {
            cout<<**itr<

状态共享

多个对象共享相同的状态，而非多个对象独立的拷贝

#include 
#include 
#include 

using namespace std;

void copyCase()
{
    list v1({"1","b","d"});
    list v2 = v1;        //v1==v2占用两段内存

    v1.push_back("cc");            // v1!=v2

    for(auto &p:v1)
    {
        cout<> v1 = make_shared>(2,"bb");
    shared_ptr> v2 = v1;

    (*v1).push_back("c2c");
    for(auto &p:*v1)
    {
        cout<

 

智能指针与异常

异常发生后，常规的动态内存常常不能正确释放。但是如果使用智能指针，即程序过早结束，智能指针也能确保在内存不需要时将其释放

 

自定义删除器

自行定义智能指针删除时的操作

#include 
#include 

using namespace std;

class DelTest
{
public:
    DelTest()
    {
        j= 0;
        cout<<"构建删除器"<<":"< p(new DelTest[10]);
}

void slefDefine()
{
    cout<<"slefDefine start running!"< p(new DelTest[10],[](DelTest *p)
    {
        delete[] p;
    });
}//传入lambada表达式代替delete操作。

int main()
{
    noDefine();//构造10次，析构1次。内存泄漏
    cout<<"---------------------"<