/*
* shared_ptr
*/
shared_ptr 是一种智能指针（smart pointer），作用有如同指针，但会记录有多少个 shared_ptrs 共同指向一个对象。
这便是所谓的引用计数（reference counting）。
一旦最后一个这样的指针被销毁，也就是一旦某个对象的引用计数变为0，这个对象会被自动删除。
这在非环形数据结构中防止资源泄露很有帮助。
类似 vector 智能指针也是模板。
shared_ptr<string> p1; // shared_ptr，可以指向string
shared_ptr<list<int>> p2; // shared_ptr,可以指向int的list
智能指针的使用方法和普通指针类似，解引用返回它指向的对象，如果在一个条件判断中使用智能指针，效果就是检测它是否为空，
// 如果 p1 不为空，检查它是否指向一个空 string
if (p1 && p1->empty()) // p->mem -- (*p).mem
*p1 = "ds"
/*
* share_ptr 的拷贝和赋值
*/
当进行拷贝或赋值操作时，每个 shared_ptr 都会记录有多少个其他 shared_ptr 指向相同的对象：
auto p = make_shared<int>(42); // p指向的对象只有p一个引用者
auto q(p); // p和q指向相同对象，此对象有两个引用者
可以认为每个shared_ptr都有一个关联的计数器，通常称其为引用计数(reference count)。
无论何时拷贝一个shared_ptr，计数器都会递增；
当给shared_ptr赋予一个新值或是shared_ptr被销毁时，计算器就会递减。
一旦一个shared_ptr的计数器变为0，它就会自动释放自己所管理的对象：
auto r = make_shared<int>(42); // r指向的int只有一个引用者
r = q; // 给r赋值，令它指向另一个地址
// 递增q指向的对象的引用计数
// 递减r原来指向对象的引用计数
// r原来指向的对象已没有引用者，会自动释放
/*
* share_ptr 自动销毁所管理的对象
*/
当指向一个对象最后一个 share_ptr 被销毁时，share_ptr 类会自动销毁此对象。
它是通过另一个特殊的成员函数------析构函数完成销毁工作的。
/*
* shared_ptr 和 new 结合使用
*/
可以使用 new 返回的指针来初始化智能指针，智能指针是一个类，分装了一个原始的 C++ 指针，用以管理所指对象的生命期。
shared_ptr<double> p1; // shared_ptr可以指向一个double
shared_ptr<int> p2(new int (42)); // p2指向一个值为42的int
接受指针参数的智能指针构造函数是 explicit 的。
因此，我们不能将一个内置指针隐式转换为一个智能指针，必须使用直接初始化形式来初始化一个智能指针：
shared_ptr<int> p1 = new int(1024); //错误：必须使用直接初始化形式
shared_ptr<int> p2(new int (1024)); //正确：使用了直接初始化
出于相同的原因，一个返回shared_ptr的函数不能在其返回语句中隐式转换一个普通指针：
shared_ptr<int> clone(int p) {
return new int(p); //错误：隐式转换为shared_ptr<int>
}
shared_ptr<int> clone(int p) {
return shared_ptr<int>(new int(p)); //正确：显式地用int*创建shared_ptr<int>
}
默认情况下，一个用来初始化智能指针的普通指针必须指向动态内存，因为智能指针默认使用delete释放它所关联的对象。
可以将智能指针绑定到一个指向其他类型的资源的指针上，但是为了这样做，必须提供操作来代替 delete 。
/*
* weak_ptr
*/
weak_ptr是为配合shared_ptr而引入的一种智能指针。
weak_ptr可以从一个shared_ptr或另一个weak_ptr对象构造，
它的构造和析构不会引起shared_ptr引用记数的增加或减少（但会导致引用计数区域内负责weak_ptr计数变量_M_weak_count的增加或减少，
当其计数为0时，调用_M_destroy()释放对象内存）。没有重载*和->但可以使用lock获得一个可用的shared_ptr对象。
weak_ptr的一个重要用途是通过lock获得this指针的shared_ptr,使对象自己能够生产shared_ptr来管理自己，
但助手类enable_shared_from_this的shared_from_this会返回this的shared_ptr，只需要让想被shared_ptr管理的类从它继承即可。
/*
* example
*/
#include <iostream>
#include <memory>
#include <thread>
#include <chrono>
#include <mutex>
struct Base
{
Base() { std::cout << " Base::Base()\n"; }
// 注意：此处非虚析构函数 OK
~Base() { std::cout << " Base::~Base()\n"; }
};
struct Derived: public Base
{
Derived() { std::cout << " Derived::Derived()\n"; }
~Derived() { std::cout << " Derived::~Derived()\n"; }
};
void thr(std::shared_ptr<Base> p)
{
std::this_thread::sleep_for(std::chrono::seconds(1));
std::shared_ptr<Base> lp = p; // 线程安全，虽然自增共享的 use_count
{
static std::mutex io_mutex;
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()
{
std::shared_ptr<Base> p = std::make_shared<Derived>();
std::cout << "Created a shared Derived (as a pointer to Base)\n"
<< " p.get() = " << p.get()
<< ", p.use_count() = " << p.use_count() << '\n';
std::thread t1(thr, p), t2(thr, p), t3(thr, p);
p.reset(); // 从 main 释放所有权
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';
t1.join(); t2.join(); t3.join();
std::cout << "All threads completed, the last one deleted Derived\n";
}
#if 0
Base::Base()
Derived::Derived()
Created a shared Derived (as a pointer to Base)
p.get() = 0x56072b522260, p.use_count() = 1
Shared ownership between 3 threads and released
ownership from main:
p.get() = 0, p.use_count() = 0
local pointer in a thread:
lp.get() = 0x56072b522260, lp.use_count() = 6
local pointer in a thread:
lp.get() = 0x56072b522260, lp.use_count() = 4
local pointer in a thread:
lp.get() = 0x56072b522260, lp.use_count() = 2
Derived::~Derived()
Base::~Base()
All threads completed, the last one deleted Derived
#endif