std::weak_ptr

-

std::weak_ptr

  • std::weak_ptr is'nt a standalone smart pointer. It's an augmentation of std::shared_ptr. 
  • It do not contribute to the reference count of the managed object they refer to.
  • By using just the raw pointer, it is impossible to know if the referenced data has been deallocated or not.
  • std::weak_ptr provides a "expired" API to check if the shared_ptr it was pointing to is expired.
In a nutshell -

The weak_ptr class template stores a “weak reference” to an object that’s already managed by a shared_ptr. To access the object, a weak_ptr can be converted to a shared_ptr using the shared_ptr constructor or the member function lock. When the last shared_ptr to the object goes away and the object is deleted, the attempt to obtain a shared_ptr from the weak_ptr instances that refer to the deleted object will fail: the constructor will throw an exception of type boost::bad_weak_ptr, and weak_ptr::lock will return an empty shared_ptr.


auto sPtr = std::make_shared<Base>(); 
// The reference count of sPtr is 1.

std::weak_ptr<Base> wPtr(sPtr); 
// wPtr points to same Base as sPtr. Reference count remains same

sPtr = nullptr;
// Referece count is 0 now, and the Base is destroyed, wPtr now dangles.

std::weak_ptr that dangles are said to be expired.
if(wPtr.expired()) 
  • std::weak_ptr lacks dereferencing operations (*, ->), to point to the shared_ptr it was referring to.

There are two ways to get the shared_ptr from weak_ptr

  • One form is std::weak_ptr::lock - which returns a std::shared_ptr , the std::shared_ptr is null if the std::weak_ptr is expired.  
        std::shared_ptr<Base> sPtr1 = wPtr.lock();
        // If wPtr is expired, sPtr1 is null
  • The other form is the std::shared_ptr constructor taking a std::weak_ptr as an argument. If passed std::weak_ptr has expired, an exception is thrown.
        std::shared_ptr<Base> sPtr3(wPtr);   
        // If wPtr is expired, throw std::bad_weak_ptr


Usage of std::weak_ptr.

  • To solve dangling pointer.
  • To remove circular reference.

Solve dangling pointer.

// Check if the pointer is expired, then get assocaited pointer and print the contents.


Another example to check for the dangling pointer.


#include <iostream>
#include <memory>

int main()
{
    // PROBLEM: ref will point to undefined data!

    int* ptr = new int(10);
    int* ref = ptr;
    delete ptr;

    // Check expired() or lock() to determine if pointer is valid

    // empty definition
    std::shared_ptr<int> sptr;

    // takes ownership of pointer
    sptr.reset(new int);
    *sptr = 10;

    // get pointer to data without taking ownership
    std::weak_ptr<int> weak1 = sptr;

    // deletes managed object, acquires new pointer
    sptr.reset(new int);
    *sptr = 5;

    // get pointer to new data without taking ownership
    std::weak_ptr<int> weak2 = sptr;

    // weak1 is expired!
    if(auto tmp = weak1.lock())
        std::cout << *tmp << '\n';
    else
        std::cout << "weak1 is expired\n";

    // weak2 points to new data (5)
    if(auto tmp = weak2.lock())
        std::cout << *tmp << '\n';
    else
        std::cout << "weak2 is expired\n";
}


/*
Output- 

weak1 is expired
5

*/

Remove circular reference.

Consider the below example - 

class B;
class A
{
   public:
        A() : sPtrToB(nullptr) { };
        ~A()
        {
             cout<<"A destrcutor\n";
        }
        std::shared_ptr<B> sPtrToB;
};

class B
{
      public:
           B() : sPtrToA(nullptr) { };
           ~B()
           {
               cout<<"B desctructor\n"
           }
           std::shared_ptr<A> sPtrToA;
};

int main()
{
     shared_ptr<A> sPtrA ( new A ); // Ref Count of sPtrA = 1
     shared_ptr<B> sPtrB ( new B ); // Ref Count of sPtrB = 1

     sPtrA->sPtrToB = sPtrB; // Ref Count of sPtrA = 2
     sPtrB->sPtrToA = sPtrA; // Ref Count of sPtrB = 2
}

Ref count of sPtrA and sPtrB is 1.

The above code has cyclic reference. class A holds a shared pointer to B and class B holds a shared pointer to A. The resource associated with both sPtrToA and sPtrToB are not released. 

It can be solved using having a std::weak_ptr as data member and as reference to another class.

class A
{
public:
    int _a;
    weak_ptr<B> sPtrToB;
    
    void printB()
    {
       if(sPtrToB->expired())
       {
            cout<<"Expired....!!!\n"
       }
       else
       {
            cout<<sPtrToB->lock()->_b<<endl;;
       }
    }
};

class B
{
public:
     int _b;
     weak_ptr<A> sPtrToA;
  
     

    void printA()
    {
       if(sPtrToA->expired())
       {
            cout<<"Expired....!!!\n"
       }
       else
       {
            cout<<sPtrToA->lock()->_a<<endl;;
       }
    }

};

Comments

Post a Comment

Popular posts from this blog

C++ Guidelines for Multithreaded System

-
Image
Mutithreading è Parallelism è  Achieve concurrency. Below are some of the guidelines to follow for building C++ Multithreaded system. Ø std::thread function arguments are pass by value by default. Thread function arguments are pass by value by default. So, if you want the change to be persisted in the arguments passed in , then pass them by reference using std::ref(). Ø Protect shared data or resource using critical section.     In a multithreaded environment if there are more than one thread sharing the resource/data then often it results in a undefined behaviour if the resource/shared data is not protected using synchronise mechanism. So, the shared resource/data must be protected with std::mutex . Ø Release lock after critical section. If a thread T1 acquires lock (mutex.lock()) before entering critical section and forgets to unlock(mutex.unlock()) then all the other threads will be blocked indefinitely and the program might hang because thread T1 gets hol
Read more

Signalling System #7(SS7) Protocol.

-
Image
            Signaling System No. 7 ( SS7 ) is a set of telephony signaling protocols which are used to set up most of the world's public switched telephone network telephone calls. The main purpose is to set up and tear down telephone calls. Other uses include number translation, prepaid billing mechanisms, short message service (SMS), and a variety of other mass market services. SS5 and earlier systems used in-band signaling(In telecommunications, In-band signaling is the sending of metadata and control information in the same band, on the same channel, as used for data.). SS6 and SS7 implement out-of-band (out-of-band control signaling, signaling bits are sent in special order in a dedicated signaling frame.) signaling protocols.         The term signaling , when used in telephony, refers to the exchange of control information associated with the establishment of a telephone call on a telecommunications circuit. An example of this control information is the digits dialed by t
Read more

std::shared_ptr

-
Image
std::shared_ptr  for shared ownership An object accessed via std::shared_ptr s has its lifetime managed by those pointers through shared ownership. No specific std::shared_ptr owns the object. Instead all shared_ptr’s pointing to it collaborates to ensure its destruction at the point where it’s no longer needed. When the last shared_ptr pointing to an object stops pointing there, that shared_ptr destroys the object it points to. A shared_ptr can tell whether it’s the last one pointing to a resource by consulting the resource’s reference count, a value associated with the resource that keeps track of how many shared_ptrs point to it. Shared_ptrs constructors increments this count shared_ptr s destructors decrements it and copy assignment operators do both. If sp1 and sp2 are shared_ptr s to different objects, the assignment “ sp1=sp2 ” , modifies sp1 such that it points  to the object pointed to by sp2 . sp1 reference count is decremented, while that for the object point
Read more