精华内容
下载资源
问答
  • 一个ReClass.NET插件,该插件显示Frostbite类的类型信息并添加WeakPtr节点。 安装 从下载 将dll文件复制到相应的Plugin文件夹(ReClass.NET/x86/Plugins或ReClass.NET/x64/Plugins)中 启动ReClass.NET并检查插件...
  • 这篇关于weakptr的文章很实在,点击跳转 二、总结 weak_ptr 在功能上类似于普通指针, 然而一个比较大的区别是, 弱引用能检测到所管理的对象是否已经被释放, 从而避免访问非法内存。 注意: 虽然通过弱引用指针可以...

    一、引用博客

    这篇关于weakptr的文章很实在,点击跳转

    二、总结

    weak_ptr 在功能上类似于普通指针, 然而一个比较大的区别是, 弱引用能检测到所管理的对象是否已经被释放, 从而避免访问非法内存。
    注意: 虽然通过弱引用指针可以有效的解除循环引用, 但这种方式必须在程序员能预见会出现循环引用的情况下才能使用, 也可以说这个仅仅是一种编译期的解决方案, 如果程序在运行过程中出现了循环引用, 还是会造成内存泄漏.。

    展开全文
  • 分析完CreateOffer来完成这篇文章
    1. 分析完CreateOffer来完成这篇文章
    展开全文
  • WeakPtr 学习

    2015-10-19 18:33:58
    [cpp] view plaincopy /*  一、说明   WeakPtr,可用来在不同线程间传递对象。  二、相关类   Flag : public RefCountedThreadSafe  ... 用来标志WeakPtr所指向的对象是否还可用IsVali
    [cpp]  view plain copy
    1. /* 
    2. 一、说明 
    3.     WeakPtr,可用来在不同线程间传递对象。 
    4. 二、相关类 
    5.     Flag : public RefCountedThreadSafe<Flag> 
    6.         -->标志类,自身是有"线程安全引用计数"的。 
    7.             用来标志WeakPtr所指向的对象是否还可用IsValid()。 
    8.     WeakReference 
    9.         -->含有一个scoped_refptr<const Flag> flag,对应Flag的一个引用 
    10.     WeakPtrBase 
    11.         -->作为WeakPtr的父类存在,它体内含有WeakReference ref_, 
    12.             实际上就是为了让WeakPtr体内包含一个WeakReference对象, 
    13.             更进一步,就是为了让WeakPtr对象拥有一个Flag对象引用。             
    14.     WeakReferenceOwner 
    15.         -->负责new出Flag对象,保证所有从本类请求的Flag对象都是同 
    16.             一个,而同一个Flag对象代表了同一个object指针 
    17.     WeakPtr : public WeakPtrBase  
    18.         -->这样的话,WeakPtr也就有了WeakReference对象,进而有了一个 
    19.             Flag对象。WeakPtr析构时,就引起Flag的引用-1 
    20.   
    21.     WeakPtrFactory 
    22.         -->WeakPtr的生产工厂,体内有一个WeakReferenceOwner,通过它 
    23.         来生产WeakPtr。 
    24. 三、原理 
    25.     对象要跨线程,比如说线程1有一个对象A通过指针将对象传递给线程2, 
    26.     线程2怕的是在用的时候,那个对象A被释放了。而如果能有一个地方查到 
    27.     此对象是否还存在的话,跨线程就ok了。 
    28.     假设有对象指针T 
    29.     Flag对象就是用来标志那个对象T是否还存在的标志。 
    30.     WeakReferenceOwner只能产生针对T的WeakReference(同一个Flag构成的) 
    31.     由于Flag是new出来的,它的析构不是由外力决定的,而是由它被引用的情况 
    32.     决定的,因为它是"可引用计数"的。引用计数归0后自然就是释放内存。所以 
    33.     Flag寿命比object长一些,与最后一个WeakPtr一起结束生命。 
    34.      
    35.     每个WeakReference是Flag的一份引用,而每个WeakPtr中有一个WeakReference 
    36.     当WeakPtr析构时,WeakReference就析构了,最终引起Flag引用数量-=1,当引用 
    37.     数量==0时,Flag析构,也就是说在所有WeakPtr析构前,Flag是不会析构的,这 
    38.     个对象可被任何关于T的WeakPtr用来查询,T是否有效 
    39.      
    40.     构建过程是同一个WeakReferenceOwner用同一个Flag来构建WeakPtr的,所以所 
    41.     有WeakPtr都指向同一个对象。 
    42.      
    43.      
    44.   
    45. */  
    46.   
    47.   
    48. #ifndef BASE_MEMORY_WEAK_PTR_H_  
    49. #define BASE_MEMORY_WEAK_PTR_H_  
    50.   
    51. namespace base {  
    52.     template <typename T> class SupportsWeakPtr;  
    53.     template <typename T> class WeakPtr;  
    54.     namespace internal {  
    55.         class Flag : public RefCountedThreadSafe<Flag> {  
    56.             public:  
    57.                 Flag();  
    58.                 void Invalidate();// is_valid_ = false;  
    59.                 bool IsValid() const;//是否可用  
    60.                 void DetachFromThread() { thread_checker_.DetachFromThread(); }  
    61.             private:  
    62.                 friend class base::RefCountedThreadSafe<Flag>;  
    63.                 ~Flag();  
    64.                 ThreadChecker thread_checker_;  
    65.                 bool is_valid_;  
    66.             };//Flag  
    67.       
    68.   
    69.         class BASE_EXPORT WeakReference {         
    70.         public:  
    71.             WeakReference();  
    72.             explicit WeakReference(const Flag* flag);  
    73.             ~WeakReference();  
    74.             bool is_valid() const;  
    75.   
    76.         private:  
    77.             scoped_refptr<const Flag> flag_;//scoped  
    78.         };//WeakReference  
    79.   
    80.         class BASE_EXPORT WeakReferenceOwner {  
    81.         public:  
    82.             WeakReferenceOwner();  
    83.             ~WeakReferenceOwner();  
    84.             WeakReference GetRef() const;//只返回唯一Flag  
    85.   
    86.             bool HasRefs() const {  
    87.                 return flag_.get() && !flag_->HasOneRef();  
    88.             }  
    89.   
    90.             void Invalidate();//flag_->Invalidate(),flag=null  
    91.   
    92.             // Indicates that this object will be used on another thread from now on.  
    93.             //valid_thread_id_ = kInvalidThreadId=0;  
    94.             void DetachFromThread() {  
    95.                 if (flag_) flag_->DetachFromThread();  
    96.             }  
    97.   
    98.         private:  
    99.             mutable scoped_refptr<WeakReference::Flag> flag_;  
    100.         };  
    101.   
    102.         // This class simplifies the implementation of WeakPtr's type conversion  
    103.         // constructor by avoiding the need for a public accessor for ref_.  A  
    104.         // WeakPtr<T> cannot access the private members of WeakPtr<U>, so this  
    105.         // base class gives us a way to access ref_ in a protected fashion.  
    106.         class BASE_EXPORT WeakPtrBase {//WeakPtr父类,封装WeakReference  
    107.         public:  
    108.             WeakPtrBase();  
    109.             ~WeakPtrBase();  
    110.   
    111.         protected:  
    112.             explicit WeakPtrBase(const WeakReference& ref);  
    113.   
    114.             WeakReference ref_;  
    115.         };  
    116.   
    117.         // This class provides a common implementation of common functions that would  
    118.         // otherwise get instantiated separately for each distinct instantiation of  
    119.         // SupportsWeakPtr<>.  
    120.         class SupportsWeakPtrBase {  
    121.         public:  
    122.             // A safe static downcast of a WeakPtr<Base> to WeakPtr<Derived>. This  
    123.             // conversion will only compile if there is exists a Base which inherits  
    124.             // from SupportsWeakPtr<Base>. See base::AsWeakPtr() below for a helper  
    125.             // function that makes calling this easier.  
    126.             // WeakPtr<Base>  WeakPtr<Derived>间转换  
    127.             // 父类继承了SupportsWeakPtr,子类继承了父类,见下面helper函数  
    128.             template<typename Derived>  
    129.             static WeakPtr<Derived> StaticAsWeakPtr(Derived* t) {  
    130.                 typedef is_convertible<Derived, internal::SupportsWeakPtrBase&> convertible;  
    131.   
    132.                 COMPILE_ASSERT(convertible::value,AsWeakPtr_argument_inherits_from_SupportsWeakPtr);  
    133.                 //只提供了一个模板参数,另一个没有,需要编译器自己推导  
    134.                 return AsWeakPtrImpl<Derived>(t, *t);  
    135.             }  
    136.   
    137.         private:  
    138.             // This template function uses type inference to find a Base of Derived  
    139.             // which is an instance of SupportsWeakPtr<Base>. We can then safely  
    140.             // static_cast the Base* to a Derived*.  
    141.             // 类型推导,找出父类子所含有的ptr,然后将其转成子类的ptr,然后再封装成  
    142.             // WeakPtr返回回去。  
    143.   
    144.             //用参数约束出了父类的名字  
    145.             template <typename Derived, typename Base>  
    146.             static WeakPtr<Derived> AsWeakPtrImpl(Derived* t, const SupportsWeakPtr<Base>&)  
    147.             {  
    148.                     WeakPtr<Base> ptr = t->Base::AsWeakPtr();  
    149.                     return WeakPtr<Derived>(ptr.ref_, static_cast<Derived*>(ptr.ptr_));  
    150.             }  
    151.         };  
    152.   
    153.     }  // namespace internal  
    154.   
    155.     template <typename T> class WeakPtrFactory;  
    156.   
    157.     // The WeakPtr class holds a weak reference to |T*|.  
    158.     //  
    159.     // This class is designed to be used like a normal pointer.  You should always  
    160.     // null-test an object of this class before using it or invoking a method that  
    161.     // may result in the underlying object being destroyed.  
    162.     //  
    163.     // EXAMPLE:  
    164.     //  
    165.     //   class Foo { ... };  
    166.     //   WeakPtr<Foo> foo;  
    167.     //   if (foo)  
    168.     //     foo->method();  
    169.     //  
    170.     template <typename T>  
    171.     class WeakPtr : public internal::WeakPtrBase {  
    172.     public:  
    173.         WeakPtr() : ptr_(NULL) {  
    174.         }  
    175.   
    176.         // Allow conversion from U to T provided U "is a" T.  
    177.         template <typename U>  
    178.         WeakPtr(const WeakPtr<U>& other) : WeakPtrBase(other), ptr_(other.get()) {  
    179.         }  
    180.   
    181.         T* get() const { return ref_.is_valid() ? ptr_ : NULL; }  
    182.         operator T*() const { return get(); }  
    183.   
    184.         T& operator*() const {  
    185.             DCHECK(get() != NULL);  
    186.             return *get();  
    187.         }  
    188.         T* operator->() const {  
    189.             DCHECK(get() != NULL);  
    190.             return get();  
    191.         }  
    192.   
    193.         void reset() {  
    194.             ref_ = internal::WeakReference();  
    195.             ptr_ = NULL;  
    196.         }  
    197.   
    198.     private:  
    199.         friend class internal::SupportsWeakPtrBase;  
    200.         friend class SupportsWeakPtr<T>;  
    201.         friend class WeakPtrFactory<T>;  
    202.   
    203.         WeakPtr(const internal::WeakReference& ref, T* ptr)  
    204.             : WeakPtrBase(ref),  
    205.             ptr_(ptr) {  
    206.         }  
    207.   
    208.         // This pointer is only valid when ref_.is_valid() is true.  Otherwise, its  
    209.         // value is undefined (as opposed to NULL).  
    210.         T* ptr_;  
    211.     };  
    212.   
    213.     // A class may extend from SupportsWeakPtr to expose weak pointers to itself.  
    214.     // This is useful in cases where you want others to be able to get a weak  
    215.     // pointer to your class.  It also has the property that you don't need to  
    216.     // initialize it from your constructor.  
    217.     template <class T>  
    218.     class SupportsWeakPtr : public internal::SupportsWeakPtrBase {  
    219.     public:  
    220.         SupportsWeakPtr() {}  
    221.   
    222.         WeakPtr<T> AsWeakPtr() {  
    223.             return WeakPtr<T>(weak_reference_owner_.GetRef(), static_cast<T*>(this));  
    224.         }  
    225.   
    226.         // Indicates that this object will be used on another thread from now on.  
    227.         void DetachFromThread() {  
    228.             weak_reference_owner_.DetachFromThread();  
    229.         }  
    230.   
    231.     protected:  
    232.         ~SupportsWeakPtr() {}  
    233.   
    234.     private:  
    235.         internal::WeakReferenceOwner weak_reference_owner_;  
    236.         DISALLOW_COPY_AND_ASSIGN(SupportsWeakPtr);  
    237.     };  
    238.   
    239.     // Helper function that uses type deduction to safely return a WeakPtr<Derived>  
    240.     // when Derived doesn't directly extend SupportsWeakPtr<Derived>, instead it  
    241.     // extends a Base that extends SupportsWeakPtr<Base>.  
    242.     //  
    243.     // EXAMPLE:  
    244.     //   class Base : public base::SupportsWeakPtr<Producer> {};  
    245.     //   class Derived : public Base {};  
    246.     //  
    247.     //   Derived derived;  
    248.     //   base::WeakPtr<Derived> ptr = base::AsWeakPtr(&derived);  
    249.     //  
    250.     // Note that the following doesn't work (invalid type conversion) since  
    251.     // Derived::AsWeakPtr() is WeakPtr<Base> SupportsWeakPtr<Base>::AsWeakPtr(),  
    252.     // and there's no way to safely cast WeakPtr<Base> to WeakPtr<Derived> at  
    253.     // the caller.  
    254.     //  
    255.     //   base::WeakPtr<Derived> ptr = derived.AsWeakPtr();  // Fails.  
    256.   
    257.   
    258.     //  在这种情况下,子类中的AsWeakPtr()函数不是WeakPtr<Derived>类型的,而是  
    259.     //  WeakPtr<Producer> SupportsWeakPtr<Base>::AsWeakPtr()类型的,因为子类中的内  
    260.     //  容是继承自父类的,所以,不能直接调用那句话。 父子类形成的模板,不再兼容  
    261.     //  也就是想要WeakPtr<Derived>  而返回的是WeakPtr<Base>  
    262.     //  
    263.     //  需要调用internal::SupportsWeakPtrBase::StaticAsWeakPtr<Derived>(t)转换  
    264.   
    265.     template <typename Derived>  
    266.     WeakPtr<Derived> AsWeakPtr(Derived* t) {  
    267.         return internal::SupportsWeakPtrBase::StaticAsWeakPtr<Derived>(t);  
    268.     }  
    269.   
    270.     // A class may alternatively be composed of a WeakPtrFactory and thereby  
    271.     // control how it exposes weak pointers to itself.  This is helpful if you only  
    272.     // need weak pointers within the implementation of a class.  This class is also  
    273.     // useful when working with primitive types.  For example, you could have a  
    274.     // WeakPtrFactory<bool> that is used to pass around a weak reference to a bool.  
    275.     // 工厂是对owner是封装  
    276.     template <class T>  
    277.     class WeakPtrFactory {  
    278.     public:  
    279.         explicit WeakPtrFactory(T* ptr) : ptr_(ptr) {  
    280.         }  
    281.   
    282.         ~WeakPtrFactory() {  
    283.             ptr_ = NULL;  
    284.         }  
    285.   
    286.         WeakPtr<T> GetWeakPtr() {  
    287.             DCHECK(ptr_);  
    288.             return WeakPtr<T>(weak_reference_owner_.GetRef(), ptr_);  
    289.         }  
    290.   
    291.         // Call this method to invalidate all existing weak pointers.  
    292.         void InvalidateWeakPtrs() {//让所有弱指针无效  
    293.             DCHECK(ptr_);  
    294.             weak_reference_owner_.Invalidate();  
    295.         }  
    296.   
    297.         // Call this method to determine if any weak pointers exist.  
    298.         bool HasWeakPtrs() const {  
    299.             DCHECK(ptr_);  
    300.             return weak_reference_owner_.HasRefs();  
    301.         }  
    302.   
    303.         // Indicates that this object will be used on another thread from now on.  
    304.         void DetachFromThread() {  
    305.             DCHECK(ptr_);  
    306.             weak_reference_owner_.DetachFromThread();  
    307.         }  
    308.   
    309.     private:  
    310.         internal::WeakReferenceOwner weak_reference_owner_;  
    311.         T* ptr_;  
    312.         DISALLOW_IMPLICIT_CONSTRUCTORS(WeakPtrFactory);  
    313.     };  
    314.   
    315. }  // namespace base  
    316.   
    317.   
    318. /* 
    319.     上面提供了两种方法,让一个类可导出WeakPtr指针。一种是将WeakPtrFactory包装到类定义中, 
    320.     工厂方法,一种是继承SupportsWeakPtr 
    321. */  
    322. #endif  // BASE_MEMORY_WEAK_PTR_H_  
    323.   
    324.   
    325.   
    326.   
    327. /* 
    328.   模板在用父子类特化后不再兼容 
    329.  
    330.  
    331. template <class T> 
    332. class WeakPtr{}; 
    333.  
    334. template <class T> 
    335. class SupportsWeakPtr{ 
    336. public: 
    337.     WeakPtr<T> AsWeakPtr() { 
    338.         return WeakPtr<T>; 
    339.     } 
    340. }; 
    341.  
    342.   
    343. class Base:public SupportsWeakPtr<Base>{}; 
    344. class Derived:public Base{}; 
    345.  
    346.  
    347. int _tmain(int argc, TCHAR* argv[], TCHAR* envp[]) 
    348. { 
    349.     Derived derived; 
    350.     //error C2440: “初始化”: 无法从“WeakPtr<T>”转换为“WeakPtr<T>” 
    351.     //WeakPtr<Derived> ptr = derived.AsWeakPtr(); 
    352.  
    353.     WeakPtr<Base> pb; 
    354.     WeakPtr<Derived> pd; 
    355.     // error C2679: 二进制“=”: 没有找到接受“WeakPtr<T>” 
    356.     //类型的右操作数的运算符(或没有可接受的转换) 
    357.     //pb=pd; 
    358.  
    359.     //error C2440: “初始化”: 无法从“WeakPtr<T> *”转换为“WeakPtr<T> *” 
    360.     //WeakPtr<Base> *p= new WeakPtr<Derived>; 
    361.  
    362.     system("pause"); 
    363.     return 0; 
    364. } 
    365.  
    366. */  
    展开全文
  • WeakPtr 不会影响Object的声明周期。 任何其他的对象,包括它自己在任何时间都可以delete。 WeakPtr存在的意义就是保证其他对象访问它的时候的安全性(有可能被意外delete,所以访问到Null等) // EXAMPLE: ...

    WeakPtr 不会影响Object的声明周期。 任何其他的对象,包括它自己在任何时间都可以delete。

    WeakPtr存在的意义就是保证其他对象访问它的时候的安全性(有可能被意外delete,所以访问到Null等)

    // EXAMPLE:
    
      class Controller {
       public:
        void SpawnWorker() { Worker::StartNew(weak_factory_.GetWeakPtr()); }
        void WorkComplete(const Result& result) { ... }
       private:
        // Member variables should appear before the WeakPtrFactory, to ensure
        // that any WeakPtrs to Controller are invalidated before its members
        // variable's destructors are executed, rendering them invalid.
        WeakPtrFactory<Controller> weak_factory_;
      };
    
      class Worker {
       public:
        static void StartNew(const WeakPtr<Controller>& controller) {
          Worker* worker = new Worker(controller);
          // Kick off asynchronous processing...
        }
       private:
        Worker(const WeakPtr<Controller>& controller)
            : controller_(controller) {}
        void DidCompleteAsynchronousProcessing(const Result& result) {
          if (controller_)
            controller_->WorkComplete(result);
        }
        WeakPtr<Controller> controller_;
      };
    
    Weak pointers may be passed safely between threads

    But the object must be dereferenced(也就是不能是RefCountedThreadSafe的实例)



    展开全文
  • 弱指针(WeakPtr)用作传递指针但不更换指针的Owner,不影响指针的状态(引用计数等),即明确知道谁去释放但其它引用者不确定其时机,用弱引用指针可随时知道其是否已delete。 1、用法:class Controller { public: ...
  • boost智能指针及chromium指针管理WeakPtr

    千次阅读 2013-10-25 14:55:07
    转自 ... 之前一直有用到智能指针,但一直没有真正去了解其内部的实现,并且...今天在研究chromium中的代码是看到了其自定义的WeakPtr的实现,感觉自己对这部分知识不甚了解,趁着这个机会,好好把跟智能指针相关的
  • /* Constructors */ constexpr WeakPtr(void) noexcept : ptr(nullptr), counter(nullptr) {} WeakPtr(const SharedPtr& sp) noexcept : ptr(sp.ptr), counter(sp.counter) { if (counter) { counter->...
  • 创建sharedptr 对象 SPTR, 赋值给WPTR : home::WPtr shandong = feicheng; 从 WPTR 获取sharedptr 对象: auto strongHome = shandong.lock(); 测试代码 #include #... } reset掉sharedptr,weakptr的lock为空
  • WeakPtr就是用来解决SharedPtr的循环引用问题的,它的实现原理是:只让指针指向,但是不增加引用计数。 也就是在使用的时候如下: struct ListNode { boost: :weak_ptr _prev; // 前驱指针 boost: :...
  • void*裸指针的使用及转换 我们知道,在使用裸指针时,对于那些不确定的类型指针,我们可以用void*来进行指向. 真正知道了类型之后,需要进行转换.具体的转换方式有: static_cast<T*> const_cast<...
  •  WeakPtr的实现思路(概念上的):(WeakPtr 1)===> (引用结构 2) (实际的对象 3) 当(实际的对象3)由于调用析构函数销毁自己时,可以清除(引用结构 2)里面的信息,这样(WeakPtr 1)就得到了null,...
  • 智能指针(三):weak_ptr浅析

    万次阅读 多人点赞 2018-09-01 14:36:26
    weak_ptr这个指针天生一副“小弟”的模样,也是在C++11的时候引入的标准库,它的出现完全是为了弥补它老大shared_ptr天生有缺陷的问题,其实相比于上一代的智能指针auto_ptr来说,新进老大shared_ptr可以说近乎完美...
  • 比如 A 通过shareptr强引用B 而B 通过shareptr 强引用 A 解决办法: 首先,A 要成为sharedptr 其次,A 传递 weakptr 给B 这样,B持有A的weakptr 如果A ,比如我使用单例模式,不是shardptr管理的,那么传递给B的...
  • C++11中weak_ptr的使用

    万次阅读 2016-08-14 12:10:04
    C++11中weak_ptr的使用
  • 智能指针weak_ptr的核心源码实现

    千次阅读 2018-03-10 00:40:47
    weakptr的作为弱引用指针,其实现依赖于counter的计数器类和share_ptr的赋值,构造,所以需要把counter和share_ptr也简单实现一下。counter对象的目地就是用来申请一个块内存来存引用基数,简单实现如下:class ...
  • https://blog.csdn.net/LLZK_/article/details/52431404
  • weak_ptr 概述 weak弱 shared_ptr强 weak_ptr:也是一个类模板,也是一个智能指针。 这个智能指针指向一个由shared_ptr管理的对象。 但是weak_ptr这种智能指针不控制所指向的对象的生命周期 ...
  • share_ptr与weak_ptr的区别与联系

    千次阅读 2019-04-23 20:57:37
    1.shared_ptr和weak_ptr 基础概念 shared_ptr与weak_ptr智能指针均是C++ RAII的一种应用,可用于动态资源管理 shared_ptr基于“引用计数”模型实现,多个shared_ptr可指向同一个动态对象,并维护了一个共享的引用...
  • 内容: c++11后,我们有了新的智能指针可以使用,我们可以抛弃auto,而使用新的智能指针,其中shared_ptr指针在正常使用是没有问题的,但是如果shared_ptr出现互相引用的时候,那么就会出现循环引用,从而导致资源...
  • 基础概念阅读另一篇文章: ...weak_ptr是一种不控制所指向对象生存周期的智能指针,它指向由一个shared_ptr管理的对象。将一个weak_ptr绑定到一个shared_ptr的对象不会改变其引用计数。当shared_ptr被销毁,即使有weak_...
  • C++笔记-shared_ptr与weak_ptr需要注意的地方

    千次阅读 多人点赞 2019-09-16 09:06:55
    目录 基本概念 代码与实例 ...share_ptr使用的是引用计数,每一个shared_ptr都指向相同的内存。只有最后一个shared_ptr析构的时候,才会释放内存,不建议直接用shared_ptr作为函数参数进行传递,尤其是复杂类型...
  • 智能指针weak_ptr的作用

    千次阅读 2018-07-25 15:26:06
    weak_ptr也是一个引用计数型智能指针,但是它不增加对象的引用计数,即弱引用。与之相对,shared_ptr是强引用,只要有一个指向对象的shared_ptr存在,该对象就不会析构,直到指向对象的最后一个shared_ptr析构或...
  • c++11之weak_ptr 使用介绍

    万次阅读 多人点赞 2018-03-04 23:29:30
    介绍 weak_ptr是弱智能指针对象,它不控制所指向对象生存期的智能指针,它指向由一个shared_ptr管理的智能指针。将一个weak_ptr绑定到一个shared_ptr对象,不会改变shared_ptr的引用计数。一旦最后一个所指向对象的...
  • *非线程安全,能够跨线程传递,但必须在一个线程上使用这个WeakPtr,即仅仅能在运行在同样线程的任务上使用这个机制。 *类中WeakPtrFactory<Foo> weak_factory_的成员须要放在全部其他成员的后面,确保其他成员的析...
  • c++11之weak_ptr剖析

    2018-07-22 16:31:28
    一、概述  引用《c++ primer》的话:weak_ptr是一种不控制所指向对象生存期的智能指针,它指向由一个shared_ptr管理的对象。 将一个weak_ptr绑定到shared_ptr不会改变shared_ptr的引用计数【0】。...
  • C++基础:weak_ptr初始化

    2021-02-20 23:54:53
    #include <memory> #include <iostream> int main() { // 1.shared_ptr直接赋值 std::shared_ptr<int> sp0(new int(10)); std::weak_ptr<... wp2 = std::make_shared&l.
  • weak_ptr是为了配合shared_ptr而引入的一种智能指针,因为它不具有普通指针的行为,没有重载operator*和->,它的最大作用在于协助shared_ptr工作,像旁观者那样观测资源的使用情况。weak_ptr可以从一个shared_ptr...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 658
精华内容 263
关键字:

weakptr