手撕shared_ptr 共享指针

于 2025-02-11 23:21:05 发布
阅读量491 收藏 15
点赞数 23
分类专栏： C++ 文章标签： c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/z3363/article/details/145581845
版权

最下面有完整的代码，不想看的可以直接跳过

        今天让我们来手撕c++的共享指针shared_ptr，共享指针的是通过引用计算和RAII思想来实现的，当我们将指针赋值给其他shared ptr时内部有一个计数变量会加1，当shared ptr触发析构时这个计数就会减1，当计数为0时就会自动的释放管理的资源

        这个就是shared ptr的基本原理下面我们开始实现，首先来介绍构造函数和成员变量，我们的类需要通用型肯定是要用模板的，所以我们的指针就用到了模板来满足对所有指针类型的支持，引用计数需要用原子变量来保证并发安全

template<typename T>
class SharedPtr{
public:
	explicit  SharedPtr() noexcept : _ptr(nullptr), _count(new std::atomic<size_t>(0)){}
	explicit  SharedPtr(T* ptr) : _ptr(ptr) { _count = (_ptr == nullptr) ? new std::atomic<size_t>(0) : new std::atomic<size_t>(1); }
	SharedPtr(const SharedPtr<T>& other):_count(other._count), _ptr(other._ptr) {
		if (_ptr != nullptr) (*_count)++;
	}
	SharedPtr(SharedPtr<T>&& other) noexcept : _count(other._count), _ptr(other._ptr) {
		other._count = nullptr;
		other._ptr = nullptr;
	}
private:
	std::atomic<size_t>* _count;
	T* _ptr;
};

        explicit关键字的作用是防止隐式转换，防止普通指针在不经意间转换成shared ptr，使用模板T作为我们内部的指针，用std::atomic原子变量来实现引用变量，这个使用指针的目的是确保多个shared ptr管理同一个资源时，他们的行为一致性，拷贝构造需要注意的是进行自增，移动构造需要注意将另一方置空

        下面我们再来介绍拷贝赋值和移动赋值，以及一些运算符重载

    SharedPtr<T>& operator=(const SharedPtr<T>& other) {
		if (this == &other) return *this;
		reset();

		_count = other._count;
		_ptr = other._ptr;
		if (other._ptr != nullptr) (*_count)++;
		return *this;
	}
	SharedPtr<T>& operator=(SharedPtr<T>&& other) noexcept {
		if (this == &other) return *this;
		reset();

		_count = other._count;
		_ptr = other._ptr;
		other._count = nullptr;
		other._ptr = nullptr;
		return *this;
	}

	T& operator*() const noexcept {
		if (_ptr == nullptr) throw std::runtime_error("nullptr dereference");
		return *_ptr;
	}
	T* operator->() const noexcept {
		if (_ptr == nullptr) throw std::runtime_error("nullptr dereference");
		return _ptr;
	}
	bool operator==(const SharedPtr<T>& other) const noexcept {
		return _ptr == other._ptr;
	}
	bool operator!=(const SharedPtr<T>& other) const noexcept {
		return _ptr!= other._ptr;
	}

*与->要确保能发出异常，reset函数的作用是重新调整自己后面我们再介绍，赋值操作一定要调用这个函数，保证能清除原来的自己

我们最后来介绍析构还有MakeShared函数

private:
    // 允许 MakeShared 访问私有构造函数
    template<typename U, typename... Args>
    friend SharedPtr<U> MakeShared(Args&&... args);
    SharedPtr(T* ptr, std::atomic<size_t>* count) noexcept : _ptr(ptr), _count(count) {}

    void reset() noexcept {
        if (_ptr != nullptr) {
            if (--(*_count) == 0) {
                _ptr->~T();
                ::operator delete(static_cast<void*>(_count));  // 释放引用计数和对象的整块内存
            }
        }
        else if (_count != nullptr) {
            ::operator delete(static_cast<void*>(_count));  // 释放引用计数和对象的整块内存
        }
        _ptr = nullptr;
        _count = nullptr;
    }


