बाकी कई भाषाओं की तरह C++ में भी पॉइंटर होते हैं।
आप जानते हैं कि रेफरेंस और पॉइंटर काफी मिलते-जुलते हैं, लेकिन इन्हें अपने कंप्यूटर के अंदरूनी कामकाज के एक कदम और करीब समझिए।
पॉइंटर ऐसे वेरिएबल होते हैं जिनमें ऑब्जेक्ट के एड्रेस रखे जाते हैं।
इन्हीं की मदद से ऑब्जेक्ट के साथ सीधे काम किया जाता है, जिससे C++ में डायनामिक मेमोरी आवंटन और डेटा को कुशलता से संभालना मुमकिन होता है।
अगर आप पॉइंटर के लिए नए हैं, तो ये थोड़े रहस्यमय लग सकते हैं, लेकिन जैसे ही आप इनके आदी हो जाते हैं, ये काफी आसान लगने लगते हैं।
ये C++ का बहुत ज़रूरी हिस्सा हैं, इसलिए इन्हें अच्छी तरह समझने के लिए कुछ समय ज़रूर दीजिए।
इस कॉन्सेप्ट में जो बुनियादी रूप आप देखेंगे, उसे डंब पॉइंटर या रॉ पॉइंटर भी कहते हैं।
आधुनिक C++ में स्मार्ट पॉइंटर भी होते हैं। बुनियादी पॉइंटर बिलकुल भी स्मार्ट नहीं होते, उनका सारा काम आपको खुद संभालना पड़ता है।
बारीकियों में उतरने से पहले यह समझ लेना फायदेमंद रहेगा कि पॉइंटर किस काम आते हैं।
इनकी मदद से हम किसी ऑब्जेक्ट का एड्रेस अपने प्रोग्राम के दूसरे हिस्सों के साथ साझा कर सकते हैं, और यह दो बड़े कारणों से काम का है:
-
रेफरेंस की तरह पॉइंटर कॉपी बनने से बचाते हैं और आपके प्रोग्राम पर पड़ने वाले संसाधनों का बोझ कम करने में मदद करते हैं।
-
रेफरेंस के उलट, पॉइंटर को किसी दूसरे ऑब्जेक्ट पर फिर से असाइन किया जा सकता है।
- पॉइंटर किसी null वैल्यू की ओर भी इशारा कर सकते हैं, जिसका मतलब है कि वे इस समय किसी ऑब्जेक्ट की ओर नहीं इशारा कर रहे।
सामान्य सिंटैक्स
C++ में पॉइंटर घोषित करने के लिए आपको वह डेटा टाइप बताना होता है जिसकी ओर पॉइंटर इशारा करेगा, उसके बाद एक तारा (*) और पॉइंटर का नाम लिखना होता है।
पॉइंटर घोषित करते समय उन्हें अपने आप कोई शुरुआती वैल्यू नहीं मिलती।
बिना साफ-साफ वैल्यू असाइन किए आम तौर पर पॉइंटर के अंदर कोई अनिश्चित वैल्यू रहती है, जिसे अक्सर "कचरा एड्रेस" कहा जाता है।
कुछ कंपाइलर पॉइंटर को शुरू में ही nullptr बना देते हैं, लेकिन हर कंपाइलर ऐसा करेगा, इसकी कोई गारंटी नहीं है, इसलिए इस पर भरोसा करना ठीक नहीं है।
इसलिए यह अच्छा तरीका है कि रॉ पॉइंटर को साफ-साफ शुरुआती वैल्यू दीजिए और इस्तेमाल से पहले जाँच लीजिए कि उसमें null नहीं है, ताकि आगे कोई दिक्कत न आए।
int* ptr{nullptr}; // Declares a pointer and makes sure it is not invalid
किसी वेरिएबल का एड्रेस किसी पॉइंटर को असाइन करने के लिए आप एड्रेस-ऑफ ऑपरेटर (&) इस्तेमाल करते हैं।
किसी पॉइंटर को डीरेफरेंस करने के लिए इनडायरेक्शन ऑपरेटर (*) का उपयोग किया जाता है।
std::string opponent{"Solomon Lane"};
// 'ethan' points to the address of the string opponent
std::string* ethan{&opponent};
// Instead of ethan's, the opponent's name address is given to the passPort
std::string passportName{*ethan};
ध्यान दीजिए: डीरेफरेंसिंग साफ-साफ करनी पड़ती है, जबकि रेफरेंस उपनाम की तरह अपने आप काम करते रहते हैं।
पॉइंटर अर्थमेटिक
पॉइंटर अर्थमेटिक की मदद से आप पॉइंटर पर गणितीय काम कर सकते हैं, जो ऐरे के साथ काम करते समय खास तौर पर काम आता है।
किसी पॉइंटर में कोई पूर्णांक जोड़ने पर वह किसी दूसरे एलिमेंट की ओर इशारा करने लगता है।
// Stargate Coordinate Code
int gateCode[] = {462, 753, 218, 611, 977};
// 'ptr' points to the first element of 'gateCode'
int* ptr{&gateCode[0]};
// Accesses the third Stargate address through pointer arithmetic
int dialedAddress{*(ptr + 2)};
// Chevron encoded! Dialing Stargate address:
openStarGate(dialedAddress);
C++ में पॉइंटर अर्थमेटिक को संभालते समय ज़रा भी लापरवाही बरती जाए, तो यह आसानी से अपरिभाषित व्यवहार तक पहुँच सकता है।
अपरिभाषित व्यवहार अप्रत्याशित नतीजों, क्रैश, या सुरक्षा से जुड़ी कमजोरियों के रूप में सामने आ सकता है।
अपरिभाषित व्यवहार के नतीजों का एक कुख्यात उदाहरण 1996 में एरियन 5 रॉकेट के विस्फोट के रूप में सामने आया था, जहाँ 64-बिट दशमलव संख्या को 16-बिट साइन्ड पूर्णांक में बदलने से पैदा हुए सॉफ्टवेयर एक्सेप्शन ने एक भयानक विफलता को जन्म दिया।
मेंबर वेरिएबल को एक्सेस करना
C++ में -> ऑपरेटर की मदद से आप किसी ऑब्जेक्ट के पॉइंटर के ज़रिए उसके मेंबर एक्सेस कर सकते हैं।
यह एक छोटा रूप है, जो पॉइंटर से इशारा किए गए ऑब्जेक्ट के मेंबर एक्सेस करना आसान बना देता है।
उदाहरण के लिए, अगर ptr किसी ऐसे ऑब्जेक्ट का पॉइंटर है जिसमें x नाम का मेंबर वेरिएबल है, तो (*ptr).x लिखने के बजाय आप सीधे ptr->x लिख सकते हैं।
ऑब्जेक्ट के पॉइंटर के साथ काम करते समय यह ऑपरेटर कोड को पढ़ने में आसान बनाता है और कोड को कम लंबा-चौड़ा बनाता है।
यहाँ एक छोटा उदाहरण देखिए, जिसमें Superhero नाम का एक struct है और उसमें superpower नाम का मेंबर वेरिएबल है।
main फंक्शन Superhero ऑब्जेक्ट (जो Wonder Woman को दर्शाता है) का एक पॉइंटर dianaPrince बनाता है।
-> ऑपरेटर का उपयोग superpower मेंबर वेरिएबल को एक्सेस करने के लिए किया गया है, जो Wonder Woman की मशहूर "Lasso of Truth" दिखाता है।
struct Superhero {
std::string superpower;
};
Superhero wonder_woman{};
Superhero* dianaPrince = &wonder_woman;
dianaPrince->superpower = "Lasso of Truth";
// Using the -> operator to access member variable superpower:
std::cout << "Wonder Woman, possesses the mighty " << dianaPrince->superpower;
पॉइंटर बनाम रेफरेंस
पॉइंटर और रेफरेंस, दोनों ही ऑब्जेक्ट तक अप्रत्यक्ष रूप से पहुँचने देते हैं, लेकिन अपनी क्षमताओं और सुरक्षा के मामले में दोनों अलग हैं।
पॉइंटर अपना लक्ष्य ऑब्जेक्ट बदलने की सुविधा देते हैं और इन्हें null भी असाइन किया जा सकता है।
लेकिन यही सुविधा कुछ जोखिम भी लाती है, जैसे null पॉइंटर को डीरेफरेंस करना या डैंगलिंग पॉइंटर बना देना।
दूसरी ओर, रेफरेंस null नहीं हो सकते और बनते ही किसी मान्य ऑब्जेक्ट से जुड़ जाते हैं, जिससे ये जोखिम टल जाते हैं।
चूँकि रेफरेंस ज़्यादा सुरक्षित होते हैं, इसलिए जब तक पॉइंटर की अतिरिक्त सुविधाएँ सचमुच ज़रूरी न हों, रेफरेंस को ही प्राथमिकता देनी चाहिए।
सीखने का अभ्यास
