std::shared_ptr<int> p(new int[8], [](int *ptr){delete []ptr;});

template<class T> class shared_ptr {
  public:
    using element_type = remove_extent_t<T>;
    using weak_type    = weak_ptr<T>;
 
    // 構(gòu)造函數(shù)
    constexpr shared_ptr() noexcept;
    constexpr shared_ptr(nullptr_t) noexcept : shared_ptr() { }
    template<class Y> explicit shared_ptr(Y* p);
    template<class Y, class D> shared_ptr(Y* p, D d);
    template<class Y, class D, class A> shared_ptr(Y* p, D d, A a);
    template<class D> shared_ptr(nullptr_t p, D d);
    template<class D, class A> shared_ptr(nullptr_t p, D d, A a);
    template<class Y>
    shared_ptr(const shared_ptr<Y>& r, element_type* p) noexcept;
    template<class Y>
    shared_ptr(shared_ptr<Y>&& r, element_type* p) noexcept;
    shared_ptr(const shared_ptr& r) noexcept;
    template<class Y> shared_ptr(const shared_ptr<Y>& r) noexcept;
    shared_ptr(shared_ptr&& r) noexcept;
    template<class Y> shared_ptr(shared_ptr<Y>&& r) noexcept;
    template<class Y> explicit shared_ptr(const weak_ptr<Y>& r);
    template<class Y, class D> shared_ptr(unique_ptr<Y, D>&& r);
 
    // 析構(gòu)函數(shù)
    ~shared_ptr();
 
    // 賦值
    shared_ptr& operator=(const shared_ptr& r) noexcept;
    template<class Y>
    shared_ptr& operator=(const shared_ptr<Y>& r) noexcept;
    shared_ptr& operator=(shared_ptr&& r) noexcept;
    template<class Y>
    shared_ptr& operator=(shared_ptr<Y>&& r) noexcept;
    template<class Y, class D>
    shared_ptr& operator=(unique_ptr<Y, D>&& r);
 
    // 修改函數(shù)
    void swap(shared_ptr& r) noexcept;
    void reset() noexcept;
    template<class Y> void reset(Y* p);
    template<class Y, class D> void reset(Y* p, D d);
    template<class Y, class D, class A> void reset(Y* p, D d, A a);
 
    // 探察函數(shù)
    element_type* get() const noexcept;
    T& operator*() const noexcept;
    T* operator->() const noexcept;
    element_type& operator[](ptrdiff_t i) const;
    long use_count() const noexcept;
    explicit operator bool() const noexcept;
    template<class U>
    bool owner_before(const shared_ptr<U>& b) const noexcept;
    template<class U>
    bool owner_before(const weak_ptr<U>& b) const noexcept;
  };

std::shared_ptr<int> pi;
int* p_reg = new int;
//pi = p_reg;  // not allowed(implicit conversion)
pi = std::shared_ptr<int>(p_reg);  // allowed(explicit conversion)
//std::shared_ptr<int> pshared = p_reg;  // not allowed(implicit conversion)
//std::shared_ptr<int> pshared(g_reg);  // allowed(explicit conversion)

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

int main()
{
    std::shared_ptr<int> sp = std::make_shared<int>(10);
    cout << sp.use_count() << endl;//1
    std::shared_ptr<int> sp1(sp);//再次被引用則計(jì)數(shù)+1
    cout << sp1.use_count() << endl;//2
}

#include <iostream>
#include <memory>

struct C {int* data;};

int main () {
 auto deleter = [](int* ptr){
    std::cout << "custom deleter called\n";
    delete ptr;
  };//Labmbda表達(dá)式

  //默認(rèn)構(gòu)造，沒(méi)有獲取任何指針的所有權(quán)，引用計(jì)數(shù)為0
  std::shared_ptr<int> sp1;
  std::shared_ptr<int> sp2 (nullptr);//同1
  //擁有指向int的指針?biāo)袡?quán)，引用計(jì)數(shù)為1
  std::shared_ptr<int> sp3 (new int);
  //同3，但是擁有自己的析構(gòu)方法，如果指針?biāo)赶驅(qū)ο鬄閺?fù)雜結(jié)構(gòu)C
  //結(jié)構(gòu)C里有指針，默認(rèn)析構(gòu)函數(shù)不會(huì)將結(jié)構(gòu)C里的指針data所指向的內(nèi)存釋放,
  //這時(shí)需要自己使用自己的析構(gòu)函數(shù)（刪除器）
  std::shared_ptr<int> sp4 (new int, deleter);
  //同4,但擁有自己的分配器（構(gòu)造函數(shù)），
  //如成員中有指針，可以為指針?lè)峙鋬?nèi)存，原理跟淺拷貝和深拷貝類似                         
  std::shared_ptr<int> sp5 (new int, [](int* p){delete p;}, std::allocator<int>());
  //如果p5引用計(jì)數(shù)不為0，則引用計(jì)數(shù)加1，否則同樣為0, p6為0
  std::shared_ptr<int> sp6 (sp5);
  //p6的所有權(quán)全部移交給p7，p6引用計(jì)數(shù)變?yōu)闉?
  std::shared_ptr<int> sp7 (std::move(sp6));
  //p8獲取所有權(quán)，引用計(jì)數(shù)設(shè)置為1
  std::shared_ptr<int> sp8 (std::unique_ptr<int>(new int));
  std::shared_ptr<C> obj (new C);
  //同6一樣，只不過(guò)擁有自己的刪除器與4一樣
  std::shared_ptr<int> sp9 (obj, obj->data);

  std::cout << "use_count:\n";
  std::cout << "p1: " << sp1.use_count() << '\n'; //0
  std::cout << "p2: " << sp2.use_count() << '\n'; //0
  std::cout << "p3: " << sp3.use_count() << '\n'; //1
  std::cout << "p4: " << sp4.use_count() << '\n'; //1
  std::cout << "p5: " << sp5.use_count() << '\n'; //2
  std::cout << "p6: " << sp6.use_count() << '\n'; //0
  std::cout << "p7: " << sp7.use_count() << '\n'; //2
  std::cout << "p8: " << sp8.use_count() << '\n'; //1
  std::cout << "p9: " << sp9.use_count() << '\n'; //2
  return 0;
}

