在管理动态分配的内存时，一个最棘手的问题就是决定何时释放这些内存，而智能指针就是用来简化内存管理的编程方式。智能指针一般有独占和共享两种所有权模型。
------------------------------------------------------------------------------------------------------------
20.1 holder和trule
本节将介绍两种智能指针类型：holder类型独占一个对象；而trule可以使对象的拥有者从一个holder传递给另一个holder。
20.1.1 安全处理异常
正常情况下，程序只有一个入口一个出口，异常的出现使程序多了其他出口，导致程序可能会提前终止，对异常的不当使用会导致许多问题，特别是内存泄漏问题。即便我们可以通过异常处理机制来解决这种问题，但我们会发现异常执行路径会影响程序正常的执行路径了，并且对象的释放操作不得不在两个不同的地方执行：一个在正常执行路径，一个在异常执行路径。
对于动态分配的内存，只要遵循“谁申请谁释放”的原则，一般都不会导致内存泄漏，但异常的出现令这种内存管理变得更加复杂，智能指针旨在解决这个问题。
同时，通常都应该避免使用会抛出异常的析构函数，因为当一个异常被抛出的时候，析构函数都是被自动调用的；而此时如果再抛出另一个异常，那么将会导致程序立即中止。
智能指针的优点在于：我们可以很方便的管理动态分配的内存（不再需要在析构函数中释放对象），同时，也避免了抛出异常而导致的资源泄漏。
20.1.2 holder
智能指针会在下面两种情况下释放所指向的对象：本身被释放，或者把另一个指针赋值给它。下面我们模拟实现一个智能指针：
// pointers/holder.hpp
template<typename T>
class Holder
{
private:
T* ptr; // 引用它所持有的对象（前提是该对象存在）
public:
// 缺省构造函数：让该holder引用一个空对象
Holder() : ptr(0) { }
// 针对指针的构造函数：让该holder引用该指针所指向的对象
// 这里使用explicit，禁止隐式转型(也即禁止了使用赋值语法来初始化Holder对象，如“holderObj = originObj”形式的赋值语法)
// 但依然可以通过对象构造的形式来给对象初始化，如"Holder holderObj(originObj)"，这里是显式转型。
explicit Holder (T* p) : ptr(p) {}
// 析构函数：释放所引用的对象（前提是该对象存在）
~Holder() {
delete ptr;
}
// 针对新指针的赋值运算符
Holder<T>& operator= (T* p){
delete ptr;
ptr = p;
return *this;
}
// 指针运算符
T& operator* () const {
return *ptr;
}
T* operator-> () const {
return ptr;
}
// 获取所引用的对象（前提是该对象存在）
T* get() const {
return ptr;
}
// 释放对所引用对象的所有权
void release() {
ptr = 0;
}
// 与另一个holder交换所有权
void exchange_with(Holder<T>& h) {
swap(ptr, h.ptr);
}
// 与其他的指针交换所有权
void exchange_twith(T*& p) { // 参数是什么语法？传入指针p的引用？
swap(ptr, p);
}
private:
// 不想外提供拷贝构造函数和拷贝赋值运算符
// 不允许一个Holder对象A赋值给另一个Holder对象B.
Holder(Holder<T> const&);
Holder<T>& operator= (Holder<T> const&);
};
从语义上讲，该holder独占ptr所引用对象的所有权。而且，这个对象一定要用new操作来创建，因为在销毁holder所拥有对象的时候，需要用到delete。接下来，release()成员函数释放holder对其持有对象的所有权。另外，上面的普通赋值运算符也设计得比较巧妙，它会销毁和释放任何被拥有的对象，因为另一个对象会替代原先的对象被holder所拥有，而且赋值运算符也不会返回原先对象的一个holder或指针（而是返回新对象的一个holder）。最后，我们添加了两个exchange_with()成员函数，从而可以在不销毁原有对象的前提下，方便地替换该holder所拥有的对象。
所以，我们可以如下使用上面的Holder创建两个对象：
void do_two_things()
{
Holder<Something> first(new Something);
firsh->perform();
Holder<Something> second(new Something);
second->perform();
}
20.1.3 作为成员的holder
我们也可以在类中使用holder来避免资源泄漏。要注意的是，只有那些完成构造之后的对象，它的析构函数才会被调用。因此，如果在构造函数内部产生异常，那么只有那些构造函数已正常执行完毕的成员对象，它的析构函数才会被调用。
// pointers/refmem2.hpp
#include "holder.hpp"
class RefMembers
{
private:
Holder<MemType> ptr1; // 所引用的成员
Holder<MemType> ptr2;
public:
// 缺省构造函数
// - 不可能出现资源泄漏
RefMembers() : ptr1(new MemType), ptr2(new MemType) { }
// 拷贝构造函数
// - 不可能出现资源泄漏
RefMembers (RefMembers const& x) : ptr1(new MemType(*x.ptr1)), ptr2(new MemType(*x.ptr2)) { }
// 赋值运算符
const RefMembers& operator= (RefMembers const& x){
*ptr1 = *x.ptr1;
*ptr2 = *x.ptr2;
return *this;
}
// 不需要析构函数
// （缺省的析构函数将会让ptr1和ptr2删除它们所引用的对象）
...
};
要注意的是，我们在这里可以省略用户定义的析构函数，但一定要编写拷贝构造函数和赋值运算符
20.1.4 资源获取于初始化
Holder所用到的基本思想是一种称为“资源获取去初始化”或RAII的模式（RAII在博文xxxxx有相关讲解，可供参考）。
20.1.5 hodler局限
包括 20.1.6 和 20.1.7两小节，介绍了holder在参数传递，返回返回值处理时的不足之处，以及复制holder、跨函数调用来复制holder所会产生的问题（这部分内容在博文xxxx中有相关讲解，可供参考）。并引出下一节trule的内容。
20.1.8 trule
为了解决上一小节留下的问题，我们引进了一个专门用于传递holder的辅助类模板，并把它称为trule。在语言中，它是一个术语，来自于transfer capsule的缩写。下面是其定义：
// pointers/trule.hpp
#ifndef TRULE_HPP
#define TRULE_HPP
template <typename T>
class Holder;
template <typename T>
class Trule
{
private:
T* ptr; // trule所引用的对象（如果有的话）
public:
// 构造函数，确保trule只能作为返回类型，用于将holder从被调用函数传递给调用函数
// 显式构造函数（会自动屏蔽默认无参构造函数），只能通过Holder构造Trule对象
Trule (Holder<T>& h){
ptr = h.get();
h.release();
}
// 拷贝构造函数
// 这里，trule通常是作为那些想传递holders的函数的返回类型，也就是 说trule对象总是作为临时对象（rvalues，右值）出现；因此它们的类型也就只能是 常引用（reference-to-const）类型。
Trule (Trule<T> const& t){
ptr = t.ptr;
// 由于Trule不能作为一份拷贝，也不能含有一份拷贝，如果我们希望实现类似于拷贝操作， 就必须移除原trule的所有权。我们是通过将被封装指针置为空来实现这种移除操作的。而最后 这个置空操作显然只能针对non-const对象，所以才有了这种把const强制转型为non-const的做法。
// 另外，由于原来的对象实际上并没有被定义为常类型，所以即使这样做有些别扭，但在这种情况下这种转型却能合法地实现。
// 因此，对于最后需要把一个holder转换为trule，并且将其返回的函数，如果要声明这类函数的 返回类型，我们就必须把它声明为trule<T>类型，而绝对不能声明为trule<T> const， 这点需特别注意。如下面例子中的函数load_something()
const_cast<Trule<T>&>(t).ptr = 0; // 置空操作
}
// 析构函数
~Trule() {
delete ptr;
}
private:
// 对于trule的用法，除了作为传递holder对象的返回类型，我们要防止把它用于其他地方。 于是，一个接收non-const引用对象的拷贝构造函数和一个类似的拷贝赋值运算符，都被声 明为私用函数，防止外界直接调用。通过禁止将trule作为左值的方法，因为左值允许取 址和赋值操作，这种特性容易导致其用于其他地方而没有报错。
Trule(Trule<T>&);
Trule<T>& operator= (Trule<T>&); // 禁止拷贝赋值
friend class Holder<T>;
};
#endif // TRULE_HPP
还有一点需要注意的是，上面的代码并不完全是把一个holder完全转换为一个trule：如果是这样的话，holder就必须是一个可修改的左值。这也是我们为什么要使用一个单独的类型来实现trule，而不是将它的功能合并到holder类模板中的原因。
最后，对于上面实现的trule，只有被holder模板所辨识并且使用之后，才能算是完整的。如下：
// pointers/holder2.hpp
template <typename T>
class Holder
{
// 前面已经定义的成员
...
public:
Holder(Trule<T> const& t){
ptr = t.ptr;
const_cast<Trule<T>&>(t).ptr = 0;
}
Holder<T>& operator= (Trule<T> const& t) {
delete ptr;
ptr = t.ptr;
const_cast<Trule<T>&>(t).ptr = 0;
return *this;
}
};
为了充分演示对holder/trule作了哪些改善，我们可以重写load_something()例子，如下：
// pointers/truletest.cpp
#include "holder2.hpp"
#include "trule.hpp"
class Something
{
};
void read_something(Something* x)
{
}
// 返回类型为Trule<Something>，通过将Holder<Something>转换成返回类型(也即，通过trule传递返回值)
Trule<Something> load_something()
{
Holder<Something> result(new Something);
read_something(result.get());
return result;
}
int main()
{
// 接收load_something函数返回的Trule<Something>类型的值，并通过Holder内部接收Trule对象的构造函数初始化Holder对象ptr
Holder<Something> ptr(load_something());
....
}
20.2 引用计数
设计一个引用计数的智能指针，基本思想是：对于每个被指向的对象，都保存一个计数，用于代表指向该对象的指针的个数，当计数值减少到0时，就删除此对象。
我们首先面对的问题是：计算器在什么地方？这里可以有两种方式，一种是把计算器放在对象中，但如果对象早期已经设计好，则无法再把计算器放入对象；另一种也是通常会使用的就是使用专用的（内存）分配器。
我们面对的第二个问题是：对象的析构和释放。我们有可能会需要使用非标准方式（比如C的free()，或者delete[]运算符释放对象数组）来释放对象，故而，我们还需要指定一种单独的对象（释放）policy。
对于大多数用CountingPtr计数的对象，我们可以使用下面这个简单的对象policy：
// pointers/stdobjpolicy.hpp
class StandardObjectPolicy
{
public:
template<typename T> void dispose(T* object){
delete object;
}
};
// pointers/stdarraypolicy.hpp
class StandardArrayPolicy
{
public:
template<typename T> void dispose(T* array){
delete[] array;
}
};
在考虑了上面两个问题之后，我们现在开始定义我们的CountingPtr模板：
// pointers/countingptr.hpp
template <typename T,
typename CounterPolicy = SimpleReferenceCount, // 计算器的policy
typename ObjectPolicy = StandardObjectPolicy> // 对象（释放）policy
class CountingPrt : private CounterPolicy, private ObjectPolicy
{
private:
// typedef 两个简单的别名
typedef CountPolicy CP;
typedef ObjectPolicy OP;
T* object_pointer_to; // 所引用的对象
// 如果没有引用任何对象，则为NULL
public:
// 缺省构造函数（没有显式初始化，即没有加上explicit关键字）
CountingPtr(){
this->object_pointed_to = NULL;
}
// 一个针对转型的构造函数（转型自一个内建的指针）
explicit CountingPtr(T* p) {
this->init(p); // 使用普通指针初始化
}
// 拷贝构造函数
CountingPtr(CountingPtr<T, CP, OP> const& cp)
: CP((CP const&)cp), // 拷贝policy
OP((OP const&)cp){
this->attach(cp); // 拷贝指针，并增加计数值
}
// 析构函数
~CountingPtr(){
this->detach(); // 减少计数值，如果计数值为0，则释放该计数器
}
// 针对内建指针的赋值运算符
CountingPtr<T, CP, OP>& operator= (T* p){
// 计数指针不能指向*p
assert(p != this->object_pointed_to);
this->detach(); // 减少计数值，如果计数值为0，则释放该计数器
this->init(p); // 用一个普通指针进行初始化
return *this;
}
// 拷贝赋值运算符（要考虑自己给自己赋值）
CountingPtr<T, CP, OP>&
operator= (CountingPtr<T, CP, OP> const& cp){
if(this->object_pointed_to != cp.object_pointed_to){
this->detach(); // 减少计数值，如果计数值为0，则释放该计数器
CP::operator=((CP const&)cp); // 对policy进行赋值
OP::operator=((OP const&)op);
this->attach(cp); // 拷贝指针并增加计数值
}
return *this；
}
// 使之成为智能指针的运算符
T* operator->() const {
return this->object_pointed_to;
}
T& operator* () const {
return *this->object_pointed_to;
}
// 以后在这里将可能会增加一些其他的接口
....
private:
// 辅助函数
// - 用普通指针进行初始化（前提是普通指针存在）
void init(T* p){
if (p != NULL)
{
CounterPolicy::init(p);
}
this->object_pointed_to = p;
}
// - 拷贝指针并且增加计数值（前提是指针存在）
void attach(CountingPtr<T, CP, OP> const& cp){
this->object_pointed_to = cp.object_pointed_to;
if (cp.object_pointed_to != NULL)
{
CounterPolicy::increment(cp.object_pointed_to);
}
}
// - 减少计数值（如果计数值为0， 则释放计数器）
void detach(){
if (this->object_pointed_to != NULL)
{
CounterPolicy::decrement(this->object_pointed_to);
if (CounterPolicy::is_zero(this->object_pointed_to))
{
// 如果有必要的话，释放计数器
CounterPolicy::dispose(this->object_pointed_to);
// 使用object policy来释放所指向的对象
ObjectPolicy::dispose(this->object_pointed_to);
}
}
}
};
上面代码需要注意：
（1）在拷贝赋值操作中，要判断是否为自赋值；
（2）由于空指针并没有一个可关联的计数器，所以在减少计数值之前，必须先显式地检查空指针的情况；
（3）在前面的代码中，我们使用继承来包含两种policy。这样做确保了在policy类为空的情况下，并不需要占用存储空间（前提是我们的编译器实现了空基类优化）；
20.2.5 一个简单的非侵入式计数器
从总体看来，我们已经完成了CountingPtr的设计，下面我们需要为计数policy编写代码。
于是，我们先来看一个针对计数器的policy，它并不把计数器存储于所指向对象的内部，也就是说，它是一种非侵入式的计数器policy（或者称为非插入式的计数器policy）。对于计数器而言，最主要的问题是如何分配存储空间。事实上，同一个计数器需要被多个CountingPtr所共享；因此，它的生命周期必须持续到最后一个智能指针被释放之后。通常而言，我们会使用一种特殊的分配器来完成这种任务，这种分配器专门用于分配大小固定的小对象。
// pointers/simplerefcount.hpp
#include <stddef.h> // 用于size_t的定义
#include "allocator.hpp"
class SimpleReferenceCount
{
private:
size_t* counter; // 已经分配的计数器
public:
SimpleReferenceCount(){
counter = NULL;
}
// 缺省的拷贝构造函数和拷贝赋值运算符都是允许的
// 因为它们只是拷贝这个共享的计数器
public:
// 分配计数器，并把它的值初始为1
template <typename T> void init(T*) {
Counter = alloc_counter();
*counter = 1;
}
// 释放该计数器
template <typename T> void dispose(T*) {
dealloc_counter(counter);
}
// 计数值加1
template<typename T> void increment(T*){
++*counter;
}
// 计数值减1
template<typename T> void decrement(T*){
--*counter;
}
// 检查计数值是否为0
template<typename T> bool is_zero(T*){
return *counter == 0;
}
};
20.2.6 一个简单的侵入式计数器模板
侵入式（或插入式）计数器policy就是将计数器放到被管理对象本身的类型中（或者可能存放到由被管理对象所控制的存储空间中）。显然，这种policy通常需要在设计对象类型的时候就加以考虑；因此这种方案很可能会专用于被管理对象的类型。
// pointers/memberrefcount.hpp
template<typename ObjectT, // 包含计数器的类型
typename CountT, // 计数器的类型
CountT Object::*CountP> // 计数器的位置，需要在设计ObjectT对象的时候就考虑到计数器
class MemberReferenceCount
{
public:
// 缺省构造函数和析构函数都是允许的
// 让计数器的值初始化为1
void init(ObjectT* object){
object->*CountP = 1;
}
// 对于计数器的释放，并不需要显式执行任何操作
void dispose(ObjectT*){ }
// 计数器加1
void increment(ObjectT* object){
++object->*CountP;
}
// 计数器减1
void increment(ObjectT* object){
--object->*CountP;
}
// 检查计数值是否为0
template<typename T> bool is_zero(ObjectT* object){
return object->*CounP == 0;
}
};
如果使用这种policy的话，那么在类的实现中，就可以很快地写出类的引用计数指针类型。其中类的设计框架大概如下：
class ManagedType
{
private:
size_t ref_count;
public:
typedef CountingPtr<ManagedType,
MemberReferenceCount
<ManagedType, // 包含计数器的对象类型
size_t, // 计数器类型
&ManagedType::ref_count> >
Ptr;
....
};
有了上面这个定义之后，我们就可以使用ManageeType::Ptr,方面地引用“那些用于访问ManagedType对象的”引用计数指针类型（在此为智能指针类型CountingPtr）。
书中还介绍了关于智能指针的其他一些功能实现，包括常数性相关内容、隐式转型，以及比较等等，有兴趣自行查阅学习，这里不介绍。