2018年怎么做网站排名,百度账号一键登录,搜索百度,做网站是先买域名还是前言: RAII是资源获得即初始化#xff0c; 是一种利用对象生命周期来控制程序资源地手段。 智能指针是在对象构造时获取资源#xff0c; 并且在对象的声明周期内控制资源#xff0c; 最后在对象析构的时候释放资源。注意#xff0c; 本篇文章参考——C 智能指针 - 全部用法… 前言: RAII是资源获得即初始化 是一种利用对象生命周期来控制程序资源地手段。 智能指针是在对象构造时获取资源 并且在对象的声明周期内控制资源 最后在对象析构的时候释放资源。注意 本篇文章参考——C 智能指针 - 全部用法详解-CSDN博客 看完博主的文章的友友们 可以去看一下该篇文章 该作者写的比博主通俗易懂。 目录
为什么需要智能指针
智能指针
auto_ptr
auto_ptr的用法:
auto_ptr的模拟实现:
unique_ptr
unique_ptr的用法
unique_ptr的模拟实现
shared_ptr
shared_ptr的用法 shared_ptr的模拟实现v1版本
weak_ptr
weak_ptr的用法:
weak_ptr的模拟实现
shared_ptr中的定制删除器
智能指针坑点 为什么需要智能指针 首先我们来看一下这一个简单的程序: void func()
{int* p new int;
}int main()
{func();return 0;
}在这个程序里面 func中定义了一个指向堆区一块空间的p。 但是当出了作用域后 p指针就被销毁了 但是p指针指向的空间没有被销毁这个时候就发生了内存泄漏。 另外一种情况就是我们虽然手动释放了内存 但是中途发生了异常 程序发生跳转 手动释放内存被截胡了。 也会导致发生内存泄漏。
void test()
{int* ptr new int;if (1) {throw 发生异常; //这里发生截胡 无法走到下一行。}delete ptr; //这里没有释放资源
}int main()
{try {test();}catch (const char* str){cout str endl;}catch (...) {cout 未知异常 endl;}return 0;
}
而只能指针就是为了这种情况设计出来的。也就是说 智能指针就是为了我们能够方便管理动态内存分配的资源 它能够在对象的声明周期结束时自动释放这些资源。 如图为一个简单的智能指针 在这个智能指针当中 当我们创建对象时可以使用一块资源初始化。 然后这块资源就会在这个对象的生命周期结束时自动销毁。 这就是智能指针的基本原理 虽然我们使用指针时 指针指向的空间不会被自动释放。但是对象在生命周期结束时会自动释放 所以我们把指针指向的资源放到对象里 让对象在释放自身的时候将资源一起释放掉。
智能指针 现在有三个智能指针的解决方案 auto_ptr C98 unique_ptr C11 share_ptr C11 另外 还有一个用来解除share_ptr中的循环引用问题的解决方案。 wake_ptr C11 auto_ptr
auto_ptr的用法: 使用智能指针需要包含头文件memory, 具体使用方法如下:
#includememory //只用智能指针需要包含memory头文件int main()
{auto_ptrint p(new int); //利用auto_ptr创建一个管理int指针资源的对象auto_ptrlistint pl(new listint); //利用auto_ptr创建一个管理listint类型的指针资源的对象*p 4; //auto_ptrint类型也能进行解引用操作(*pl).push_back(16); //容器的指针 解引用后就是容器本身。(*pl).push_back(15);(*pl).push_back(14);(*pl).push_back(13);(*pl).push_back(12);cout *p endl; //打印*pauto it (*pl).begin(); //pl解引用获得listint对象 可以像使用指针while (it ! (*pl).end()) {cout *it endl;it;}return 0;
} 这里创建智能指针对象是: auto_ptr类型名 p(new 类型名) 这里创建的时候不能使用 ’ ‘ 只能使用 ( ) ; auto_ptr是在C98创建出来的 但是这个智能指针在之后很少被人用。 因为它有一个弊端 就是当进行拷贝的时候 该智能指针管理的资源会被 ”抛弃“ 另一个智能指针进行接收。 也就是如图: 这个模式存在一些弊端。如果我们使用一个容器进行插入操作的时候插入操作一定会赋值。 那么赋值就会导致原本智能指针对象中的资源被转移。 另外 auto_ptr的另一个弊端就是auto_ptr不支持对象数组的操作。所以在C11出现更好的unique_ptr和share_ptr后auto_ptr已经很少被使用。 auto_ptr有三个常用接口。 get, release, reset。
三个函数的主要功能
1. get get是获取对象中管理的资源 2.release release 是取消对象中管理的资源 3.reset reset 是重新分配对象中管理的资源 auto_ptr的模拟实现:
//首先 对于智能指针来说他们的模板类名是这样的 templateclass T //模板类 可以接收T类型的资源class auto_ptr //智能指针类名{};
//然后 在类里面定义资源类型的指针 用来维护这块资源: templateclass Tclass auto_ptr{private:T* _ptr; //T类型资源的指针 用来维护一块资源};
//所有智能指针的构造都是一样的 就是使用一块资源交给智能指针里面的指针变量进行维护。 auto_ptr(T* ptr):_ptr(ptr){}//auto_ptr的拷贝构造 其实就是把一个智能指针管理的资源 “抛弃”然后另一个智能指针进行接收。 至于这样做的弊端 上面已经提到过 这里不赘述。 auto_ptr(auto_ptrT ptr):_ptr(ptr._ptr) {ptr._ptr nullptr;}
//最重要的就是智能指针的销毁 销毁时 要将管理的资源一块释放掉 代码如下: ~auto_ptr() {delete _ptr;_ptr nullptr;}
//然后智能指针还要像普通指针一样能够进行基本运算——加加 减减 解引用等。那么就要重载这些运算符 如下图: T operator*() //解引用{return *_ptr;}T* operator-() //箭头{return _ptr;}auto_ptrT operator() //加加重载{_ptr;return *this;}
unique_ptr
unique_ptr的用法
unique_ptr相交于auto_ptr更加严谨 它相对于auto_ptr做了一下改变: 两块指针不能指向同一块资源(否则在释放空间时多次释放空间报错)。 同时它也不能赋值注意 右值可以赋值但是右值赋值后 如果该右值为一个左值临时转化的 那么使用赋值后和auto_ptr的效果一样
左值赋值 右值赋值 要注意的坑点就是不能一块资源给多个对象赋值 不然会报错: auto_ptr也一样 这是unique_ptr和auto_ptr中使用的坑。 后面的share_ptr解决了这个坑点引用计数
unique_ptr的模拟实现
有前面auto_ptr的基础 这里unique_ptr的细节不再讲解 只讲解重要的部分:
//首先模板类 templateclass Tclass unique_ptr {private:T* _ptr; //管理资源};//然后就是主要的地方 unique_ptr不能进行赋值 所以要将拷贝构造和赋值重载封起来。 templateclass Tclass unique_ptr {public:unique_ptr(T* ptr):_ptr(ptr) {}private:unique_ptr(unique_ptrT ) delete; //将拷贝构造删掉unique_ptrT operator(unique_ptrT ) delete; //将赋值重载删掉private:T* _ptr;};
shared_ptr
shared_ptr的用法
shared_ptr解决了unique_ptr和auto_ptr的排他性 shared_ptr即使多个智能指针指向同一块空间也能正常工作。 shared_ptr采用了引用计数 当一个新的share_ptr指针管理一块资源的时候 引用计数就1, 当一个shared_ptr指针过期时 引用计数就-1。当一块资源的引用计数到0时 这块资源就可以被释放。
1. use_count() : 获得当前资源的引用计数 2.conductor: 有多种构造形式——直接赋值一块资源、 赋值一块数组资源、传送定制删除器。
定义如下:
//带有定制删除器
templateclass U, class Dshared_ptr(U* p, D del)
//普通构造
templateclass Ushared_ptr(U* p)
//数组构造
shared_ptrT[] p(new T[5]{1, 2, 3, 4, 5}); //据说是C17后支持, 但是vsC14也能跑
3.make_shared
make_shared可以用来分配一块空间并且初始化这块空间 效率更加高效。make_shared是一个函数模板 并且需要指定分配资源的类型 如图: shared_ptr的模拟实现v1版本
首先类名 解引用之类和其他智能指针相差不大 这里不做赘述 然后有区别的就是成员变量以及构造 拷贝 赋值。 首先看成员变量 成员变量需要有一块空间来作为引用计数。 templateclass Tclass shared_ptr {private:T* _ptr;int* _pcount;};
*_pcount作为引用计数。
//构造 //引用计数ptrshared_ptr(T* ptr):_ptr(ptr) {*_pcount 1;}
//拷贝构造 //引用计数地拷贝构造shared_ptr(shared_ptrT ptr) :_ptr(ptr._ptr),_pcount(ptr._pcount){(*_pcount);}
//析构 ~shared_ptr() {if (--(*_pcount) 0) {delete _ptr;delete _pcount;}}
赋值 这里赋值要先将原本的管理的资源取消托管 那么引用计数就要减一 还要判断引用计数是否为0 为0就要释放资源。 shared_ptrT operator(shared_ptrT p) {if (_ptr ! p._ptr) //如果不判断 当自己给自己赋值的时候 自己会先将自己的资源释放 然后就变成了野指针。 自己再给自己赋值一个野指针。 就会报错。{if (--(*_pcount) 0){delete _ptr;delete _pcount;}//_ptr p._ptr;_pcount p._pcount;(*_pcount);}return *this;}
shared_ptr中的坑 1. 其实 shared_ptr还有一种情况同样具有排他性, 和unique_ptr、auto_ptr一样 当没有调用拷贝构造 而是直接使用构造函数的时候 引用计数不回加一 那么就会多次释放资源。 这个无法避免。 2.第二个坑就是循环引用的问题为了方便观察 我们使用我们自己定义的shared_ptr进行测试 现在看如下一个例子:
#includeshare_ptr.h //自己写的shared_ptr头文件
struct chicken; //前置声明struct fish //定义一个鱼类对象 里面有一个鸡的智能指针实例
{cws_RAII::shared_ptrchicken _chicken;
};struct chicken //定义一个鸡类对象 里面有一个鱼的智能指针实例。
{cws_RAII::shared_ptrfish _fish;
};int main()
{cws_RAII::shared_ptrfish f1(new fish);cws_RAII::shared_ptrchicken c1(new chicken);(*f1)._chicken c1;//(*c1)._fish f1;return 0;
} 在当前状态下 我们如果运行程序 f1的资源和c1的资源可以被释放 但是如过图中(*c1)._fish f1取消注释 那么f1的资源和c1的资源就不能被释放。 这是为什么
其实 这就是循环引用的问题。 在这里面 如果只定义了f1和c1. 这个时候是这样的: 但是如果给执行两条赋值语句后 就变成了这样: 这个时候当f1和c1的生命周期结束时 f1的_pcount-- c1的_pcount--。 这两个_pcount都只能变成1 变不成0 所以不能释放资源。 所以 我们在使用shared_ptr时 要避免交叉赋值的情况。否则会出现内存泄漏。
weak_ptr
weak_ptr是用来解决shared_ptr的循环引用问题。 当两个类需要交叉进行赋值的时候 类中所定义的智能指针可以使用weak_ptr(原本使用shared_ptr), 因为weak_ptr不会增加资源的引用计数。
weak_ptr的用法:
weak_ptr本人觉得最重要的一点就是可以和shared_ptr进行相互转化
int main()
{shared_ptrfish f2(new fish);weak_ptrfish f3(f2); //将一个shared_ptr给给f3f3 f2; //将shared_ptr赋值给weak_ptrf2 f3.lock(); //将一个weak_ptr使用lock接口转化为shared_ptr; return 0;
}
同时 还可以构造出一个空指针: int main()
{weak_ptrfish f3; //构造一个空指针return 0;
}
但是 wear_ptr不支持解引用以及- weak_ptr也能使用use_count函数查看引用计数: weak_ptr的模拟实现 templateclass Tclass weak_ptr {public://不支持RAII 也就是不能初始化管理资源weak_ptr(const shared_ptrT ptr) {_ptr ptr._ptr; //这里可以将weak_ptr弄成shared_ptr的友元 就能访问私有_ptr_pcount ptr._pcount;}weak_ptrT operator(const shared_ptrT ptr) {_ptr ptr._ptr;_pcount ptr._pcount;return *this;}int use_count() {return (*_pcount);}T* get() {return _ptr;}private:T* _ptr;int* _pcount;};
shared_ptr中的定制删除器 在shared_ptr中 可以管理一块连续的数组空间 也可以管理一个单独的一块空间。 这两种资源类型需要不同的销毁方法。 单独的使用delete, 而数组空间需要使用delete[], 库里面的默认是使用delete, 但是如果我们想使用delete[]来销毁一块数组空间。 或者我们使用shared_ptr管理一块文件 shared_ptr生命周期结束时关闭文件。 那么就需要我们自己传一个定制删除器。 定制删除器是放在如图所示红框框的代码块中: 定制删除器的用法: 如何实现定制删除器
其实定制删除器就是添加一个模板类 如图: 下面是shared_ptr完整的版本v2 templateclass Tclass shared_ptr {public://引用计数ptrshared_ptr(T* ptr nullptr):_ptr(ptr) ,_pcount(new int(0)){if (_ptr ! nullptr) {*_pcount 1;}}//引用计数地拷贝构造shared_ptr(shared_ptrT ptr) :_ptr(ptr._ptr),_pcount(ptr._pcount){(*_pcount);}//添加一个带有定制删除器的构造函数templateclass D //D就是定制删除器的模板类shared_ptr(T* ptr, D del):_Del(del), _ptr(ptr) {}void destroy() {if (--(*_pcount) 0) {_Del; //将定制删除器放在这就好了}}~shared_ptr() {destroy();}//赋值shared_ptrT operator(shared_ptrT p) {if (_ptr ! p._ptr) {destroy();//_ptr p._ptr;_pcount p._pcount;(*_pcount);}return *this;}T* operator-() {return _ptr;}T operator*() {return *_ptr;}T* _ptr;int* _pcount;functionvoid(T*) _Del [](T*) {delete _Del};};智能指针坑点
在看完大佬们的博客之后 本人也总结了一些智能指针的 “坑点“ 这个坑点其实都是围绕 原生指针 展开的。
第一个原生指针不能用来初始化智能指针 否则两个智能指针指向同一块资源 引用计数不增加。智能指针过期时会报错
第二个get获得的原生指针 不能delete掉 否则智能指针在过期后还会delete。会报错
第三个get获得的原生指针也是原生指针 不能初始化另一个智能指针。
第四个release返回后的原生指针要被delete掉。 否则内存泄漏。
----以上 就是本篇全部内容。
