C++——智能指针

智能指针

布隆过滤器 (1)

文章目录

  • 智能指针
      • 内存泄漏
      • 智能指针解决内存泄漏问题
      • 智能指针的使用及原理
        • RAII
        • 智能指针对象的拷贝问题
    • C++中的智能指针
      • auto_ptr
      • unique_ptr
      • shared_ptr
      • weak_ptr
      • 定制包装器
      • C++11和boost中智能指针的关系

内存泄漏

  1. 什么是内存泄漏：内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内 存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对 该段内存的控制，因而造成了内存的浪费。

  2. 内存泄漏的危害：长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现 内存泄漏会导致响应越来越慢，最终卡死。

C/C++程序中一般我们关心两种方面的内存泄漏：

  • 堆内存泄漏(Heap leak)

堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc / new等从堆中分配的一 块内存，用完后必须通过调用相应的 free或者delete 删掉。假设程序的设计错误导致这部分 内存没有被释放，那么以后这部分空间将无法再被使用，就会产生Heap Leak。

  • 系统资源泄漏

指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放 掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定。

内存泄漏很常见，解决方案通常分为两种：

  1. 事前预防型。如智能指针等。
  2. 事后查错型。如泄 漏检测工具。

智能指针解决内存泄漏问题

场景：main函数里调用func函数，在func函数里申请了一个int大小的空间，然后调用div函数，在div函数进行除法操作，若出现除零，则直接抛异常，直接跳转到main函数捕获异常，从而没有释放掉在func函数内申请的资源，即内存泄漏。

#include<iostream>
#include<vector>
using namespace std;int div()
{int a, b;cin >> a >> b;if (b == 0)throw invalid_argument("除0错误");return a / b;
}
void func()
{int* ptr = new int;//new了一个int大小的资源cout << div() << endl;delete ptr;//因为抛异常导致这个int资源没有被正常释放cout << "delete ptr" << endl;
}
int main()
{try{func();}catch (exception& e){cout << e.what() << endl;}return 0;
}

解决方法一：在func函数内捕获一次异常，进行对申请资源的释放后，再将异常抛出，让外层栈帧去捕获解决异常。

int div()
{int a, b;cin >> a >> b;if (b == 0)throw invalid_argument("除0错误");return a / b;
}
void func()
{	int* ptr = new int;//new了一个int大小的资源
try {cout << div() << endl;
}
catch (...)
{delete ptr;//因为抛异常导致这个int资源没有被正常释放cout << "delete ptr" << endl;throw;
}}
int main()
{try{func();}catch (exception& e){cout << e.what() << endl;}return 0;
}

image-20230903191348146

解决方案二：让智能指针对资源进行管理，调用智能指针的构造函数申请资源，调用智能指针的析构函数释放资源。

template<class T>
class smartptr
{
public:smartptr(T* ptr=nullptr) :_ptr(ptr){}~smartptr(){if (_ptr){cout << "delete _ptr" << endl;delete _ptr;}}// 像指针一样T& operator*(){return *_ptr;}T* operator->(){return _ptr;}private:T* _ptr;};int div()
{int a, b;cin >> a >> b;if (b == 0)throw invalid_argument("除0错误");return a / b;
}
void func()
{	smartptr<int> sma(new int);cout << div() << endl;	
}
int main()
{try{func();}catch (exception& e){cout << e.what() << endl;}return 0;
}

image-20230903192627650

  • 在构造sma对象时，让smartptr的构造函数去申请资源。
  • 当退出func函数这层栈帧时，sma对象的生命周期结束，自动调用smartptr的析构函数去释放资源。
  • 将申请到的资源交给一个smartptr对象进行管理，这样无论是否出现除零都能正常释放资源。
  • 此外为了让smartptr对象能够像原生指针一样使用，还需要对*和->运算符进行重载。

智能指针的使用及原理

RAII

RAII（Resource Acquisition Is Initialization）是一种利用对象生命周期来控制程序资源（如内 存、文件句柄、网络连接、互斥量等等）的简单技术。

在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在对象析构的时候释放资源。借此，我们实际上把管理一份资源的责任托管给了一个对象。这种做 法有两大好处：

  • 不需要显式地释放资源。
  • 采用这种方式，对象所需的资源在其生命期内始终保持有效。

需要注意的是：

