【面试总结】C++手写智能指针shared_ptr

最新推荐文章于 2025-07-05 15:45:45 发布
最新推荐文章于 2025-07-05 15:45:45 发布
阅读量1k 收藏 9
点赞数 12
CC 4.0 BY-SA版权
文章标签： 面试 c++ 职场和发展
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44225182/article/details/135454721
本文详细介绍了C++中的shared_ptr智能指针的结构、构造函数、成员函数以及在面试中的实际应用。通过简化版代码和面试实战案例，强调了理解和实践的重要性。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

目录

在这里插入图片描述

简介

Hello！
非常感谢您阅读海轰的文章，倘若文中有错误的地方，欢迎您指出～
 
ଘ(੭ˊᵕˋ)੭
昵称：海轰
标签：程序猿｜C++选手｜学生
简介：因C语言结识编程，随后转入计算机专业，获得过国家奖学金，有幸在竞赛中拿过一些国奖、省奖…已保研
学习经验：扎实基础 + 多做笔记 + 多敲代码 + 多思考 + 学好英语！
 
唯有努力💪
 
本文仅记录自己感兴趣的内容

shared_ptr

代码

#include <iostream>
#include <memory>
using namespace std;

namespace smart_pointer
{

    template <typename T>
    struct defaultDeleter
    {
        void operator()(const T *ptr)
        {
            if (ptr)
            {
                delete ptr;
                ptr = nullptr;
            }
        }
    };

    template <typename T, typename Deleter = defaultDeleter<T>>
    class shared_ptr
    {
    public:
        shared_ptr();
        shared_ptr(T *ptr);
        shared_ptr(const shared_ptr &sp); // 拷贝构造
        shared_ptr(shared_ptr &&sp);      // 移动构造
        ~shared_ptr();

        T *operator->() const;
        T &operator*() const;
        operator bool() const;

        shared_ptr &operator=(const shared_ptr &sp);
        shared_ptr &operator=(shared_ptr &&sp);

        T *get() const;
        void reset(T *ptr);
        void swap(shared_ptr &sp);
        int count();

    private:
        atomic<int> *use_count;
        T *ptr;
    };

    template <typename T, typename Deleter>
    shared_ptr<T, Deleter>::shared_ptr()
    {
    }

    template <typename T, typename Deleter>
    shared_ptr<T, Deleter>::shared_ptr(T *_ptr)
        : ptr(_ptr), use_count(new atomic<int>(1))
    {
    }

    template <typename T, typename Deleter>
    shared_ptr<T, Deleter>::shared_ptr(const shared_ptr &sp)
        : ptr(sp.ptr), use_count(sp.use_count)
    {
        ++*use_count;
    }

    template <typename T, typename Deleter>
    shared_ptr<T, Deleter>::shared_ptr(shared_ptr &&sp)
    {
        std::swap(ptr, sp.ptr);
        std::swap(use_count, sp.use_count);
    }

    template <typename T, typename Deleter>
    shared_ptr<T, Deleter>::~shared_ptr()
    {
        if (ptr)
        {
            --*use_count;
            if (*use_count <= 0)
            {
                Deleter()(ptr);
                delete use_count;
                cout << "shared_ptr dctor" << endl;
            }
        }
    }

    template <typename T, typename Deleter>
    T *shared_ptr<T, Deleter>::operator->() const
    {
        return ptr;
    }

    template <typename T, typename Deleter>
    T &shared_ptr<T, Deleter>::operator*() const
    {
        return *ptr;
    }

    template <typename T, typename Deleter>
    shared_ptr<T, Deleter>::operator bool() const
    {
        return ptr != nullptr;
    }

    /* 异常安全赋值 */
    template <typename T, typename Deleter>
    shared_ptr<T, Deleter> &shared_ptr<T, Deleter>::operator=(const shared_ptr<T, Deleter> &sp)
    {
#if 1
        // copy and swap
        shared_ptr<T, Deleter> tmp(sp);
        swap(tmp);
        return *this;
#else
        // 自我赋值
        if (sp.ptr == ptr)
            return *this;

        ptr = sp.ptr;
        use_count = sp.use_count;
        ++*use_count;
        return *this;
#endif
    }

