Weak Pointer in C++

In this article, we will discuss the weak pointer in C++ with their syntax and examples.

The C++ weak_ptr is a standard library component. It is used to store weak references to any objects controlled by the shared_ptr standard library pointer, which is used to ultimately transform weak_ptr to shared_ptr. The shared_ptr that was ultimately created from the weak_ptr is used to access the referenced object. A weak_ptr loses its capacity to remain forever after it is transformed into a shared_ptr, indicating that it only exists momentarily. It is not advised to access weak_ptr first before granting access to the reference object.

Syntax:

It has the following syntax:

The type controlled by the weak pointer is used for the parameter supplied as Class T according to the syntax for the C++ weak_ptr function.

How does C++'s weak_ptr operate?

Every pointer in a high-level language is primarily used to reference objects and subsequently access elements that are available in an array in a well-organized style. Similar circumstances apply to C++'s weak_ptr. The weak_ptr working flow is described throughout the class template:

The weak_ptr used for referencing an object initially is not the actual pointer, as it is considered as a temporary pointer in terms of object referencing and assigning.
However, once weak_ptr gains final control or authority over share_ptr, object accessing and referencing become simple and efficient.
The main purpose of this coordination and sharing, and switching between the weak_ptr and share_ptr for reading and referencing, is to prevent lengthy cycles within the data structure.
When share_ptr assumes full responsibility for managing resources during resource allocation and analysis, weak_ptr loses all control and is erased.
A weak_ptr never allows access to the elements directly; instead, it uses the shared_ptr object, which owns the complete code, to call the member function Lock to access the code that needs to use the resource.
Once the Lock or weak_ptr is called for resource allocation or to control any bLock, an empty weak_ptr object is generated.
Once the Lock or the weak_ptr is jointly referenced or held by the majority of the shared_ptr object, one complete cycle has been accomplished or finished.
Instead of merely employing weak_ptr, which is a component of the complete working format of pointers in any of the pointer concepts, it makes use of all resources prominently with the aid of share_ptr.
The shared_ptr makes use of the weak_ptr's behaviour of obtaining Locks and weak_ptr's points to make the end resources freed and released by the weak_ptr.
The list and its related nodes will also be easily deleted and distinguished once all the aforementioned resources have been released, creating an optimized method of analysis and format sizing.
This complete cycle consists of numerous checks and methods, including the expired() method, which is used to determine whether or not ownership has expired.
By using Lock(), you can take an individual, exclusive Lock over a resource, preventing other resources from trying to target it and causing conflicts in their attempts to do so.
The weak_ptr pointing is checked using the owner () before, which returns true if it points correctly.
Within that entire cycle, the owned resource is released using Reset().
A swap() technique is used when two weak_ptr are acting on the objects.
The number of shared_ptr objects is counted and tracked using the use_count()
The technique for swapping out the initially owned resources is operator=.

Examples of weak_ptr in C++:

Here are some examples of weak_ptr in C++:

Example - 1:

#include <iostream>
#include <memory>

int main() {
std::shared_ptr<int>sharedPtr = std::make_shared<int>(42);

std::weak_ptr<int>weakPtr = sharedPtr;

    if (auto LockedPtr = weakPtr.Lock()) {
        // Use the weak pointer's shared object
std::cout<< "Weak pointer value: " << *LockedPtr<< std::endl;
    } else {
std::cout<< "Weak pointer is expired" << std::endl;
    }

sharedPtr.reset(); // The shared pointer is reset, object may be deleted

    if (auto LockedPtr = weakPtr.Lock()) {
std::cout<< "Weak pointer value after reset: " << *LockedPtr<< std::endl;
    } else {
std::cout<< "Weak pointer is expired after reset" << std::endl;
    }

    return 0;
}

Output:

Weak pointer value: 42
Weak pointer is expired after reset

Explanation:

In this example, the shared pointer shared_Ptr points to an int with the value 42. After that, a sharedPtr and a std::weak_ptrweakPtr are created. If the original object has been removed, the Lock() function returns an empty shared pointer, which is used to retrieve a shared pointer from a weak pointer.

The program prints the shared object's value first when it uses the weak pointer to access it. After that, the shared pointer is reset, simulating a scenario in which the initial shared pointer no longer controls the object. After resetting the shared pointer, the program tries to access the object again using the weak pointer.

Example - 2:

#include <memory>
#include <iostream>

