手撸一个智能指针，你学会了吗？

估计大家面试过程中应该都会被问到C++11的shared_ptr是如何实现的，大家应该都能答出来引用计数的概念，但是如果要让你手写一个shared_ptr，你能写出来吗?

创新互联公司长期为超过千家客户提供的网站建设服务，团队从业经验10年，关注不同地域、不同群体，并针对不同对象提供差异化的产品和服务；打造开放共赢平台，与合作伙伴共同营造健康的互联网生态环境。为洮南企业提供专业的网站设计、成都做网站，洮南网站改版等技术服务。拥有10年丰富建站经验和众多成功案例,为您定制开发。

最近，我写了一个简单的shared_ptr，在这里分享一波。

首先定义一个主管引用计数的类：

class SharedCount {
   public:
    SharedCount() : count_{1} {}

    void add() { ++count_; }

    void minus() { --count_; }

    int get() const { return count_; }

   private:
    std::atomic count_;
};

然后就是SharedPtr类，首先在构造函数中创建SharedCount的对象：

template 
class SharedPtr {
   public:
    SharedPtr(T* ptr) : ptr_{ptr}, ref_count_{new SharedCount} {}

    SharedPtr() : ptr_{nullptr}, ref_count_{new SharedCount} {}

   private:
    T* ptr_;
    SharedCount* ref_count_;
};

通过构造函数创建出来的SharedPtr引用计数肯定是1，那析构函数怎么实现?无非就是将引用计数减1，如果引用计数最终减到0，则释放所有指针：

template 
class SharedPtr {
   public:
    ~SharedPtr() { clean(); }

   private:
    void clean() {
        if (ref_count_) {
            ref_count_->minus();
            if (ref_count_->get() == 0) {
                if (ptr_) delete ptr_;
                delete ref_count_;
            }
        }
    }
};

然后就是智能指针的关键部分，即在拷贝构造和拷贝赋值的时候将引用计数+1：

template 
class SharedPtr {
   public:
    SharedPtr(const SharedPtr& p) {
        this->ptr_ = p.ptr_;
        this->ref_count_ = p.ref_count_;
        ref_count_->add();
    }

    SharedPtr& operator=(const SharedPtr& p) {
        clean();
        this->ptr_ = p.ptr_;
        this->ref_count_ = p.ref_count_;
        ref_count_->add();
        return *this;
    }
};

处理了拷贝语义，还需要处理移动语义，即实现移动构造和移动赋值函数：

template 
class SharedPtr {
   public:
    SharedPtr(SharedPtr&& p) {
        this->ptr_ = p.ptr_;
        this->ref_count_ = p.ref_count_;
        p.ptr_ = nullptr;
        p.ref_count_ = nullptr;
    }

    SharedPtr& operator=(SharedPtr&& p) {
        clean();
        this->ptr_ = p.ptr_;
        this->ref_count_ = p.ref_count_;
        p.ptr_ = nullptr;
        p.ref_count_ = nullptr;
        return *this;
    }
};

在移动语义中，引用计数保持不变，同时清空原参数中的指针。

关于共享指针，到这里基本逻辑都已经实现完成，但还需要补充获取裸指针、获取引用计数等接口：

这样一个完整的智能指针大体已经实现完成，运行一下看看：

struct A { A() { std::cout << "A() \n"; } ~A() { std::cout << "~A() \n"; }};void test_simple_shared() { A* a = new A; SharedPtr ptr(a); { std::cout << ptr.use_count() << std::endl; SharedPtr b = ptr; std::cout << ptr.use_count() << std::endl; SharedPtr c = ptr; std::cout << ptr.use_count() << std::endl; SharedPtr d = std::move(b); std::cout << ptr.use_count() << std::endl; } std::cout << ptr.use_count() << std::endl;}int main() { test_simple_shared(); }

结果为：

template 
class SharedPtr {
   public:
    int use_count() { return ref_count_->get(); }

    T* get() const { return ptr_; }

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

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

    operator bool() const { return ptr_; }

   private:
    T* ptr_;
    SharedCount* ref_count_;
};

基本的shared_ptr完成后，再来写点有意思的，不知道大家有没有用过这几个指针转换函数：

struct A {
    A() { std::cout << "A() \n"; }
    ~A() { std::cout << "~A() \n"; }
};

void test_simple_shared() {
    A* a = new A;
    SharedPtr ptr(a);
    {
        std::cout << ptr.use_count() << std::endl;
        SharedPtr b = ptr;
        std::cout << ptr.use_count() << std::endl;
        SharedPtr c = ptr;
        std::cout << ptr.use_count() << std::endl;
        SharedPtr d = std::move(b);
        std::cout << ptr.use_count() << std::endl;
    }
    std::cout << ptr.use_count() << std::endl;
}

int main() { test_simple_shared(); }

结果为：

A()
1
2
3
3
1
~A()

基本的shared_ptr完成后，再来写点有意思的，不知道大家有没有用过这几个指针转换函数：

template
std::shared_ptr static_pointer_cast(const std::shared_ptr& r) noexcept;