  1. 在对象构造时获取资源，在对象析构时释放资源，即要具备RAII特性。
  2. 对*和->运算符进行重载，使得对象具有像指针一样的行为。
  3. 智能指针对象的拷贝问题。

智能指针对象的拷贝问题

int main()
{smartptr<int> sm1(new int);smartptr<int> sm2(sm1);//拷贝构造smartptr<int> sm3(new int);//赋值重载sm3 = sm1;return 0;
}

image-20230903194741686

  • 编译器默认生成的拷贝构造是对内置类型完成值拷贝（浅拷贝），因此sm2对象对sm1对象的拷贝构造，是对sm1对象的资源的地址拷贝过来，即sm1和sm2对同一份资源进行管理，当退出栈帧对象的生命周期结束时，sm1和sm2一起会对一份资源析构两次，造成越界问题。
  • 编译器默认生产的拷贝赋值函数是对内置类型完成值拷贝（浅拷贝）。因此将sm1对象赋值給sm3对象，是将sm1管理资源的地址赋值給sm3的_ptr，即sm1和sm3对同一份资源进行管理，当退出栈帧对象的生命周期结束时，sm1和sm3一起会对同一份资源析构两次，造成越界问题。

智能指针要模拟出原生指针的行为，而我们将一个指针赋值給另一个指针，其目的就是让两个指针对同一份资源进行管理，但单纯的浅拷贝会导致空间多次释放，因此根据实现的场景不同，衍生出不同的智能指针。

C++中的智能指针

auto_ptr

auto_ptr的实现目的：对资源的管理权进行转移

auto_ptr是C++98中引入的智能指针，auto_ptr通过管理权转移的方式解决智能指针的拷贝问题，保证一个资源在任何时刻都只有一个对象在对其进行管理，这时同一个资源就不会被多次释放了。

auto_ptr的模拟实现

template<class T>
class Auto_ptr
{
public:Auto_ptr(T* ptr=nullptr):_ptr(ptr){}~Auto_ptr() { cout << "delete _ptr" << endl; delete _ptr; }T* operator->(){return _ptr;}T& operator*(){return *_ptr;}Auto_ptr(Auto_ptr<T>& tp)//拷贝构造:_ptr(tp._ptr){tp._ptr = nullptr;//悬空}Auto_ptr& operator=(Auto_ptr<T>& tp){if (this!=&tp)//判断是否是自己赋值給自己{if (_ptr){delete _ptr;_ptr = nullptr;}_ptr = tp._ptr;//转移资源管理权tp._ptr = nullptr;//悬空}return *this;}
private:T* _ptr;
};

简易auto_ptr实现思路：

  1. 在构造函数获取资源，在析构函数释放资源，利用对象的生命周期管理资源。
  2. 对*和->运算符进行重载，使得对象具有像指针一样的行为。
  3. 在拷贝构造函数中，将传入对象的资源来构造当前对象，然后将传入对象管理资源的指针置空。
  4. 在拷贝赋值函数中，，先将当前对象的资源释放，然后将传入对象的资源来构造当前对象，最后将传入对象管理资源的指针置空。

测试代码

int main()
{Auto_ptr<int> apt1(new int(1));*apt1 = 10;Auto_ptr<int> apt2(apt1);Auto_ptr<int> apt3(new int(3));apt3 = apt2;return 0;
}

image-20230903204754573

image-20230903205008489

unique_ptr

unique_ptr的实现目的：防止拷贝

通过防止在智能指针之间互相拷贝，暴力的解决了多个智能指针对同一块资源进行释放的问题。

template<class T>
class Unique_ptr
{
public:Unique_ptr(T* ptr):_ptr(ptr){}~Unique_ptr(){if (_ptr){cout << "delete _ptr" << endl;delete _ptr;}}T& operator*(){return *_ptr;}T* operator->(){return _ptr;}Unique_ptr<T>& operator=(const Unique_ptr<T>& upt) = delete;//禁用拷贝构造Unique_ptr(const Unique_ptr<T>& upt) = delete;//禁用拷贝赋值
private:T* _ptr;
};int main()
{Unique_ptr<int> upt1(new int(1));cout << *(upt1) << endl;Unique_ptr<int> upt2(upt1);Unique_ptr<int> upt3(new int(3));upt3 = upt1;return 0;
}

简易unique_ptr实现思路：