#include <iostream>
#include <memory>

int main () {
  std::shared_ptr<int> foo;
  std::shared_ptr<int> bar (new int(10));
  //右邊是左值，拷貝賦值，引用計(jì)數(shù)加1
  foo = bar; 
  //右邊是右值，所以是移動(dòng)賦值
  bar = std::make_shared<int> (20); 
  //unique_ptr 不共享它的指針。它無(wú)法復(fù)制到其他 unique_ptr，
  //無(wú)法通過(guò)值傳遞到函數(shù)，也無(wú)法用于需要副本的任何標(biāo)準(zhǔn)模板庫(kù) (STL) 算法。只能移動(dòng)unique_ptr
  std::unique_ptr<int> unique (new int(30));
  // move from unique_ptr，引用計(jì)數(shù)轉(zhuǎn)移
  foo = std::move(unique); 

  std::cout << "*foo: " << *foo << '\n';
  std::cout << "*bar: " << *bar << '\n';

  return 0;
}

#include <iostream>
#include <memory>

int main () {

  std::shared_ptr<int> foo = std::make_shared<int> (10);
  // same as:
  std::shared_ptr<int> foo2 (new int(10));
  //創(chuàng)建內(nèi)存，并返回共享指針，只創(chuàng)建一次內(nèi)存
  auto bar = std::make_shared<int> (20);

  auto baz = std::make_shared<std::pair<int,int>> (30,40);

  std::cout << "*foo: " << *foo << '\n';
  std::cout << "*bar: " << *bar << '\n';
  std::cout << "*baz: " << baz->first << ' ' << baz->second << '\n';

  return 0;
}

std::shared_ptr<Test> sp(new Test);

auto sp = std::make_shared<Test>();

callTest(std::shared_ptr<Test>(new Test), secondFun());

new Test()
secondFun()
std::shared_ptr<Test>()

callTest(std::make_shared<Test>(), secondFun());           

#include <iostream>
#include <memory>
#include <thread>
#include <chrono>
#include <mutex>
 
struct Test
{
    Test() { std::cout << " Test::Test()\n"; }
    ~Test() { std::cout << " Test::~Test()\n"; }
};
 
//線程函數(shù)
void thr(std::shared_ptr<Test> p)
{
    //線程暫停1s
    std::this_thread::sleep_for(std::chrono::seconds(1));

    //賦值操作, shared_ptr引用計(jì)數(shù)use_cont加1(c++11中是原子操作)
    std::shared_ptr<Test> lp = p;
    {
        //static變量(單例模式),多線程同步用
        static std::mutex io_mutex;

        //std::lock_guard加鎖
        std::lock_guard<std::mutex> lk(io_mutex);
        std::cout << "local pointer in a thread:\n"
            << " lp.get() = " << lp.get()
            << ", lp.use_count() = " << lp.use_count() << '\n';
    }
}
 
int main()
{
    //使用make_shared一次分配好需要內(nèi)存
    std::shared_ptr<Test> p = std::make_shared<Test>();
    //std::shared_ptr<Test> p(new Test);

    std::cout << "Created a shared Test\n"
        << " p.get() = " << p.get()
        << ", p.use_count() = " << p.use_count() << '\n';

    //創(chuàng)建三個(gè)線程,t1,t2,t3
    //形參作為拷貝, 引用計(jì)數(shù)也會(huì)加1
    std::thread t1(thr, p), t2(thr, p), t3(thr, p);
    std::cout << "Shared ownership between 3 threads and released\n"
        << "ownership from main:\n"
        << " p.get() = " << p.get()
        << ", p.use_count() = " << p.use_count() << '\n';
    //等待結(jié)束
    t1.join(); t2.join(); t3.join();
    std::cout << "All threads completed, the last one deleted\n";

    return 0;
}

#include <iostream>
#include <memory>

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

    std::shared_ptr<Test> GetThis(){
        return std::shared_ptr<Test>(this);
    }
};

int main()
{
    std::shared_ptr<Test> p(new Test());
    std::shared_ptr<Test> p_this = p->GetThis();

    std::cout << p.use_count() << std::endl;
    std::cout << p_this.use_count() << std::endl;

    return 0;
}

#include <iostream>
#include <memory>

// 這里必須要 public繼承，除非用struct
class Test : public std::enable_shared_from_this<Test> {
public:
    Test(){
        std::cout << "Test::Test()" << std::endl;
    }
    ~Test(){
        std::cout << "Test::~Test()" << std::endl;
    }

    std::shared_ptr<Test> GetThis(){
        std::cout << "shared_from_this()" << std::endl;
        return shared_from_this();
    }
};

int main()
{
    std::shared_ptr<Test> p(new Test());
    std::shared_ptr<Test> p_this = p->GetThis();

    std::cout << p.use_count() << std::endl;
    std::cout << p_this.use_count() << std::endl;

    return 0;
}