c++智能指针的原理与简单实现

一、问题的引入

先看一段简单的代码如下：

#include<iostream>using namespace std;class Person {private:char *name ;public:Person() {cout<<"Person()"<<endl ;}~Person() {cout<<"~Person()"<<endl ;}} ;void test(void){Person *p = new Person() ;}int main(int argc , char** argv){test();return 0 ;}

 在这段代码里面，定义了一个简单的类Person，它只有一个name成员和简单的构造函数和析构函数。在test函数里面，使用Person *p = new Person()构造了一个person对象，并在main函数里面调用了test（）。很明显，在test（）里面并没有去delete p ，将不会调用析构函数，因此可能在main函数退出前造成内存泄漏。

 我们当然可以在test（）函数里面将“Person *p = new Person()  ” 替换成 “Person p ; ” ，对应为p分配的内存是在栈里面，因此在test（）函数退出前会自动释放分配的内存（执行析构函数），但是这样就无法使用指针操作了（除非我们每次手工执行delete操作）。

 

二 、 智能指针的引入

 定义一个Sp类，如下：

#include<iostream>using namespace std;class Person {private:char *name ;public:Person() {cout<<"Person()"<<endl ;}~Person() {cout<<"~Person()"<<endl ;}} ;class Sp {private:Person *p ;public:Sp(Person *per){cout<<"Sp(Person *per)"<<endl ;p = per ;}~Sp(){cout<<"~Sp()"<<endl ;if(p){delete p ;p = NULL ;}}} ;void test(void){//Person *p = new Person() ;Sp s = new Person() ;}int main(int argc , char** argv){test();return 0 ;}

 

在test（）函数里面，我们同样使用new来构造出来一个Person的实例化对象，与前面不同的是，这个对象指针作为一个参数传给Sp类的构造函数构造出来了一个实例化对象s。当test（）函数执行完后，对象s的析构函数被调用，在析构函数里面再去delete Person的实例化对象。这是一种非常巧妙的方法，使用Sp s 代替了 Person *  ， 由Sp为我们做好了delete操作，这样即使不手工执行delete操作也不会造成内存泄漏的问题 。

因此，此时的Sp s 就可以替代 Person * 指针，这就是智能指针的智能之处，最终目的还是为了防止我们因为忘记delete操作而造成内存泄漏。

 

接下来我们在Person类里面添加一个普通的成员函数printInfo

void printInfo(void){cout<<"just for test !"<<endl ;}

在test（）函数里面，我们要调用p的printInfo,即 s->printInfo( ) ，但是Sp 类里面并没有定义这个函数，我们可以在Sp类里面重载“->”：

Person * operator->(){return p ;}

同样，我们也应该重载“*”，它返回对象的引用：

Person& operator*(){return *p ;}

这样，就可以使用s->printInfo( ) 或者 （*s）.printInfo() ;

 

三 、 智能指针的完善

1、为智能指针（Sp）添加拷贝构造函数

代码如下：

class Sp {private:Person *p ;public:/*使用Person *来构造*/Sp(Person *per){cout<<"Sp(Person *per)"<<endl ;p = per ;}/*拷贝构造函数*/Sp(const Sp &other){cout<<"Sp(Sp &other)"<<endl ;p = other.p;}~Sp(){cout<<"~Sp()"<<endl ;if(p){delete p ;p = NULL ;}}Person * operator->(){return p ;}} ;

在这个Sp类里面，我们实现了两个构造函数：使用Person * 来构造、使用拷贝构造函数构造。

这里要注意：拷贝构造函数中要将参数Sp & 这个引用声明为const，否则编译器会报错！！！（编译器不知道先使用Person * 来构造还是直接使用拷贝构造函数构造 s）。

 

2、添加引用计数

先看看如下代码：

#include<iostream>using namespace std;class Person {private:char *name ;public:Person() {cout<<"Person()"<<endl ;}~Person() {cout<<"~Person()"<<endl ;}void printInfo(void){cout<<"just for test !"<<endl ;}} ;class Sp {private:Person *p ;public:/*使用Person *来构造*/Sp(Person *per){cout<<"Sp(Person *per)"<<endl ;p = per ;}/*拷贝构造函数*/Sp(const Sp &other){cout<<"Sp(Sp &other)"<<endl ;p = other.p;}~Sp(){cout<<"~Sp()"<<endl ;if(p){delete p ;p = NULL ;}}} ;int main(int argc , char** argv){Sp s = new Person() ;Sp s2 = s;               return 0 ;}