template<typename T, typename... Args>
SharedPtr<T> MakeShared(Args&&... args) {
    // 使用 std::aligned_storage 来确保内存对齐
    using StorageType = typename std::aligned_storage<sizeof(T) + sizeof(std::atomic<size_t>), alignof(T)>::type;
    void* mem = ::operator new(sizeof(StorageType));  // 一次性分配内存
    auto* count = new (mem) std::atomic<size_t>(1);   // 在已分配的内存上构造引用计数
    auto* obj = new (static_cast<void*>(static_cast<char*>(mem) + sizeof(std::atomic<size_t>))) T(std::forward<Args>(args)...);  // placement new构造对象

    return SharedPtr<T>(obj, count);  // 返回构造的 SharedPtr
}

reset函数会将引用计数减1并检测是否为0，为0后就清除当前的资源，MakeShared函数的作用是内存对齐并保证一次性创建内存空间

手撕shared ptr就这样完成了，希望能够帮助到大家，如果有不对的地方欢迎指正

#pragma once

template<typename T>
class SharedPtr{
public:
    explicit  SharedPtr() noexcept : _ptr(nullptr), _count(new std::atomic<size_t>(0)){}
    explicit  SharedPtr(T* ptr) : _ptr(ptr) { _count = (_ptr == nullptr) ? new std::atomic<size_t>(0) : new std::atomic<size_t>(1); }
    SharedPtr(const SharedPtr<T>& other):_count(other._count), _ptr(other._ptr) {
        if (_ptr != nullptr) (*_count)++;
    }
    SharedPtr(SharedPtr<T>&& other) noexcept : _count(other._count), _ptr(other._ptr) {
        other._count = nullptr;
        other._ptr = nullptr;
    }

    SharedPtr<T>& operator=(const SharedPtr<T>& other) {
        if (this == &other) return *this;
        reset();

        _count = other._count;
        _ptr = other._ptr;
        if (other._ptr != nullptr) (*_count)++;
        return *this;
    }
    SharedPtr<T>& operator=(SharedPtr<T>&& other) noexcept {
        if (this == &other) return *this;
        reset();

        _count = other._count;
        _ptr = other._ptr;
        other._count = nullptr;
        other._ptr = nullptr;
        return *this;
    }

    T& operator*() const noexcept {
        if (_ptr == nullptr) throw std::runtime_error("nullptr dereference");
        return *_ptr;
    }
    T* operator->() const noexcept {
        if (_ptr == nullptr) throw std::runtime_error("nullptr dereference");
        return _ptr;
    }
    bool operator==(const SharedPtr<T>& other) const noexcept {
        return _ptr == other._ptr;
    }
    bool operator!=(const SharedPtr<T>& other) const noexcept {
        return _ptr!= other._ptr;
    }


    T* get() const noexcept {
        return _ptr;
    }
    size_t use_count() const noexcept {
        return *_count;
    }

    ~SharedPtr() {
        reset();
    }

private:
    // 允许 MakeShared 访问私有构造函数
    template<typename U, typename... Args>
    friend SharedPtr<U> MakeShared(Args&&... args);
    SharedPtr(T* ptr, std::atomic<size_t>* count) noexcept : _ptr(ptr), _count(count) {}

    void reset() noexcept {
        if (_ptr != nullptr) {
            if (--(*_count) == 0) {
                _ptr->~T();
                ::operator delete(static_cast<void*>(_count));  // 释放引用计数和对象的整块内存
            }
        }
        else if (_count != nullptr) {
            ::operator delete(static_cast<void*>(_count));  // 释放引用计数和对象的整块内存
        }
        _ptr = nullptr;
        _count = nullptr;
    }
private:
    std::atomic<size_t>* _count;
    T* _ptr;
};

