当前位置：首页 > 编程日记 > 正文

C++11中weak_ptr的使用

编程日记 2024-12-25 01:30:00

在C++中，动态内存的管理是通过一对运算符来完成的：new，在动态内存中为对象分配空间并返回一个指向该对象的指针，可以选择对对象进行初始化；delete，接受一个动态对象的指针，销毁该对象，并释放与之关联的内存。

动态内存的使用很容易出问题，因为确保在正确的时间释放内存是极其困难的。有时会忘记释放内存，在这种情况下会产生内存泄露；有时在尚有指针引用内存的情况下就释放了它，在这种情况下就会产生引用非法内存的指针。

为了更容易(同时也更安全)地使用动态内存，C++11标准库提供了两种智能指针(smart pointer)类型来管理动态对象。智能指针的行为类似常规指针，重要的区别是它负责自动释放所指的对象。C++11标准库提供的这两种智能指针的区别在于管理底层指针的方式：shared_ptr允许多个指针指向同一个对象；unique_ptr则"独占"所指向的对象。C++11标准库还定义了一个名为weak_ptr的辅助类，它是一种弱引用，指向shared_ptr所管理的对象。这三种类型都定义在memory头文件中。智能指针是模板类而不是指针。类似vector，智能指针也是模板，当创建一个智能指针时，必须提供额外的信息即指针可以指向的类型。默认初始化的智能指针中保存着一个空指针。智能指针的使用方式与普通指针类似。解引用一个智能指针返回它指向的对象。如果在一个条件判断中使用智能指针，效果就是检测它是否为空。

Pointer misuse can be a major source of bugs. Smart pointers prevent most situations of memory leaks by making the memory deallocation automatic. More generally, they make object destruction automatic: an object controlled by a smart pointer is automatically destroyed (finalized and then deallocated) when the last (or only) owner of an object is destroyed.

In C++, a smart pointer is implemented as a template class that mimics, by means of operator overloading, the behaviors of a traditional (raw) pointer, while providing additional memory management features.

std::weak_ptr is a smart pointer that holds a non-owning ("weak") reference to an object that is managed by std::shared_ptr. It must be converted to std::shared_ptr in order to access the referenced object.

std::weak_ptr models temporary ownership: when an object needs to be accessed only if it exists, and it may be deleted at any time by someone else, std::weak_ptr is used to track the object, and it is converted to std::shared_ptr to assume temporary ownership. If the original std::shared_ptr is destroyed at this time,the object's lifetime is extended until the temporary std::shared_ptr is destroyed as well.

In addition,std::weak_ptr is used to break circular references of std::shared_ptr.

weak_ptr is primarily useful in the rare cases where it is needed in order to break'circular references' – a problem with the use of reference counting in shared_ptr.

Sometimes an object must store a way to access the underlying object of a shared_ptr without causing the reference count to be incremented. Typically, this situation occurs when you have cyclic references between shared_ptr instances. The best design is to avoid shared ownership of pointers whenever you can. However, if you must have shared ownership of shared_ptr instances, avoid cyclic references between them. When cyclic references are unavoidable, or even preferable for some reason, use weak_ptr to give one or more of the owners a weak reference to another shared_ptr. By using a weak_ptr, you can create a shared_ptr that joins to an existing set of related instances, but only if the underlying memory resource is still valid. A weak_ptr itself does not participate in the reference counting, and therefore, it cannot prevent the reference count from going to zero. However, you can use a weak_ptr to try to obtain a new copy of the shared_ptr with which it was initialized. If the memory has already been deleted, a bad_weak_ptr exception is thrown. If the memory is still valid, the new shared pointer increments the reference count and guarantees that the memory will be valid as long as the shared_ptr variable stays in scope.

weak_ptr被设计为与shared_ptr共同工作，可以从一个shared_ptr或者另一个weak_ptr对象构造，获得资源的观测权。但weak_ptr没有共享资源，它的构造不会引起指针引用计数的增加。同样，在weak_ptr析构时也不会导致引用计数的减少，它只是一个静静地观察者。weak_ptr没有重载operator*和->，这是特意的，因为它不共享指针，不能操作资源，这是它弱的原因。但它可以使用一个非常重要的成员函数lock()从被观测的shared_ptr获得一个可用的shared_ptr对象，从而操作资源。

