凌云的博客

成功=工作+游戏+少说空话

漫谈 C++ 智能指针 05

分类:c++| 发布时间:2015-10-20 00:48:00


带引用计数的智能指针

在前面的文章中,我们实现了一个类似 std::auto_ptr 的智能指针。 这个实现最大的问题是赋值前后的两个元素不是逻辑独立的 (其中的一个直观表现是不能保存在 STL 容器中)。

通过实现带有引用计数的指针指针可以解决这个问题。 下面通过 C++11 的 std::shared_ptr 来演示下 (如果你的编译器不支持 C++11 可以使用 boost::shared_ptr 替代)。

#include <memory>
#include <iostream>

using namespace std;

void some_func()
{
    shared_ptr<int> p1(new int(3));
    shared_ptr<int> p2 = p1;

    cout << "p1 pointer: " << hex << p1.get() << endl;
    if (p1.get()) {
        cout <<  "p1 value: " << *p1 << endl;
    }

    cout << "p2 pointer: " << hex << p2.get() << endl;
    if (p2.get()) {
        cout << "p2 value: " << *p2 << endl;
    }
}

输出:

p1 pointer: 0x230b010
p1 value: 3
p2 pointer: 0x230b010
p2 value: 3

保存到 STL 容器中:

#include <vector>
#include <memory>
#include <iostream>

using namespace std;

void save_in_container()
{
    vector<shared_ptr<int> > vec;
    shared_ptr<int> p(new int(3));
    vec.push_back(p);
    shared_ptr<int> p2(new int(4));
    vec.push_back(p2);
    for (vector<shared_ptr<int> >::iterator i = vec.begin();
         i != vec.end(); ++i) {
        cout << **i << endl;
    }
}

实现带有引用计数的智能指针

下面来看看如何实现带有引用计数的智能指针。

namespace MY_DEMO {

template<typename T>
class shared_ptr
{
public:
    explicit shared_ptr(T *p = 0): p_(p), shared_count_(create_share_count()) {
    }

    shared_ptr(const shared_ptr<T> &rhs) {
        rhs.inc();
        this->p_ = rhs.p_;
        this->shared_count_ = rhs.shared_count_;
    }

    ~shared_ptr() {
        dec();
    }

    void reset(T *p) {
        if (this->get() == p)
            return;

        dec();
        shared_count_ = create_share_count();
        p_ = p;
    }

    T* get() {
        return p_;
    }

    shared_ptr<T>& operator= (const shared_ptr<T> &rhs) {
        if (rhs.shared_count_ != 0) {
            rhs.inc();
            this->dec();
            this->shared_count_ = rhs.shared_count_;
            this->p_ = rhs.p_;
        } else {
            this->dec();
            this->shared_count_ = 0;
            this->p_ = 0;
        }

        return *this;
    }

    bool operator! () const {
        return !p_;
    }

    T& operator* () const {
        return *p_;
    }

    T* operator-> () const {
        return p_;
    }

private:
    void inc() const {
        if (!shared_count_)
            return;

        ++*shared_count_;
    }

    void dec() {
        if (!shared_count_)
            return;

        if (!(--*shared_count_)) {
            delete shared_count_;
            shared_count_ = 0;

            if (p_) {
                delete p_;
                p_ = 0;
            }
        }
    }

    int* create_share_count() {
        int *tmp = new int(1);
        return tmp;
    }
private:
    T *p_;
    mutable int *shared_count_;
};

} // namespace MY_DEMO

带引用计数的智能指针通过共享一个引用计数器(在我们的实现中是 sharedcount\) 来跟踪一共有多少个智能指针引用到了这个原始指针。 在拷贝构造函数或者赋值运算时将右值的引用计数加 1,然后将自身的引用计数减 1。 在构造函数中将引用计数置为 1,析构时将引用计数减 1。 当引用计数为 0 时,删除引用计数以及保存的原始指针。

测试带引用的指针指针

下面我们来测试下我们实现的智能指针是否如我们预期地工作。

首先,在 shared_ptr 上添加一些输出:

namespace MY_DEMO {

#include <iostream>
#include <string>

using namespace std;

template<typename T>
class shared_ptr
{
public:
    // See other impl above

    explicit shared_ptr(T *p = 0): p_(p), shared_count_(create_share_count()) {
        cout << "shared_ptr default constructor" << endl;
    }

    shared_ptr(const shared_ptr<T> &rhs) {
        cout << "shared_ptr copy constructor" << endl;
        rhs.inc();
        this->p_ = rhs.p_;
        this->shared_count_ = rhs.shared_count_;
    }

    ~shared_ptr() {
        cout << "shared_ptr destructor" << endl;
        dec();
    }

    void reset(T *p) {
        cout << "shared_ptr reset" << endl;
        if (this->get() == p)
            return;

        dec();
        shared_count_ = create_share_count();
        p_ = p;
    }

    shared_ptr<T>& operator= (const shared_ptr<T> &rhs) {
        cout << "shared_ptr operator=" << endl;
        if (rhs.shared_count_ != 0) {
            rhs.inc();
            this->dec();
            this->shared_count_ = rhs.shared_count_;
            this->p_ = rhs.p_;
        } else {
            this->dec();
            this->shared_count_ = 0;
            this->p_ = 0;
        }

        return *this;
    }

