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

2015-12-20  本文已影响3885人  书呆子的复仇

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;

为了让测试结果更明显,我在方法中加入了一些输出,测试结果如下:

上一篇下一篇

猜你喜欢

热点阅读