    template <typename T, typename Deleter>
    shared_ptr<T, Deleter> &shared_ptr<T, Deleter>::operator=(shared_ptr<T, Deleter> &&sp)
    {
        std::swap(ptr, sp.ptr);
        std::swap(use_count, sp.use_count);
        return *this;
    }

    template <typename T, typename Deleter>
    T *shared_ptr<T, Deleter>::get() const
    {
        return ptr;
    }

    template <typename T, typename Deleter>
    void shared_ptr<T, Deleter>::reset(T *_ptr)
    {
        shared_ptr<T, Deleter>().swap(*this);

        ptr = _ptr;
        use_count = new atomic<int>(1);
    }

    template <typename T, typename Deleter>
    void shared_ptr<T, Deleter>::swap(shared_ptr<T, Deleter> &sp)
    {
        std::swap(ptr, sp.ptr);
        std::swap(use_count, sp.use_count);
    }

    template <typename T, typename Deleter>
    int shared_ptr<T, Deleter>::count()
    {
        return *use_count;
    }

}; // namespace smart_pointer

int main(int argc, char *argv[])
{
    {
        smart_pointer::shared_ptr<int> p(new int(12));
        smart_pointer::shared_ptr<int> p1(p);
        *p1 = 2;
        cout << *p << endl;
        cout << p.count() << endl;

        // 异常安全测试
        p = p;
        cout << *p << endl;
        cout << p.count() << endl;
    }

    {
        smart_pointer::shared_ptr<int> p(new int(12));
        p.reset(new int(13));
        cout << *p << endl;

        // 右值赋值测试
        p = smart_pointer::shared_ptr<int>(new int(14));
        cout << *p << endl;

        // 移动构造测试
        smart_pointer::shared_ptr<int> p1(smart_pointer::shared_ptr<int>(new int(15)));
        cout << *p1 << endl;
    }

    return 0;
}

实验结果

在这里插入图片描述

简化版

面试时上面代码很难在短时间内写完，可以参考下面的代码

#include <iostream>
#include <memory>
using namespace std;

namespace smart_pointer
{
    template <typename T>
    struct defaultDeleter
    {
        void operator()(const T *ptr)
        {
            if (ptr)
            {
                delete ptr;
                ptr = nullptr;
            }
        }
    };
    template <typename T, typename Deleter = defaultDeleter<T>>
    class shared_ptr
    {
    public:
        shared_ptr();
        shared_ptr(T *ptr);
        shared_ptr(const shared_ptr &sp);
        shared_ptr(shared_ptr &&sp);
        ~shared_ptr();
        // T *operator->() const;
        T &operator*() const;
        int count();
        // shared_ptr &operator=(const shared_ptr &sp);
        // shared_ptr &operator=(shared_ptr &&sp);
    private:
        atomic<int> *use_count;
        T *ptr;
    };
    template <typename T, typename Deleter>
    shared_ptr<T, Deleter>::shared_ptr()
    {
    }
    template <typename T, typename Deleter>
    shared_ptr<T, Deleter>::shared_ptr(T *_ptr)
        : ptr(_ptr), use_count(new atomic<int>(1))
    {
    }
    template <typename T, typename Deleter>
    shared_ptr<T, Deleter>::shared_ptr(const shared_ptr &sp)
        : ptr(sp.ptr), use_count(sp.use_count)
    {
        ++*use_count;
    }
    template <typename T, typename Deleter>
    shared_ptr<T, Deleter>::shared_ptr(shared_ptr &&sp)
    {
        std::swap(ptr, sp.ptr);
        std::swap(use_count, sp.use_count);
    }
    template <typename T, typename Deleter>
    shared_ptr<T, Deleter>::~shared_ptr()
    {
        if (ptr)
        {
            --*use_count;
            if (*use_count <= 0)
            {
                Deleter()(ptr);
                delete use_count;
                cout << "shared_ptr dctor" << endl;
            }
        }
    }

