Java面试官经常喜欢问关于垃圾回收的问题。而他最终给出的答案往往是：给对象中添加一个引用计数器，每当有一个地方引用它时，计算器值就加1；当引用失效时，计数器值就减1；任何时候计数器为0的对象就是不可能再被使用的。
客观的说，引用计数算法的实现简单，判定效率也很高，在大部分情况下它都是一个不错的算法。但是，至少主流的Java虚拟机里面没有选用引用计数算法来管理内存，其中最主要的原因是它很难解决对象之间的相互循环引用的问题。在主流的商用程序语言（Java、C#）的主流实现中通过可达性分析来判定对象存活的。
这里，我们不去谈可达性分析策略。至少，引用计数算法还是有一定的用武之地的。比如说，苹果为自家的ios开发编程语言objective-c引用了ARC机制来进行内存管理，在很大程度上消除了手动内存管理的负担。为了避免对象之间循环引用，我们可以将对象声明为弱引用。而在C++中，内存的分配和释放需要手动来管理，这在一定程度上带来了内存泄漏的隐患。幸运的是，C++标准库中提供了一种叫做智能指针(shared_ptrs)的类，智能指针的作用有如同指针，但会记录有多少个shared_ptrs共同指向一个对象。这便是所谓的引用计数。一旦最后一个这样的指针被销毁，也就是一旦某个对象的引用计数变为0，这个对象会被自动删除。
比如说，用智能指针来创建一个动态分配的字符串对象：
//新创建一个对象，引用计数器为1
shared_ptr<string> pstr(new string("abc"));
解引用一个智能指针返回它指向的对象。同样，我们可以像操作普通指针一样调用string提供的方法。
if (pstr && pstr->empty()) {
*pstr = "hello";
}
当有另外一个智能指针对当前智能指针进行拷贝时，引用计数器加1：
shared_ptr<string> pstr(new string("abc")); //pstr指向的对象只有一个引用者
shared_ptr<string> pstr2(pstr); //pstr跟pstr2指向相同的对象，此对象有两个引用者
当两个智能指针进行赋值操作时，左边的指针指向的对象引用计数减1，右边的加1。
shared_ptr<string> pstr(new string("abc"));
shared_ptr<string> pstr2(new string("hello"));
pstr2 = pstr; //给pstr2赋值，令他指向另一个地址，递增pstr指向的对象的引用计数，递减pstr2原来指向的对象引用计数
指针离开作用域范围时，同样引用计数减1。当引用计数为0时，对象被回收。
根据以上的分析，我们对它做一个简单的实现：
template <typename T>
class smart_ptrs {
public:
smart_ptrs(T*); //用普通指针初始化智能指针
smart_ptrs(smart_ptrs&);
T* operator->(); //自定义指针运算符
T& operator*(); //自定义解引用运算符
smart_ptrs& operator=(smart_ptrs&); //自定义赋值运算符
~smart_ptrs(); //自定义析构函数
private:
int *count; //引用计数
T *p; //智能指针底层保管的指针
};
跟标准库一样，我们使用模板来实现它。
用普通指针进行初始化时，需要将该指针进行封装，并且引用计数初始化为1。
template <typename T>
smart_ptrs<T>::smart_ptrs(T *p): count(new int(1)), p(p) {
}
定义拷贝构造函数：
template <typename T>
//对普通指针进行拷贝，同时引用计数器加1，因为需要对参数进行修改，所以没有将参数声明为const
smart_ptrs<T>::smart_ptrs(smart_ptrs &sp): count(&(++*sp.count)), p(sp.p) {
}
定义指针运算符：
template <typename T>
T* smart_ptrs<T>::operator->() {
return p;
}
定义解引用运算符，直接返回底层指针的引用：
template <typename T>
T& smart_ptrs<T>::operator*() {
return *p;
}
定义赋值运算符，左边的指针计数减1，右边指针计数加1，当左边指针计数为0时，释放内存：
template <typename T>
smart_ptrs<T>& smart_ptrs<T>::operator=(smart_ptrs& sp) {
++*sp.count;
if (--*count == 0) { //自我赋值同样能保持正确
delete count;
delete p;
}
this->p = sp.p;
this->count = sp.count;
return *this;
}
定义析构函数：
template <typename T>
smart_ptrs<T>::~smart_ptrs() {
if (--*count == 0) {
delete count;
delete p;
}
}
好了，大功告成！接下来，我们用这段代码进行测试：
smart_ptrs<string> pstr(new string("abc"));
smart_ptrs<string> pstr2(pstr);
smart_ptrs<string> pstr3(new string("bcd"));
pstr3 = pstr2;
为了让测试结果更明显，我在方法中加入了一些输出，测试结果如下：
