cpp智能指针

作者: 码农练功房 | 来源:发表于2021-11-29 14:31 被阅读0次

Rust for cpp devs - 智能指针
cpp智能指针
cpp一些常见问题
Cpp：指针
cpp指针操作
智能指针小例子
目录
c经典多级指针练习,写一个简单的集合
智能指针到Android引用计数
LeetCode—— 移动零

搜了下智能指针的博客，发现很乱，c++ Primer上也一大堆废话，有时看的不知所云。

最后在博客园上找到一个总结还算不错的，可以快速了解下基础用法和场景。

里面有些代码有点问题，修正后贴出，方便后续快速查阅。

智能指针都是值语义（通常作为类的数据成员或者在stack上或者是标准容器库里面的元素），几乎不会有如下用法：
shared_ptr<Foo>* pFoo = new shared_ptr<Foo>(new Foo);
如果智能指针是对象x的数据成员，而他的模板参数T是个incomplete类型，那么x的析构函数不能是默认的或者内联的，必须在cpp文件里面显式定义，否则会出现编译错误或者运行错误。

shared_ptr:

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

C++ 11 创建和使用 shared_ptr - 滴水瓦 - 博客园 (cnblogs.com)

shared_ptr的 reset用法 - tycoon3 - 博客园 (cnblogs.com)

为了使用enable_shared_from_this(),对象不能是stack object，必须是heap object，并且由shared_ptr来管理其生命周期。

enable_shared_from_this(),不能在构造函数中调用,因为在构造的时候，对象还没有被shared_ptr接管;
enable_shared_from_this参考文献

shared_ptr的unique为真可以认为是use_count == 1

shared_ptr<Data> p = make_shared<Data>();
p.reset();
cout << p.unique() << endl;  // 打印0

shared_ptr的reset方法，将引用计数器减一，如果减到0时，对象被析构，否则对象仍然存在。

unique_ptr:

unique_ptr独占使用的对象。

C++ 11 创建和使用 unique_ptr - 滴水瓦 - 博客园 (cnblogs.com)

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

struct Foo
{
    Foo()
    {
        std::cout << "Foo::Foo\n";
    }
    ~Foo()
    {
        std::cout << "Foo::~Foo\n";
    }
    void bar()
    {
        std::cout << a<< "Foo::bar\n";
    }
private:
    int a;
};

void f(const Foo &)
{
    std::cout << "f(const Foo&)\n";
}

struct D
{
    void operator()(Foo* foo)
    {
        std::cout << "D operator()" << std::endl;
        delete foo;
    }
};


void TestAutoDestroy()
{
    //1. 普通的new对象.
    std::cout << "TestDestroy...................." << std::endl;
    {
        std::unique_ptr<Foo> p1(new Foo);
    }
    //2. 普通的new[]对象.
    {
        std::unique_ptr<Foo[]> p2(new Foo[4]);
    }
    //3. 自定义的deleter.
    {
        std::unique_ptr<Foo, D> p3(new Foo);
    }
}

void TestOwner()
{
    std::cout << "TestOwner...................." << std::endl;
    //1. new object.
    std::unique_ptr<Foo> p1(new Foo);  // p1 owns Foo
    if (p1) p1->bar();

    {
        std::unique_ptr<Foo> p2(std::move(p1));  // now p2 owns Foo
        f(*p2);

        p1 = std::move(p2);  // ownership returns to p1
        if (p2)
        {
            p2->bar();
        }
        else
        {
            cout << "ownership returns to p1" << endl;
        }
        std::cout << "destroying p2...\n";
    }

    p1->bar();
}

void TestArrayOwner()
{
    std::cout << "TestArrayOwner...................." << std::endl;
    //1. new[] object.
    std::unique_ptr<Foo[]> p1(new Foo[4]);  // p1 owns Foo
    if (p1) p1[0].bar();

    {
        std::unique_ptr<Foo[]> p2(std::move(p1));  // now p2 owns Foo
        f(p2[0]);

        p1 = std::move(p2);  // ownership returns to p1
        if (p2)
        {
            p2[0].bar();
        }
        else
        {
            cout << "ownership returns to p1" << endl;
        }
        std::cout << "destroying p2...\n";
    }
    p1[0].bar();
}

int main()
{
    TestAutoDestroy();
    TestOwner();
    TestArrayOwner();
    system("pause");
    return 0;
}