    void dump() {
        cout << "value = " << *p_ << endl;
        cout << "shared_count_ = " << *shared_count_ << endl;
    }

private:
    void inc() const {
        if (!shared_count_)
            return;

        ++*shared_count_;
        cout << "inc shared_count_ " << *shared_count_ << endl;
    }

    void dec() {
        if (!shared_count_)
            return;

        if (!(--(*shared_count_))) {
            cout << "dec shared_count_ " << *shared_count_ << endl;
            delete shared_count_;
            shared_count_ = 0;

            if (p_) {
                delete p_;
                p_ = 0;
            }
        } else {
            cout << "dec shared_count_ " << *shared_count_ << endl;
        }
    }
}

} // namespace MY_DEMO

测试拷贝构造函数

using MY_DEMO::shared_ptr;

void test_copy_constructor()
{
    cout << "begin test_copy_constructor" << endl;
    shared_ptr<int> p1(new int(3));
    shared_ptr<int> p2(p1);
    cout << "p1 dump:" << endl;
    p1.dump();
    cout << "p2 dump:" << endl;
    p2.dump();
    cout << "end test_copy_constructor" << endl;
}

输出为:

begin test_copy_constructor
shared_ptr default constructor
shared_ptr copy constructor
inc shared_count_ 2
p1 dump:
value = 3
shared_count_ = 2
p2 dump:
value = 3
shared_count_ = 2
end test_copy_constructor
shared_ptr destructor
dec shared_count_ 1
shared_ptr destructor
dec shared_count_ 0

首先我们通过默认的构造函数创建了 p1,然后将 p1 拷贝给 p2, 此时引用计数为 2。 然后退出 test_copy_constructor,调用 p2 的析构函数,引用计数减 1, 此时引用计数为 1,调用 p1 的析构函数,引用计数减 1, 此时引用计数为 0,删除引用计数以及原始指针。

测试 operator=

using MY_DEMO::shared_ptr;

void test_assign()
{
    cout << "begin test_assign" << endl;
    shared_ptr<int> p1(new int(3));
    shared_ptr<int> p2;
    p2 = p1;
    cout << "p1 dump:" << endl;
    p1.dump();
    cout << "p2 dump:" << endl;
    p2.dump();
    cout << "end test_assign" << endl;
}

输出为:

begin test_assign
shared_ptr default constructor
shared_ptr default constructor
shared_ptr operator=
inc shared_count_ 2
dec shared_count_ 0
p1 dump:
value = 3
shared_count_ = 2
p2 dump:
value = 3
shared_count_ = 2
end test_assign
shared_ptr destructor
dec shared_count_ 1
shared_ptr destructor
dec shared_count_ 0

首先我们通过默认的构造函数创建了 p1,p2。 然后将 p1 赋值 p2,此时 p1 引用计数为 2, p2 本来的引用计数为 0,删除本来的引用计数以及原始指针, 将 p1 的引用计数以及原始指针赋给 p2。 然后退出 test_copy_constructor,调用 p2 的析构函数,引用计数减 1, 此时引用计数为 1,调用 p1 的析构函数,引用计数减 1, 此时引用计数为 0,删除引用计数以及原始指针。

测试 reset

using MY_DEMO::shared_ptr;

void test_reset()
{
    cout << "begin test_reset" << endl;
    shared_ptr<int> p1(new int(3));
    int *tmp = new int(6);
    p1.reset(tmp);
    p1.reset(tmp);
    p1.dump();
    cout << "end test_reset" << endl;
}

输出为:

begin test_reset
shared_ptr default constructor
shared_ptr reset
dec shared_count_ 0
shared_ptr reset
value = 6
shared_count_ = 1
end test_reset
shared_ptr destructor
dec shared_count_ 0

通过默认构造函数创建 p1,然后创建原始指针 tmp, 第一次将 tmp 设置给 p1 时 p1 原来的引用计数减 1, 此时原来的引用计数为 0,删除原来的引用计数以及原始指针。 创建新的引用计数,并将原始指针设置为 tmp。 再次将 tmp 设置给 p1,此时由于 tmp 与 p1 保存的原始指针是 同一个指针,直接退出 reset 。 然后就是退出 test_reset,p1 析构。

保存到 STL 容器中

using MY_DEMO::shared_ptr;

void test_save_in_vector()
{
    cout << "begin test_save_in_vector" << endl;
    vector<shared_ptr<int> > vec;
    shared_ptr<int> p1(new int(3));
    vec.push_back(p1);
    cout << "p1 dump:" << endl;
    p1.dump();
    cout << "end test_save_in_vector" << endl;
}

输出为:

begin test_save_in_vector
shared_ptr default constructor
shared_ptr copy constructor
inc shared_count_ 2
p1 dump:
value = 3
shared_count_ = 2
end test_save_in_vector
shared_ptr destructor
dec shared_count_ 1
shared_ptr destructor
dec shared_count_ 0

可以正常保存到 std::vector 中。