RAII(Resource Acquisition Is Initialization): 资源获得即初始化
利用对象生命周期来控制程序的资源(将资源交给对象处理) 智能指针利用了该思想
- 将资源交给一个对象, 初始化资源(可以是指针或者等等资源), 释放交给析构函数
因为析构函数无论是什么场景, 对象销毁时一定会被调用, 故此资源一定会被释放
智能指针
使用了RAII的思想管理动态内存分配的一个工具，以减少内存泄露的风险。
在使用上像一个普通指针一样操作(*和->)
头文件<memory.h>
auto_ptr（C++11及以后已被弃用）
- 拷贝→ 资源管理权转移(会导致原拷贝对象悬空)
即将原先的智能指针内容转换到新的智能指针内 - 该智能指针属于一个反面教材
template<typename T>
class auto_ptr { T* ptr;
public: explicit auto_ptr(T* p = nullptr) : ptr(p) {} ~auto_ptr() { delete ptr; } auto_ptr(const auto_ptr& other) : ptr(other.ptr) { other.ptr = nullptr; // 所有权转移！这是有问题的部分。 } auto_ptr& operator=(const auto_ptr& other) { if (this != &other) { delete ptr; // 删除当前对象所拥有的资源 ptr = other.ptr; // 获取新资源的所有权 other.ptr = nullptr; // 将原所有者的指针设为 nullptr } return *this; } T& operator*() const { return *ptr; } T* operator->() const { return ptr; }
};
unique_ptr
一个智能指针只能管理一个指针对象(不支持赋值和拷贝)
- 从类的语法角度将拷贝构造和赋值用delete关键字删除, 使得无法复制
- 并没有从根上解决auto_ptr的问题
template<typename T>
class unique_ptr { T* ptr;
public: unique_ptr(T* p = nullptr) : ptr(p) {} ~unique_ptr() { delete ptr; } // 手动禁止拷贝和赋值unique_ptr(const unique_ptr& other) = delete; unique_ptr& operator=(const unique_ptr& other) = delete; // 移动构造和赋值unique_ptr(unique_ptr&& other) noexcept : ptr(other.ptr) { other.ptr = nullptr; } unique_ptr& operator=(unique_ptr&& other) noexcept { if (this != &other) { delete ptr; ptr = other.ptr; other.ptr = nullptr; } return *this; } T& operator*() const { return *ptr; } T* operator->() const { return ptr; } explicit operator bool() const { return ptr != nullptr; }
};
shared_ptr
可以表示用多个智能指针管理同一个指针对象(支持赋值和拷贝)
-
使用引用计数来实现
- 每个对象生成时计数++
- 对象释放时计数–
- 计数为0时则释放所管理的资源
-
实现shared_ptr
-
不能使用静态成员变量, 如此静态成员变量是属于整个类, 所有的智能指针对象都会共享该计数(我们应该不同的智能指针对象拥有不同的计数)
-
应在shared_ptr中添加一个计数指针(指针保存的为地址, 可以在不同对象内传递)在构造中初始化为1, 拷贝时将计数也拷贝+1,在析构时将对应的计数指针–即可
template<typename T> class shared_ptr { T* ptr; int* count; public: shared_ptr(T* p = nullptr) : ptr(p), count(new int(1)) {} shared_ptr(const shared_ptr& other) : ptr(other.ptr), count(other.count) { ++(*count); } ~shared_ptr() { if (--(*count) == 0) { delete ptr; delete count; } } shared_ptr& operator=(const shared_ptr& other) { if (this != &other) { if (--(*count) == 0) { delete ptr; delete count; } ptr = other.ptr; count = other.count; ++(*count); } return *this; } T& operator*() const { return *ptr; } T* operator->() const { return ptr; } }; -
shared_ptr的问题
-
循环引用(无法在内部解决), 需要使用weak_ptr解决
weak_ptr主要用shared_ptr构造, 用于解决循环引用问题- 当一个自定义类型内也存在多个shared_ptr时, 两个及以上个自定义类型通过shared_ptr互相指向时则会出现循环引用的问题
- weak_ptr不会增加对应shared_ptr的引用计数(即不参与资源管理)
但是仍旧可以像指针一样使用weak_ptr(可以访问和修改资源)
struct Node {int _val;//成员包含shared_ptr类型, 去管理其它对象时会对应增加计数/*std::shared_ptr<Node> _next;std::shared_ptr<Node> _prev;*///管理其它对象时不会增加对应计数std::weak_ptr<Node> _next;std::weak_ptr<Node> _prev;~Node(){cout << "~Node" << endl;} };// 循环引用 -- weak_ptr不是常规智能指针，没有RAII，不支持直接管理资源 // weak_ptr主要用shared_ptr构造，用来解决shared_ptr循环引用问题 void test_shared_ptr2() {/*std::shared_ptr<Node> n1(new Node);std::shared_ptr<Node> n2(new Node);//通过成员进行了相互引用, 则彼此"缠绕"了起来//n1的_next释放需要依赖指针类型的析构, 结点的析构需要依赖所在对象的析构, 但所在对象的析构又依赖于n2的_prev的析构(当_prev析构了, node1才会被析构); 反之类似, 故彼此缠绕, 形成循环引用n1->_next = n2;//增加了node2的计数n2->_prev = n1;//增加了node1的计数*/std::shared_ptr<Node> n1(new Node);std::shared_ptr<Node> n2(new Node);cout << n1.use_count() << endl;cout << n2.use_count() << endl;n1->_next = n2;n2->_prev = n1;cout << n1.use_count() << endl;cout << n2.use_count() << endl; }
weak_ptr
一般都作为shared_ptr的辅助指针, 解决其循环引用的问题, 它只会指向资源, 而不参与管理资源(即不会增加引用计数)
删除器
关于new和new[]生成的指针对应delete和delete[]的问题(是否匹配使用, 释放空间)
- 为什么存在删除器 ?
- new和new[]底层都是调用了operator new函数, 然后调用了malloc以及对应对象的构造函数,但区别在于new[]在malloc时多malloc了4个字节存在首部(用于delete[]时对应找到malloc了多少个对象空间)
- delete和delete[]底层都是调用了operator delete, 然后调用了对应对象的析构和free,区别在于delete调用了一次析构和一次free, 但delete[]调用了n次析构和1次free
但在析构时,指针会往前偏移4个字节找到总构造的对象个数所对应的空间, 然后依次调用析构和free - 如果是new[]出来的对象使用delete释放时, 由于delete不会进行偏移, 会导致free的位置不正确, 导致程序崩溃
- 定制删除器
- 仿函数
- lambda表达式
- 不同的智能指针对应的删除器
- shared_ptr可在构造函数内传入仿函数或者lambda表达式
- unique_ptr只能从模板参数传入
)
广播机制|torch.norm())
