shared_ptr的简单实现

namespace bit{
	template<class T>
	class SharedPtr
	{
    public:
        SharedPtr(T* ptr = nullptr):_ptr(ptr),_pRefCount(new int(1)){}
    	~SharedPtr(){Release();}
		//拷贝构造
    	SharedPtr(const SharedPtr<T>&sp):_ptr(sp._ptr),_pRefCount(sp._pRefCount){
            ++(*_pRefCount);
        }
    	//sp1 = sp2,赋值操作符
    	SharedPtr<T>&operator=(const SharedPtr<T>&sp){
            if(_ptr != sp._ptr){//是否是给自己赋值
                // 释放管理的旧资源sp1
                Release();
				// 共享管理新对象的资源,并增加引用计数
                _ptr = sp._ptr;
                _pRefCount = sp._pRefCount;//这里只是一个浅拷贝
                ++(*_pRefCount);//共享同一片内存sp2
            }
            return *this;
        }
    	T& operator*(){return *_ptr;}
		T* operator->(){return _ptr;}

    	int UseCount(){return *_pRefCount;}
		T* Get(){return _ptr;}
private:
	void Release(){
       // 引用计数先减1,如果减到0,则释放资源
        if(--(*_pRefCount) == 0){
            delete _ptr;
            delete _pRefCount;
            cout<<"资源释放了"<<endl;
            //以防万一
            _ptr = nullptr;
            _pRefCount = nullptr;
        }
    }
private:
	int*_pRefCount;//引用计数,注意这里不能写成引用,否则外面可以更改值,不安全
	T* _ptr;//指向管理资源的指针
	}
};
int main(){
	bit::sharedPtr<int>sp1(new int(10));
    bit::SharedPtr<int>sp2(sp1);
    return 0;
}

  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