template<typename T, typename... Args>
SharedPtr<T> MakeShared(Args&&... args) {
    // 使用 std::aligned_storage 来确保内存对齐
    using StorageType = typename std::aligned_storage<sizeof(T) + sizeof(std::atomic<size_t>), alignof(T)>::type;
    void* mem = ::operator new(sizeof(StorageType));  // 一次性分配内存
    auto* count = new (mem) std::atomic<size_t>(1);   // 在已分配的内存上构造引用计数
    auto* obj = new (static_cast<void*>(static_cast<char*>(mem) + sizeof(std::atomic<size_t>))) T(std::forward<Args>(args)...);  // placement new构造对象

    return SharedPtr<T>(obj, count);  // 返回构造的 SharedPtr
}

面试真题 | 百度C++研发工程师面经
叫好与叫座虽然不是对立面，但想在同一个作品中达到双重效果很难。
10-13 217
智能指针是C++中的一种内存管理工具，它能够在对象不再需要时自动释放内存，从而避免内存泄漏。智能指针通过封装原始指针，并在适当的时候自动删除所指向的对象，简化了内存管理的工作。C++标准库提供了几种类型的智能指针，包括和（但已被C++11弃用，不推荐使用）。独占所有权的智能指针，意味着同一时间只能有一个指向一个给定的资源。当被销毁时（例如，离开作用域时），它所管理的资源也会被自动释放。不支持拷贝构造和赋值操作，但支持移动语义，允许将所有权从一个转移到另一个。共享所有权的智能指针，允许多个。
C++面试题：手撕智能指针shared_ptr
weixin_44537258的博客
03-28 1607
template<class T> class SmartPtr{ public: SmartPtr(T* ptr = NULL): _ptr(ptr), _pcount(new int(1)) {} SmartPtr(const SmartPtr& s): _ptr(s.ptr), _pcount(s._pcount){ *(_pcount)++; } SmartPtr<T>& operator=(const SmartPtr& s){ if
手撕一个shared_ptr吧
yanchenzhi的博客
07-26 1235
智能指针的优点不多赘述，前面的文章已经说过。这次直接手撕一个智能指针的代码顺便帮助自己理解一下智能指针的使用。 首先，智能指针有几个注意点： 智能指针适用于各类型参数，所以要用T模板； 智能指针有引用计数，所以在构造和析构的时候要进行引用计数的加减； 需要重载指针的“->”“*”功能，使其能像正常指针一样使用； 主要是析构函数的不同之处在于加个条件判断 好，那我们开始吧： class Shared_mptr { public: //空类构造，count，ptr均置空 Shared_mptr()
手撕一个简易的shared_ptr
Nothing721的博客
04-24 345
主要是为了保证所有指向该内存的指针共享同一份数据，每次指针拷贝的时候，实际上是拷贝的指针，该指针同样指向的是相同的地址，所以实现了一个同步的功能。共享指针shared_ptr是RALL机制的一个典型实现，主要功能是管理动态创建对象的销毁,从而帮助彻底消除内存泄漏和悬空指针(野指针)的问题，并且通过引用计数的方式实现了可以多个共享指针可以指向同一个对象。首先实现一下构造函数与拷贝构造函数，主要是对指针、引用计数以及锁进行初始化，注意引用计数改变时需要加锁，保证线程安全。可以再写一个获取当前引用计数的接口。
手撕智能指针shareptr
qq_41511474的博客
03-27 429
手撕一个share_ptr智能指针
手撕shared_ptr智能指针
weixin_49220519的博客
09-01 428
面试中遇到的，自己做个总结
【C++智能指针】简易shared_ptr实现（手撕shared_ptr）
weixin_43954810的博客
06-06 2708
手撕实现简易的C++智能指针shared_ptr
手写c++shared_ptr
干啥啥不行，但是也要干的博客
05-09 434
思路 shared_ptr将一个计数器与类指向的对象相关联，引用计数跟踪该类有多少个对象共享同一指针。每次创建类的新对象时，初始化指针并将引用计数置为1； 当对象作为另一对象的副本而创建时，拷贝构造函数拷贝指针并增加与之相应的引用计数； 对一个对象进行赋值时，赋值操作符减少左操作数所指对象的引用计数（如果引用计数为减至0，则删除对象），并增加右操作数所指对象的引用计数； 调用析构函数时，构造函数减少引用计数（如果引用计数减至0，则自动删除所指向的堆内存）。 template<class T>
shared_ptr手撕
09-08
shared_ptr是C++11引入的智能指针，用于管理动态分配的内存。它可以自动地进行内存的释放，避免了手动管理内存的麻烦和潜在错误。 下面是一个简单的手写shared_ptr的示例代码： ```cpp template class shared_ptr ...
指针是否释放判断_面试官让我手撕智能指针 shared_ptr
05-17
每个新的 `shared_ptr` 实例与原有的 `shared_ptr` 实例共享同一个引用计数器，当引用计数器为 0 时，释放被管理的内存空间。 3. 在多个 `shared_ptr` 实例中，不要出现循环引用的情况，即 `shared_ptr` 对象之间...
手撕线程安全智能指针
最新发布
02-18
下面展示了一个基于`shared_ptr`概念的手动实现方案。 #### 定义控制块结构体 首先定义一个用于管理对象生命周期以及维护引用次数的数据结构ControlBlock： ```cpp #include #include #include template ...
面试手撕-shared_ptr
code for life
05-30 599
std::shared_ptr 是C++标准库中的一个智能指针类型，它提供了自动的内存管理功能，通过引用计数机制来决定所管理的对象何时应该被删除。当最后一个指向对象的 shared_ptr 离开作用域或者被重置时，它所指向的对象会被自动删除，从而防止了内存泄漏。
手撕c++ shared_ptr（字节跳动手写算法）
m0_38076911的博客
07-01 2697
#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 <
手撕C++ shared_ptr智能指针
olivia_yuen的博客
07-29 1209
面试高频手写shared_ptr智能指针
【重学C++】【指针】手撕shared_ptr：源码阅读及从零开始亲自动手写一个自己的智能指针
同学小张的博客
05-06 1705
今天我们首先阅读一下shared_ptr的源码，然后亲自动手，从零开始实现一个自己的智能指针，从而对智能指针的底层原理有一个更深入的理解。
从零简单实现一个线程安全的C++共享指针(shared_ptr)
星空_MAX
03-23 1386
shared_ptr主要是用来自动管理动态创建对象的销毁，记录对象被引用的次数，当引用计数清零的时候，把指向的内存区域自动释放掉。如果要手动实现一个共享指针的话就需要一个共享指针类，类中存着被指向的对象的指针。当对象被多个共享指针指向的时候，就需要一个共享的引用计数器counter。当都断的时候，引用计数器变为0，这时候清理对象A。当对象被共享指针指向的时候，引用计数器为2。当一个共享指针被释放后，引用计数器的值减1。
qt中的共享指针，QSharedPointer类
qq_42815643的博客
03-16 7653
当引用计数减少到零时，该对象将被销毁。在容器中存储对象：共享指针可以存储在STL容器中，如std::vector，这样可以在容器中存储指向T类型对象的指针，并且当容器元素被删除时，共享指针会自动处理内存释放。需要注意的是，在使用Qt共享指针时，应该避免使用裸指针来操作被共享的对象，以免造成悬挂指针的问题。在多线程环境中共享对象：共享指针可以在多个线程之间共享同一个对象，由于引用计数的机制，可以确保对象在所有线程都不再需要时被安全地销毁，而不会导致内存泄漏或竞态条件。
C++智能指针shared_ptr
weixin_44651073的博客
02-26 927
shared_ptr的基本用法
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值