  1. 在构造函数获取资源，在析构函数释放资源，利用对象的生命周期管理资源。
  2. 对*和->运算符进行重载，使得对象具有像指针一样的行为。
  3. 用C++98的方式将拷贝构造函数和拷贝赋值函数声明为私有，或者用C++11的方式在这两个函数后面加上=delete，防止外部调用。

image-20230904132449297

shared_ptr

share_ptr的实现目的：是通过引用计数的方式来实现多个shared_ptr对象之间共享资源。

namespace s
{template<class T>class Share_ptr{public:Share_ptr(T* ptr = nullptr) :_ptr(ptr), _pcount(new int(1)) {}Share_ptr<T>& operator=(const Share_ptr<T>& spt)//赋值重载{if (_ptr != spt._ptr){Release();_ptr = spt._ptr;_pcount = spt._pcount;Addpcount();}return *this;}int use_count(){return *_pcount;}void Addpcount(){(*_pcount)++;}Share_ptr(const Share_ptr<T>& spt)//拷贝构造:_ptr(spt._ptr), _pcount(spt._pcount){Addpcount();}void Release(){if (--(*_pcount) == 0 && _ptr){//计数为0，释放资源cout << "delete _ptr" << endl;delete _ptr;delete _pcount;}}~Share_ptr(){Release();}T* operator->(){return _ptr;}T* get(){return _ptr;}T& operator*(){return *_ptr;}private:T* _ptr;int* _pcount;};
}int main()
{s::Share_ptr<int> spt1(new int(1));cout << "spt1 pcount: " << spt1.use_count() << endl;s::Share_ptr<int> spt2(spt1);cout << "spt2 pcount: " << spt2.use_count() << endl;s::Share_ptr<int> spt3(new int(3));spt3 = spt1;cout << "spt3 pcount: " << spt3.use_count() << endl;return 0;
}

​ image-20230904200615577

简易auto_ptr实现思路：

  1. Shared_ptr在其内部，给每个资源都维护了着一份计数_pcount，用来记录该份资源被几个对象共 享。
  2. 在构造函数中获取资源，并且设置计数器_pcount为1，表示当前只有自己在管理该资源。
  3. 在拷贝构造函数中，要与传入的对象一起管理它所管理的资源，因此同时将该资源对应的计数器++。
  4. 在拷贝赋值函数中，若在管理资源需要先放弃管理当前资源，即先--_pcount,然后与传入对象一起管理传入对象所管理的资源，即++ _pcount。
  5. 在对象被销毁时(也就是析构函数调用)，就说明自己不使用该资源了，对象的引用计数减 一。如果引用计数为0，说明自己是最后一个使用该资源的对象，这时候必须由自己释放资源；如果引用计数不为0，说明还有其他对象使用该资源，不能释放资源，否则其他对象就成野指针了
  6. 对*和->运算符进行重载，使得对象具有像指针一样的行为。

为什么share_ptr的引用计数要放在堆上？

  • 该引用计数不能是内置函数成员int类型的数据，这样会导致每个对象都有一个引用计数，而当多个对象管理同一个资源时，这些对象所用的引用计数应该是同一个。

image-20230904203433565

  • 该引用计数也不能是静态变量，静态变量会造成所有share_ptr类型的对象所共用同一个引用计数，那么当管理不同资源时就出计数问题。

image-20230904203807749

  • 因此将shared_ptr的引用计数设置为一个指针，指针指向一个计数器，当一个资源第一次被管理时就去堆区开辟一块空间用于存储其对应的引用计数，而当前其他对象也管理该资源时，除了将该资源交给对象外，该指针也要交给它，其他对象就能拿到该引用计数。
  • 这时候管理同一个资源的多个对象所访问到的引用计数就是同一个，管理不同资源的对象所访问的引用计数不是同一个，等同于资源与其引用计数一一对应起来。

image-20230904204607295

std::shared_ptr的线程安全问题