int main() {
    // Creating a shared pointer to an int with value 14
std::shared_ptr<int>sharedPtr(new int(14));

    // Creating a weak pointer that shares ownership with the shared pointer
std::weak_ptr<int>weakPtr(sharedPtr);

    // Accessing the object using the weak pointer's Lock() function
    // The shared object is still alive, so this will succeed
std::cout<< "Acquired weak_ptr through Lock(): " << *weakPtr.Lock() << std::endl;

    // Checking if the weak pointer is expired
    // Since the shared object is still alive, this will output "false"
std::cout<< "Weak pointer expired: " << std::boolalpha<<weakPtr.expired() << std::endl;

    // Resetting the weak pointer
weakPtr.reset();

    // Checking if the weak pointer is expired after reset
    // Since we reset the weak pointer, it's no longer associated with any object
    // This will output "true"
std::cout<< "Weak pointer expired after reset: " << std::boolalpha<<weakPtr.expired() << std::endl;

    return 0;
}

Output:

Acquired weak_ptr through Lock(): 14
Weak pointer expired: false
Weak pointer expired after reset: true

Example - 3:

#include <memory>
#include <iostream>

int main() {
    // Creating a shared pointer to an int with value 8
std::shared_ptr<int> sharedPtr1(new int(8));

    // Creating a weak pointer that shares ownership with the shared pointer
std::weak_ptr<int>weakPtr(sharedPtr1);

std::cout<< "Count of sharedPtr1: " << sharedPtr1.use_count() << std::endl;
std::cout<< "Count of weakPtr: " <<weakPtr.use_count() << std::endl;

    // Creating another shared pointer that shares ownership with sharedPtr1
std::shared_ptr<int> sharedPtr2(sharedPtr1);

std::cout<< "Count of sharedPtr1 after sharedPtr2 creation: " << sharedPtr1.use_count() << std::endl;
std::cout<< "Count of weakPtr after sharedPtr2 creation: " <<weakPtr.use_count() << std::endl;

    return 0;
}

Output:

Count of sharedPtr1: 1
Count of weakPtr: 1
Count of sharedPtr1 after sharedPtr2 creation: 2
Count of weakPtr after sharedPtr2 creation: 2

Example - 4:

#include <memory>
#include <iostream>
int main()
{
std::shared_ptr<int> shrd_ptr_1(new int(8));
std::shared_ptr<int> shrd_ptr_2(new int(10));
std::cout<< "*shrd_ptr_1 == " << *shrd_ptr_1 << std::endl;
shrd_ptr_1.swap(shrd_ptr_2);
std::cout<< "*shrd_ptr_1 == " << *shrd_ptr_1 << std::endl;
swap(shrd_ptr_1, shrd_ptr_2);
std::cout<< "*shrd_ptr_1 == " << *shrd_ptr_1 << std::endl;
std::cout<< std::endl;
std::weak_ptr<int> wk_ptr_1(shrd_ptr_1);
std::weak_ptr<int> wk_ptr_2(shrd_ptr_2);
std::cout<< "*wk_ptr_1 == " << *wk_ptr_1.Lock() << std::endl;
wk_ptr_1.swap(wk_ptr_2);
std::cout<< "*wk_ptr_2 == " << *wk_ptr_2.Lock() << std::endl;
swap(wk_ptr_1, wk_ptr_2);
std::cout<< "*wk_ptr_1 == " << *wk_ptr_1.Lock() << std::endl;
return (0);
}

Output:

*shrd_ptr_1 == 8
*shrd_ptr_1 == 10
*shrd_ptr_1 == 8

*wk_ptr_1 == 8
*wk_ptr_2 == 10
*wk_ptr_1 == 8

Explanation:

This program shows how to utilize the swap() method to swap the weak_ptr when it's necessary to get the needed resource, as seen by the output.

In the shared_ptr instances, the shrd_ptr_1 and shrd_ptr_2 that point to the integers 8 and 10 are created at the beginning of the supplied program. After that, the value of shrd_ptr_1 (which is 8) is printed. Next, it uses both the member function swap and the swap function from the standard library to swap the contents of shrd_ptr_1 and shrd_ptr_2. As a result, shrd_ptr_1's value shifts from 8 to 10 and back again. As part of the shared_ptr instances, the program creates two weak_ptr instances, wk_ptr_1 and wk_ptr_2. wk_ptr_1's value, 8, is printed by t. After that, the ownership of wk_ptr_1 and wk_ptr_2 are switched using the member function swap and the swap function from the standard library. After the values of wk_ptr_1 and wk_ptr_2 are switched, wk_ptr_1 now contains the number 10. The program ends by switching wk_ptr_1 and wk_ptr_2 once more to return to the previous ownership. After that, the value of wk_ptr_1 is printed, which returns 8.

Conclusion:

The C++ weak_ptr function is essential for obtaining and accessing the list node's elements. Additionally, shared_ptr and weak_ptr work together to create an optimized cycle for accessing the elements. Once shared_ptr has been chosen, it is generally thought of as a permanent operation. The C++ weak_ptr function offers numerous advantages for resource acquisition.

Next TopicApriori Algorithm Implementation in C++

← prev next →