weak_ptr用于解决”引用计数”模型循环依赖问题，weak_ptr指向一个对象，并不增减该对象的引用计数器。weak_ptr用于配合shared_ptr使用，并不影响动态对象的生命周期，即其存在与否并不影响对象的引用计数器。weak_ptr并没有重载operator->和operator *操作符，因此不可直接通过weak_ptr使用对象。weak_ptr提供了expired()与lock()成员函数，前者用于判断weak_ptr指向的对象是否已被销毁，后者返回其所指对象的shared_ptr智能指针(对象销毁时返回”空”shared_ptr)。

智能指针是模板类而不是指针.

weak_ptr并没有重载operator->和operator *操作符，因此不可直接通过weak_ptr使用对象，典型的用法是调用其lock函数来获得shared_ptr示例，进而访问原始对象。

weak_ptr是一种不控制所指向对象生存期的智能指针，它指向由一个shard_ptr管理的对象。将一个weak_ptr绑定到一个shared_ptr不会改变shared_ptr的引用计数。一旦最后一个指向对象的shared_ptr被销毁，对象就会被释放。即使有weak_ptr指向对象，对象也还是会被释放。

当创建一个weak_ptr时，要用一个shared_ptr来初始化它。不能使用weak_ptr直接访问对象，而必须调用lock。此函数检查weak_ptr指向的对象是否仍存在。如果存在，lock返回一个指向共享对象的shared_ptr。与任何其它shared_ptr类似，只要此shared_ptr存在，它所指向的底层对象也就会一直存在。

下图列出了weak_ptr支持的操作(来源于C++ Primer Fifth Edition 中文版)：

下面是从其他文章中copy的测试代码，详细内容介绍可以参考对应的reference：

