C++智能指针之shared_ptr（保姆级教学）

最新推荐文章于 2025-04-22 09:15:00 发布

竹烟淮雨（408考研ing）

最新推荐文章于 2025-04-22 09:15:00 发布

阅读量770

点赞数 1

分类专栏： C/C++内存管理精讲文章标签： c++ 嵌入式内存管理智能指针 share_ptr

本文链接：https://blog.youkuaiyun.com/qq_25218501/article/details/132660875

版权

C/C++内存管理精讲专栏收录该内容

8 篇文章

订阅专栏

std::make_shared函数（C++14提出）

C++智能指针之shared_ptr

共享式指针：多个指针可以同时指向同一个对象（共享所有权，协同工作），当最后一个指针被销毁或者指向其他对象时，这个对象会被释放；

本文涉及所有程序

00_code.cpp

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

class A
{
public:
    A()
    {
        cout << "A" << endl;
    }
    ~A()
    {
        cout << "~A" << endl;
    }
};

void test(shared_ptr<A> pb)
{
    cout << "test func" << endl;
}

shared_ptr<A>test1()
{
    shared_ptr<A>temp(new A());
    return temp;
}

int main(int argc, char const* argv[])
{
    // int *p = new int(5);//裸指针

    // shared_ptr是类模板
    // shared_ptr<int> p = new int(5);//调用类型转换构造函数初始化 explicit不支持
    shared_ptr<int> p(new int(5));

    cout << *p << endl;

    // string *s = new string("hello world");
    shared_ptr<string> s(new string("hello world"));
    cout << *s << endl;

    // int num = 10;
    // shared_ptr<int>p2(&num);//报错：智能指针指向栈空间时，会导致释放两次空间或者对象

    shared_ptr<A> pa(new A()); //程序运行结束后会自动调用A的析构函数

    shared_ptr<A>result = test1();

    test(pa);

    shared_ptr<A> pa2(pa); // pa2,p同时指向同一个对象或者空间
    return 0;
}

01_code.cpp

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

int main(int argc, char const *argv[])
{
    shared_ptr<int> pi = make_shared<int>(5);

    cout << *pi << endl;

    shared_ptr<string> ps = make_shared<string>("hello world");
    cout << *ps << endl;

    //手动初始化和使用make_shared函数模板初始化有什么区别
    /**
    *推荐使用make_shared进行初始化；开销小，效率高（数据和引用计数存在同一段空间）
    *构造函数初始化：数据和引用计数不在同一段空间中，需要间接访问
    */
    return 0;
}

02_code.cpp

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

class A
{
public:
    A()
    {
        cout << "A" << endl;
    }

    A(int num):m_num(num)
    {
        cout <<"A int"<<endl;
    }

    A(const A&& other):m_num(other.m_num)
    {
        cout <<"A move int"<<endl;
    }

    ~A()
    {
        cout << "~A" << endl;
    }

public:
    int m_num;
};

void test(int *ptr)
{

}

void mydelete(A *pa)
{
    cout <<"call my delete" <<endl;
    delete []pa;
}
int main(int argc, char const *argv[])
{
#if 0
    //shared_ptr<A> pa = make_shared<A>(5); //隐式类型转换
    //cout<< pa->m_num<<endl;

    shared_ptr<A> pb = make_shared<A>(); 
    //cout<< pb->m_num<<endl;
    shared_ptr<A>pc(pb);
    cout << pb.use_count()<<endl;

    if(pb.unique())
    {
        cout << "pb is unique ptr" << endl;
    }

    // pb.reset();
    // if(pb == nullptr)
    // {
    //     cout << "pb is nullptr" << endl;  
    // }
    //shared_ptr<A>pd(new A(1));
    //pb.reset(pd);//reset不支持传入共享指针
    pb.reset(new A(6));
    cout <<  pb.use_count() <<endl;

    shared_ptr<int>pi(new int(19));
    test(pi.get());//void test(int *ptr);
    
#endif
    //指定删除器
    //shared_ptr<A>ptr(new A[3],mydelete);

    //shared_ptr<A[]>ptr(new A[3]);
    // shared_ptr<A>ptr(new A[3],[](A *a)
    // {
    //     delete []a;
    // });

    //shared_ptr<A>ptr(new A[3],default_delete<A[]>());

    shared_ptr<A>ptr(new A(6));
    shared_ptr<A>&&rptr = std::move(ptr);

    cout <<  ptr.use_count() <<endl;
    cout <<  rptr.use_count() <<endl;
    return 0;
}

03_code.cpp

#include <iostream>
using namespace std;

template <typename T>
class shared_ptr
{
public:
    shared_ptr(const shared_ptr<T> &other)
    {
        this->ptr = other.ptr;
        strong_ref++;
    }

    shared_ptr(const T *t)
    {
        this->ptr = t;
        strong_ref++;
    }

    T *get()
    {
        return ptr;
    }

    ~shared_ptr()
    {
        strong_ref--;
        if (strong_ref == 0)
        {
            delete ptr;
        }
    }

private:
    T *ptr;
    static int strong_ref;
};

template <typename T>
int shared_ptr<T>::strong_ref = 0;

int main(int argc, char const *argv[])
{

    return 0;
}