【转】C++实用技巧（三）
今天是关于内存的最后一篇了。上一篇文章讲了为什么不能对一个东西随便memset。里面的demo代码出了点小bug，不过我不喜欢在发文章的时候里面的demo代码也拿去编译和运行，所以大家有什么发现的问题就评论吧。这样也便于后来的人不会受到误导。这次说的仍然是构造函数和析构函数的事情，不过我们将通过亲手开发一个智能指针的方法，知道引用计数如何帮助管理资源，以及错误使用引用计数的情况。
首先先来看一下智能指针是如何帮助我们管理内存的。现在智能指针的实现非常多，我就假设这个类型叫Ptr<T>吧。这跟Vczh Library++ 3.0所使用的实现一样。
2 {
3 public:
4 virtual ~Base(){}
5 };
6
7 class Derived1 : public Base
8 {
9 };
10
11 class Derived2 : public Base
12 {
13 };
14
15 //---------------------------------------
16
17 List<Ptr<Base>> objects;
18 objects.Add(new Derived1);
19 objects.Add(new Derived2);
20
21 List<Ptr<Base>> objects2;
22 objects2.Add(objects[0]);
当然这里的List也是Vczh Library++3.0实现的，不过这玩意儿跟vector也好跟C#的List也好都是一个概念，因此也就不需要多加解释了。我们可以看到智能指针的一个好处，只要没有循环引用出现，你无论怎么复制它，最终总是可以被析构掉的。另一个例子告诉我们智能指针如何处理类型转换：
2 Ptr<Base> b=d1;
3 Ptr<Derived2> d2=b.Cast<Derived2>();
4 // d2是空，因为b指向的是Derived1而不是Derived2。
这就如同我们Derived1*可以隐式转换到Base*，而当你使用dynamic_cast<Derived2*>(static_cast<Base*>(new Derived1))会得到0一样。智能指针在帮助我们析构对象的同时，也要做好类型转换的工作。
好了，现在先让我们一步一步做出那个Ptr<T>。我们需要清楚这个智能指针所要实现的功能是什么，然后我们一个一个来做。首先让我们列出一张表：
1、没有参数构造的时候，初始化为空
2、使用指针构造的时候，拥有那个指针，并且在没有任何智能指针指向那个指针的时候删除掉该指针。
3、智能指针进行复制的时候，两个智能指针共同拥有该内部指针。
4、智能指针可以使用新的智能指针或裸指针重新赋值。
5、需要支持隐式指针类型转换，static_cast不支持而dynamic_cast支持的转换则使用Cast<T2>()成员函数来解决。
6、如果一个裸指针直接用来创建两个智能指针的话，期望的情况是当两个智能指针析构掉的时候，该指针会被delete两次从而崩溃。
7、不处理循环引用。
最后两点实际上是错误使用智能指针的最常见的两种情况。我们从1到5一个一个实现。首先是1。智能指针可以隐式转换成bool，可以通过operator->()拿到内部的T*。在没有使用参数构造的时候，需要转换成false，以及拿到0：
2 class Ptr
3 {
4 private:
5 T* pointer;
6 int* counter;
7
8 void Increase()
9 {
10 if(counter)++*counter;
11 }
12
13 void Decrease()
14 {
15 if(counter && --*counter==0)
16 {
17 delete counter;
18 delete pointer;
19 counter=0;
20 pointer=0;
21 }
22 }
23
24 public:
25 Ptr():pointer(0),counter(0)
26 {
27 }
28
29 ~Ptr()
30 {
31 Decrease();
32 }
33
34 operator bool()const
35 {
36 return counter!=0;
37 }
38
39 T* operator->()const
40 {
41 return pointer;
42 }
43 };
在这里我们实现了构造函数和析构函数。构造函数把内部指针和引用计数的指针都初始化为空，而析构函数则进行引用计数的减一操作。另外两个操作符重载很容易理解。我们主要来看看Increase函数和Decrease函数都分别做了什么。Increase函数在引用计数存在的情况下，把引用计数加一。而Decrease函数在引用计数存在的情况下，把引用计数减一，如果引用计数在减一过程中变成了0，则删掉拥有的资源。
当然到了这个时候智能指针还不能用，我们必须替他加上复制构造函数，operator=操作符重载以及使用指针赋值的情况。首先让我们来看使用指针赋值的话我们应该加上什么：
2 {
3 *this=p;
4 }
5
6 Ptr<T>& operator=(T* p)
7 {
8 Decrease();
9 if(p)
10 {
11 pointer=p;
12 counter=new int(1);
13 }
14 else
15 {
16 pointer=0;
17 counter=0;
18 }
19 return *this;
20 }
这里还是偷工减料了的，构造函数接受了指针的话，还是转给operator=去调用了。当一个智能指针被一个新指针赋值的时候，我们首先要减掉一个引用计数，因为原来的指针再也不被这个智能指针共享了。之后就进行判断，如果来的是0，那么就变成空。如果不是0，就拥有该指针，引用计数初始化成1。于是我们就可以这么使用了：
2 Ptr<Derived2> d2=new Derived2;
让我们开始复制他们吧。复制的要领是，先把之前拥有的指针脱离掉，然后连接到一个新的智能指针上面去。我们知道非空智能指针有多少个，总的引用计数的和就是多少，只是分配到各个指针上面的数字不一样而已：
2 {
3 Increase();
4 }
5
6 Ptr<T>& operator=(const Ptr<T>& p)
7 {
8 if(this!=&p)
9 {
10 Decrease();
11 pointer=p.pointer;
12 counter=p.counter;
13 Increase();
14 }
15 return *this;
16 }
在上一篇文章有朋友指出重载operator=的时候需要考虑是不是自己赋值给自己，其实这是很正确的。我们写每一类的时候，特别是当类拥有自己控制的资源的时候，需要非常注意这件事情。当然如果只是复制几个对象而不会new啊delete还是close什么handle，那检查不检查也无所谓了。在这里我们非常清楚，当增加一个新的非空智能指针的时候，引用计数的总和会加一。当修改一个非空智能指针的结果也是非空的时候，引用计数的和保持不变。当然这是应该的，因为我们需要在所有非空智能指针都被毁掉的时候，释放受保护的所有资源。
到了这里一个智能指针基本上已经能用了，但是还不能处理父类子类的情况。这个是比较麻烦的，一个Ptr<Derived>事实上没有权限访问Ptr<Base>的内部对象。因此我们需要通过友元类来解决这个问题。现在让我们来添加两个新的函数吧，从一个任意的Ptr<C>复制到Ptr<T>，然后保证只有当C*可以隐式转换成T*的时候编译能够通过：
2
3 template<typename C>
4 Ptr(const Ptr<C>& p):pointer(p.pointer),counter(p.counter)
5 {
6 Increase();
7 }
8
9 template<typename C>
10 Ptr<T>& operator=(const Ptr<C>& p)
11 {
12 Decrease();
13 pointer=p.pointer;
14 counter=p.counter;
15 Increase();
16 return *this;
17 }
注意这里我们的operator=并不用检查是不是自己给自己赋值，因为这是两个不同的类，相同的话会调用上面那个operator=的。如果C*不能隐式转换到T*的话，这里的pointer=p.pointer就会失败，从而满足了我们的要求。
现在我们能够做的事情就更多了：
2 Ptr<Base> b=d1;
于是我们只剩下最后一个Cast函数了。这个函数内部使用dynamic_cast来做判断，如果转换失败，会返回空指针：
2 Ptr<C> Cast()const
3 {
4 C* converted=dynamic_cast<C*>(pointer);
5 Ptr<C> result;
6 if(converted)
7 {
8 result.pointer=converted;
9 result.counter=counter;
10 Increase();
11 }
12 return result;
13 }
这是一种hack的方法，平时是不鼓励的……不过因为操作的都是Ptr，而且特化Ptr也是使用错误的一种，所以这里就不管了。我们会检查dynamic_cast的结果，如果成功了，那么会返回一个非空的新智能指针，而且这个时候我们也要记住Increase一下。
好了，基本功能就完成了。当然一个智能指针还要很多其他功能，譬如说比较什么的，这个就你们自己搞定哈。
指针和内存就说到这里了，下一篇讲如何利用一个好的IDE构造轻量级单元测试系统。我们都说好的工具能够提高生产力，因此这种方法不能脱离一个好的IDE使用。