    template <typename T, typename Deleter>
    T &shared_ptr<T, Deleter>::operator*() const
    {
        return *ptr;
    }

    template <typename T, typename Deleter>
    int shared_ptr<T, Deleter>::count()
    {
        return *use_count;
    }
};

int main()
{
    smart_pointer::shared_ptr<int> p(new int(12));
    smart_pointer::shared_ptr<int> p1(p);

    *p = 33;
    cout << *p << endl;
    cout << p.count() << endl;
    return 0;
}

在这里插入图片描述

面试实战

智能指针被问到多次，一般都是先简单按照自己的理解解释c++智能指针，然后有些面试官会要求自己手写一遍，如果可以仔细研究此代码，还是可以学到很多知识点的。

手写智能指针在今年的大厂面试中，自己也是遇到了多次，基本上有会要求手写一点，时间大概10分钟左右，所以平时在复习的时候，一定要十分熟练。开始的时候，自己以为看懂了就行了，结果在面试中高压环境下写代码的时候，会犯很多的错误，所以平时一定要自己多练习，规定时间内熟练的写出来。

现代C++之手写智能指针
编程与实战的博客
11-24 1395
现代C++之手写智能指针0.回顾所有代码还是放在仓库里面，欢迎star!https://github.com/Light-City/CPlusPlusThings前面一节编写了一个RAI...
C++14 智能指针unique_ptr、shared_ptr、weak_ptr
热门推荐
机器学习
07-09 1万+
内存控制这一大毒瘤，几乎一致伴随着C/C++工程师。随着计算机技术的发展，在boost准标准库的推动下，C++11终于将unique_ptr、shared_ptr、weak_ptr这几类智能指针纳入C++中。当然，在这之前还有一种auto_ptr智能指针，不过由于它的设计存在较大问题（比如：auto_ptr与STL不兼容），现阶段已经很少能看到它的出现了。
(C++) 手写智能指针(unique_ptr；share_ptr)
cuber-lotus的博客
03-20 1758
RAII资源获取即初始化 C++11更是弥补了auto_ptr的缺陷，提出了unique_ptr,share_ptr,weak_ptr 注意智能指针的本质就是一个模板类，通过类的内部的操作，来管理资源 本文简单实现了一下
2 手写智能指针——shared_ptr
最新发布
weixin_34663092的博客
07-05 30
其中控制块中包含引用计数，weak_ptr计数等，这里第一版只考虑引用计数，也就是说我们类的私有成员应该含有。在手写一个比较完整的类之前，有一些前置知识需要了解，创建一个空类的时候，编译器会自动生成哪些函数了？2）判定该指向内存的引用计数是否为0，为0则释放内存，置空指针(可不必置空，后续会为其赋值)；1）为提高效率，避免过多的副本产生，尤其在链式赋值的情况下，这里返回值应该为。接下来，就是我们文章开头所说的，构建一个空类所涉及到的自动创建的成员函数了。这里我们的指针是指向引用计数的内存，如果直接定义。
C++_1_手写智能指针
雨落凡城的博客
06-08 645
文章目录1 :book: `share_ptr`仿写2 :book: `auto_ptr`仿写(C17的时候被废除了)3 :book: `unique_ptr`仿写(C11引入)10 :book: 参考资源 1 ???? share_ptr<T>仿写 智能指针（shareptr<T>）有两个关键变量，而且都是指针类型： 1 引用对象的指针（类型为指针） 2 引用对象的引用次数（类型为指针） 每次智能指针对象更换对象的时候，都会先更新当前的引用次数（减一） ，然后才会接管新的传入对象
手写智能指针 模板 C++
人面桃花
03-23 329
template <class T> class SmartPointer { public: //普通构造函数， 设定T * ptr的值，并将引用计数设为1 SmartPointer(T * ptr) { ref = ptr; ref_count = new unsigned; *ref_count = 1; } //指针拷贝构造函数，新建一个指向已有对象的智能指针 //需要先设定ptr和ref_count //设为指向sptr的ptr和ref_count //并
C++ 手工编写智能指针
HelloKandy's Blog
10-30 328
其实，我也不知道原作者是谁了，今天把代码整理后，测试没问题就发上来了： // smartptr_test.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include <iostream> #include <windows.h> using namespace std; #define SAFE_DELETE(p) if...
C++11 shared_ptr手写---面试常考
qq_40872103的博客
07-05 1050
共享对其所指堆内存空间的所有权，当最后⼀个指涉到该对象的shared_ptr不再指向他时，shared_ptr会⾃动析构所指对象如何判断⾃⼰是否指涉到该资源的最后⼀个？《引⽤计数》shared_ptr构造函数，使引⽤计数++析构函数，–赋值运算符，sp1 = sp2;sp1++,sp2–移动构造函数，会将源shared_ptr置空，所引引⽤计数不变，所以移动操作⽐复制快（复制要递增引⽤计数，移动不需要）引⽤计数使得shred_ptr⼤小是裸指针的2。
C++自定义智能指针——shared_ptr
MOMO
08-07 6475
C++自定义智能指针——shared_ptr 最近在找工作，发现许多公司在面试的时候会要求手写智能指针，因此自己参照的别人的博客在上面修改了一些，作为参考原文连接。shared_ptr通过引用计数来管理多个指针指向同一个对象，对计数器的操作要格外重视。 #include<iostream> using namespace std; //自定义智能指针 template <class T> class SmartPointer { public: SmartPointer(T* pt
手写智能指针shared_ptr
08-24
shared_ptr 是 C++ 标准库中的智能指针之一，用于管理动态分配的对象。它可以跟踪对象的引用计数，并在没有引用时自动释放内存。下面是一个手写的简单版本： ```cpp template class shared_ptr { public: shared_...
手写c++shared_ptr
干啥啥不行，但是也要干的博客
05-09 459
思路 shared_ptr将一个计数器与类指向的对象相关联，引用计数跟踪该类有多少个对象共享同一指针。每次创建类的新对象时，初始化指针并将引用计数置为1； 当对象作为另一对象的副本而创建时，拷贝构造函数拷贝指针并增加与之相应的引用计数； 对一个对象进行赋值时，赋值操作符减少左操作数所指对象的引用计数（如果引用计数为减至0，则删除对象），并增加右操作数所指对象的引用计数； 调用析构函数时，构造函数减少引用计数（如果引用计数减至0，则自动删除所指向的堆内存）。 template<class T>
手写一下智能指针
cja974182468的博客
08-28 379
#pragma once template class UniquePtr { public: private: T *_data; }; template class SharedPtr { public: explicit SharedPtr():_count(nullptr), _data(nullptr){} explicit SharedPtr(const SharedPtr &sor) { if (this != &sor) { _count = sor._count; _dat
c++ 手写智能指针shared_ptr
qq_37294304的博客
01-31 1279
c++ 手写智能指针shared_ptr 留个坑，回头在填。 #include <utility> #include <iostream> #include <cstddef> #include <string> template<typename T> class shared_ptr { friend class shared_ptr; public: shared_ptr(T* ptr = nullptr) :
C/C++面试：手写智能指针类
OceanStar的博客
01-21 1985
template<class T> class SharedPtr{ public: SharedPtr() : m_ptr(nullptr) , m_count_(new size_t) { } SharedPtr(T *ptr) : m_ptr(ptr) , m_count_(new size_t) { *m_count_ = 1; } ~SharedPtr(){
手写智能指针(smart_ptr)
L_Y_Fei的博客
09-05 498
1. 摘要
C++ 手写智能指针 shared_ptr
zsiming的博客
06-30 2364
C++智能指针简单实现
C++：指针：智能指针(一)：智能指针及其类型，手写智能指针
C++ JAVA的专栏
03-22 806
C++：指针：智能指针(一)：智能指针及其类型的介绍。
手写智能指针的C++简单实现(赋值运算符重载时考虑空指针的情况)
Mrchen157的博客
03-29 451
手写智能指针的C++简单实现(赋值运算符重载时考虑空指针的情况)
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

海轰Pro

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值