Smart pointers std::unique_ptr, std::shared_ptr, std::weak_ptr c++ In Hindi
C++ प्रोग्रामिंग लैंग्वेज में स्मार्ट पॉइंटर्स ऐसे क्लास प्रोग्राम पैरामीटर वेरिएबल ऑब्जेक्ट्स होते हैं, जो किसी यूजर डिफाइन क्लास प्रोग्राम में डायनामिक रूप से एलोकेटेड ऑब्जेक्ट मेमोरी (या किसी भी यूज़ प्रोग्राम रिसोर्स) के लाइफटाइम को मैनेज और होल्ड करते हैं, और स्मार्ट पॉइंटर्स मौजूदा प्रोग्राम में यह मैनेज और कण्ट्रोल करते हैं कि जब किसी प्रोग्राम में C++ ऑब्जेक्ट सिस्टम रिसोर्स की ज़रूरत न हो तो उसे प्रॉपर आर्डर में डीलोकेशन किया जाए। C++ में स्मार्ट पॉइंटर्स C++ स्टैंडर्ड लाइब्रेरी का बिल्ट-इन फीचर्स हैं. जिसे C++11 वर्जन में पहली बार में लांच किया गया था, और स्मार्ट पॉइंटर्स C++ यूजर को मेमोरी लीक और डैंगलिंग पॉइंटर्स जैसी कॉमन मेमोरी मैनेजमेंट मिस्टेक्स को अवॉयड करने में हेल्प करते हैं।
There are three main types of smart pointers in C++ programming.
- std::unique_ptr
- std::shared_ptr
- std::weak_ptr
So, let’s explore each smart pointer in C++ programming in detail.
std::unique_ptr overview in C++.
- Ownership – C++ प्रोग्राम में std::unique_ptr एक स्मार्ट पॉइंटर ऑब्जेक्ट मेथड है, जो किसी प्रोग्राम रिसोर्स की एक सिंगल ओनरशिप वैल्यू को होल्ड करता है। जब किसी प्रोग्राम में unique_ptr इसके स्कोप से बाहर हो जाता है. तो यह उस प्रोग्राम रिसोर्स को ऑटोमैटिकली डिलीट कर देता है, जिसकी ओर वह पॉइंट करता है
- Transfer Ownership – C++ प्रोग्राम में std::unique_ptr द्वारा मैनेज और कण्ट्रोल किए जाने वाले प्रोग्राम पैरामीटर ऑब्जेक्ट की डिफ़ॉल्ट ओनरशिप को मूव सिमेंटिक्स (जैसे, std::move मेथ) का यूज़ करके ट्रांसफर किया जा सकता है।
- Non-copyable – C++ प्रोग्राम में एक std::unique_ptr स्मार्ट पॉइंटर को मौजूदा प्रोग्राम में कॉपी नहीं किया जा सकता है, इन स्मार्ट पॉइंटर को जरूरत पड़ने पर सिर्फ़ मूव किया जा सकता है। इससे किसी प्रोग्राम में यह फिक्स होता है कि किसी भी समय प्रोग्राम स्मार्ट पॉइंटर रिसोर्स का सिर्फ़ एक ही ओनर डिफाइन हो, जिससे किसी प्रोग्राम में अलॉट मेमोरी मिस्टकेली डबल डिलीशन नहीं हो जाए।
Syntax of the std::unique_ptr smart pointer.
#include <memory>
std::unique_ptr<T> ptrone(new T()); // Here, create a smart pointer unique_ptr with the new keyword.
std::unique_ptr<T> ptrtwo = std::make_unique<T>(); // Here, a basic method for creating ptrtwo.
Example of std::unique_ptr smart pointer.
#include <iostream>
#include <memory> // here we use memory header file for smart pointer memory object
class SampleClass {
public:
SampleClass() { std::cout << “SampleClass Constructor created \n”; }
~SampleClass() { std::cout << “SampleClass Destructor created \n”; }
};
int main() {
std::unique_ptr<SampleClass> ptrone = std::make_unique<SampleClass>(); // here we memory allocated for SampleClass
// here we ownership transferred, ptrone is now nullptr value
std::unique_ptr<SampleClass> ptrtwo = std::move(ptrone);
// here ptrone is now nullptr value, but ptrtwo still owns the memory value object.
return 0; // here destructor for SampleClass will be automatically called when ptrtwo goes out of its scope.
}
Special features of the std::unique_ptr smart pointer.
- Automatic deletion – जब किसी C++ प्रोग्राम में std::unique_ptr उसके स्कोप से बाहर हो जाता है. तो यह ऑटोमैटिकली एसोसिएट मेमोरी ऑब्जेक्ट को डीएलोकेट कर देता है।
- No copy semantics – याद रहे किसी C++ प्रोग्राम में std::unique_ptr स्मार्ट पॉइंटर को को कॉपी नहीं किया जा सकता है. लेकिन इन स्मार्ट पॉइंटर को std::move मेथड का यूज़ करके मूव जरूर किया जा सकता है।
- Efficient – क्योंकि किसी प्रोग्राम में स्मार्ट पॉइंटर एक सिंगल ओनरशिप को होल्ड करता है. इस वजह से इसमें कोई रेफरेंस काउंटिंग ओवरहेड नहीं होते है।
- Use Case – C++ प्रोग्राम में एक स्मार्ट पॉइंटर को ऐसे सिस्टम प्रोग्राम रिसोर्स को मैनेज और कण्ट्रोल करने के लिए आइडियल माना जाता है. जिसमे एक क्लियर, सिंगल ओनरशिप डिफाइन हो, जैसे किसी यूजर डिफाइन क्लास में डायनामिकली एलोकेट किए गए ऑब्जेक्ट वैल्यू हो।
std::shared_ptr overview in C++.
- Ownership – C++ प्रोग्राम में एक std::shared_ptr स्मार्ट पॉइंटर किसी प्रोग्राम मेमोरी रिसोर्स की शेयर्ड ओनरशिप परमिशन को प्रोवाइड करते है। जहा एक से ज़्यादा shared_ptr स्मार्ट पॉइंटर एक ही सिस्टम रिसोर्स को मैनेज और कण्ट्रोल कर सकते हैं। ये स्मार्ट पॉइंटर प्रोग्राम रिसोर्स तभी डिस्ट्रॉय होते है, जब इन स्मार्ट पॉइंटर की ओनरशिप वाला लास्ट shared_ptr डिस्ट्रॉय या रीसेट हो जाता है।
- Reference Counting – किसी C++ प्रोग्राम में std::shared_ptr स्मार्ट पॉइंटर यह ट्रैक करने के लिए प्रोग्राम रेफरेंस काउंटिंग मेथड को यूज़ करता है कि मौजूदा प्रोग्राम में कितने shared_ptr इंस्टेंस एक ही पैरामीटर वेरिएबल ऑब्जेक्ट को मैनेज और कण्ट्रोल कर रहे हैं। जब इसमें इसका रेफरेंस काउंट ज़ीरो पर पहुँच जाता है, तो इसमें अलॉट ऑब्जेक्ट डिलीट हो जाता है।
Syntax of std::shared_ptr smart pointer.
#include <memory>
std::shared_ptr<T> ptrone = std::make_shared<T>(); // Here is the method to create a smart pointer
std::shared_ptr<T> ptrtwo(new T); // Here is the smart pointer direct initialization method
Instance of a std::shared_ptr smart pointer.
#include <iostream>
#include <memory>
class SampleClass {
public:
SampleClass() { std::cout << “SampleClass Constructor created \n”; }
~SampleClass() { std::cout << “SampleClass Destructor created \n”; }
};
int main() {
std::shared_ptr<SampleClass> ptrone = std::make_shared<SampleClass>(); // here we use Reference 1
{
std::shared_ptr<SampleClass> ptrtwo = ptrone; // here we use Reference 2
std::cout << “Internal inner scope is \n”;
} // ptrtwo goes out of scope, reference 1
std::cout << “External inner scope is \n”;
return 0; // here we use destructor for SampleClass, when the last shared_ptr goes out of its scope.
}
Special features of the std::shared_ptr smart pointer.
- Reference counting – यह C++ प्रोग्राम के अंदर से ट्रैक करता है कि कितने shared_ptr स्मार्ट पॉइंटर इंस्टेंस रिसोर्स की ओनरशिप को आपस में शेयर करते हैं। जब लास्ट shared_ptr स्मार्ट पॉइंटर टर्मिनेट हो जाता है. तो इसमें स्टोर ऑब्जेक्ट अपने आप डिलीट हो जाते है।
- Thread-safe – यहाँ C++ प्रोग्राम में रेफरेंस काउंट थ्रेड-सेफ मेथड है, इसका मतलब है कि इन प्रोग्राम में कई थ्रेड एक ही प्रोग्राम के रिसोर्स को सिक्योर आर्डर में मैनेज कर सकते हैं।
- Overhead – C++ प्रोग्राम में रेफरेंस काउंटिंग की वजह से, std::unique_ptr स्मार्ट पॉइंटर की तुलना में std::shared_ptr पर थोड़ा परफॉर्मेंस ओवरहेड सा लगता है।
- Use Case – C++ प्रोग्राम में shared_ptr कुछ पर्टिकुलर कंडीशन के लिए बेस्ट चॉइस है. जहाँ प्रोग्राम सोर्स कोड के कई हिस्सों को रिसोर्स के लिए शेयर्ड या एक्सेस की ज़रूरत होती है।
std::weak_ptr overview in C++.
- Non-owning Reference – C++ प्रोग्राम में एक std::weak_ptr स्मार्ट पॉइंटर रिसोर्स का ओनर नहीं होता है। इस स्मार्ट पॉइंटर का यूज़ std::shared_ptr द्वारा मैनेज किए जाने वाले क्लास प्रोग्राम ऑब्जेक्ट को उसके रेफरेंस काउंट पर इम्पैक्ट डाले बिना व्यू करने में किया जाता है।
- Prevents Circular References – C++ प्रोग्राम में std::weak_ptr स्मार्ट पॉइंटर स्पेशली उन सर्कुलर रेफरेंस को ब्रेक करने के लिए यूज़फुल है, जो shared_ptrs के बीच डिफाइन हो सकते हैं। स्मार्ट पॉइंटर में सर्कुलर रेफरेंस तब होता है. जब दो या ज़्यादा shared_ptr स्मार्ट पॉइंटर एक-दूसरे को आपस में रेफर करते हैं. जिससे स्मार्ट पॉइंटर रेफरेंस काउंट कभी भी ज़ीरो तक नहीं पहुँचता है, इस वजह से मौजूदा C++ प्रोग्राम में मेमोरी लीक होती है।
- Expired Resources – यदि मौजूदा C++ प्रोग्राम में std::shared_ptr द्वारा मैनेज किया जाने वाला ऑब्जेक्ट रिसोर्स डिलीट कर दिया गया है. (क्योंकि इसका लास्ट ओनर shared_ptr स्कोप से बाहर हो गया है), तो std::weak_ptr स्मार्ट पॉइंटर “एक्सपायर्ड” हो जाता है. और अब क्लास प्रोग्राम ऑब्जेक्ट को एक्सेस करने के लिए इसका यूज़ नहीं किया जा सकता है।
Syntax std::weak_ptr smart pointer.
#include <memory>
std::weak_ptr<T> weak_ptr = shared_ptr_instance; // This represents a shared_ptr
Example of std::weak_ptr smart pointer.
#include <iostream>
#include <memory>
class SampleClass {
public:
SampleClass() { std::cout << “SampleClass Constructor created \n”; }
~SampleClass() { std::cout << “SampleClass Destructor created \n”; }
};
int main() {
std::shared_ptr<SampleClass> sharedPtr = std::make_shared<SampleClass>();
std::weak_ptr<SampleClass> weakPtr = sharedPtr; // here we define weak reference to sharedPtr
if (auto temp = weakPtr.lock()) { // here it convert weak_ptr to shared_ptr class object
std::cout << “Smart pointer Resource is working \n”;
} else {
std::cout << “Smart pointer Resource deleted \n”;
}
sharedPtr.reset(); // here it reset the sharedPtr, causing SampleClass to be deleted here
if (auto temp = weakPtr.lock()) { // here it check if resource is still available or not
std::cout << “Smart pointer Resource is working \n”;
} else {
std::cout << “Smart pointer Resource deleted \n”; // here this information will be printed
}
return 0;
}
Special features of the std::weak_ptr smart pointer.
- Non-owning – C++ प्रोग्राम में एक weak_ptr उस shared_ptr के रेफरेंस काउंट पर इम्पैक्ट नहीं करता है, जिसे वह व्यू कर रहा है।
- Expired State – किसी C++ प्रोग्राम में एक weak_ptr को लॉक किया जा सकता है, (जैसे, shared_ptr में कन्वर्ट किया जा सकता है) मौजूदा प्रोग्राम में यह चेक करने के लिए कि क्लास ऑब्जेक्ट अभी भी वर्किंग या अलाइव है, या नहीं है। यदि मौजूदा क्लास ऑब्जेक्ट डिलीट हो गया है, (जैसे, रेफरेंस काउंट ज़ीरो पर पहुँच जाता है), तो यह लॉक एक nullptr वैल्यू को रिटर्न करेगा।
- Avoids circular references – C++ प्रोग्राम में इसका यूज़ ज्यादातर shared_ptr इंस्टेंस के बीच सर्कुलर डिपेंडेंसी को अवॉयड करने में किया जाता है. जिससे किसी एक क्लास ऑब्जेक्ट रेफरेंस को रेफरेंस काउंट इनक्रीस करने की परमिशन नहीं मिलती है।
- Use Cases – weak_ptr मेथड C++ प्रोग्राम में कैशिंग, ऑब्ज़र्वर पैटर्न और ग्राफ़ जैसे स्ट्रक्चर में सर्कुलर रेफरेंस को ब्रेक करने के लिए एक आइडियल चॉइस है।
