【C++】auto_ptr为何被唾弃?以及其他智能指针的学习
搭配异常可以让异常的代码更简洁
文章目录
- 智能指针
- 内存泄漏的危害
- 1.auto_ptr(非常不建议使用)
- 2.unique_ptr
- 3.shared_ptr
- 4.weak_ptr
- 总结
智能指针
C++中为什么会需要智能指针呢?下面我们看一下样例:
int div()
{int a, b;cin >> a >> b;if (b == 0)throw invalid_argument("除0错误");return a / b;
}
void Func()
{// 1、如果p1这里new 抛异常会如何?// 2、如果p2这里new 抛异常会如何?// 3、如果div调用这里又会抛异常会如何?int* p1 = new int;int* p2 = new int;cout << div() << endl;delete p1;delete p2;
}
int main()
{try{Func();}catch (exception& e){cout << e.what() << endl;}return 0;
}
在上面的代码中,一旦出现异常那就会造成内存泄漏,什么是内存泄漏呢:
如果func函数里的p1new的时候抛异常该怎么办呢?对于第一个new如果抛异常会直接跳到main函数中的catch被捕获,那么p2new失败了会怎么办呢?div函数抛异常我们可以捕获一下:
那么如果是p2失败了我们还要再catch一下:
void Func()
{// 1、如果p1这里new 抛异常会如何?// 2、如果p2这里new 抛异常会如何?// 3、如果div调用这里又会抛异常会如何?int* p1 = new int;int* p2 = nullptr;try{p2 = new int;try{cout << div() << endl;}catch (...){delete p1;delete p2;throw;}}catch (...){delete p1;delete p2;}
}
那么这样的代码看起来会不会有些冗余呢?为了处理这样的问题,智能指针就能起到很好的作用:
template <class T>
class SmartPtr
{
public:SmartPtr(T* ptr):_ptr(ptr){}~SmartPtr(){delete _ptr;cout << _ptr << endl;}
private:T* _ptr;
};
int div()
{int a, b;cin >> a >> b;if (b == 0)throw invalid_argument("除0错误");return a / b;
}
void Func()
{int* p1 = new int;SmartPtr<int> sp1(p1);int* p2 = new int;SmartPtr<int> sp2(p2);cout << div() << endl;delete p1;delete p2;
}
int main()
{try{Func();}catch (exception& e){cout << e.what() << endl;}return 0;
}
可以看到有了智能指针即使抛异常了我们没有释放的空间也会被自动释放,因为抛异常后自定义类型出了作用域我们智能指针的析构函数会将这个空间释放。当然,我们的智能指针也可以直接创建资源,比如下面这样:
但是我们这样写不就不可以对指针解引用访问指针的资源了吗?其实我们只需要再给智能指针多加加个功能让它变得像指针一样就解决了这个问题:
template <class T>
class SmartPtr
{
public://保存资源SmartPtr(T* ptr):_ptr(ptr){}//释放资源~SmartPtr(){delete _ptr;cout << _ptr << endl;}//像指针一样T& operator*(){return *_ptr;}T* operator->(){return _ptr;}T& operator[](size_t pos){return _ptr[pos];}
private:T* _ptr;
};
这个时候我们来使用一下这个指针:
可以看到现在我们的这个智能指针也可以正常使用了,再次说明一下:智能指针的构造函数是为了保存资源,析构函数是为了释放资源,其他功能是为了和指针一样。我们上面将资源管理的责任托管给对象的做法就叫做RAII(资源获得即初始化),这就是避免内存泄漏的一种方法。
那么C++库里面有没有智能指针呢?答案是有的,并且有好几种。
auto_ptr:
下面我们看一下C++中被骂了很多年的一款智能指针auto_ptr.
上图中出错的原因是重复析构了两次sp1,这是因为我们用的编译器自动生成的拷贝构造,是个浅拷贝。auto_ptr的最大问题在于就像我们的SmartPtr一样支持拷贝但是又会让另一个指针悬空,什么意思呢,我们先来调试看一下然后把代码写出来:
上图是拷贝之前sp1的资源
上图是拷贝之后sp2的资源,我们可以看到auto_ptr的拷贝就是将资源管理权转移,原本sp1指向的内容被sp2指向了,但是问题就在于auto_ptr竟然让原先的sp1指针悬空了也就是说什么也没指向,这就导致不知道的人对原先sp1这个指针解引用等操作,这样就对空指针进行解引用了,这就是auto_ptr被吐槽的根源所在。下面我们看看auto_ptr是如何实现的:
namespace sxy
{template <class T>class auto_ptr{public://保存资源auto_ptr(T* ptr):_ptr(ptr){}//拷贝构造auto_ptr(auto_ptr<T>& ap):_ptr(ap._ptr){ap._ptr = nullptr;}//释放资源~auto_ptr(){delete _ptr;cout << _ptr << endl;}//像指针一样T& operator*(){return *_ptr;}T* operator->(){return _ptr;}T& operator[](size_t pos){return _ptr[pos];}private:T* _ptr;};
}
上面代码中大家重点看auto_ptr的构造函数就可以了:
一旦我们对之前的空指针sp1进行解引用操作程序立马就挂掉了。注意:auto_ptr这款指针指针,很多公司都明确规定不能使用它,如果有面试官让你写一款智能指针,一定不要写auto_ptr!!!
下面我们讲解三种算是经常被使用的智能指针:unique_ptr, shared_ptr, weak_ptr.我们可以先看看unique_ptr是如何实现的:
unique_ptr:
其实unique_ptr的实现很简单,就是直接禁掉了拷贝构造函数和赋值重载。
template <class T>class unique_ptr{public://保存资源unique_ptr(T* ptr):_ptr(ptr){}//拷贝构造unique_ptr(const unique_ptr<T>& up) = delete;unique_ptr<T>& operator=(const unique_ptr<T>&) = delete;//释放资源~unique_ptr(){delete _ptr;cout << _ptr << endl;}//像指针一样//.........private:T* _ptr;};
后面像指针一样的功能都是相同的我们就直接删掉了,可以看到unique_ptr的实现还是非常简单粗暴的。
当然也不能都不能拷贝吧,所以又出现了一个可以进行拷贝的指针指针shared_ptr,这个智能指针可算是在这之中最优秀的了,下面我们来讲讲:
shared_ptr:
int main()
{shared_ptr<int> sp1(new int(0));shared_ptr<int> sp2(sp1);(*sp1)++;(*sp2)++;cout << *sp1 << endl;cout << *sp2 << endl;return 0;
}
我们可以看到shared_ptr不仅可以拷贝还没有之前那么多的问题,那么shared_ptr是如何实现的呢?实际上shared_ptr的是借助引用计数实现的,我们可以调试看一下:
经过拷贝后引用计数由1变成了2,如下图:
那么如何实现引用计数比较好呢?是在类中加一个私有成员变量count吗?首先直接加私有变量肯定是不可以的,因为我们的引用计数是要所有的类对象都能看到并且只有一份,如果是私有变量count那么多个对象每个对象都有一个count就不叫引用计数了。那么能否用static静态成员变量呢?静态成员变量不就是所有对象都有的吗?注意:静态的是不可以的,静态变量是属于整个类的,前三个指针指向的都是同一块资源计数为3,然后第四个指针指向不同的资源,这个不同的指针的计数器应该是1才对,但是如果将静态计数器改为1那么前三个指针的计数右不对了,所以不能使用静态变量。这里我们可以使用静态的map来做计数器,让每个不同的资源与计数器做一个KV映射,拷贝哪个资源就映射到map让V值++即可,这里提供一个最好的方式:多开一个指针,这个指针里保存的就是一个计数器,相同拷贝的资源里的计数器指针直接指向这个计数器即可。
了解了这个后我们就来实现一下,不理解的也没关系看着下面的代码就理解了:
template <class T>class shared_ptr{public://保存资源shared_ptr(T* ptr):_ptr(ptr),_pcount(new int(1)){}//拷贝构造shared_ptr(const shared_ptr<T>& sp):_ptr(sp._ptr),_pcount(sp._pcount){++(*_pcount);}//释放资源~shared_ptr(){if (--(*_pcount) == 0){delete _ptr;delete _pcount;}}//像指针一样//.......private:T* _ptr;int* _pcount;};
首先类中私有成员多了一个_pcount的引用计数,注意:这是在堆上开的空间。我们在构造函数初始化的时候,每当有新的对象被创建我们就给这个引用计数初始化为1,释放资源的时候我们不能直接释放,因为有可能其他拷贝的对象和我们指向同一块资源,所以这个时候我们只需要将引用计数--即可,注意:我们用的前置--只要进入判断语句就会先解引用拿到计数器的值然后--之后才会判断,即使判断条件不满足还是会--计数器,只有当计数器为0说明没有对象在指向这个资源了,那么这个时候就可以将资源释放了,释放的时候记得将引用计数也释放了防止内存泄漏。我们的拷贝构造就非常简单了,直接让ptr和pcount指向被拷贝的那个对象的资源,然后让计数器++就行了。
当然即使支持了拷贝构造那么赋值重载也是能支持的,因为已经不惧怕拷贝了嘛。对于赋值重载我们一定要铭记:防止相同资源进行赋值,防止直接释放资源导致其他对象不能使用其资源,下面我们给出代码:
//赋值重载shared_ptr<T>& operator=(shared_ptr<T>& sp){if (_ptr != sp._ptr){if (--(*_pcount) == 0){delete _ptr;delete _pcount;}_ptr = sp._ptr;_pcount = sp._pcount;++(*_pcount);}return *this;}
首先我们判断了相同资源赋值的情况,因为我们本身是被sp赋值的,所以我们本身的计数一定会少一个,一旦计数少了那么就要判断是否需要释放资源,所以我们还是减自身的计数器,如果减到0了我们就将自身的资源释放掉,如果没有到0就不释放,然后获取sp的资源和引用计数,因为sp赋值给我们我们本身少了一个sp多了一个,所以获取sp的计数器资源后我们还要加加一下计数器。下面我们验证一下是否正确:
int main()
{sxy::shared_ptr<int> sp1(new int(0));sxy::shared_ptr<int> sp2(sp1);(*sp1)++;(*sp2)++;cout << *sp1 << endl;cout << *sp2 << endl;sxy::shared_ptr<int> sp3 = sp1;sxy::shared_ptr<int> sp4(new int(10));sxy::shared_ptr<int> sp5 = sp4;return 0;
}
可以看到程序是没有问题的,不管是赋值还是拷贝都可以完成任务。下面我们提出一个新问题:如果我们目前的场景是多线程并发的,那么引用计数还能正确的计数吗我们来看看:
#include <thread>int main()
{sxy::shared_ptr<int> sp(new int(1));int n = 10000;thread t1([&, n](){for (int i = 0; i < n; i++){sxy::shared_ptr<int> cp1(sp);}});thread t2([&, n](){for (int i = 0; i < n; i++){sxy::shared_ptr<int> cp2(sp);}});t1.join();t2.join();cout << sp.use_count() << endl;return 0;
}
首先我们创造了一个场景,这个场景是两个线程多次对sp这个智能指针进行拷贝,最后我们输出这个智能指针的引用计数,注意:shared_ptr中通常会有use_count这个接口返回当前资源的引用计数,实现如下:
int use_count() const{return *_pcount;}
注意:如果use_count返回1是正确的,因为我们是在返回前打印的,所以这个时候还有sp这个指针指向这个资源,所以是1.下面我们运行起来:
如果我们多运行几次就会发现程序有时候是正常的有时候是不正常的,那么这种情况一定是有问题的,那么该如何解决这个问题呢?其实很简单加锁就可以了。
因为我们的shared指针可以支持拷贝和赋值,所以我们定义锁的时候还是像引用计数一样不能让每个对象都有一个锁,并且这个锁还要支持赋值等操作,要知道库里的锁是不支持赋值的直接禁掉了,所以我们只需要定义一个锁的指针,赋值的时候把锁资源让另一个对象指向即可。注意:我们的锁一定是要保护每个资源对应的引用计数器的,所以相当于每个对象有三个资源:数据资源,计数器资源,锁资源。
当然加锁之前我们还可以优化一下:
template <class T>class shared_ptr{public://保存资源shared_ptr(T* ptr):_ptr(ptr),_pcount(new int(1)){}//拷贝构造shared_ptr(const shared_ptr<T>& sp):_ptr(sp._ptr),_pcount(sp._pcount){++(*_pcount);}void Release(){if (--(*_pcount) == 0){delete _ptr;delete _pcount;}}//赋值重载shared_ptr<T>& operator=(shared_ptr<T>& sp){if (_ptr != sp._ptr){Release();_ptr = sp._ptr;_pcount = sp._pcount;++(*_pcount);}return *this;}//释放资源~shared_ptr(){Release();}int use_count() const{return *_pcount;}//像指针一样//.........private:T* _ptr;int* _pcount;};
我们直接用一个Release()函数代替释放资源的函数,这样代码看起来会更简单,下面我们开始加锁:
template <class T>class shared_ptr{public://保存资源shared_ptr(T* ptr):_ptr(ptr),_pcount(new int(1)),_pmtx(new mutex){}//拷贝构造shared_ptr(const shared_ptr<T>& sp):_ptr(sp._ptr),_pcount(sp._pcount),_pmtx(sp._pmtx){_pmtx->lock();++(*_pcount);_pmtx->unlock();}void Release(){_pmtx->lock();if (--(*_pcount) == 0){delete _ptr;delete _pcount;}_pmtx->unlock();}//赋值重载shared_ptr<T>& operator=(shared_ptr<T>& sp){if (_ptr != sp._ptr){Release();_ptr = sp._ptr;_pcount = sp._pcount;_pmtx = sp._pmtx;_pmtx->lock();++(*_pcount);_pmtx->unlock();}return *this;}//释放资源~shared_ptr(){Release();}int use_count() const{return *_pcount;}//像指针一样// ...............private:T* _ptr;int* _pcount;mutex* _pmtx;};
我们构造初始化的时候先给锁的指针开一个锁,拷贝构造如果谁和我们指向同一块资源那么就让他的锁的指针指向我们开好的锁,然后遇到计数器++或者--的地方我们就加锁保护起来,这样在计数器++或--的过程中即使是多线程也依旧是串行的而不是并行的,下面我们运行起来看看能否解决刚刚的问题:
经过多次的运行后我们发现是没问题的,但是如果有细心的同学应该会发现我们的指针new了锁但是没有释放啊,所以下面我们赶紧加上:
void Release(){bool flag = false;_pmtx->lock();if (--(*_pcount) == 0){delete _ptr;delete _pcount;flag = true;}_pmtx->unlock();if (flag){delete _pmtx;}}
我们再保护计数器的时候用了锁,所以不能在if语句中释放ptr和pcount资源的时候将锁释放,而是需要一个标志只要计数器为0需要释放资源了那么就将标志标记,最后解锁后将锁释放就好了。
那么我们前面已经说过,锁是保护计数器的,那么指针指向的资源该如何被保护呢?下面我们写个例子:
struct Date
{int _year = 0;int _month = 0;int _day = 0;
};
int main()
{sxy::shared_ptr<Date> sp(new Date);int n = 100000;thread t1([&, n](){for (int i = 0; i < n; i++){sxy::shared_ptr<Date> cp1(sp);cp1->_day++;cp1->_month++;cp1->_year++;}});thread t2([&, n](){for (int i = 0; i < n; i++){sxy::shared_ptr<Date> cp2(sp);cp2->_day++;cp2->_month++;cp2->_year++;}});t1.join();t2.join();cout << sp.use_count() << endl;cout << sp->_year << " : " << sp->_month << " : " << sp->_day << endl;return 0;
}
我们可以看到正常的结果应该是200000才对,对于这种情况我们只需要对资源进行加锁即可:
int main()
{sxy::shared_ptr<Date> sp(new Date);int n = 100000;mutex mtx;thread t1([&, n](){for (int i = 0; i < n; i++){sxy::shared_ptr<Date> cp1(sp);mtx.lock();cp1->_day++;cp1->_month++;cp1->_year++;mtx.unlock();}});thread t2([&, n](){for (int i = 0; i < n; i++){sxy::shared_ptr<Date> cp2(sp);mtx.lock();cp2->_day++;cp2->_month++;cp2->_year++;mtx.unlock();}});t1.join();t2.join();cout << sp.use_count() << endl;cout << sp->_year << " : " << sp->_month << " : " << sp->_day << endl;return 0;
}
加锁后我们运行多次答案依旧是正确的,所以一定要注意:shared_ptr的锁只保护引用计数,不保护指针所指向的资源。
总结:shared_ptr本身是线程安全的(拷贝和析构时,引用计数++ --是线程安全的)
shared_ptr管理资源的访问不是线程安全的,需要用的地方自行保护。
下面我们讲一下shared_ptr的循环引用问题:
struct ListNode
{int val;/*ListNode* _next;ListNode* _prev;*/sxy::shared_ptr<ListNode> _next;sxy::shared_ptr<ListNode> _prev;~ListNode(){cout << "distory" << endl;}
};int main()
{sxy::shared_ptr<ListNode> n1(new ListNode);sxy::shared_ptr<ListNode> n2(new ListNode);//n1->_next = n2;//n2->_prev = n1;return 0;
}
现在有两个链表,我们用指针指针让他们在析构的时候可以自己释放节点的空间,当我们不让n1和n2前后连接时,运行可以正常释放:
注意:我们为了能在ListNode中将next和prev设为智能指在构造函数中加了缺省参数,否则编译不过去:
然后我们让n1和n2两个节点前后链接再看看是否可以可以成功释放:
可以看到释放不了,这就是循环引用,循环引用会导致内存泄漏。下面我们讲讲原理:
刚开始这两个节点引用计数为1是因为n1和n2都是智能指针,初始化引用计数为1,一点n1的next链接到n2,这个时候相当于n1的next管理了n2(因为我们链表节点中prev和next也是智能指针),这样的话n2就由n1的next和n2本身这个智能指针一起管理,所以引用计数变成2,n1也同理变成2.然后出了n1和n2作用域要析构的时候他们引用计数--变成了1,如下图:
这个时候n1这个资源由n2的prev管理,n2这个资源由n1的next管理,析构的时候没有办法析构了呀,n1要析构那么next管理的资源的引用计数必须减为0但是n2的引用计数不为0,n2要析构那么prev管理的资源的引用计数必须减为0但是n1的引用计数不为0,谁都退出不了就导致了死循环,所以最后就无法成功释放,造成了内存泄漏。为了解决这个问题,weak_ptr就应运而生了。我们刚刚最主要的问题在于next和prev这两个指针参与资源的管理了导致引用计数变了,如果我们让这两个指针不参与资源的管理不就解决了吗,实际上weak_ptr就是一个不参与资源管理的指针,并且weak_ptr是配合shared_ptr使用的。
整体分析:
weak_ptr:
下面是没有用weak_ptr的n1和n2的退出前的引用计数:
下面是用weak_ptr的n1和n2的退出前的引用计数:
struct ListNode
{int val;//weak_ptr可以指向资源,访问资源,不参与资源管理,不增加引用计数weak_ptr<ListNode> _next;weak_ptr<ListNode> _prev;~ListNode(){cout << "distory" << endl;}
};
下面我们就实现一下weak_ptr:
template <class T>class weak_ptr{public:weak_ptr():_ptr(nullptr){}weak_ptr(const shared_ptr<T>& sp):_ptr(sp.get()){}weak_ptr<T>& operator=(const shared_ptr<T>& sp){//由于_ptr是私有成员weak_ptr无法直接访问,所以shared_ptr有一个get()接口是返回_ptr的_ptr = sp.get();return *this;}//像指针一样.................private:T* _ptr;};
首先weak_ptr不接受RAII操作,也就是说单独使用weak_ptr起不到释放的作用,是需要配合shared_Ptr解决循环引用问题的。我们前面说过,weak_ptr不管理资源,引用计数也不会++,所以这个指针只会指向shared_ptr指向的资源。
下面我们就用自己的weak_ptr解决一下循环引用问题:
通过运行结果可以看到没有任何问题。
总结
相关文章:

【C++】auto_ptr为何被唾弃?以及其他智能指针的学习
搭配异常可以让异常的代码更简洁 文章目录 智能指针 内存泄漏的危害 1.auto_ptr(非常不建议使用) 2.unique_ptr 3.shared_ptr 4.weak_ptr总结 智能指针 C中为什么会需要智能指针呢?下面我们看一下样例: int div() {int a, b;cin >&g…...

数据结构练习题1:基本概念
练习题1:基本概念 1 抽象数据类型概念分析2. 逻辑结构与存储结构概念分析3.综合选择题4.综合判断题5.时间复杂度相关习题6 时间复杂度计算方法(一、二、三层循环) 1 抽象数据类型概念分析 1.可以用(抽象数据类型)定义…...

如何消除Msxml2.XMLHTTP组件的缓存
之前使用这个组件,是每隔十分钟取数据,没有遇到这个缓存问题, 这次使用它是频繁访问接口,就出现了一直不变的问题。觉得是缓存没有清除的问题。 网上搜了一些方案。最好的方案就是给url地址末尾给一个随机参数。用于让组件觉得是…...

深入理解Java虚拟机jvm-运行时数据区域(基于OpenJDK12)
运行时数据区域 运行时数据区域程序计数器Java虚拟机栈本地方法栈Java堆方法区运行时常量池直接内存 运行时数据区域 Java虚拟机在执行Java程序的过程中会把它所管理的内存划分为若干个不同的数据区域。这些区域有各自的用途,以及创建和销毁的时间,有的…...
(OpenCV) 基础demo
文章目录 前言Demo图片录制播放人脸识别 END 前言 OpenCV - Open Computer Vision Library OpenCV的名声想必不用多说了。 本文介绍4个基础使用demo。分别为,显示图片,录制视频,播放视频和一个基于开源算法库的人脸识别小demo。 只要环境…...
using 的使用
作者: 苏丙榅 链接: https://subingwen.cn/cpp/using/ 在 C 中 using 用于声明命名空间,使用命名空间也可以防止命名冲突。在程序中声明了命名空间之后,就可以直接使用命名空间中的定义的类了。在 C11 中赋予了 using 新的功能,让C变得更年轻…...
Websocket、Socket、HTTP之间的关系
Websocket、Socket、HTTP之间的关系 ★ Websocket是什么?★ Websocket的原理★ websocket具有以下特点:★ webSocket可以用来做什么?★ websocket与socket区别:★ WebSocket与HTTP区别 ★ Websocket是什么? ● Websocket是HTML5下…...
hustoj LiveCD版系统在局域网虚拟机安装和配置
root权限 打开terminal命令行输入sudo su输入初始密码freeproblemsetmysql数据库的密码的位置,如何登陆数据库 数据库账号密码存放在两个配置文件中: /home/judge/etc/judge.conf/home/judge/src/web/include/db_info.inc.php 新版本中,快…...
读书-代码整洁之道10-14
类 类的三大特性:封装、继承、多态;类应该短小;单一权责原则认为,类或模块应有且只有一条加以修改的理由;当类丧失了内聚性,就拆分它;隔离修改 系统 构造和使用是非常不一样的过程。每个应用…...
UDP 广播/组播
广播UDP与单播UDP的区别就是IP地址不同,广播使用广播地址xxx.xxx.xxx.255,将消息发送到在同一广播网络上的每个主机,广播/组播只能用udp进行实现 函数:int setsockopt(int sockfd, int level, int optname, const void *optval, socklen_topt…...

高效创作助手:ChatGPT最新版实现批量撰写聚合文章的全新水平
随着人工智能技术的不断发展,ChatGPT最新版作为一款智能创作助手,实现了批量撰写聚合文章的全新水平。它能够在短时间内生成高质量的文章,极大地提高了创作效率。本文将从随机8-20个方面对ChatGPT最新版进行详细的阐述,让我们一起…...
Python中的包是什么,如何创建和使用包?
在Python中,包是一种将相关模块分组在一起的方式。它可以让我们更好地组织和重用代码。 一个Python包实际上是一个文件夹,其中包含该包的Python模块和其他资源文件(例如配置文件、数据文件等)。包的根目录通常包含一个名为__init…...

Spring Cloud Alibaba Seata(二)
目录 一、Seata 1、Seata-AT模式 1.1、具体案例 1.2、通过Seata的AT模式解决分布式事务 2、Seata-XA模式 3、Seata-TCC模式 4、Seata-SAGA模式 一、Seata 1、Seata-AT模式 概念:AT模式是一种无侵入的分布式事务解决方案,在 AT 模式下,…...
如何在 MySQL 中使用 COALESCE 函数
1. 简介 在 MySQL 中,COALESCE 函数可以用来返回参数列表中的第一个非空值。如果所有参数都为空,则返回 NULL。本文将介绍 COALESCE 函数的语法和用法,并通过示例演示其效果。 2. 语法 COALESCE 函数的语法如下所示: COALESCE(…...
Python爬虫之Scrapy框架系列(22)——初识分布式爬虫scrapy_redis
目录: 分布式爬虫(Scrapy\_redis):1.简单介绍:2.Scrapy_redis的安装:分布式爬虫(Scrapy_redis): 官方文档:https://scrapy-redis.readthedocs.io/en/stable/1.简单介绍: scrapy_redis是一个基于Redis的Scrapy组件,用于scrapy项目的分布式部署和开发。 特点: 分布…...

ChatGPT的前世今生
原文首发于博客文章ChatGPT发展概览 ChatGPT 是OpenAI开发的人工智能聊天机器人程序,于2022年11月推出。该程序使用基于 GPT-3.5、GPT-4 架构的大语言模型并以强化学习训练。ChatGPT目前仍以文字方式交互,而除了可以用人类自然对话方式来交互,…...

WireShark常用协议抓包与原理分析
1.ARP协议(地址解析协议) nmap 发现网关nmap -sn 192.168.133.2wireshark 抓请求包和响应包 arp请求包内容 arp响应包内容 总结:请求包包含包类型(request),源IP地址,源MAC地址,目标IP地址,目标MAC地址(未知,此处为全0);响应包包含包类型(reply),源IP地址,源…...

Mysql数据库操作总结
文章目录 1. DDL(Data Definition Language - 数据定义语言)1.1 数据库1.2 数据表(创建查询删除)1.3 数据表(修改) 2. 数据类型2.1 数值2.2 字符2.3 日期 3. 字段约束3.1 约束3.2 主键约束修改3.3 主键自增 联合主键 4. DML(Data Manipulation Language - 数据操作语言)4.1 添…...

在 ZBrush、Substance 3D Painter 和 UE5 中创作警探角色(P2)
大家好,下篇分享咱们继续来说警探角色的重新拓扑、UV、材质贴图和渲染处理。 重新拓扑/UV 这是对我来说最不有趣的部分——重新拓扑。它显然是实时角色中非常重要的一部分,不容忽视,因为它会影响大量的 UV、绑定和后期渲染,这里…...

如何在大规模服务中迁移缓存
当您启动初始服务时,通常会过度设计以考虑大量流量。但是,当您的服务达到爆炸式增长阶段,或者如果您的服务请求和处理大量流量时,您将需要重新考虑您的架构以适应它。糟糕的系统设计导致难以扩展或无法满足处理大量流量的需求&…...
生成xcframework
打包 XCFramework 的方法 XCFramework 是苹果推出的一种多平台二进制分发格式,可以包含多个架构和平台的代码。打包 XCFramework 通常用于分发库或框架。 使用 Xcode 命令行工具打包 通过 xcodebuild 命令可以打包 XCFramework。确保项目已经配置好需要支持的平台…...

【Python】 -- 趣味代码 - 小恐龙游戏
文章目录 文章目录 00 小恐龙游戏程序设计框架代码结构和功能游戏流程总结01 小恐龙游戏程序设计02 百度网盘地址00 小恐龙游戏程序设计框架 这段代码是一个基于 Pygame 的简易跑酷游戏的完整实现,玩家控制一个角色(龙)躲避障碍物(仙人掌和乌鸦)。以下是代码的详细介绍:…...
多场景 OkHttpClient 管理器 - Android 网络通信解决方案
下面是一个完整的 Android 实现,展示如何创建和管理多个 OkHttpClient 实例,分别用于长连接、普通 HTTP 请求和文件下载场景。 <?xml version"1.0" encoding"utf-8"?> <LinearLayout xmlns:android"http://schemas…...
大学生职业发展与就业创业指导教学评价
这里是引用 作为软工2203/2204班的学生,我们非常感谢您在《大学生职业发展与就业创业指导》课程中的悉心教导。这门课程对我们即将面临实习和就业的工科学生来说至关重要,而您认真负责的教学态度,让课程的每一部分都充满了实用价值。 尤其让我…...
JavaScript 数据类型详解
JavaScript 数据类型详解 JavaScript 数据类型分为 原始类型(Primitive) 和 对象类型(Object) 两大类,共 8 种(ES11): 一、原始类型(7种) 1. undefined 定…...

计算机基础知识解析:从应用到架构的全面拆解
目录 前言 1、 计算机的应用领域:无处不在的数字助手 2、 计算机的进化史:从算盘到量子计算 3、计算机的分类:不止 “台式机和笔记本” 4、计算机的组件:硬件与软件的协同 4.1 硬件:五大核心部件 4.2 软件&#…...
tomcat指定使用的jdk版本
说明 有时候需要对tomcat配置指定的jdk版本号,此时,我们可以通过以下方式进行配置 设置方式 找到tomcat的bin目录中的setclasspath.bat。如果是linux系统则是setclasspath.sh set JAVA_HOMEC:\Program Files\Java\jdk8 set JRE_HOMEC:\Program Files…...
redis和redission的区别
Redis 和 Redisson 是两个密切相关但又本质不同的技术,它们扮演着完全不同的角色: Redis: 内存数据库/数据结构存储 本质: 它是一个开源的、高性能的、基于内存的 键值存储数据库。它也可以将数据持久化到磁盘。 核心功能: 提供丰…...

AD学习(3)
1 PCB封装元素组成及简单的PCB封装创建 封装的组成部分: (1)PCB焊盘:表层的铜 ,top层的铜 (2)管脚序号:用来关联原理图中的管脚的序号,原理图的序号需要和PCB封装一一…...

深入解析光敏传感技术:嵌入式仿真平台如何重塑电子工程教学
一、光敏传感技术的物理本质与系统级实现挑战 光敏电阻作为经典的光电传感器件,其工作原理根植于半导体材料的光电导效应。当入射光子能量超过材料带隙宽度时,价带电子受激发跃迁至导带,形成电子-空穴对,导致材料电导率显著提升。…...