  1. 智能指针对象中引用计数是多个智能指针对象共享的，两个线程中智能指针的引用计数同时++或–，这个操作不是原子的，引用计数原来是1，++了两次，可能还是2。这样引用计数就错乱了。会导致资源未释放或者程序崩溃的问题。所以只能指针中引用计数++、–是需要加锁的，也就是说引用计数的操作是线程安全的。
  2. . 智能指针管理的对象存放在堆上，两个线程中同时去访问，会导致线程安全问题。

首先验证C++库里的shared_ptr

#include<iostream>
#include<vector>
#include<memory>
#include<mutex>
#include<thread>
using namespace std;struct Date
{
public:int _year = 0;int _month = 0;int _day = 0;
};
void test_shared_ptr1()
{int n = 50000;mutex mtx;std::shared_ptr<Date> sp1(new Date);thread t1([&](){for (int i = 0; i < n; ++i){std::shared_ptr<Date> sp2(sp1);//mtx.lock();sp2->_year++;sp2->_day++;sp2->_month++;//	mtx.unlock();}});thread t2([&](){for (int i = 0; i < n; ++i){std::shared_ptr<Date> sp3(sp1);//	mtx.lock();sp3->_year++;sp3->_day++;sp3->_month++;//	mtx.unlock();}});t1.join();t2.join();cout << sp1.use_count() << endl;cout << sp1.get() << endl;cout << sp1->_year << endl;cout << sp1->_month << endl;cout << sp1->_day << endl;
}int main()
{test_shared_ptr1();
}
  • 首先创建一个sp1对象，对象管理Date结构体，结构体里有三个成员变量，_year、 _month、 _day。
  • 在线程thread1里sp2对象对sp1对象进行拷贝构造，即sp2也同sp1一起管理同一个Date结构体，并且对里面的成员变量进行加加，循环500次；
  • 在线程thread2里sp3对象对sp1对象进行拷贝构造，即sp3也同sp1、sp2一起管理同一个Date结构体，并且对里面的成员变量进行加加，循环500次；
  • 即sp2和sp3两个对象总和对Date对象里的成员变量加加1000次，遍历完后可以看到三个参数都为1000（如下图）

image-20230905142908596

  • 经过多次实验，可以看到存在成员对象不为1000的结果，说明了shared_ptr存在线程安全问题。其根本在于多线程访问同一块资源时，可能存在多个线程同时对同一个成员变量进行自增或自减操作，而其++操作不具备原子性。因此需要借助锁，将++操作的代码划分为临界区，互斥锁将临界区保护起来，每次只允许一个线程进入临界区，访问临界资源。

image-20230905143447807

	struct Date
{
public:int _year = 0;int _month = 0;int _day = 0;
};void test_shared_ptr1()
{int n = 500;mutex mtx;std::shared_ptr<Date> sp1(new Date);thread t1([&](){for (int i = 0; i < n; ++i){std::shared_ptr<Date> sp2(sp1);mtx.lock();sp2->_year++;sp2->_day++;sp2->_month++;mtx.unlock();}});thread t2([&](){for (int i = 0; i < n; ++i){std::shared_ptr<Date> sp3(sp1);mtx.lock();sp3->_year++;sp3->_day++;sp3->_month++;mtx.unlock();}});t1.join();t2.join();cout << sp1.use_count() << endl;cout << sp1.get() << endl;cout <<"sp1->_year: " << sp1->_year << endl;cout <<"sp1->_month: " << sp1->_month << endl;cout <<"sp1->_year: " << sp1->_day << endl;
}int main()
{test_shared_ptr1();
}

加互斥锁解决shared_ptr的线程安全问题

要解决引用计数的线程安全问题，本质就是让对引用计数的自增和自减变成一个原子操作，因此对引用计数的操作进行加锁保护，将对引用计数的操作划分为临界区，每次只允许一个线程进入临界区做引用计数操作。

namespace s
{template<class T>class Share_ptr{public:Share_ptr(T* ptr = nullptr) :_ptr(ptr), _pcount(new int(1)),_mut(new mutex) {}Share_ptr<T>& operator=(const Share_ptr<T>& spt)//赋值重载{if (_ptr != spt._ptr){Release();_ptr = spt._ptr;_pcount = spt._pcount;_mut = spt._mut;Addpcount();}return *this;}int use_count(){return *_pcount;}void Addpcount(){_mut->lock();(*_pcount)++;_mut->unlock();}Share_ptr(const Share_ptr<T>& spt)//拷贝构造:_ptr(spt._ptr), _pcount(spt._pcount),_mut(spt._mut){Addpcount();}void Release(){bool flag = false;_mut->lock();if (--(*_pcount) == 0 && _ptr){//计数为0，释放资源cout << "delete _ptr" << endl;delete _ptr;delete _pcount;flag = true;}_mut->unlock();if (flag == true){delete _mut;}}~Share_ptr(){Release();}T* operator->(){return _ptr;}T* get(){return _ptr;}T& operator*(){return *_ptr;}private:T* _ptr;int* _pcount;mutex* _mut;};
}
  • 在shared_ptr类中新增互斥锁，为了让管理同一份资源的多个对象访问到的是同一个互斥锁，管理不同资源的对象访问到的不是同一个互斥锁，互斥锁需要在堆区创建。
  • 在拷贝构造函数和拷贝赋值函数中，除了将对应资源和引用计数交给当前对象时，还需要将其资源对应互斥锁也交给当前对象。
  • 当一个资源对应的引用计数为0时，，除了将对应资源和引用计数释放外，还需要将其资源对应的互斥锁释放。
  • 在拷贝构造函数、拷贝赋值函数、析构函数中需要对引用计数做自增或自减操作，可以将其操作封装为Addpcount函数、Release函数，然后只需要在这两个函数中进行加锁保护。
  • shared_ptr只需要保证引用计数的线程安全问题，而管理资源的线程安全问题由管理这块资源的操作者来保证

shared_ptr的循环引用问题

struct ListNode
{int _data=0;s::Share_ptr<ListNode> _prev;s::Share_ptr<ListNode> _next;~ListNode() { cout << "~ListNode()" << endl; }
};
int main()
{s::Share_ptr<ListNode> node1(new ListNode);s::Share_ptr<ListNode> node2(new ListNode);cout << node1.use_count() << endl;cout << node2.use_count() << endl;node1->_next = node2;node2->_prev = node1;cout << node1.use_count() << endl;cout << node2.use_count() << endl;return 0;
}

image-20230905201042714

  • 新建一个listNode对象，让shared_ptr类node1对象管理，此时node1对应的引用计数为1，即listNode资源被一个shared_ptr对象管理。
  • 新建一个listNode对象，让shared_ptr类node2对象管理，此时node2对应的引用计数为1，即listNode资源被一个shared_ptr对象管理。
  • 此时node1和node2的引用计数都为1，我们不需要手动释放资源。在退出栈帧的时候会调用析构函数进行资源释放

image-20230905201101396

  • 让node1的next指向node2，即node1和node2一起来管理node2所管理的资源，因此node2的use_count等于2。
  • 让node2的prev指针指向node1，即node1和node2一起来管理node1所管理的资源，因此node1的use_count等于2。

image-20230905202103752

  • 在程序结束时，会调用node1和node2的析构函数，此时node1的use_count减减等于1，node2的use_count减减等于1；但node1无法被释放，原因在于node2的prev指针指向node1，想要释放node1需要先释放node2的prev指针，释放node2的prev指针的前提是释放node2；而node2也无法被释放，原因在于node1的next指针指向node2，想要释放node2需要先释放node1的next指针，释放node1的next指针的前提是释放node1。因此造成了循环引用问题。

weak_ptr

weak_ptr的作用为：

  • 构造出来的weak_ptr对象与shared_ptr对象管理同一份资源，但不会增加这块资源对应的引用计数。
  • weak_ptr支持用shared_ptr对象来构造weak_ptr对象
  • weak_ptr不是用来管理资源释放的，它主要是用来解决shared_ptr的循环引用问题。
namespace t
{template<class T>
class weak_ptr
{
public:weak_ptr() :_ptr(nullptr) {}weak_ptr<T>& operator=( s::Share_ptr<T>& spt)//赋值重载{_ptr = spt.get();return *this;}weak_ptr(const s::Share_ptr<T>& spt)//拷贝构造:_ptr(spt.get()){}T* operator->(){return _ptr;}T& operator*(){return *_ptr;}private:T* _ptr;
};
}
  • 提供一个无参的构造函数。
  • 拷贝构造函数用shared_ptr构造weak_ptr，把shared_ptr的指针传递給weak_ptr，weak_ptr也能够管理shared_ptr所管理的对象。
  • 赋值重载函数用shared_ptr构造weak_ptr，把shared_ptr的指针传递給weak_ptr，weak_ptr也能够管理shared_ptr所管理的对象。
  • 对*和->运算符进行重载，使得对象具有像指针一样的行为。
  • shared_ptr提供一个get函数，用于获取指针管理资源。
struct ListNode
{int _data = 0;t::weak_ptr<ListNode> _prev;t::weak_ptr<ListNode> _next;~ListNode() { cout << "~ListNode()" << endl; }
};
int main()
{s::Share_ptr<ListNode> node1(new ListNode);s::Share_ptr<ListNode> node2(new ListNode);cout << " node1.use_count: " << node1.use_count() << endl;cout << " node2.use_count: " << node2.use_count() << endl;node1->_next = node2;node2->_prev = node1;cout << " node1.use_count: " << node1.use_count() << endl;cout << " node2.use_count: " << node2.use_count() << endl;return 0;
}

image-20230905205547763

可以看到此时资源正常释放了。

定制包装器

当智能指针的生命周期结束，所有的智能指针的析构函数都默认以delete的方式将资源释放。实际上这种方式并不好，因为不是所有智能指针所管理的资源都是以new的方式创建的。比如智能指针可能管理以new[]方式创建的资源，也管理的是一个文件指针。

int main()
{s::Share_ptr<int> sp(new int[10]);s::Share_ptr<int> sp1(fopen("test.cpp", "r"));return 0;
}
  • 在生命周期结束时，对于以new[]方式创建的资源进行delete会造成程序崩溃，因为以new[]申请到的资源必须以delete[]的方式释放。而以fopen打开的文件指针必须以fclose的方式进行关闭。

定制删除器的实现问题

  • C++标准库中实现shared_ptr时是分成了很多个类的，因此C++标准库中可以将删除器的类型设置为构造函数的模板参数，然后将删除器的类型在各个类之间进行传递。
  • 我们是直接用一个类来实现share_ptr,因此不能将定制删除器的类型设置为构造函数的模板参数。删除器需要在析构函数的Release函数中使用，因此需要用一个成员变量将器删除器保存下来，而在定义这个成员变量时就需要指定删除器的类型，因此就需要給shared_ptr类再增加一个模板参数，在构造shared_ptr对象时就指定删除器的类型。然后增加一个支持传入删除器的构造函数，在构造shared_ptr对象时就传递删除器，在释放资源时就调用该删除器即可。设置一个默认删除器，当用户定义shared_ptr对象时不传入删除器，就默认以delete的方式释放资源。
	template<class T>class default_delete{public:void operator()(T* ptr){cout << "delete ptr" << endl;delete ptr;}};template<class T>class Delarry{public:void operator()( T* arr){cout << "delete[]" << arr << endl;delete[]arr;}};template<class T,class D=default_delete<T>>class Share_ptr{public:Share_ptr(T* ptr ,D del) :_ptr(ptr), _pcount(new int(1)),_mut(new mutex),_del(del) {}void Release(){bool flag = false;_mut->lock();if (--(*_pcount) == 0 && _ptr){//计数为0，释放资源cout << "delete _ptr" << endl;_del( _ptr);//调用对应制定删除器释放资源delete _pcount;flag = true;}_mut->unlock();if (flag == true){delete _mut;}}~Share_ptr(){Release();}//......private:T* _ptr;int* _pcount;mutex* _mut;D _del;

class Fclose
{
public:void operator()(FILE* ptr){cout << "fclose ptr" << endl;fclose(ptr);}
};int main()
{s::Share_ptr<int,s::Delarry<int>> sp(new int[10],s::Delarry<int>());s::Share_ptr<FILE, function<void(FILE*)>> sp2(fopen("test.cpp", "r"), [](FILE* ptr) {cout << "fclose: " << ptr << endl;fclose(ptr); });return 0;
}

C++11和boost中智能指针的关系

  1. C++ 98 中产生了第一个智能指针auto_ptr。
  2. . C++ boost给出了更实用的scoped_ptr和shared_ptr和weak_ptr。
  3. . C++ TR1，引入了shared_ptr等。不过注意的是TR1并不是标准版。
  4. C++ 11，引入了unique_ptr和shared_ptr和weak_ptr。需要注意的是unique_ptr对应boost 的scoped_ptr。并且这些智能指针的实现原理是参考boost中的实现的。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/71554.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

NSSCTF2nd与羊城杯部分记录

NSSCTF2nd与羊城杯部分记录

文章目录 前言[NSSCTF 2nd]php签到[NSSCTF 2nd]MyBox[NSSCTF 2nd]MyHurricane[NSSCTF 2nd]MyJs[NSSCTF 2nd]MyAPK羊城杯[2023] D0nt pl4y g4m3!!!羊城杯[2023]ezyaml羊城杯[2023]Serpent羊城杯[2023]EZ_web羊城杯[2023]Ez_misc总结 前言 今天周日&#xff0c;有点无聊没事干&a…
阅读更多...
Vue框架学习记录之环境安装与第一个Vue项目

Vue框架学习记录之环境安装与第一个Vue项目

Node.js的安装与配置 首先是Node.js的安装&#xff0c;安装十分简单&#xff0c;只需要去官网下载安装包后&#xff0c;一路next即可。 Node.js是一个开源的、跨平台的 JavaScript 运行时环境 下载地址&#xff0c;有两个版本&#xff0c;一个是推荐的&#xff0c;一个是最新…
阅读更多...
Python爬虫数据存哪里|数据存储到文件的几种方式

Python爬虫数据存哪里|数据存储到文件的几种方式

前言 大家早好、午好、晚好吖 ❤ ~欢迎光临本文章 爬虫请求解析后的数据&#xff0c;需要保存下来&#xff0c;才能进行下一步的处理&#xff0c;一般保存数据的方式有如下几种&#xff1a; 文件&#xff1a;txt、csv、excel、json等&#xff0c;保存数据量小。 关系型数据库…
阅读更多...
Python小知识 - Python装饰器

Python小知识 - Python装饰器

Python装饰器 在Python中&#xff0c;装饰器是一个特殊的函数&#xff0c;可以将其他函数包装在装饰器函数中&#xff0c;并且将被包装的函数作为参数传递给装饰器函数。 使用装饰器的好处是可以自动在被包装的函数前后执行一些额外的代码&#xff0c;比如在函数执行前后打印日…
阅读更多...
嵌入式开发-11 Linux下GDB调试工具

嵌入式开发-11 Linux下GDB调试工具

目录 1 GDB简介 2 GDB基本命令 3 GDB调试程序 1 GDB简介 GDB是GNU开源组织发布的一个强大的Linux下的程序调试工具。 一般来说&#xff0c;GDB主要帮助你完成下面四个方面的功能&#xff1a; 1、启动你的程序&#xff0c;可以按照你的自定义的要求随心所欲的运行程序&#…
阅读更多...
PaddleX：一站式、全流程、高效率的飞桨AI套件

PaddleX：一站式、全流程、高效率的飞桨AI套件

随着ChatGPT引领的AI破圈&#xff0c;各行各业掀起了AI落地的潮流&#xff0c;从智能客服、智能写作、智能监控&#xff0c;到智能医疗、智能家居、智能金融、智能农业&#xff0c;谁能快速将AI与传统业务相结合&#xff0c;谁就将成为企业数字化和智能化变革的优胜者。然而&am…
阅读更多...
Git 命令行查看仓库信息

Git 命令行查看仓库信息

目录 查看系统config ​编辑查看当前用户&#xff08;global&#xff09;配置 查看当前仓库配置信息 查看系统config git config --system --list 1 查看当前用户&#xff08;global&#xff09;配置 git config --global --list 1 查到的是email , name 等ssl签名信息&a…
阅读更多...
知识大杂烩(uniapp)

知识大杂烩(uniapp)

首先声明&#xff1a;不敢保证都管用&#xff0c;这是我自己实践得来的。 box-shadow: 这段 CSS 样式代码用于创建一个阴影效果&#xff0c;它是通过 box-shadow 属性来实现的。让我解释一下这段代码的含义&#xff1a; - box-shadow: 这是 CSS 的属性&#xff0c;用于添加阴影…
阅读更多...
算法笔记：平衡二叉树

算法笔记：平衡二叉树

1 介绍 平衡二叉树&#xff08;AVL树&#xff09;是一种特殊的二叉搜索树&#xff08;BST&#xff09;&#xff0c;它自动确保树保持低高度&#xff0c;以便实现各种基本操作&#xff08;如添加、删除和查找&#xff09;的高效性能。 ——>时间都维持在了O(logN)它是一棵空…
阅读更多...
百度百科词条怎么更新？怎么能顺利更新百科词条？

百度百科词条怎么更新？怎么能顺利更新百科词条？

企业和个人百度百科词条的更新对于他们来说都具有重要的意义&#xff0c;具体如下&#xff1a; 对企业来说&#xff1a; 塑造品牌形象&#xff1a;百度百科是一个常被用户信任并参考的知识平台&#xff0c;通过更新企业词条可以提供准确、全面的企业信息&#xff0c;帮助企业塑…
阅读更多...
算法专题：前缀和

算法专题：前缀和

文章目录 Acwing&#xff1a;前缀和示例2845.统计趣味子数组的数目思路容易理解的写法&#xff1a;前缀和两层循环存在问题&#xff1a;超时 优化写法&#xff1a;两数之和思路&#xff0c;转换为哈希表 前缀和&#xff0c;就是求数组中某一段的所有元素的和。 求子数组中某一…
阅读更多...
Unity3D 连接 SQLite 作为数据库基础功能【详细图文教程】

Unity3D 连接 SQLite 作为数据库基础功能【详细图文教程】

一、简单介绍一下SQLite的优势&#xff08;来自ChatGPT&#xff09; 轻量级: SQLite是一个嵌入式数据库引擎&#xff0c;它的库文件非常小巧&#xff0c;没有独立的服务器进程&#xff0c;适用于嵌入到其他应用程序中&#xff0c;对于轻量级的项目或移动应用程序非常适用。零配…
阅读更多...
Golang RabbitMQ实现的延时队列

Golang RabbitMQ实现的延时队列

文章目录 前言一、延时队列与应用场景二、RabbitMQ如何实现延时队列实现延时队列的基本要素整体的实现原理如下 三、Go语言实战生产者消费者 前言 之前做秒杀商城项目的时候使用到了延时队列来解决订单超时问题&#xff0c;本博客就总结一下Golang是如何利用RabbitMQ实现的延时…
阅读更多...
结构体对齐原理及在STM32中的设计原则和实现

结构体对齐原理及在STM32中的设计原则和实现

在嵌入式系统开发中&#xff0c;结构体作为一种常见的数据组织方式&#xff0c;在内存中的布局方式对于程序性能和内存占用具有重要影响。本文将深入探讨单片机C语言中的结构体对齐原理、重要性以及不同的对齐方式&#xff0c;并通过示例演示结构体对齐如何影响内存占用、访问性…
阅读更多...
【代码随想录】Day 50 动态规划11 （买卖股票Ⅲ、Ⅳ）

【代码随想录】Day 50 动态规划11 （买卖股票Ⅲ、Ⅳ）

买卖股票Ⅲ https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-iii/ 无语了。。。 写的很好就是怎么都过不了。。。 还是就用代码随想录的写法吧。。。 class Solution { public:int maxProfit(vector<int>& prices) {int n prices.size();vector&…
阅读更多...
权限提升-Windows本地提权-AT+SC+PS命令-进程迁移-令牌窃取-getsystem+UAC

权限提升-Windows本地提权-AT+SC+PS命令-进程迁移-令牌窃取-getsystem+UAC

权限提升基础信息 1、具体有哪些权限需要我们了解掌握的&#xff1f; 后台权限&#xff0c;网站权限&#xff0c;数据库权限&#xff0c;接口权限&#xff0c;系统权限&#xff0c;域控权限等 2、以上常见权限获取方法简要归类说明&#xff1f; 后台权限&#xff1a;SQL注入,数…
阅读更多...
DCMM数据能力成熟度评估模型--学习笔记（1）

DCMM数据能力成熟度评估模型--学习笔记（1）

DCMM数据能力成熟度评估模型--学习笔记 1、DCMM简介、结构组成和成熟度评估等级划分1.1 DCMM简介1.2 DCMM结构组成1.3 DCMM关键过程域1.3.1、数据战略&#xff08;指导方针&#xff09;1.3.2、数据治理 &#xff08;机制保障&#xff09;1.3.3、数据架构 (施工图纸)1.3.4、数据…
阅读更多...
【Java】线程都有哪几种状态

【Java】线程都有哪几种状态

文章目录 前言传统线程模型&#xff08;操作系统&#xff09;中线程状态Java线程中的状态线程的运行流程 前言 首先我们要知道&#xff0c;在传统&#xff08;操作系统&#xff09;的线程模型中线程被分为五种状态&#xff0c;在java线程中&#xff0c;线程被分为六种状态。 …
阅读更多...
iOS 16.4更新指南：问题解答与新功能一览

iOS 16.4更新指南：问题解答与新功能一览

我应该更新到iOS 16.4吗&#xff1f;这是许多iPhone用户在新更新可用时问自己的一个常见问题。最新的iOS版本提供了各种功能和改进&#xff0c;因此更新的诱惑力很大。 但是&#xff0c;在更新之前&#xff0c;你应该考虑几个因素&#xff0c;以确保安装过程顺利成功。这些因素…
阅读更多...
云计算中的负载均衡技术，确保资源的平衡分配

云计算中的负载均衡技术，确保资源的平衡分配

文章目录 1. 硬件负载均衡器2. 软件负载均衡器3. DNS负载均衡4. 内容分发网络&#xff08;CDN&#xff09; &#x1f388;个人主页&#xff1a;程序员 小侯 &#x1f390;CSDN新晋作者 &#x1f389;欢迎 &#x1f44d;点赞✍评论⭐收藏 ✨收录专栏&#xff1a;云计算 ✨文章内…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023