初识智能指针

C++11 引入了 3 种智能指针类型：

1. std::unique_ptr<T> ：独占资源所有权的指针。
2. std::shared_ptr<T> ：共享资源所有权的指针。
3. std::weak_ptr<T> ：共享资源的观察者，需要和 std::shared_ptr 一起使用，不影响资源的生命周期。

std::unique_ptr

简单说，当我们独占资源的所有权的时候，可以使用 std::unique_ptr 对资源进行管理——离开 unique_ptr 对象的作用域时，会自动释放资源。

注意事项

1.其为是唯一的

{
    std::unique_ptr<int> uptr = std::make_unique<int>(200);
    std::unique_ptr<int> uptr1 = uptr;  // 编译错误，std::unique_ptr<T> 是 move-only 的

    std::unique_ptr<int> uptr2 = std::move(uptr);
    assert(uptr == nullptr);
}

2. std::unique_ptr 可以指向一个数组。

{
    std::unique_ptr<int[]> uptr = std::make_unique<int[]>(10);
    for (int i = 0; i < 10; i++) {
        uptr[i] = i * i;
    }   
    for (int i = 0; i < 10; i++) {
        std::cout << uptr[i] << std::endl;
    }   
}

3.自定义 deleter

{
    struct FileCloser {
        void operator()(FILE* fp) const {
            if (fp != nullptr) {
                fclose(fp);
            }
        }   
    };  
    std::unique_ptr<FILE, FileCloser> uptr(fopen("test_file.txt", "w"));
}

4使用 Lambda 的 deleter。

{
    std::unique_ptr<FILE, std::function<void(FILE*)>> uptr(
        fopen("test_file.txt", "w"), [](FILE* fp) {
            fclose(fp);
        });
}

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

class Person
{
public:
    Person()
    {

    }

    Person(string name)
    {
        m_name = name;
    }

    Person(int age)
    {
        m_age = age;
    }

    ~Person()
    {
        cout << "destruct Person" << endl;
    }

private:
    int m_age;
    string m_name;
};

void manageClass()
{
    shared_ptr<Person> ptr1 = make_shared<Person>();
    {
        shared_ptr<Person> ptr2 = make_shared<Person>("xiaohua");
    }
    shared_ptr<Person> ptr3 = make_shared<Person>(29);
    
    cout << "---------------" << endl;

    //智能指针管理对象数组
    shared_ptr<Person> ptr4(new Person[5], [](Person *p){
        //释放内存
        delete []p; 
    });
    getchar();
}

int main()
{
    //1 使用构造函数的方式初始化
    shared_ptr<int> ptr(new int(10));
    
    //使用智能指针操作内存
    int *p = ptr.get();
    cout << "value:" << *p << endl;
    cout << "value:" << *ptr << endl;

    *p = 999;
    cout << "value:" << *p << endl;    
    cout << "value:" << *ptr << endl; 

    //第二种方法: 使用make_shared
    shared_ptr<int> ptr1 = make_shared<int>(99);
    p = ptr1.get();
    cout << "ptr1:" << *p << endl; 
    cout << "ptr1:" << *ptr1 << endl;

    //直接赋值
    {
        shared_ptr<int> ptr2 = ptr1;
        cout << "ptr2:" << *ptr2 << endl;
        cout << "use_count:" << ptr2.use_count() << endl;
    }
    cout << "use_count:" << ptr1.use_count() << endl;  

    //智能指针重置操作
    shared_ptr<int> ptr3(new int(111));
    shared_ptr<int> ptr4 = ptr3;
    cout << "ptr3引用计数" << ptr3.use_count() << endl;
    cout << "ptr4引用计数" << ptr4.use_count() << endl;

    //将ptr4进行reset重置
    ptr4.reset(new int(980));
    cout << "ptr3引用计数" << ptr3.use_count() << endl;
    cout << "ptr4引用计数" << ptr4.use_count() << endl;      
    cout << "ptr4:value" << *ptr4 << endl;


    //智能指针操作指向类对象
    manageClass();

    getchar();

    return 0;
}

std::shared_ptr 其实就是对资源做引用计数——当引用计数为 0 的时候，自动释放资源。