template
std::shared_ptr const_pointer_cast(const std::shared_ptr& r) noexcept;

template
std::shared_ptr dynamic_pointer_cast(const std::shared_ptr& r) noexcept;

template
std::shared_ptr reinterpret_pointer_cast(const std::shared_ptr& r) noexcept;

我默认大家已经知道这几个函数的作用，这里直接研究一下它的实现：

template 
class SharedPtr {
   public:
   private:
    template 
    SharedPtr(const SharedPtr& p, T* ptr) {
        this->ptr_ = ptr;
        this->ref_count_ = p.ref_count_;
        ref_count_->add();
    }

    T* ptr_;
    SharedCount* ref_count_;
};

template 
SharedPtr static_pointer_cast(const SharedPtr& p) {
    T* ptr = static_cast(p.get());
    return SharedPtr(p, ptr);
}

SharedPtr和SharedPtr不是一个类，所以上面的代码会稍微有点问题，p无法访问它的private成员变量ref_count，那怎么解决呢?上友元：

template 
class SharedPtr {
   public:
    template 
    friend class SharedPtr;
};

上面的代码还是有问题，因为SharedPtr(const SharedPtr& p, T* ptr)是private，static_pointer_cast无法访问，有两种办法，一是变成public，二是友元，这里还是友元更合理些，添加友元后的代码如下：

template 
class SharedPtr {
   public:
    template 
    friend class SharedPtr;

    template 
    friend SharedPtr static_pointer_cast(const SharedPtr& p);

   private:
    template 
    SharedPtr(const SharedPtr& p, T* ptr) {
        this->ptr_ = ptr;
        this->ref_count_ = p.ref_count_;
        ref_count_->add();
    }

    T* ptr_;
    SharedCount* ref_count_;
};

template 
SharedPtr static_pointer_cast(const SharedPtr& p) {
    T* ptr = static_cast(p.get());
    return SharedPtr(p, ptr);
}

再测试一下：

struct A {
    A() { std::cout << "A() \n"; }
    ~A() { std::cout << "~A() \n"; }
};

struct B : A {
    B() { std::cout << "B() \n"; }
    ~B() { std::cout << "~B() \n"; }
};

void test_cast_shared() {
    B* a = new B;
    SharedPtr ptr(a);
    {
        std::cout << ptr.use_count() << std::endl;
        SharedPtr b = static_pointer_cast(ptr);
        std::cout << ptr.use_count() << std::endl;
        SharedPtr c = ptr;
        std::cout << ptr.use_count() << std::endl;
        SharedPtr d = ptr;
        std::cout << ptr.use_count() << std::endl;
    }
    std::cout << ptr.use_count() << std::endl;
}

int main() { test_cast_shared(); }

结果为：

A()
B()
1
2
3
4
1
~B()
~A()

上面只实现了static_pointer_cast，其他xxx_pointer_cast的原理类似，大家应该也明白了吧。
C++还有个unique_ptr，这个相对于shared_ptr就简单多了，表示unique语义，没有引用计数的概念，因为不允许拷贝，原理就是禁止调用拷贝构造函数和拷贝赋值函数，直接贴代码吧：

template
class UniquePtr {
public:
UniquePtr(T* ptr) : ptr_{ptr} {}

UniquePtr() : ptr_{nullptr} {}

UniquePtr(const UniquePtr& p) = delete;
UniquePtr& operator=(const UniquePtr& p) = delete;

UniquePtr(UniquePtr&& p) {
this->ptr_ = p.ptr_;
p.ptr_ = nullptr;
}

UniquePtr& operator=(UniquePtr&& p) {
clean();
this->ptr_ = p.ptr_;
p.ptr_ = nullptr;
return *this;
}

T* get() const { return ptr_; }

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

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

operator bool() const { return ptr_; }

~UniquePtr() { clean(); }

private:
void clean() {
if (ptr_) delete ptr_;
}

T* ptr_;
};

重点其实只有这两个delete：

template
class UniquePtr {
public:
UniquePtr(const UniquePtr& p) = delete;
UniquePtr& operator=(const UniquePtr& p) = delete;
};

到这里已经实现了一个简单的shared_ptr和unique_ptr，希望对大家有所帮助，完整代码见这里：
https://github.com/chengxumiaodaren/cpp-learning/blob/master/src/test_shared_ptr.cc
网页标题：手撸一个智能指针，你学会了吗？
网站链接：http://www.csdahua.cn/qtweb/news6/487656.html

网站建设、网络推广公司-快上网，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源：快上网

成都快上网为您推荐相关内容

创新互联Python教程：Python基础：return和break的不同
创新互联百度小程序教程：grid宫格
通通透透看无服务器计算：由来、场景和问题
AVG虽然免费，但是有窃取用户隐私的行为
武汉网络营销企业是什么,武汉网络营销企业的优势和特点
共享位置为什么不显示距离
HP-UX11.23如何删除和新增IP
警惕Redis空闲连接过多可能引发问题（redis空闲连接太多）
使用cmd脚本快速更新mysql数据库(cmd脚本更新mysql数据库)