C++智能指针shared_ptr讲解与使⽤ ⼿动管理的弊端 在简单的程序中,我们不⼤可能忘记释放 new 出来的指针,但是随着程序规模的增⼤,我们忘了 delete 的概率也随之增⼤。在 C++ 中 new 出来的指针,赋值意味着引⽤的传递,当赋值运算符同时展现出"值拷贝"和"引⽤传递"两种截然不同的语义时,就很容易导致"内 存泄漏"。 ⼿动管理内存带来的更严重的问题是,内存究竟要由谁来分配和释放呢?指针的赋值将同⼀对象的引⽤散播到程序各处,但是该对象的释放 却只能发⽣⼀次。当在代码中⽤完了⼀个资源指针,该不该释放 delete 掉它?这个资源极有可能同时被多个对象拥有着,⽽这些对象中的 任何⼀个都有可能在之后使⽤该资源,其余指向这个对象的指针就变成了"野指针";那如果不 delete 呢?也许你就是这个资源指针的唯 ⼀使⽤者,如果你⽤完不 delete,内存就泄漏了。 资源的拥有者是系统,当我们需要时便向系统申请资源,当我们不需要时就让系统⾃⼰收回去(Garbage Collection)。当我们⾃⼰处理的时 候,就容易出现各种各样的问题。 C++中的智能指针 ⾃C++11起,C++标准提供两⼤类型的智能指针: 1. Class shared_ptr实现共享式拥有(shared ownership)概念。多个智能指针可以指向相同对象,该对象和其相关资源会在"最后⼀个引 ⽤(reference)被销毁"时候释放。为了在结构复杂的情境中执⾏上述⼯作,标准库提供了weak_ptr、bad_weak_ptr和 enable_shared_from_this等辅助类。 2. Class unique_ptr实现独占式拥有(exclusive ownership)或严格拥有(strict ownership)概念,保证同⼀时间内只有⼀个智能指针 可以指向该对象。它对于避免资源泄露(resourece leak)——例如"以new创建对象后因为发⽣异常⽽忘记调⽤delete"——特别有⽤。 注:C++98中的Class auto_ptrC++11中已不再建议使⽤。 share_ptr 智能指针是(⼏乎总是)模板类,shared_ptr 同样是模板类,所以在创建 shared_ptr 时需要指定其指向的类型。shared_ptr 负责在不使 ⽤实例时释放由它管理的对象,同时它可以⾃由的共享它指向的对象。 shared_ptr 使⽤经典的 "引⽤计数" 的⽅法来管理对象资源。引⽤计数指的是,所有管理同⼀个裸指针( raw pointer )的 shared_ptr,都共享⼀个引⽤计数器,每当⼀个 shared_ptr 被赋值(或拷贝构造)给其它 shared_ptr 时,这个共享的引⽤计数器就加 1,当⼀个 shared_ptr 析构或者被⽤于管理其它裸指针时,这个引⽤计数器就减1,如果此时发现引⽤计数器为0,那么说明它是管理这个 指针的最后⼀个 shared_ptr 了,于是我们释放指针指向的资源。 在底层实现中,这个引⽤计数器保存在某个内部类型⾥(这个类型中还包含了 deleter,它控制了指针的释放策略,默认情况下就是普通的 delete操作),⽽这个内部类型对象在 shared_ptr 第⼀次构造时以指针的形式保存在 shared_ptr 中(所以⼀个智能指针的析构会影响到 其他指向同⼀位置的智能指针)。shared_ptr 重载了赋值运算符,在赋值和拷贝构造另⼀个 shared_ptr 时,这个指针被另⼀个 shared_ptr 共享。在引⽤计数归零时,这个内部类型指针与 shared_ptr 管理的资源⼀起被释放。此外,为了保证线程安全性,引⽤计数 器的加1,减1操作都是 原⼦操作,它保证 shared_ptr 由多个线程共享时不会爆掉。 对于 shared_ptr 在拷贝和赋值时的⾏为,《C++Primer第五版》中有详细的描述: 每个 shared_ptr 都有⼀个关联的计数值,通常称为引⽤计数。⽆论何时我们拷贝⼀个 shared_ptr,计数器都会递增。 例如,当⽤⼀个 shared_ptr 初始化另⼀个 shred_ptr,或将它当做参数传递给⼀个函数以及作为函数的返回值时,它所关联的计数 器就会递增。当我们给 shared_ptr 赋予⼀个新值或是 shared_ptr 被销毁(例如⼀个局部的 shared_ptr 离开其作⽤域)时,计数 器就会递减。⼀旦⼀个 shared_ptr 的计数器变为0,它就会⾃动释放⾃⼰所管理的对象。 下⾯看⼀个常见⽤法,包括: 1. 创建 shared_ptr 实例 2. 访问所指对象 3. 拷贝和赋值操作 4. 检查引⽤计数。 #include <iostream> #include
C++智能指针详解 1、概述 我们知道除了静态内存和栈内存外,每个程序还有⼀个内存池,这部分内存被称为⾃由空间或者堆。程序⽤堆来存储动态分配的对象即那些 在程序运⾏时分配的对象,当动态对象不再使⽤时,我们的代码必须显式的销毁它们。 在C++中,动态内存的管理是⽤⼀对运算符完成的:new和delete。 new:在动态内存中为对象分配⼀块空间并返回⼀个指向该对象的指针; delete:指向⼀个动态独享的指针,销毁对象,并释放与之关联的内存。 动态内存管理经常会出现两种问题: (1)⼀种是忘记释放内存,会造成内存泄漏; (2)⼀种是尚有指针引⽤内存的情况下就释放了它,就会产⽣引⽤⾮法内存的指针。 为了更加容易(更加安全)的使⽤动态内存,引⼊了智能指针的概念。智能指针的⾏为类似常规指针,重要的区别是它负责⾃动释放所指向 的对象。 标准库提供的两种智能指针的区别在于管理底层指针的⽅法不同:shared_ptr和unique_ptr。 (1)shared_ptr允许多个指针指向同⼀个对象; (2)unique_ptr则"独占"所指向的对象。 标准库还定义了⼀种名为weak_ptr的伴随类,它是⼀种弱引⽤,指向shared_ptr所管理的对象,这三种智能指针都定义在memory头⽂件 中。 2、auto_ptr (不要使⽤的指针) (1)内部⼤概实现:做成⼀个auto_ptr类,包含原始指针成员。 当auto_ptr类型的对象被释放时,利⽤析构函数,将拥有的原始指针delete掉。 //⼤概长这个样⼦(简化版) template<class T> class auto_ptr {   T* ptr; }; (2)⽰例⽤法: void runGame() { std::auto_ptr<Monster> monster1(new Monster());//monster1 指向 ⼀个怪物 monster1->doSomething();//怪物做某种事 }//runGame函数执⾏完时,monster1被释放,然后它的析构函数也把指向的⼀个怪物释放了 复制auto_ptr对象时,把指针指传给复制出来的对象,原有对象的指针成员随后重置为nullptr。 这说明auto_ptr是独占性的,不允许多个auto_ptr指向同⼀个资源。 void runGame() { std::auto_ptr<Monster> monster1(new Monster());//monster1 指向 ⼀个怪物 monster1->doSomething(); //怪物做某种事 std::auto_ptr<Monster> monster2 = monster1; //转移指针 monster2->doSomething(); //怪物做某种事 monster1->doSomething(); //Oops!monster1智能指针指向了nullptr,运⾏期崩溃。 } 注意: 虽然本⽂简单介绍了auto_ptr。 但是不要⽤auto_ptr! 不要⽤auto_ptr! 虽然它是c++11以前的最原始的智能指针,但是在c++11中已经被弃⽤(使⽤的话会被警告)了。 它的替代品,也就是c++11新智能指针unique_ptr,shared_ptr,weak_ptr。 3、shared_ptr(⼀种强引⽤指针) 多个shared_ptr指向同⼀处资源,当所有shared_ptr都全部释放时,该处资源才释放。 (有某个对象的所有权(访问权,⽣命控制权) 即是 强引⽤,所以shared_ptr是⼀种强引⽤型指针) (1)内部⼤概实现:每次复制,多⼀个共享同处资源的shared_ptr时,计数+1。每次释放shared_ptr时,计数-1。 当shared计数为0时,则证明所有指向同⼀处资源的shared_ptr们全都释放了,则随即释放该资源(哦,还会释放new出来的 SharedPtrControlBlock)。 //shared计数放在这个结构体⾥⾯,实际上结构体⾥还应该有另⼀个weak计数。下⽂介绍weak_ptr时会解释。 struct SharedPtrControlBlock {   int shared_count; }; //⼤概长这个样⼦(简化版) template<class T> class shared_ptr {   T* ptr;   SharedPtrControlBlock* count; }; (2)⽰例⽤法: void runGame() {   std::shared_ptr<Monster> monster1(new Monster());  //计数加到1  do{ std::shared_ptr<Monster> monster

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值