简单的C++智能指针

本文链接：简单的C++智能指针

­

从书上看到了一个C++智能指针的例子，感觉不错，小改进了下，放出来。

 

智能指针的大意是：对普通的类（假设C）指针进行包装，内部维护一个引用计数。程序中只要使用智能指针包装类（假设SafeC）就行了。用的时候只用new C(), 然后把其给包装类进行构造，然后就随便用啦，不用担心C的析构问题了。

 

众所周知，C++中如果需要动态申请内存的话，就一定要释放。可是不是所有new出来的对象都能明确的知道该在哪里释放。释放的话，不知道在哪里释放才好，总不能某处正在使用着呢，就给delete了；不释放的话，就是传说中的内存泄漏。

所以，智能指针（好像也有叫安全指针的）的作用就显出来了。把一个申请来的对象指针，扔给智能指针去管理。智能指针会在对其所有引用都释放后，把内部管理的指针所指向的对象删除。使用起来的效果就像.Net和Java的引用一样。不过垃圾回收的机理应该和这个有些不同。

 

智能指针只使用值传递就可以，没有必要使用指针传递或引用传递，虽然效率高一点点。需要注意的是，智能指针就不要去new了，不然就失去其本来的意义了。

 

代码我改动了不少，还添加了测试代码。书上的代码只有很简单的非泛型的SafeC类。各种优缺点大家自己体会吧。（和Java或者是.Net对比一下，发现了这样写的优点了吧～）

另外说明一点：这个代码是没法在普通的C++环境下编译的，因为用的是C++.Net……用的.Net的控制台输出。大家把所有的输出代码删掉或改用C++的输出流就可以运行了（不要告诉我你看不出来哪个是.Net的东西啊……）。

 

另外：这个安全指针不是线程安全的，多线程中跨线程使用会出问题，需要添加线程锁。加锁一种可能的做法是：再维护一个锁对象的指针，在所有能接收到C新实例的指针的构造器中进行初始化，并与C的指针一同析构，在所有可能改变引用计数的地方进行线程同步，如构造器，赋值操作符，析构器。

 

代码：（自己写主函数）

template<class C>class SafeC {C* instance;int* count;private:void ShowCount() {Console::WriteLine("reference count in SafeC.constructor: " + *count);}public:SafeC(int i):instance(new C(i)), count(new int(1)) {ShowCount();}SafeC(C* aInstance):instance(aInstance), count(new int(1)) {ShowCount();}SafeC(const SafeC& other):instance(other.instance), count(other.count) {++(*count);ShowCount();}C* operator ->() {return instance;}C* operator =(const SafeC& other) {if(other.instance==instance) {return *this;} else {~SafeC(); instance=other.instance;count=other.count;++(*count);return *this;}}~SafeC() {Console::WriteLine("in SafeC.destructor, before excute, count: "+*count);Console::WriteLine(" and the instance's id: "+instance->GetId());if(--(*count) == 0) {Console::WriteLine(" and delete the pointer to instance !! instance's id: " + instance->GetId());delete instance;delete count;}}};

相关测试代码：

class C1 {protected:int id;public:C1(int i):id(i) {Console::WriteLine("! in C1.C1, id: " + id);}virtual void Func() {Console::WriteLine("! in C1.f, id: " + id);}virtual int GetId() {return id;}virtual ~C1() {Console::WriteLine("! in C1.~C1, id: " + id);}};class C2 : public C1 {public:C2(int i):C1(i) {}virtual void Func() {Console::WriteLine("! in C2.f, id: " + id);}virtual ~C2() {Console::WriteLine("! in C2.~C2, id: " + id);}};void TestSafeC() {Console::WriteLine(">>>>> object in stack test:");SafeC<C1> s1(new C1(1));Console::WriteLine("s1");SafeC<C1> s2(s1);Console::WriteLine("s2");SafeC<C1>& rs3 = s2;Console::WriteLine("rs3");SafeC<C1> s4 = s2;Console::WriteLine("invoke: s4->Func()");s4->Func();Console::WriteLine("<<<<< end stack test.");Console::WriteLine(">>>>> object in heap test:");Console::WriteLine("ps5");SafeC<C2>* ps5 = new SafeC<C2>(2); // not recommended. don't new SafeC, or it will be like a ordinary pointer.Console::WriteLine("rs6");SafeC<C2>& rs6 = *new SafeC<C2>(3); // notice! no delete operation on this. this is dangerous.Console::WriteLine("s7");SafeC<C2> s7 = *ps5;Console::WriteLine("delete ps5");delete ps5;Console::WriteLine("<<<<< end heap test.");Console::WriteLine(">>>>> method return value test:");C1* InnerFunc();SafeC<C1> s8(InnerFunc()); // the most important point~Console::WriteLine("<<<<< end method return value test.");}C1* InnerFunc() {return new C1(10);}

输出：

­In Singleton's Constructor.
>>>>> object in stack test:
! in C1.C1, id: 1
reference count in SafeC.constructor: 1
s1
reference count in SafeC.constructor: 2
s2
rs3
reference count in SafeC.constructor: 3
invoke: s4->Func()
! in C1.f, id: 1
<<<<< end stack test.
>>>>> object in heap test:
ps5
! in C1.C1, id: 2
reference count in SafeC.constructor: 1
rs6
! in C1.C1, id: 3
reference count in SafeC.constructor: 1
s7
reference count in SafeC.constructor: 2
delete ps5
in SafeC.destructor, before excute, count: 2
 and the instance's id: 2
<<<<< end heap test.
>>>>> method return value test:
! in C1.C1, id: 10
reference count in SafeC.constructor: 1
<<<<< end method return value test.
in SafeC.destructor, before excute, count: 1
 and the instance's id: 10
 and delete the pointer to instance !! instance's id: 10
! in C1.~C1, id: 10
in SafeC.destructor, before excute, count: 1
 and the instance's id: 2
 and delete the pointer to instance !! instance's id: 2
! in C2.~C2, id: 2
! in C1.~C1, id: 2
in SafeC.destructor, before excute, count: 3
 and the instance's id: 1
in SafeC.destructor, before excute, count: 2
 and the instance's id: 1
in SafeC.destructor, before excute, count: 1
 and the instance's id: 1
 and delete the pointer to instance !! instance's id: 1
! in C1.~C1, id: 1