编译、运行该程序 ，发现程序崩溃。

分析原因：

（1）由前一点分析，在main函数里，它首先构造出来一个Person 的实例化对象(假设为p)，并使s的p成员指向new出来的p；

（2）接着执行Sp s2 = s，将调用Sp的拷贝构造函数，在里面的s2 的p成员同样指向传入的s的p成员；

（3）main函数退出之前，将分别调用s、s2的析构函数，它们均delete p对应的内存；

因此，问题在于p对象被销毁了两次，这是明显不合理的。第一次释放了p对应的内存后，p = NULL；第二次来释放时，对象已经不存在了，main函数找不到p对象，会出现异常，程序自然崩溃了。

这里，通常的解决方法是给对象p添加一个引用计数，两次构造后p被引用了两次，引用计数为2；当第一次调用Sp的析构函数时，由于对象p仍然被引用，所以先不销毁它，仅仅减少它的引用计数为1；第二次调用Sp的析构函数时，先减少p的引用计数为0，即不被任何对象所引用了，再来销毁p。

（1）为Person添加引用计数，并增加相应接口，在第一次构造Person时初始化计数值为0：

class Person {private:char *name ;/*添加引用计数*/int count;public:void incStrong() {count ++ ;}void decStrong() {count -- ;}int getStrong() {return count ;}Person(): count(0) {cout<<"Person()"<<endl ;}~Person() {cout<<"~Person()"<<endl ;}void printInfo(void){cout<<"just for test !"<<endl ;}} ;

（2）在Sp的构造函数里面，调用Person的incStrong增加引用；在析构函数里面，先调用decStrong减少引用，若此时引用值为0，则销毁它：

class Sp {private:Person *p ;public:/*使用Person *来构造*/Sp(Person *per){cout<<"Sp(Person *per)"<<endl ;p = per ;p->incStrong();}/*拷贝构造函数*/Sp(const Sp &other){cout<<"Sp(Sp &other)"<<endl ;p = other.p;p->incStrong() ;}~Sp(){cout<<"~Sp()"<<endl ;if(p){p->decStrong() ;if(p->getStrong() == 0){delete p ;p = NULL ;}}}} ;

3、使用类模板

我们可以将引用计数独立出来，实现一个名为RefBase的基类，并将Sp类定义为模板类：

#include<iostream>using namespace std;class RefBase {private:int count;public:RefBase() : count(0) {} ;void incStrong() {count ++ ;}void decStrong() {count -- ;}int getStrong() {return count ;}};class Person :public RefBase{private:char *name ;public:Person() {cout<<"Person()"<<endl ;}~Person() {cout<<"~Person()"<<endl ;}void printInfo(void){cout<<"just for test !"<<endl ;}} ;template <typename T>class Sp {private:T *p ;public:/*使用Person *来构造*/Sp(T *per){cout<<"Sp(Person *per)"<<endl ;p = per ;p->incStrong();}/*拷贝构造函数*/Sp(const Sp &other){cout<<"Sp(Sp &other)"<<endl ;p = other.p;p->incStrong() ;}~Sp(){cout<<"~Sp()"<<endl ;if(p){p->decStrong() ;if(p->getStrong() == 0){delete p ;p = NULL ;}}}T * operator->(){return p ;}T& operator*(){return *p ;}} ;int main(int argc , char** argv){Sp<Person> s = new Person() ;Sp<Person> s2 = s;s->printInfo();(*s).printInfo();return 0 ;}

总结：

我们可以使用智能指针代替平时的指针操作 ,使用智能指针来自动维护对象的生命周期。实际上，智能指针的目的就是防止在new操作后忘记delete操作从而造成内存泄漏，它仅仅是一种手段。Android源代码庞大且复杂，大量地采用智能指针来维护对象的生命周期，而在实际编程中，我们要时刻关注对象的生命周期，不应该依赖于这些手段而忽视对内存的重视，因为c/c++编程的本质就是在操作内存。