#include <iostream>
#include <vector>
#include <memory>
#include <assert.h>
using namespace std;
class A {
public:
    void do_something();
};
// 智能指针有一个通用的规则，就是`->`表示用于调用指针原有的方法，而`.`则表示调用智能指针本身的方法.
// 对于unique_ptr有下面几种本身方法
// get 获取智能指针保存的原生指针
// bool 判断该智能指针是否拥有指针
// release 释放所管理指针的所有权，返回原生指针，但是不销毁原生指针
// reset 释放并销毁原生指针。如果参数为一个新指针，将管理这个新指针
int main() {
    std::unique_ptr<A> a(new A());
    A* origin_a = a.get();
    if (a) {
        printf("a仍然拥有指针");
    }
    std::unique_ptr<A> a2(a.release()); // 转移拥有权
    a2.reset(new A());  // 释放并销毁原有对象，持有一个新对象
    a2.reset(); // 释放并销毁原有对象，等同于 a2 == nullptr
    assert(a2 == nullptr);
    return 0;
}

// 对于shared_ptr有下面几种本身方法
// get 获取智能指针保存的原生指针
// bool 判断该智能指针是否拥有指针
// reset 释放并销毁原生指针。如果参数为一个新指针，将管理这个新指针
// unique 如果引用计数为1返回true，否则返回false
// use_count 返回引用计数大小

// 智能指针有一个通用的规则，就是`->`表示用于调用指针原有的方法，而`.`则表示调用智能指针本身的方法.
// expired 判断所指向的原生指针是否被释放，如果释放了返回true，否则返回false
// use_count 返回原生指针的引用计数
// lock 返回shared_ptr;如果原生指针没有被释放，则返回一个非空的shared_ptr,否则返回一个空的shared_ptr
// reset 将本身置空
int main() {
    std::shared_ptr<A> a(new A());
    std::weak_ptr<A> weak_a = a;    // 不增加引用计数

}

class A {
private:
    std::weak_ptr<B> b_;
    std::weak_ptr<C> c_;
public:
    void do_something();
    void set_b_c(const std::shared_ptr<B>& b, const std::shared_ptr<C>& c) {
        b_ = b;
        c_ = c;
    }
};

#include <iostream>
#include <vector>
#include <memory>
using namespace std;
class A;

class D {
private:
    std::shared_ptr<A> a_;
public:
    D(std::shared_ptr<A>& a): a_(a) {}
};


class A : public std::enable_shared_from_this<A>{
public:
    void new_D()
    {
        // 错误方式，用this指针重新构造shared_ptr，将导致二次释放当前对象,重新创建的shared_ptr与当前对象的shared_ptr没有关系，没有增加当前对象的引用计数
        // 关于这个问题，可以详细地看一下这篇博客：https://www.cnblogs.com/jo3yzhu/p/11358400.html
//        std::shared_ptr<A> this_shared_ptr1(this);
//        std::unique_ptr<D> d1(new D(this_shared_ptr1));
        // 正确方式 对象继承了enable_shared_from_this后，可以通过shared_from_this()获取当前对象的shared_ptr指针。
        std::shared_ptr<A> this_shared_ptr2 = shared_from_this();
        std::unique_ptr<D> d2(new D(this_shared_ptr2));
    }
};

int main() {
    std::shared_ptr<A> a(new A());
    a->new_D();
}

void function() {
    int tmp = 0;
    std::unique_ptr<int> a(tmp);
}

class A {
public:
    void function() {
        // 错误方式
        std::shared_ptr<A> this_shared_ptr(this);
    }
};
std::shared_ptr<A> e = std::make_shared<E>();