#include "weak_ptr.hpp"
#include <iostream>
#include <memory>
#include <algorithm>
#include <string>
#include <vector>///
// reference: http://en.cppreference.com/w/cpp/memory/weak_ptr
std::weak_ptr<int> gw;void f()
{if (auto spt = gw.lock()) { // Has to be copied into a shared_ptr before usagestd::cout << *spt << "\n";}else {std::cout << "gw is expired\n";}
}int test_weak_ptr1()
{{auto sp = std::make_shared<int>(42);gw = sp;f();}f();return 0;
}/
// reference: http://stackoverflow.com/questions/12030650/when-is-stdweak-ptr-useful
int test_weak_ptr2()
{// OLD, problem with dangling pointer// PROBLEM: ref will point to undefined data!int* ptr = new int(10);int* ref = ptr;delete ptr;// NEW// SOLUTION: check expired() or lock() to determine if pointer is valid// empty definitionstd::shared_ptr<int> sptr;// takes ownership of pointersptr.reset(new int);*sptr = 10;// get pointer to data without taking ownershipstd::weak_ptr<int> weak1 = sptr;// deletes managed object, acquires new pointersptr.reset(new int);*sptr = 5;// get pointer to new data without taking ownershipstd::weak_ptr<int> weak2 = sptr;// weak1 is expired!if (auto tmp = weak1.lock())std::cout << *tmp << '\n';elsestd::cout << "weak1 is expired\n";// weak2 points to new data (5)if (auto tmp = weak2.lock())std::cout << *tmp << '\n';elsestd::cout << "weak2 is expired\n";return 0;
}//
// reference: https://msdn.microsoft.com/en-us/library/hh279672.aspx
class Controller
{
public:int Num;std::string Status;std::vector<std::weak_ptr<Controller>> others;explicit Controller(int i) : Num(i), Status("On"){std::cout << "Creating Controller" << Num << std::endl;}~Controller(){std::cout << "Destroying Controller" << Num << std::endl;}// Demonstrates how to test whether the pointed-to memory still exists or not.void CheckStatuses() const{for_each(others.begin(), others.end(), [](std::weak_ptr<Controller> wp) {try {auto p = wp.lock();std::cout << "Status of " << p->Num << " = " << p->Status << std::endl;}catch (std::bad_weak_ptr b) {std::cout << "Null object" << std::endl;}});}
};void RunTest()
{std::vector<std::shared_ptr<Controller>> v;v.push_back(std::shared_ptr<Controller>(new Controller(0)));v.push_back(std::shared_ptr<Controller>(new Controller(1)));v.push_back(std::shared_ptr<Controller>(new Controller(2)));v.push_back(std::shared_ptr<Controller>(new Controller(3)));v.push_back(std::shared_ptr<Controller>(new Controller(4)));// Each controller depends on all others not being deleted.// Give each controller a pointer to all the others. for (int i = 0; i < v.size(); ++i) {for_each(v.begin(), v.end(), [v, i](std::shared_ptr<Controller> p) {if (p->Num != i) {v[i]->others.push_back(std::weak_ptr<Controller>(p));std::cout << "push_back to v[" << i << "]: " << p->Num << std::endl;}});}for_each(v.begin(), v.end(), [](std::shared_ptr<Controller>& p) {std::cout << "use_count = " << p.use_count() << std::endl;p->CheckStatuses();});
}int test_weak_ptr3()
{RunTest();std::cout << "Press any key" << std::endl;char ch;std::cin.getline(&ch, 1);return 0;
}// reference: https://oopscenities.net/2014/08/03/c-smart-pointers-part-5-weak_ptr/
struct Child;
struct Parent
{std::shared_ptr<Child> child;~Parent() { std::cout << "Bye Parent" << std::endl; }void hi() const { std::cout << "Hello" << std::endl; }
};struct Child
{std::weak_ptr<Parent> parent;//std::shared_ptr<Parent> parent; // memory leak~Child() { std::cout << "Bye Child" << std::endl; }
};int test_weak_ptr4()
{auto parent = std::make_shared<Parent>();auto child = std::make_shared<Child>();parent->child = child;child->parent = parent;child->parent.lock()->hi();// child->parent->hi();return 0;
}/
// reference: http://thispointer.com/shared_ptr-binary-trees-and-the-problem-of-cyclic-references/
class Node
{int value;
public:std::shared_ptr<Node> leftPtr;std::shared_ptr<Node> rightPtr;// Just Changed the shared_ptr to weak_ptrstd::weak_ptr<Node> parentPtr;Node(int val) : value(val)     {std::cout << "Contructor" << std::endl;}~Node()     {std::cout << "Destructor" << std::endl;}
};int test_weak_ptr5()
{std::shared_ptr<Node> ptr = std::make_shared<Node>(4);ptr->leftPtr = std::make_shared<Node>(2);ptr->leftPtr->parentPtr = ptr;ptr->rightPtr = std::make_shared<Node>(5);ptr->rightPtr->parentPtr = ptr;std::cout << "ptr reference count = " << ptr.use_count() << std::endl;std::cout << "ptr->leftPtr reference count = " << ptr->leftPtr.use_count() << std::endl;std::cout << "ptr->rightPtr reference count = " << ptr->rightPtr.use_count() << std::endl;std::cout << "ptr->rightPtr->parentPtr reference count = " << ptr->rightPtr->parentPtr.lock().use_count() << std::endl;std::cout << "ptr->leftPtr->parentPtr reference count = " << ptr->leftPtr->parentPtr.lock().use_count() << std::endl;return 0;
}

GitHub：https://github.com/fengbingchun/Messy_Test

https://www.dkcj.cn/info/33305.html

C++11中weak_ptr的使用

相关文章：

经典不过时，回顾DeepCompression神经网络压缩

区块链技术特点之去中心化特性

Android APK反编译

Java泛型进阶 - 如何取出泛型类型参数

C++11中override的使用

平头哥发布一站式芯片设计平台“无剑”，芯片设计成本降低50%

Windows XP下，JDK环境变量配置

Markdown语法简介

吴恩达：AI未来将呈现四大发展趋势

嵌入式课程安排嵌入式培训课程大纲参考

Linux网站架构系列之Apache----进阶篇

仅用10天设计的JavaScript，凭什么成为程序员最受欢迎的编程语言？

C++11中= delete;的使用

vue 使用scss

EBS form日历可选范围设置（calendar.setup ）介绍

人工智能对地球环境科学的推进

从概念到应用，终于有人把数据挖掘讲明白了

C++11中default的使用

Android开发：setAlpha()方法和常用RGB颜色表----颜色, r g b分量数值(int), 16进制表示一一对应...

【redis】c/c++操作redis（对于hiredis的封装）

OpenCV代码提取：transpose函数的实现

只给测试集不给训练集，要怎么做自己的物体检测器？

MYSQL忘记登录密码

OpenCV代码提取：flip函数的实现

NLP这两年：15个预训练模型对比分析与剖析

大三下学期第一周总结

AD rodc扩展报错

Dropout、梯度消失/爆炸、Adam优化算法，神经网络优化算法看这一篇就够了

入行AI，你需要一本Python机器学习入门

通过transpose和flip实现图像旋转90/180/270度