सूचक (कंप्यूटर प्रोग्रामिंग)

अन्य उपयोगों के लिए, पॉइंटर (बहुविकल्पी) देखें।

कंप्यूटर विज्ञान में, कई प्रोग्रामिंग भाषाओं में एक पॉइंटर एक वस्तु है जो मेमोरी एड्रेस को संग्रहित करता है। यह कंप्यूटर मेमोरी में स्थित किसी अन्य मान का हो सकता है, या कुछ स्थितियों में, मेमोरी-मैप्ड कंप्यूटर हार्डवेयर का हो सकता है। एक पॉइंटर मेमोरी में एक स्थान का संदर्भ देता है, और उस स्थान पर संग्रहीत मान प्राप्त करना पॉइंटर को संदर्भित करने के रूप में जाना जाता है। सादृश्य के रूप में, किसी पुस्तक की अनुक्रमणिका में पेज संख्या को संबंधित पेज का पॉइंटर माना जा सकता है; इस तरह के पॉइंटर को डिफ्रेंसिंग दिए गए पेज संख्या के साथ पेज पर फ़्लिप करके और उस पेज पर मिले टेक्स्ट को पढ़कर किया जाएगा। पॉइंटर वेरिएबल (चर) का वास्तविक प्रारूप और सामग्री अंतर्निहित कंप्यूटर संरचना पर निर्भर है।

पॉइंटर्स का उपयोग करने से पुनरावृत किए जाने वाले संचालन के लिए कंप्यूटर के प्रदर्शन में अपेक्षाकृत अधिक संशोधन होता है, जैसे चलने योग्य डेटा संरचनाओं ((जैसे स्ट्रिंग्स, लुकअप सारणी, नियंत्रण सारणी और ट्री संरचना) का पता लगाना। विशेष रूप से, पॉइंटर्स को कॉपी करने और डेटा को अभिगम्य करने की तुलना में पॉइंटर्स को कॉपी और डीरेफेरेंस करना प्रायः समय और स्थान में बहुत सस्ता होता है।

पॉइंटर्स का उपयोग प्रक्रियात्मक प्रोग्रामिंग में सबरूटीन्स नामक सिस्टम कॉल लिए एंट्री पॉइंट्स के एड्रैस और गतिशील लिंक लाइब्रेरीज़ (डीएलएल) से रन-टाइम लिंकिंग के लिए भी किया जाता है। वस्तु-उन्मुख प्रोग्रामिंग में, फंक्शन पॉइंटर का उपयोग बाइंडिंग विधियों (कंप्यूटर प्रोग्रामिंग) के लिए किया जाता है, प्रायः वर्चुअल विधि सारणी का उपयोग किया जाता है।

पॉइंटर अधिक अमूर्त संदर्भ डेटा प्रकार का एक सामान्य, अधिक मूर्त कार्यान्वयन है। कई भाषाएँ, विशेष रूप से निम्न-स्तरीय भाषाएँ, कुछ प्रकार के पॉइंटर का समर्थन करती हैं, हालाँकि कुछ में दूसरों की तुलना में उनके उपयोग पर अधिक प्रतिबंध हैं। जबकि "पॉइंटर" का उपयोग सामान्य रूप से संदर्भों को संदर्भित करने के लिए किया गया है, यह डेटा संरचनाओं पर अधिक उपयुक्त रूप से प्रयुक्त होता है जिसका इंटरफ़ेस स्पष्ट रूप से पॉइंटर को कुशलतापूर्वक प्रयोग करने की स्वीकृति देता है (अंकगणितीय रूप से पॉइंटर अंकगणित के माध्यम से) एक मेमोरी एड्रेस के रूप में, एक मैजिक कुकी या क्षमता के विपरीत जो ऐसी स्वीकृति नहीं देता। क्योंकि पॉइंटर्स मेमोरी एड्रैस तक सुरक्षित और असुरक्षित दोनों तरह की अभिगम्य की स्वीकृति देते हैं, इसलिए, विशेषकर बाद के स्थिति में उनका उपयोग करने से जुड़े जोखिम हैं। प्रिमिटिव पॉइंटर्स को प्रायः पूर्णांक के समान प्रारूप में संग्रहीत किया जाता है; हालांकि, इस तरह के पॉइंटर को डीरेफरेंस या "लुक अप" करने का प्रयास जिसका मान वैध मेमोरी एड्रेस नहीं है, प्रोग्राम क्रैश (या अमान्य डेटा हो सकता है) का कारण बन सकता है। इस संभावित समस्या को कम करने के लिए, प्रकार की सुरक्षा के स्थिति में, पॉइंटर्स को एक अलग प्रकार माना जाता है, जिस प्रकार के डेटा को वे इंगित करते हैं, तथापि अंतर्निहित प्रतिनिधित्व एक पूर्णांक हो। अन्य संशोधन भी किए जा सकते हैं (जैसे सत्यापन और सीमा जाँच), यह सत्यापित करने के लिए कि पॉइंटर चर में एक मान है जो एक वैध मेमोरी एड्रेस और संख्यात्मक सीमा के अंदर है जिसे प्रोसेसर संबोधित करने में सक्षम है।

इतिहास
1955 में, सोवियत कंप्यूटर वैज्ञानिक कतेरीना युशचेंको ने एड्रेस प्रोग्रामिंग भाषा का आविष्कार किया, जिसने अप्रत्यक्ष एड्रेसिंग और उच्चतम सीमा के एड्रेस - पॉइंटर्स के अनुरूप संभव बनाया। सोवियत संघ के कंप्यूटरों पर इस भाषा का व्यापक रूप से उपयोग किया जाता था। हालांकि, यह सोवियत संघ के बाहर अज्ञात था और सामान्य रूप से हेरोल्ड लॉसन को 1964 में पॉइंटर के आविष्कार का श्रेय दिया जाता है। 2000 में लॉसन को इंस्टीट्यूट ऑफ़ इलेक्ट्रिकल एंड इलेक्ट्रॉनिक्स इंजीनियर्स द्वारा कंप्यूटर पायनियर अवार्ड प्रदान किया गया था "[f] या पॉइंटर वेरिएबल का आविष्कार करना और इस अवधारणा को प्रोग्रामिंग भाषा/आई में प्रस्तुत करना इस प्रकार पहली बार एक सामान्य-उद्देश्य उच्च-स्तर भाषा में लिंक्ड सूचियों को नमनीय रूप से गतिविधि करने की क्षमता प्रदान करना"। अवधारणाओं पर उनका सेमिनल पेपर सेंट्रल अमेरिकन कॉमन मार्केट मे जून 1967 के अंक में प्रोग्रामिंग भाषा/आई सूची प्रोसेसिंग के नाम से प्रकाशित हुआ। ऑक्सफोर्ड इंग्लिश डिक्शनरी के अनुसार, 'पॉइंटर' शब्द पहली बार प्रणाली विकास निगम द्वारा एक तकनीकी ज्ञापन में पॉइंटर शब्द पहली बार स्टैक पॉइंटर के रूप में प्रिंट में दिखाई दिया।

औपचारिक विवरण
कंप्यूटर विज्ञान में, एक पॉइन्टर एक प्रकार का संदर्भ (कंप्यूटर विज्ञान) है।

एक डेटा प्रिमिटिव (या सिर्फ प्रिमिटिव) कोई भी डेटा है जिसे एक मेमोरी एक्सेस (उदाहरण के लिए, एक बाइट और एक शब्द दोनों प्रिमिटिव हैं) का उपयोग करके कंप्यूटर मेमोरी से पढ़ा या लिखा जा सकता है।

एक डेटा एग्रीगेट (संग्रह) (या सिर्फ एग्रीगेट) प्रिमिटिव्स का एक समूह है जो मेमोरी में तार्किक एड्रैस सन्निहित है और जिसे सामूहिक रूप से एक डेटा के रूप में देखा जाता है (उदाहरण के लिए, एक एग्रीगेट 3 तार्किक रूप से सन्निहित बाइट्स हो सकता है, जिसके मान 3 निर्देशांक का प्रतिनिधित्व करते हैं अंतरिक्ष में एक बिंदु)। जब समुच्चय पूरी तरह से एक ही प्रकार के प्रिमिटिव्स से बना होता है, तो समुच्चय को एक सरणी डेटा संरचना कहा जा सकता है; एक स्थिति में, एक बहु-बाइट शब्द प्रारम्भिक बाइट्स की एक सरणी है, और कुछ प्रोग्राम इस तरह से शब्दों का उपयोग करते हैं।

इन परिभाषाओं के संदर्भ में, एक बाइट सबसे छोटा प्रिमिटिव है; प्रत्येक मेमोरी एड्रैस एक अलग बाइट निर्दिष्ट करता है। किसी डेटा के प्रारम्भिक बाइट का मेमोरी एड्रेस पूरे डेटा का मेमोरी एड्रेस (या बेस मेमोरी एड्रेस) माना जाता है।

एक मेमोरी पॉइंटर (या सिर्फ पॉइंटर) एक प्रिमिटिव है, जिसका मान मेमोरी एड्रेस के रूप में उपयोग करने के लिए अभिप्रेत है; ऐसा कहा जाता है कि एक पॉइन्टर मेमोरी एड्रैस को इंगित करता है। यह भी कहा जाता है कि एक पॉइंटर डेटा [मेमोरी में] की ओर संकेत करता है जब पॉइंटर का मान डेटा का मेमोरी एड्रेस होता है।

अधिक सामान्य रूप से, एक पॉइन्टर एक प्रकार का संदर्भ (कंप्यूटर विज्ञान) है, और यह कहा जाता है कि एक पॉइन्टर मेमोरी में कहीं संग्रहीत डेटा का संदर्भ देता है; उस डेटा को प्राप्त करने के लिए पॉइंटर को हटाना है। पॉइंटर्स को अन्य प्रकार के संदर्भों से अलग करने वाली विशेषता यह है कि एक पॉइंटर के मान को मेमोरी एड्रेस के रूप में व्याख्या किया जाना है, जो कि एक निम्न-स्तरीय अवधारणा है।

संदर्भ संकेत के स्तर के रूप में कार्य करते हैं: एक पॉइन्टर का मान निर्धारित करता है कि गणना में कौन सा मेमोरी एड्रैस (अर्थात, कौन सा डेटा) उपयोग किया जाना है। क्योंकि अप्रत्यक्ष एल्गोरिदम का एक मूलभूत स्वरूप है, पॉइंटर्स को प्रायः प्रोग्रामिंग भाषाओं में एक मौलिक डेटा प्रकार के रूप में व्यक्त किया जाता है; सांख्यिकीय रूप से (या दृढ़ता से) टाइप की गई प्रोग्रामिंग भाषाओं में, पॉइंटर का प्रकार उस डेटा के प्रकार को निर्धारित करता है जिस पर पॉइंटर इंगित करता है।

संरचना आधार
अधिकांश आधुनिक संरचना द्वारा प्रदान की जाने वाली एड्रेसिंग क्षमताओं के शीर्ष पर पॉइंटर्स बहुत पतले अमूर्त हैं। सबसे सरल योजना में, एक एड्रैस, या एक संख्यात्मक इंडेक्स, सिस्टम में मेमोरी की प्रत्येक इकाई को प्रस्तुत किया गया है, जहां इकाई सामान्य रूप से या तो एक बाइट या एक शब्द है - यह इस बात पर निर्भर करता है कि संरचना बाइट-एड्रेसेबल है या शब्द-एड्रेसेबल - प्रभावी रूप से सभी मेमोरी को एक बहुत बड़ी सरणी में परिवर्तित करता है। सिस्टम तब दिए गए एड्रैस पर मेमोरी यूनिट में संग्रहीत मान को पुनः प्राप्त करने के लिए एक संचालन भी (सामान्य रूप से मशीन के सामान्य प्रयोजन रजिस्टरों का उपयोग) प्रदान करेगा।

सामान्य स्थिति में, एक पॉइंटर इतना बड़ा होता है कि वह सिस्टम में मेमोरी की इकाइयों की तुलना में अधिक एड्रैस को रखने के लिए पर्याप्त होता है। यह इस संभावना का परिचय देता है कि एक प्रोग्राम किसी ऐसे एड्रैस तक पहुंचने का प्रयास कर सकता है जो मेमोरी की कोई इकाई नहीं है, या तो पर्याप्त मेमोरी स्थापित नहीं है (अर्थात उपलब्ध मेमोरी की सीमा से आगे है) या संरचना ऐसे एड्रैस का समर्थन नहीं करता है। पहली स्थिति, कुछ प्लेटफॉर्म जैसे कि x86 संरचना में, विभाजन दोष (सेगफॉल्ट) कहा जा सकता है। उन्नत माइक्रो डिवाइस64 के के वर्तमान कार्यान्वयन में दूसरी स्थिति संभव है, जहां संकेत 64 बिट लंबे हैं और एड्रैस केवल 48 बिट तक विस्तारित हैं। पॉइंटर्स को कुछ नियमों (कैनोनिकल एड्रेस) के अनुरूप होना चाहिए, इसलिए यदि एक गैर-कैनोनिकल पॉइंटर को डीरेफरेंस किया जाता है, तो प्रोसेसर एक सामान्य सुरक्षा दोष उत्पन्न करता है।

दूसरी ओर, कुछ प्रणालियों में एड्रैस की तुलना में मेमोरी की अधिक इकाइयाँ होती हैं। इस स्थिति में, एक अधिक जटिल योजना जैसे मेमोरी विभाजन या पेजिंग को अलग-अलग समय पर मेमोरी के विभिन्न भागों का उपयोग करने के लिए नियोजित किया जाता है। x86 संरचना के अंतिम स्वरूप भौतिक मेमोरी एड्रैस के 36 बिट्स तक का समर्थन करते हैं, जिन्हें भौतिक एड्रैस एक्सटेंशन पेजिंग तंत्र के माध्यम से 32-बिट रैखिक एड्रैस स्थान पर मैप किया गया था। इस प्रकार, एक समय में संभावित कुल मेमोरी का केवल 1/16 ही अभिगम्य किया जा सकता है। उसी कंप्यूटर परिवार में एक और उदाहरण इंटेल 80286 प्रोसेसर का 16-बिट संरक्षित मोड था, जो हालांकि केवल 16 एमबी भौतिक मेमोरी का समर्थन करता था, 1 गीगाबाइट तक वर्चुअल मेमोरी तक पहुंच सकता था, लेकिन 16-बिट एड्रेस का संयोजन और सेगमेंट रजिस्टरों ने एक डेटा संरचना में 64 किलोबाइट से अधिक अभिगम्य करना जटिल बना दिया है।

एक सुसंगत इंटरफ़ेस प्रदान करने के लिए, कुछ संरचना मेमोरी-मैप्ड इनपुट/आउट्पुट प्रदान करते हैं, जो कुछ एड्रैस को मेमोरी की इकाइयों को संदर्भित करने की स्वीकृति देता है जबकि अन्य कंप्यूटर में अन्य उपकरणों के डिवाइस रजिस्टर को संदर्भित करते हैं। फाइल ऑफ़सेट्स, सरणी इंडेक्स और दूरस्थ वस्तु संदर्भ जैसी समान अवधारणाएँ हैं जो अन्य प्रकार की वस्तुओं के लिए एड्रैस के समान उद्देश्यों को पूरा करती हैं।

उपयोग करता है
प्रोग्रामिंग भाषा/आई, C (प्रोग्रामिंग भाषा), C ++, पास्कल प्रोग्रामिंग भाषा, फ्री-प्रारंभिक सर्व-उद्देश्यीय प्रतीकात्मक निर्देश कोड जैसी भाषाओं में प्रतिबंधों के बिना पॉइंटर्स का प्रत्यक्ष रूप से समर्थन किया जाता है, और अधिकांश असेंबली भाषाओं में निहित है।। वे मुख्य रूप से संदर्भ (कंप्यूटर विज्ञान) के निर्माण के लिए उपयोग किए जाते हैं, जो बदले में लगभग सभी डेटा संरचनाओं के निर्माण के साथ-साथ एक प्रोग्राम के विभिन्न भागों के बीच डेटा पास करने के लिए मौलिक हैं।

कार्यात्मक प्रोग्रामिंग भाषाओं में जो सूचियों पर बहुत अधिक निर्भर करती हैं, डेटा संदर्भों को दोष और संबंधित तत्वों रजिस्टर संख्या के एड्रैस वाले भाग की सामग्री और रजिस्टर संख्या के डिक्रीमेंट भाग की सामग्री जैसे प्रारम्भिक निर्माणों का उपयोग करके अमूर्त रूप से प्रबंधित किया जाता है, जिसे कॉन्स-सेल के पहले और दूसरे घटकों के लिए विशेष पॉइंटर के रूप में माना जा सकता है। यह कार्यात्मक प्रोग्रामिंग के कुछ सिद्धप्रयुक्त फ़्लेवर को उत्पन्न करता है। ऐसी कंस-सूचियों में डेटा की संरचना करके, ये भाषाएँ डेटा के निर्माण और प्रसंस्करण के लिए पुनरावर्ती साधनों की सुविधा प्रदान करती हैं - उदाहरण के लिए, सूचियों की सूचियों के शीर्ष और अंत के तत्वों तक पुनरावर्ती रूप से पहुंचकर; उदाहरण के लिए रजिस्टर संख्या के डिक्रीमेंट भाग की सामग्री के रजिस्टर संख्या के डिक्रीमेंट भाग की सामग्री हैं। इसके विपरीत, मेमोरी एड्रैस की एक सरणी डेटा संरचना के कुछ सन्निकटन में पॉइंटर डेरेफ़रिंग पर आधारित मेमोरी प्रबंधन वेरिएबल को स्लॉट के रूप में मानने की सुविधा देता है जिसमें डेटा को अनिवार्य प्रोग्रामिंग निर्दिष्ट किया जा सकता है।

सरणियों के साथ कार्य करते समय, महत्वपूर्ण लुकअप सारणी संचालन में सामान्य रूप से  एड्रैस गणना नामक एक चरण सम्मिलित होता है जिसमें सरणी में वांछित डेटा तत्व के लिए एक पॉइन्टर का निर्माण सम्मिलित होता है। अन्य डेटा संरचनाओं में, जैसे कि लिंक की गई सूचियाँ, पॉइंटर्स को संरचना के एक भाग को दूसरे से स्पष्ट रूप से संबंध के लिए संदर्भ के रूप में उपयोग किया जाता है।

पॉइंटर्स का उपयोग संदर्भ द्वारा पैरामीटर पास करने के लिए किया जाता है। यह उपयोगी है यदि प्रोग्रामर चाहता है कि फ़ंक्शन के कॉलर को फ़ंक्शन के पैरामीटर में संशोधन दिखाई दे। यह किसी फ़ंक्शन से एकाधिक मान वापस करने के लिए भी उपयोगी है।

मेमोरी आवंटन के लिए पॉइंटर्स का भी उपयोग किया जा सकता है और मेमोरी में गतिशील वेरिएबल्स और सरणी को डिलीकेट किया जा सकता है। चूंकि एक वेरिएबल अपने उद्देश्य को पूरा करने के बाद प्रायः अनावश्यक हो जाएगा, इसे रखने के लिए मेमोरी की अपव्यय होती है, और इसलिए यह आवश्यक नहीं होने पर (मूल पॉइन्टर संदर्भ का उपयोग करके) इसे हटाने के लिए अच्छा अभ्यास है। ऐसा करने में विफलता के परिणामस्वरूप मेमोरी लीक हो सकता है (जहां मुक्त मेमोरी धीरे-धीरे उपलब्ध होती है, या तीव्र स्थितियो में तीव्रता से, कई अनावश्यक मेमोरी ब्लॉकों के संचय के कारण कम हो जाती है)।

C पॉइंटर्स
पॉइंटर को परिभाषित करने के लिए मूल सिंटेक्स (प्रोग्रामिंग भाषाएं) है:

यह   को निम्न प्रकार की वस्तु के पहचानकर्ता के रूप में घोषित करता है: यह सामान्य रूप से अधिक संक्षेप में कहा जाता है क्योंकि     का पॉइन्टर है
 * पॉइन्टर जो  प्रकार की वस्तु को इंगित करता है

चूंकि C भाषा स्वत: भंडारण अवधि की वस्तुओं के लिए एक अंतर्निहित प्रारंभिकरण निर्दिष्ट नहीं करती है, प्रायः यह सुनिश्चित करने के लिए देखभाल की जानी चाहिए कि जिस एड्रैस पर  अंक मान्य है; यही कारण है कि कभी-कभी यह सुझाव दिया जाता है कि एक पॉइन्टर को शून्य पॉइन्टर मान के लिए स्पष्ट रूप से प्रारंभ किया जाना चाहिए, जो परंपरागत रूप से C  मानकीकृत मैक्रो के साथ  के साथ निर्दिष्ट किया गया है:

C में एक अशक्त पॉइन्टर को डिफ्रेंस करने से अपरिभाषित व्यवहार उत्पन्न होता है, जो विनाशकारी हो सकता है। हालाँकि, अधिकांश कार्यान्वयन सामान्य रूप से सेगमेंटेशन दोष के साथ, विचाराधीन प्रोग्राम के निष्पादन को रोकते है।

हालाँकि, पॉइंटर्स को आरंभ करना अनावश्यक रूप से प्रोग्राम विश्लेषण में प्रतिबाधित कर सकता है, जिससे बग छिप जाते हैं।

किसी भी स्थिति में, एक बार पॉइन्टर घोषित होने के बाद, अगला तार्किक चरण इसके लिए कुछ इंगित करना है: int a = 5; int *ptr = NULL; ptr = &a; यह   को  के एड्रैस का मान निर्दिष्ट करता है उदाहरण के लिए, यदि   को 0x8130 के मेमोरी स्थान पर संग्रहीत किया जाता है, तो समनुदेशन के बाद   का मान 0x8130 होगा। पॉइंटर को डिरेफेरेंस करने के लिए, एक तारांकन (अस्ट्रिस्क) चिह्न का पुनः उपयोग किया जाता है:

इसका तात्पर्य है कि  (जो 0x8130 है) की सामग्री लें, उस एड्रैस को मेमोरी में जाँचे और उसका मान 8 पर स्थापित करें। यदि   बाद में पुनः अभिगम्य किया जाता है, इसका नया मान 8 होगा।

यदि मेमोरी की प्रत्यक्ष जाँच की जाए तो यह उदाहरण अधिक स्पष्ट हो सकता है। ये मान लीजिए  मेमोरी में एड्रैस 0x8130 पर स्थित है और   0x8134 पर; यह भी मान लें कि यह 32-बिट मशीन है जैसे कि int 32-बिट चौड़ा है। निम्नलिखित कोड स्निपेट निष्पादित होने के बाद मेमोरी में क्या होगा: int a = 5; int *ptr = NULL;
 * {| class="wikitable"

! एड्रैस ! सामग्री (यहां दिखाया गया NULL पॉइंटर 0x00000000 है।)   को  का पता निर्दिष्ट करके: ptr = &a;
 * 0x8130
 * 0x00000005
 * 0x8134
 * 0x00000000
 * }
 * 0x00000000
 * }

निम्नलिखित मेमोरी मान उत्पन्न करता है:


 * {| class="wikitable"

! एड्रैस !! सामग्री फिर कोडिंग द्वारा  को डिफ्रेंसिंग करके: *ptr = 8;
 * 0x8130 || 0x00000005
 * 0x8134 || 0x00008130
 * }
 * 0x8134 || 0x00008130
 * }

कंप्यूटर  (जो 0x8130 है), उस एड्रैस को 'जांच करे', और उस स्थान पर 8 निर्दिष्ट करें जो निम्नलिखित मेमोरी प्रदान करता है:


 * {| class="wikitable"

! एड्रैस !! सामग्री स्पष्ट रूप से,   से तक अभिगम्य से 8 का मान निकलेगा क्योंकि पिछले निर्देश ने   पॉइन्टर के माध्यम से  की सामग्री को संशोधित किया था।
 * 0x8130 || 0x00000008
 * 0x8134 || 0x00008130
 * }
 * 0x8134 || 0x00008130
 * }

डेटा संरचनाओं में प्रयोग
सूची (कंप्यूटिंग), श्रेणी (अमूर्त डेटा प्रकार) और ट्री जैसी डेटा संरचनाएं स्थापित करते समय, संरचना को कार्यान्वित और नियंत्रित करने के तरीके को प्रबंधित करने में सहायता के लिए पॉइंटर्स होना आवश्यक है। पॉइंटर्स के विशिष्ट उदाहरण स्टार्ट पॉइंटर्स, एंड पॉइंटर्स और स्टैक (अमूर्त डेटा प्रकार) पॉइंटर्स हैं। ये पॉइंटर या तो निरपेक्ष हो सकते हैं (वास्तविक भौतिक एड्रैस या आभासी मेमोरी में एक आभासी एड्रैस) या सापेक्ष (एक ऑफ़सेट (कंप्यूटर विज्ञान) एक पूर्ण प्रारंभ पता (आधार) से जो सामान्य रूप से पूर्ण एड्रैस की तुलना में कम बिट्स का उपयोग करता है, लेकिन सामान्य रूप से  इसकी आवश्यकता होगी हल करने के लिए एक अतिरिक्त अंकगणितीय संचालन)।

सापेक्ष एड्रैस आभासी मेमोरी सेगमेंटेशन का एक रूप हैं, और इसके कई लाभ और दोष साझा करते हैं। एक दो-बाइट ऑफ़सेट, जिसमें एक 16-बिट, अहस्ताक्षरित पूर्णांक होता है, का उपयोग 64 किलोबाइट (216 बाइट्स) तक सापेक्ष एड्रैस प्रदान करने के लिए किया जा सकता है एक डेटा संरचना की। इसे आसानी से 128, 256 या 512 कीवीबाइट तक बढ़ाया जा सकता है यदि इंगित किए गए एड्रैस को आधे-शब्द, शब्द या दोहरे-शब्द सीमा पर डेटा संरचना संरेखण के लिए अनिवार्य किया जाता है (लेकिन, एक अतिरिक्त शिफ्ट बाएं बिटवाइज़ संचालन की आवश्यकता होती है - 1 तक, 2 या 3 बिट्स - ऑफसेट को 2, 4 या 8 के एक कारक द्वारा समायोजित करने के लिए, इसके अतिरिक्त बेस एड्रैस से पहले)। सामान्य रूप से, हालांकि, ऐसी योजनाएं बहुत संचारित होती हैं, और प्रोग्रामर की सुविधा के लिए पूर्ण एड्रैस (और अंतर्निहित, एक फ्लैट एड्रैस स्थान) को प्राथमिकता दी जाती है।

एक बाइट ऑफ़सेट, जैसे किसी वर्ण का हेक्साडेसिमल सूचना विनिमय के लिए अमेरिकी मानक कोड मान (उदाहरण X'29') का उपयोग किसी सरणी में वैकल्पिक पूर्णांक मान (या अनुक्रमणिका) को इंगित करने के लिए किया जा सकता है (उदाहरण, X'01'). इस तरह, वर्णों को ' मूल एवं प्रारम्भिक तथ्य' से प्रयोग करने योग्य अनुक्रमिक सरणी डेटा संरचना में और फिर लुकअप सारणी के बिना एक पूर्ण एड्रैस पर बहुत कुशलता से अनुवादित किया जा सकता है।

C सरणियाँ
C में, पॉइन्टर अंकगणितीय के संदर्भ में सरणी अनुक्रमण औपचारिक रूप से परिभाषित किया गया है; अर्थात्, भाषा विनिर्देश के लिए इसकी आवश्यकता है कि  के   समान हो। इस प्रकार C में, सरणियों को मेमोरी के निरंतर क्षेत्रों के संकेत के रूप में माना जा सकता है (बिना अंतराल के), और सरणियों तक पहुँचने के लिए सिंटैक्स उसके लिए समान है जिसका उपयोग पॉइंटर्स को हटाने के लिए किया जा सकता है। उदाहरण के लिए, एक    निम्नलिखित तरीके से घोषित और उपयोग किया जा सकता है: int array[5];     /* Declares 5 contiguous integers */ int *ptr = array; /* Arrays can be used as pointers */ ptr[0] = 1;       /* Pointers can be indexed with array syntax */ *(array + 1) = 2; /* Arrays can be dereferenced with pointer syntax */ *(1 + array) = 2; /* Pointer addition is commutative */ 2[array] = 4;     /* Subscript operator is commutative */ यह पांच पूर्णांकों का एक ब्लॉक आवंटित करता है और ब्लॉक को नाम देता है, जो ब्लॉक के लिए एक पॉइंटर के रूप में कार्य करता है। पॉइंटर्स का एक अन्य सामान्य उपयोग मॉलोक से गतिशील रूप से आवंटित मेमोरी को इंगित करना है जो अनुरोधित आकार से कम की मेमोरी का निरंतर ब्लॉक देता है जिसे एक सरणी के रूप में उपयोग किया जा सकता है।

जबकि सरणियों और पॉइंटर्स पर अधिकांश ऑपरेटर समतुल्य हैं,  ऑपरेटर का परिणाम भिन्न होता है। इस उदाहरण में,     (सरणी का आकार) का मूल्यांकन करेगा, जबकि   पॉइंटर के आकार,  का मूल्यांकन करेगा।

किसी सरणी के डिफ़ॉल्ट मानों को इस प्रकार घोषित किया जा सकता है: int array[5] = {2, 4, 3, 1, 5}; यदि  32-बिट छोटी-एंडियन मशीन पर एड्रैस 0x1000 से प्रारंभ होने वाली मेमोरी में स्थित है, तो मेमोरी में निम्नलिखित सम्मिलित होंगे (मान हेक्साडेसिमल में हैं, जैसे एड्रैस):


 * {| class="wikitable" style="font-family:monospace;"

! 0 || 1 || 2 || 3 ! 1000 ! 1004 ! 1008 ! 100C ! 1010 यहां प्रस्तुत पांच पूर्णांक 2, 4, 3, 1, और 5 हैं। ये पांच पूर्णांक 32 बिट्स (4 बाइट्स) पर प्रग्रहण कर लेते हैं, जिनमें से प्रत्येक सबसे कम-महत्वपूर्ण बाइट पहले संग्रहीत होता है (यह एक छोटा-एंडियन सेंट्रल प्रोसेसिंग यूनिट संरचना है) और निरंतर संग्रहीत किया जाता है और एड्रैस 0x1000 से प्रारंभ है।
 * 2 || 0 || 0 || 0
 * 4 || 0 || 0 || 0
 * 3 || 0 || 0 || 0
 * 1 || 0 || 0 || 0
 * 5 || 0 || 0 || 0
 * }

पॉइंटर्स के साथ C का सिंटैक्स है:
 * तात्पर्य 0x1000;
 * तात्पर्य 0x1004: + 1 का तात्पर्य , के आकार को जोड़ना है, जो 4 बाइट्स है
 * का तात्पर्य है की सामग्री को हटाना है। मेमोरी एड्रैस (0x1000) के रूप में सामग्री को ध्यान में रखते हुए, उस स्थान पर  (0x0002) मान देखें;
 * तात्पर्य तत्व संख्या, 0-आधारित,    का है, जिसका अनुवाद   किया गया है।

अंतिम उदाहरण यह है कि  इसे तोड़ना:
 * (i) वें   की मेमोरी लोकेशन है i=0 से प्रारंभ होता है;
 * उस मेमोरी एड्रेस को लेता है और मान को अभिगम्य करने के लिए इसे संदर्भित करता है।

C से लिंक की गई सूची
नीचे C में लिंक की गई सूची की एक उदाहरण परिभाषा दी गई है। /* the empty linked list is represented by NULL * or some other sentinel value */ struct link { void       *data;  /* data of this link */ struct link *next; /* next link; EMPTY_LIST if there is none */ }; यह पॉइन्टर-पुनरावर्ती परिभाषा अनिवार्य रूप से हास्केल (प्रोग्रामिंग भाषा) से संदर्भ-पुनरावर्ती परिभाषा के समान है: data Link a = Nil | Cons a (Link a) रिक्त सूची है, और   टाइप   का एक कॉन्स सेल है जिसमें एक अन्य लिंक भी टाइप  का है।
 * 1) define EMPTY_LIST NULL

हालाँकि, संदर्भों के साथ परिभाषा टाइप-जांच की गई है और संभावित रूप से भ्रमित करने वाले सिग्नल मानों का उपयोग नहीं करती है। इस कारण से, C में डेटा संरचनाओं को सामान्य रूप से रैपर फ़ंक्शन  के माध्यम से  विभाजित किया जाता है, जिन्हें शुद्धता के लिए सावधानीपूर्वक जाँचा जाता है।

पॉइंटर्स का उपयोग करके एड्रेस देना
पॉइंटर्स का उपयोग वेरिएबल्स को उनके एड्रैस से पास करने के लिए किया जा सकता है, जिससे उनका मान बदला जा सकता है। उदाहरण के लिए, निम्नलिखित C (प्रोग्रामिंग भाषा) कोड पर विचार करें: /* a copy of the int n can be changed within the function without affecting the calling code */ void passByValue(int n) { n = 12; } /* a pointer m is passed instead. No copy of the value pointed to by m is created */ void passByAddress(int *m) { *m = 14; } int main(void) { int x = 3; /* pass a copy of x's value as the argument */ passByValue(x); // the value was changed inside the function, but x is still 3 from here on    /* pass x's address as the argument */ passByAddress(&x); // x was actually changed by the function and is now equal to 14 here return 0; }

गतिशील मेमोरी आवंटन
कुछ प्रोग्राम में, आवश्यक मात्रा में मेमोरी इस बात पर निर्भर करती है कि उपयोगकर्ता क्या प्रविष्ट कर सकता है। ऐसे स्थितियो में प्रोग्रामर को गतिशील रूप से मेमोरी आवंटित करने की आवश्यकता होती है। यह स्टैक के अतिरिक्त हीप पर मेमोरी आवंटित करके किया जाता है, जहां वेरिएबल सामान्य रूप से संग्रहीत होते हैं (वेरिएबल्स को सेंट्रल प्रोसेसिंग यूनिट रजिस्टरों में भी संग्रहीत किया जा सकता है, लेकिन यह एक और स्थिति है)। गतिशील मेमोरी आवंटन केवल पॉइंटर्स के माध्यम से किया जा सकता है, और नाम (जैसे सामान्य वेरिएबल के साथ) नहीं दिए जा सकते।

पॉइंटर्स का उपयोग मेमोरी के गतिशील मेमोरी एलोकेशन ब्लॉक्स के एड्रेस को संग्रहित और प्रबन्ध करने के लिए किया जाता है। इस तरह के ब्लॉक का उपयोग डेटा ऑब्जेक्ट्स या ऑब्जेक्ट्स के सारणी को संग्रहित करने के लिए किया जाता है। अधिकांश संरचित और वस्तु-उन्मुख भाषा मेमोरी का एक क्षेत्र प्रदान करती हैं, जिसे हीप या फ्री संग्रहित कहा जाता है, जिससे ऑब्जेक्ट्स को गतिशील रूप से आवंटित किया जाता है।

नीचे दिया गया उदाहरण C कोड दिखाता है कि कैसे संरचना वस्तुओं को गतिशील रूप से आवंटित और संदर्भित किया जाता है। मानक C लाइब्रेरी फ़ंक्शन  स्टैक से मेमोरी ब्लॉक आवंटित करने के लिए प्रदान करती है । यह एक पैरामीटर के रूप में आवंटित करने के लिए एक वस्तु का आकार लेता है और ऑब्जेक्ट को संग्रहीत करने के लिए उपयुक्त मेमोरी के एक नए आवंटित ब्लॉक के लिए एक पॉइन्टर देता है, या आवंटन विफल होने पर यह एक अशक्त पॉइन्टर देता है। /* Parts inventory item */ struct Item { int        id;     /* Part number */ char *     name;   /* Part name   */ float      cost;   /* Cost        */ }; /* Allocate and initialize a new Item object */ struct Item * make_item(const char *name) { struct Item * item; /* Allocate a block of memory for a new Item object */ item = malloc(sizeof(struct Item)); if (item == NULL) return NULL; /* Initialize the members of the new Item */ memset(item, 0, sizeof(struct Item)); item->id =  -1; item->name = NULL; item->cost = 0.0; /* Save a copy of the name in the new Item */ item->name = malloc(strlen(name) + 1); if (item->name == NULL) { free(item); return NULL; }    strcpy(item->name, name); /* Return the newly created Item object */ return item; } नीचे दिया गया कोड बताता है कि मेमोरी ऑब्जेक्ट्स को गतिशील रूप से कैसे हटाया जाता है, अर्थात स्टैक या मुफ्त संग्रहित में वापस किया जाता है। मानक C लाइब्रेरी  पहले आवंटित मेमोरी ब्लॉक को हटाने और इसे वापस स्टैक पर वापस करने के लिए प्रदान करती है। /* Deallocate an Item object */ void destroy_item(struct Item *item) { /* Check for a null object pointer */ if (item == NULL) return; /* Deallocate the name string saved within the Item */ if (item->name != NULL) { free(item->name); item->name = NULL; }    /* Deallocate the Item object itself */ free(item); }

मेमोरी-मैप किया गया हार्डवेयर
कुछ कंप्यूटिंग संरचना पर, पॉइंटर्स का उपयोग प्रत्यक्ष रूप से मेमोरी या मेमोरी-मैप्ड डिवाइसेस में कुशलतापूर्वक प्रयोग करने के लिए किया जा सकता है।

माइक्रोकंट्रोलर्स की प्रोग्रामिंग करते समय पॉइंटर्स को एड्रेस निर्दिष्ट करना एक अमूल्य उपकरण है। नीचे एक सामान्य उदाहरण है जो एक प्रकार के int के पॉइन्टर को घोषित करता है और इसे हेक्साडेसिमल एड्रैस पर प्रारंभ करता है, इस उदाहरण में निरंतर 0x7FFF: int *hardware_address = (int *)0x7FFF; 80 के दशक के मध्य में, पर्सनल कंप्यूटर की वीडियो क्षमताओं तक पहुँचने के लिएबेसिक इनपुट/आउटपुट सिस्टम का उपयोग मंद था। प्रदर्शन-गहन अनुप्रयोग सामान्य रूप से हेक्साडेसिमल स्थिर 0xB8000 को 80 अहस्ताक्षरित 16-बिट int मानों की एक सरणी के लिए पॉइंटर में निर्धारित करके प्रत्यक्ष रूप से रंग ग्राफिक्स एडेप्टर वीडियो मेमोरी तक पहुंचने के लिए उपयोग किया जाता है। प्रत्येक मान में निम्न बाइट में एक सूचना विनिमय के लिए अमेरिकी मानक कोड और उच्च बाइट में एक रंग सम्मिलित होता है। इस प्रकार, अक्षर 'A' को पंक्ति 5 में, कॉलम 2 को नीले रंग पर चमकीले सफेद रंग में रखने के लिए, निम्नलिखित कोड की तरह लिखा जाएगा: void foo(void) { VID[4][1] = 0x1F00 | 'A'; }
 * 1) define VID ((unsigned short (*)[80])0xB8000)

नियंत्रण तालिकाओं में प्रयोग करें
प्रोग्राम संचार को नियंत्रित करने के लिए उपयोग की जाने वाली नियंत्रण तालिकाएं सामान्य रूप से पॉइंटर्स का व्यापक उपयोग करती हैं। पॉइंटर्स, सामान्य रूप से  सारणी  एंट्री में एम्बेडेड होते हैं, उदाहरण के लिए, उसी सारणी  एंट्री में परिभाषित कुछ शर्तों के आधार पर सबरूटीन को एंट्री पॉइंट्स को निष्पादित करने के लिए उपयोग किया जा सकता है। हालाँकि पॉइंटर्स केवल अन्य अलग-अलग, लेकिन संबंधित तालिकाओं के लिए अनुक्रमित हो सकते हैं, जिसमें वास्तविक एड्रैस की एक सरणी होती है या स्वयं एड्रैस होते हैं (प्रोग्रामिंग भाषा के उपलब्ध निर्माण के आधार पर)। उनका उपयोग पहले की सारणी प्रविष्टियों (लूप प्रोसेसिंग में) को इंगित करने के लिए या कुछ सारणी प्रविष्टियों को छोड़ने के लिए आगे बढ़ने के लिए भी किया जा सकता है (जैसे कि स्विच स्टेटमेंट में या लूप से शीघ्र बाहर निकलना)। इस बाद के उद्देश्य के लिए, पॉइन्टर केवल सारणी प्रविष्टि संख्या ही हो सकता है और साधारण अंकगणितीय द्वारा वास्तविक एड्रैस में परिवर्तित किया जा सकता है।

टाइप किए गए पॉइंटर्स और कास्टिंग ( प्रक्षेप)
कई भाषाओं में, पॉइंटर्स के पास अतिरिक्त प्रतिबंध होता है कि वे जिस ऑब्जेक्ट को इंगित करते हैं उसका एक विशिष्ट डेटा प्रकार होता है। उदाहरण के लिए, एक पूर्णांक को इंगित करने के लिए एक पॉइन्टर घोषित किया जा सकता है; भाषा तब प्रोग्रामर को उन वस्तुओं की ओर संकेत करने से रोकने का प्रयास करेगी जो पूर्णांक नहीं हैं, जैसे चल बिन्दु संख्या, कुछ त्रुटियों को समाप्त करना।

उदाहरण के लिए, C में int *money; char *bags; एक पूर्णांक पॉइन्टर होगा और  एक चार पॉइन्टर होगा। निम्नलिखित जीएनयू कंपाइलर संग्रह के अंतर्गत असंगत पॉइन्टर प्रकार से समनुदेशन की एक कंपाइलर चेतावनी उत्पन्न करेगा bags = money; क्योंकि  और   विभिन्न प्रकारों के साथ घोषित किए गए थे। कंपाइलर चेतावनी को दबाने के लिए, यह स्पष्ट किया जाना चाहिए कि आप वास्तव में टाइप रूपांतरण द्वारा समनुदेशन करना चाहते हैं bags = (char *)money; जो पूर्णांक पॉइन्टर को    निर्दिष्ट करने और  को निर्दिष्ट करने के लिए कहता है।

C मानक के 2005 के एक प्रारूप के लिए आवश्यक है कि एक प्रकार से दूसरे प्रकार से प्राप्त पॉइन्टर को कास्टिंग करने से दोनों प्रकारों के लिए संरेखण शुद्धता बनाए रखनी चाहिए (6.3.2.3 पॉइंटर्स, पैरा। 7): char *external_buffer = "abcdef"; int *internal_data; internal_data = (int *)external_buffer; // UNDEFINED BEHAVIOUR if "the resulting pointer                                          // is not correctly aligned" उन भाषाओं में जो पॉइंटर अंकगणित की स्वीकृति देती हैं, पॉइंटर्स पर अंकगणित प्रकार के आकार को ध्यान में रखता है। उदाहरण के लिए, एक पॉइंटर में एक पूर्णांक संख्या जोड़ने से एक और पॉइंटर उत्पन्न होता है जो उस एड्रैस की ओर संकेत करता है जो उस संख्या के प्रकार के आकार से अधिक होता है। यह हमें किसी दिए गए प्रकार की सरणी के तत्वों के एड्रैस की आसानी से गणना करने की स्वीकृति देता है, जैसा ऊपर C सरणी उदाहरण में दिखाया गया था। जब एक प्रकार के पॉइंटर को दूसरे प्रकार के भिन्न आकार में निर्दिष्ट किया जाता है, तो प्रोग्रामर को यह उपेक्षा करनी चाहिए कि पॉइंटर अंकगणित की अलग-अलग गणना की जाएगी। C में, उदाहरण के लिए, यदि  सरणी 0x2000 से प्रारंभ होती है और   4 बाइट है जबकि   1 बाइट है, तो   0x2004 को इंगित करेगा, लेकिन   0x2001 को इंगित करेगा। कास्टिंग के अन्य जोखिमों में डेटा की हानि सम्मिलित है जब विस्तृत डेटा संकीर्ण स्थानों पर लिखा जाता है (उदाहरण   ), अनपेक्षित परिणाम जब बिट-शिफ्टिंग मान, और तुलना समस्याएं, विशेष रूप से हस्ताक्षरित बनाम अहस्ताक्षरित मूल्यों के साथ होती है।

हालांकि संकलन-समय पर सामान्य रूप से यह निर्धारित करना असंभव है कि कौन C कास्ट सुरक्षित है, कुछ भाषाएँ रन-टाइम प्रकार की जानकारी संग्रहीत करती हैं जिनका उपयोग यह पुष्टि करने के लिए किया जा सकता है कि ये जोखिमयुक्त कास्ट रनटाइम पर मान्य हैं। अन्य भाषाएँ केवल सुरक्षित कास्ट के एक संरक्षी अनुमान को स्वीकार करती हैं, या कोई भी नहीं।

पॉइंटर्स का मूल्य
C और C ++ में, तथापि दो पॉइंटर्स समान के रूप में तुलना करें, इसका तात्पर्य यह नहीं है कि वे समकक्ष हैं। इन भाषाओं और एलएलवीएम में, नियम की व्याख्या इस अर्थ में की जाती है कि सिर्फ इसलिए कि दो पॉइंटर्स एक ही एड्रैस की ओर संकेत करते हैं, इसका तात्पर्य यह नहीं है कि वे इस अर्थ में समान हैं कि उन्हें एक दूसरे के स्थान पर उपयोग किया जा सकता है, पॉइंटर्स के बीच के अंतर को उनके उद्गम के रूप में संदर्भित किया जाता है। एक पूर्णांक प्रकार जैसे कि कास्टिंग करना  कार्यान्वयन-परिभाषित है और यह जो तुलना प्रदान करता है वह इस बारे में अधिक जानकारी प्रदान नहीं करता है कि क्या दो पॉइंटर्स विनिमेय हैं। इसके अतिरिक्त, बाइट्स और अंकगणित में आगे रूपांतरण पॉइंटर्स के उपयोग को ट्रैक करने की प्रयास कर रहे ऑप्टिमाइज़र को मुक्त कर देगा, एक समस्या अभी भी अकादमिक शोध में स्पष्ट है।

पॉइंटर्स को सुरक्षित बनाना
एक पॉइन्टर के रूप में एक प्रोग्राम को एक ऐसी वस्तु तक पहुँचने का प्रयास करने की स्वीकृति देता है जिसे परिभाषित नहीं किया जा सकता है, संकेत विभिन्न प्रकार के सॉफ्टवेयर बग की उत्पत्ति हो सकते हैं। हालाँकि, पॉइंटर्स की उपयोगिता इतनी अधिक है कि उनके बिना प्रोग्रामिंग त्रुटियों का मूल हो सकते हैं। परिणामस्वरूप, कई भाषाओं ने अपने कुछ नुकसान के बिना पॉइंटर्स की कुछ उपयोगी विशेषताओं को प्रदान करने के लिए डिज़ाइन किए गए निर्माणों का निर्माण किया है, जिन्हें कभी-कभी पॉइंटर जोखिमों के रूप में भी जाना जाता है। इस संदर्भ में, पॉइंटर्स जो प्रत्यक्ष रूप से मेमोरी को संबोधित करते हैं (जैसा कि इस आलेख में उपयोग किया गया है) और स्मार्ट पॉइंटर्स या अन्य वेरिएंट के विपरीत   अपरिष्कृत पॉइंटर्स के रूप में संदर्भित किया जाता है।

पॉइंटर्स के साथ एक बड़ी समस्या यह है कि जब तक उन्हें प्रत्यक्ष रूप से एक संख्या के रूप में कुशलतापूर्वक प्रयोग किया जा सकता है, तब तक उन्हें अप्रयुक्त एड्रैस या अन्य उद्देश्यों के लिए उपयोग किए जा रहे डेटा को इंगित करने के लिए बनाया जा सकता है। अधिकांश कार्यात्मक प्रोग्रामिंग भाषाओं और जावा (प्रोग्रामिंग भाषा) जैसी हाल ही मे अनिवार्य भाषाओं सहित कई भाषाएं, पॉइंटर्स को एक अधिक अपारदर्शी प्रकार के संदर्भ से प्रतिस्थापित करती हैं, जिसे सामान्य रूप से केवल 'संदर्भ' के रूप में संदर्भित किया जाता है, जिसका उपयोग केवल वस्तुओं को संदर्भित करने के लिए किया जा सकता है। और इस प्रकार की त्रुटि को रोकने के लिए संख्या के रूप में कुशलतापूर्वक प्रयोग नहीं किया गया। सरणी इंडेक्सिंग को एक विशेष स्थिति के रूप में संभाला जाता है।

एक पॉइंटर जिसका कोई एड्रैस नहीं होता है, उसे वाइल्ड पॉइन्टर कहा जाता है। इस तरह के गैर-प्रारंभिकृत पॉइंटर्स का उपयोग करने का कोई भी प्रयास अप्रत्याशित गतिविधि का कारण बन सकता है, या तो प्रारंभिक मान एक वैध एड्रैस नहीं है, या इसका उपयोग करने से प्रोग्राम के अन्य भागों को नुकसान हो सकता है। परिणाम प्रायः एक सेगमेंटेशन दोष, भंडारण उल्लंघन या वाइल्ड ब्रांच होती है (यदि फ़ंक्शन पॉइंटर या ब्रांच एड्रैस के रूप में उपयोग किया जाता है)।

स्पष्ट मेमोरी आवंटन वाले सिस्टम में, उस मेमोरी क्षेत्र को हटाकर एक डांगलिंग पॉइन्टर बनाना संभव है जो इसे इंगित करता है। इस प्रकार का पॉइंटर जोखिम युक्त और सूक्ष्म है क्योंकि एक हटाए गए मेमोरी क्षेत्र में वही डेटा हो सकता है जैसा कि इसे हटाए जाने से पहले किया गया था, लेकिन फिर इसे असंबंधित कोड द्वारा पुनः आवंटित और अधिलेखित किया जा सकता है, जो पहले के कोड के लिए अज्ञात था। गारवेज संग्रह (कंप्यूटर विज्ञान) वाली भाषाएं इस प्रकार की त्रुटि को रोकती हैं क्योंकि विस्तार में कोई और संदर्भ नहीं होने पर डीलोकेशन (आवंटन रद्द) स्वचालित रूप से किया जाता है।

कुछ भाषाएँ, जैसे C++, स्मार्ट पॉइंटर्स का समर्थन करती हैं, जो एक संदर्भ के रूप में कार्य करने के अतिरिक्त गतिशील मेमोरी के आवंटन को जांच करने में सहायता करने के लिए संदर्भ गणना के एक सामान्य रूप का उपयोग करती हैं। संदर्भ चक्रों की अनुपस्थिति में, जहां कोई वस्तु अप्रत्यक्ष रूप से स्मार्ट पॉइंटर्स के अनुक्रम के माध्यम से स्वयं को संदर्भित करती है, ये डांगलिंग पॉइंटर्स और मेमोरी लीक की संभावना को समाप्त करते हैं। डेल्फी (प्रोग्रामिंग भाषा) वायर मूल रूप से संदर्भ गणना का समर्थन करते हैं।

रस्ट प्रोग्रामिंग भाषा गारबेज संग्रह का सहारा लिए बिना पॉइंटर बग्स को नष्ट करने के लिए अशक्त पॉइंटर्स के लिए वैकल्पिक प्रकारों के आधार पर उद्धृत चेकर, पॉइंटर लाइफटाइम और एक ऑप्टिमाइज़ेशन प्रस्तुत करती है।

अशक्त पॉइन्टर
एक अशक्त पॉइन्टर का एक मान आरक्षित होता है जो इंगित करता है कि पॉइन्टर एक वैध वस्तु का संदर्भ नहीं देता है। अशक्त पॉइंटर नियमित रूप से अज्ञात लंबाई की सूची (कंप्यूटिंग) के अंत या कुछ प्रतिक्रिया करने में विफलता जैसी स्थितियों का प्रतिनिधित्व करने के लिए उपयोग किए जाते हैं; अस्थिर पॉइंटर्स के इस उपयोग की तुलना अशक्त प्रकारों और विकल्प प्रकार में कुछ भी नहीं मान से की जा सकती है।

डांगलिंग पॉइन्टर
डैंगलिंग पॉइंटर एक पॉइंटर होता है जो किसी वैध वस्तु की ओर संकेत नहीं करता है और इसके परिणामस्वरूप प्रोग्राम क्रैश हो सकता है या अद्वितीय गतिविधि कर सकता है। पास्कल (प्रोग्रामिंग भाषा) या C (प्रोग्रामिंग भाषा) में, पॉइंटर्स जो विशेष रूप से आरंभीकृत नहीं होते हैं, वे मेमोरी में अप्रत्याशित एड्रैस की ओर संकेत कर सकते हैं।

निम्न उदाहरण कोड डांगलिंग पॉइन्टर को दिखाता है: int func(void) { char *p1 = malloc(sizeof(char)); /* (undefined) value of some place on the heap */ char *p2;      /* dangling (uninitialized) pointer */ *p1 = 'a';     /* This is OK, assuming malloc has not returned NULL. */    *p2 = 'b';      /* This invokes undefined behavior */ } यहाँ,  मेमोरी में कहीं भी इंगित कर सकता है, इसलिए समनुदेशन    कर रहा है, मेमोरी के अज्ञात क्षेत्र को नष्ट कर सकता है या विभाजन दोष को ट्रिगर कर सकता है।

वाइल्ड ब्रांच
जहां एक पॉइंटर का उपयोग किसी प्रोग्राम के प्रवेश बिंदु के एड्रैस के रूप में किया जाता है या एक सबरूटीन की प्रारंभ होती है। फ़ंक्शन जो कुछ भी वापस नहीं करता है और या तो अप्रारंभीकृत या अनुपयोगी है, यदि इस एड्रैस पर कॉल या जंप किया जाता है, तो एक "वाइल्ड ब्रांच" "कहा जाता है। दूसरे शब्दों में, एक वाइल्ड ब्रांच एक फ़ंक्शन पॉइंटर है जो वाइल्ड (डैंगलिंग) है।

परिणाम सामान्य रूप से अप्रत्याशित होते हैं और त्रुटि स्वयं को कई अलग-अलग तरीकों से प्रस्तुत कर सकती है, जो इस बात पर निर्भर करता है कि पॉइन्टर एक वैध एड्रैस है या नहीं और उस एड्रैस पर (संयोग से) एक वैध निर्देश (ओपकोड) है या नहीं है। एक वाइल्ड ब्रांच का पता लगाना सबसे कठिन और विफल डिबगिंग अभ्यासों में से एक को प्रस्तुत कर सकता है क्योंकि बहुत से प्रमाण पहले ही नष्ट हो सकते हैं या ब्रांच स्थान पर एक या अधिक अनुपयुक्त निर्देशों के निष्पादन से हो सकते हैं। यदि उपलब्ध हो, तो एक निर्देश सेट सिम्युलेटर सामान्य रूप से  प्रभावी होने से पहले न केवल एक वाइल्ड ब्रांच का पता लगा सकता है, बल्कि इसके इतिहास का पूर्ण या आंशिक निशान भी प्रदान करता है।

ऑटोरिलेटिव (स्वत:सापेक्ष) पॉइंटर
एक ऑटोरिलेटिव पॉइंटर एक पॉइंटर होता है जिसका मान पॉइंटर के एड्रैस से ऑफ़सेट के रूप में व्याख्या किया जाता है; इस प्रकार, यदि डेटा संरचना में एक ऑटोरिलेटिव पॉइंटर सदस्य है जो डेटा संरचना के कुछ भाग को इंगित करता है, तो डेटा संरचना को ऑटो रिलेटिव पॉइंटर के मान को अपडेट किए बिना मेमोरी में स्थानांतरित किया जा सकता है।

उद्धृत पेटेंट एक ही वस्तु का अर्थ करने के लिए स्व-सापेक्ष पॉइन्टर शब्द का भी उपयोग करता है। हालाँकि, उस शब्द का अर्थ अन्य तरीकों से उपयोग किया गया है:
 * पॉइन्टर के एड्रैस के अतिरिक्त संरचना के एड्रैस से ऑफ़सेट का तात्पर्य;
 * तात्पर्य एक पॉइन्टर जिसमें अपना एड्रैस होता है, जो मेमोरी के किसी भी एकपक्षीय क्षेत्र में पुनर्निर्माण के लिए उपयोगी हो सकता है जो एक दूसरे को इंगित करने वाले डेटा संरचनाओं का संग्रह होता है।

आधारित पॉइन्टर
एक आधारित पॉइंटर एक पॉइंटर होता है जिसका मान दूसरे पॉइंटर के मान से ऑफ़सेट होता है। इसका उपयोग डेटा के ब्लॉक को संग्रहित और लोड करने के लिए किया जा सकता है, ब्लॉक की प्रारंभ के एड्रैस को बेस पॉइंटर को निर्दिष्ट कर सकता है।

एकाधिक संकेत
कुछ भाषाओं में, एक पॉइंटर दूसरे पॉइंटर को संदर्भित कर सकता है, जिसके लिए मूल मान प्राप्त करने के लिए कई संदर्भित संचालन की आवश्यकता होती है। जबकि संकेत का प्रत्येक स्तर एक प्रदर्शन कीमत जोड़ सकता है, जटिल डेटा संरचनाओं के लिए सही गतिविधि प्रदान करने के लिए कभी-कभी यह आवश्यक होता है। उदाहरण के लिए, C में एक तत्व के संदर्भ में एक लिंक्ड सूची को परिभाषित करना सामान्य है जिसमें सूची के अगले तत्व के लिए पॉइन्टर होता है: struct element { struct element *next; int           value; }; struct element *head = NULL;

यह कार्यान्वयन पूरी सूची के लिए प्रतिनिधि के रूप में सूची में पहले तत्व के लिए पॉइन्टर का उपयोग करता है। यदि सूची के आरंभ में एक नया मान जोड़ा जाता है, तब नए तत्व को इंगित करने के लिए  को बदलना होगा। चूंकि C तर्क सदैव  मूल्य से पारित होते हैं, दोहरे संकेत का उपयोग करके सम्मिलन को सही रूप से कार्यान्वित करने की स्वीकृति मिलती है, और सूची के सामने सम्मिलन से सम्पर्क के लिए विशेष केस कोड को समाप्त  करने का वांछनीय दुष्प्रभाव होता है:

// Given a sorted list at *head, insert the element item at the first // location where all earlier elements have lesser or equal value. void insert(struct element **head, struct element *item) { struct element **p; // p points to a pointer to an element for (p = head; *p != NULL; p = &(*p)->next) { if (item->value <= (*p)->value) break; }    item->next = *p; *p = item; } // Caller does this: insert(&head, item); इस स्थिति में, यदि का मान  से कम है , फोन करने वाले का   नए आइटम के एड्रैस पर परिशुद्ध रूप से अपडेट किया गया है।

एक मूल उदाहरण C (और C++) में मुख्य फ़ंक्शन के argv तर्क में है, जो प्रोटोटाइप में —के रूप में दिया गया है - ऐसा इसलिए है क्योंकि वेरिएबल   स्वयं स्ट्रिंग्स की एक सरणी के लिए एक पॉइन्टर है (एक सरणी की सरणियाँ), इसलिए   0 वीं स्ट्रिंग के लिए एक पॉइन्टर है (कन्वेंशन द्वारा प्रोग्राम का नाम), और   0वीं स्ट्रिंग का 0वां वर्ण है।

फंक्शन पॉइंटर
कुछ भाषाओं में, एक पॉइंटर निष्पादन योग्य कोड को संदर्भित कर सकता है, अर्थात यह किसी फ़ंक्शन, विधि या प्रक्रिया को इंगित कर सकता है। एक फ़ंक्शन पॉइंटर फ़ंक्शन के एड्रैस को कॉल करने के लिए संग्रहीत करेगा। जबकि इस फीचर का उपयोग फंक्शनों को गतिशील रूप से कॉल करने के लिए किया जा सकता है, यह प्रायः वायरस और अन्य दुर्भावनापूर्ण सॉफ़्टवेयर लेखकों की चयनात्मक तकनीक है। int sum(int n1, int n2) {  // Function with two integer parameters returning an integer value return n1 + n2; } int main(void) { int a, b, x, y;    int (*fp)(int, int);    // Function pointer which can point to a function like sum fp = &amp;sum;             // fp now points to function sum x = (*fp)(a, b);       // Calls function sum with arguments a and b     y = sum(a, b);          // Calls function sum with arguments a and b }

बैक पॉइंटर
दोगुनी लिंक्ड सूचियों या ट्री (डेटा संरचना) में, एक तत्व पर रखा गया एक बैक पॉइंटर वर्तमान तत्व का उद्धरण करते हुए वस्तु को 'पॉइंट बैक' करता है। अधिक मेमोरी उपयोग की कीमत पर ये नेविगेशन और कुशलतापूर्वक प्रयोग के लिए उपयोगी हैं।

एक सरणी अनुक्रमणिका का उपयोग कर सिमुलेशन
एक (सामान्य रूप से एक-आयामी) सरणी के सूचकांक का उपयोग करके पॉइन्टर गतिविधि को अनुकरण करना संभव है।

मुख्य रूप से उन भाषाओं के लिए जो स्पष्ट रूप से पॉइंटर्स का समर्थन नहीं करती हैं, लेकिन सरणियों का समर्थन करती हैं, सरणी डेटा प्रकार के बारे में सोचा और संसाधित किया जा सकता है जैसे कि यह संपूर्ण मेमोरी सीमा (विशेष सरणी के प्रसार के अंदर) और किसी भी इंडेक्स के बारे में विचार किया जा सकता है। असेंबली भाषा में एक सामान्य उद्देश्य रजिस्टर के समान (जो व्यक्तिगत बाइट्स को इंगित करता है लेकिन जिसका वास्तविक मूल्य सरणी की प्रारंभ के सापेक्ष है, मेमोरी में इसका पूर्ण एड्रैस नहीं)। सरणी मानते हुए, कहते हैं, एक सन्निहित 16 मेगाबाइट वर्ण डेटा संरचना, व्यक्तिगत बाइट्स (या सरणी के अंदर सन्निहित बाइट्स का एक स्ट्रिंग (कंप्यूटर विज्ञान)) को प्रत्यक्ष रूप से संबोधित किया जा सकता है और 31 बिट अहस्ताक्षरित पूर्णांक के साथ सरणी के नाम का उपयोग करके कुशलतापूर्वक प्रयोग किया जा सकता है। सिम्युलेटेड पॉइंटर के रूप में (यह ऊपर दिखाए गए C सरणियों के उदाहरण के समान है)। पॉइंटर अंकगणित को वास्तविक पॉइंटर अंकगणित की तुलना में न्यूनतम अतिरिक्त ओवरहेड के साथ इंडेक्स से जोड़कर या घटाकर अनुकरण किया जा सकता है।

यह सैद्धांतिक रूप से भी संभव है, उपरोक्त तकनीक का उपयोग करके, उपयुक्त निर्देश सेट सिम्युलेटर के साथ किसी भी मशीन कोड या किसी प्रोसेसर/भाषा के इंटरमीडिएट (बाइट कोड) को किसी अन्य भाषा में अनुकरण करने के लिए जो पॉइंटर्स का समर्थन नहीं करता है (उदाहरण के लिए जावा / जावास्क्रिप्ट)। इसे प्राप्त करने के लिए, बाइनरी कोड को प्रारंभ में सरणी के सन्निहित बाइट्स में सिम्युलेटर के लिए "पढ़ने", व्याख्या करने और पूरी तरह से उसी सरणी में निहित मेमोरी के अंदर लोड किया जा सकता है। यदि आवश्यक हो, तो बफर ओवरफ्लो समस्याओं से पूरी तरह से बचने के लिए, सामान्य रूप से संकलक के लिए सीमा जाँच की जा सकती है (या यदि नहीं, तो सिम्युलेटर में हाथ से कोडित)।

एडीए
एडीए (प्रोग्रामिंग भाषा) एक दृढ़ता से टाइप की जाने वाली भाषा है जहां सभी पॉइंटर्स टाइप किए जाते हैं और केवल सुरक्षित प्रकार के रूपांतरणों की स्वीकृति है। डिफ़ॉल्ट रूप से सभी पॉइंटर्स को इनिशियलाइज़ (आरंभीकृत) किया जाता है, और डेटा तक अभिगम्य का कोई भी प्रयास a   पॉइन्टर एक्सेप्शन हैंडलिंग को किए जाने का कारण बनता है। एडीए में पॉइंटर्स को पहुंच प्रकार कहा जाता है। एडीए 83 ने अभिगम्य प्रकारों पर अंकगणित की स्वीकृति नहीं दी (हालाँकि कई कंपाइलर विक्रेता इसके लिए एक गैर-मानक विशेषता के रूप में प्रदान करते हैं), लेकिन एडीए 95 पैकेज   के माध्यम से अभिगम्य प्रकारों पर "सुरक्षित" अंकगणित का समर्थन करता है

प्रारम्भिक सर्व-उद्देश्यीय प्रतीकात्मक निर्देश कोड
विंडोज प्लेटफ़ॉर्म के लिए प्रारम्भिक सर्व-उद्देश्यीय प्रतीकात्मक निर्देश कोड के कई पुराने संस्करणों में स्ट्रिंग का एड्रैस वापस करने के लिए एसटीआरपीटीआर और एक वेरिएबल का एड्रैस वापस करने के लिए वीएआरपीटीआर  के लिए समर्थन था। विजुअल प्रारम्भिक सर्व-उद्देश्यीय प्रतीकात्मक निर्देश कोड 5 में ओबीजेपीटीआर  के लिए एक ऑब्जेक्ट इंटरफेस का एड्रैस वापस करने के लिए और एक एड्रैसऑफ ऑपरेटर के लिए एक फ़ंक्शन का एड्रैस वापस करने के लिए समर्थन था। इन सभी के प्रकार पूर्णांक हैं, लेकिन उनके मान पॉइन्टर प्रकारों द्वारा रखे गए के समान हैं।

हालाँकि, प्रारम्भिक सर्व-उद्देश्यीय प्रतीकात्मक निर्देश कोड की नई भाषाओ, जैसे मुक्त-प्रारम्भिक सर्व-उद्देश्यीय प्रतीकात्मक निर्देश कोड या ब्लिट्ज मैक्स, में संपूर्ण पॉइंटर कार्यान्वयन हैं। मुक्त-प्रारम्भिक सर्व-उद्देश्यीय प्रतीकात्मक निर्देश कोड में, अंकगणित पर   पॉइंटर्स (C के समान  ) के रूप में माना जाता है   पॉइन्टर एक बाइट चौड़ाई थी।   पॉइंटर्स को C संदर्भित नहीं किया जा सकता है, जैसा कि   और किसी अन्य प्रकार के पॉइंटर्स के बीच कास्टिंग करने से कोई संकेत उत्पन्न नहीं करेंगे। dim as integer f = 257 dim as any ptr g = @f dim as integer ptr i = g assert(*i = 257) assert( (g + 4) = (@f + 1) )

C और C ++
C (प्रोग्रामिंग भाषा) और C++ पॉइंटर्स वेरिएबल्स हैं जो एड्रैस को संग्रहित करते हैं और शून्य हो सकते हैं। प्रत्येक पॉइन्टर के पास एक प्रकार होता है जिसे वह इंगित करता है, लेकिन कोई पॉइन्टर प्रकारों के बीच स्वतंत्र रूप से कास्ट कर सकता है (लेकिन फ़ंक्शन पॉइंटर और ऑब्जेक्ट पॉइंटर के बीच नहीं)। एक विशेष पॉइन्टर प्रकार जिसे "शून्य पॉइन्टर" कहा जाता है, किसी भी (गैर-फ़ंक्शन) ऑब्जेक्ट को इंगित करने की स्वीकृति देता है, लेकिन इस तथ्य से सीमित है कि इसे प्रत्यक्ष रूप से संदर्भित नहीं किया जा सकता है (इसे कास्ट किया जाएगा)। पर्याप्त आकार के एक अभिन्न प्रकार से और उसके लिए एक पॉइन्टर को कास्ट करके एड्रैस ही प्रायः प्रत्यक्ष रूप से कुशलतापूर्वक प्रयोग किया जा सकता है, हालांकि परिणाम कार्यान्वयन-परिभाषित होते हैं और वास्तव में अपरिभाषित गतिविधि का कारण बन सकते हैं; जबकि पहले C मानकों में एक अभिन्न प्रकार नहीं था जो अपेक्षाकृत अधिक बड़ा होने की प्रत्याभूति देता था, C 99  में परिभाषित   typedef  नाम निर्दिष्ट करता है, लेकिन एक कार्यान्वयन को इसे प्रदान करने की आवश्यकता नहीं है।

C ++ पूरी तरह से C पॉइंटर्स और C टाइपकास्टिंग का समर्थन करता है। यह संकलन-समय पर कुछ अनपेक्षित जोखिमयुक्त विक्षेप को प्रग्रहण में सहायता करने के लिए टाइपकास्टिंग ऑपरेटरों के एक नए समूह का भी समर्थन करता है। C++11 के बाद से, C++ मानक लाइब्रेरी स्मार्ट पॉइंटर्स भी प्रदान करता है (,   और  ) जिसका उपयोग कुछ स्थितियों में स्थिति C पॉइंटर्स के सुरक्षित विकल्प के रूप में किया जा सकता है। C++ संदर्भ के दूसरे रूप का भी समर्थन करता है, जो पॉइन्टर से अपेक्षाकृत अधिक भिन्न होता है, जिसे केवल एक संदर्भ (C++) या संदर्भ प्रकार कहा जाता है।

'प्वाइंटर अंकगणित', अर्थात, अंकगणितीय संचालन (साथ ही साथ परिमाण तुलना) के साथ एक पॉइन्टर के लक्ष्य एड्रैस को संशोधित करने की क्षमता, भाषा मानक द्वारा एकल सरणी वस्तु (या उसके ठीक बाद) की सीमा के अंदर रहने के लिए प्रतिबंधित है। और अन्यथा अपरिभाषित गतिविधि का उपयोग करेगा। एक पॉइन्टर से जोड़ना या घटाना इसे अपने डेटाटाइप के आकार के एक से अधिक द्वारा ले जाता है। उदाहरण के लिए, 4-बाइट पूर्णांक मानों में एक पॉइंटर में 1 जोड़ने से पॉइंटर के पॉइंट-से-बाइट-एड्रेस में 4 की वृद्धि होगी। इसका प्रभाव पूर्णांकों की एक सन्निहित सरणी में अगले तत्व को इंगित करने के लिए पॉइंटर को बढ़ाने का प्रभाव है जो  प्रायः  नियत परिणाम है। पॉइन्टर    पॉइंटर्स अंकगणित पर नहीं किया जा सकता है क्योंकि शून्य प्रारूप का कोई आकार नहीं है, और इस प्रकार इंगित एड्रैस जोड़ा नहीं जा सकता है, हालांकि जीएनयू कंपाइलर संग्रह और अन्य कंपाइलर    बाइट अंकगणितीय प्रदर्शन करेंगे एक गैर-मानक एक्सटेंशन के रूप में निष्पादित करेंगे इसे इस तरह मानते हैं यह  थे।

पॉइंटर अंकगणित प्रोग्रामर को विभिन्न प्रकारों से सम्पर्क का एक ही तरीका प्रदान करता है: बाइट्स में वास्तविक ऑफ़सेट के अतिरिक्त आवश्यक तत्वों की संख्या को जोड़ना और घटाना। (पॉइन्टर अंकगणित के साथ  पॉइंटर्स बाइट ऑफ़सेट का उपयोग करते हैं, क्योंकि   परिभाषा के अनुसार 1 है।) विशेष रूप से, C परिभाषा स्पष्ट रूप से सिंटैक्स की घोषणा करती है , जो कि  - सरणी का तत्व  , के समान है  , जो कि   द्वारा इंगित तत्व की सामग्री है। इसका अर्थ यह है कि     के समान है और कोई लिख सकता है, उदाहरण के लिए,   या   किसी सरणी के चौथे तत्व   तक पहुँचने के लिए समान रूप से अच्छा है।

जबकि शक्तिशाली, पॉइन्टर अंकगणित सॉफ़्टवेयर बग का स्रोत हो सकता है। यह नोविस (नया प्रारंभ करने वाला ) प्रोग्रामर को भ्रमित करता है, उन्हें अलग-अलग संदर्भों में अनिवार्य करता है: एक अभिव्यक्ति एक सामान्य अंकगणितीय या पॉइन्टर अंकगणितीय हो सकती है, और कभी-कभी दूसरे के लिए दोष करना आसान होता है। इसके जवाब में, कई आधुनिक उच्च-स्तरीय कंप्यूटर भाषाएं (उदाहरण के लिए जावा (प्रोग्रामिंग भाषा)) एड्रैस का उपयोग करके मेमोरी तक प्रत्यक्ष रूप से अभिगम्य की स्वीकृति नहीं देती हैं। इसके अतिरिक्त, सुरक्षित C भाषा साइक्लोन प्रोग्रामिंग भाषा पॉइंटर्स के साथ कई समस्याओ को संबोधित करती है। अधिक चर्चा के लिए C (प्रोग्रामिंग भाषा) पॉइंटर्स देखें।

पॉइन्टर, या, अमेरिकन राष्ट्रीय मानक संस्थान C और C ++ में एक सामान्य पॉइन्टर प्रकार के रूप में समर्थित है। के लिए एक पॉइंटर  किसी भी ऑब्जेक्ट (फ़ंक्शन नहीं) के एड्रैस को संग्रहित कर सकता है, और, C में, समनुदेशन पर किसी अन्य ऑब्जेक्ट पॉइंटर प्रकार में अंतर्निहित रूप से परिवर्तित हो जाता है, लेकिन इसे संदर्भित होने पर स्पष्ट रूप से निर्धारित किया जाना चाहिए। K&R C प्रोग्रामिंग भाषा ने "टाइप-एग्नोस्टिक पॉइंटर" उद्देश्य  (अमेरिकन राष्ट्रीय मानक संस्थान C से पहले) के लिए वेरिएबल   का उपयोग किया। int x = 4; void* p1 = &x; int* p2 = p1;      // void* implicitly converted to int*: valid C, but not C++ int a = *p2; int b = *(int*)p1; // when dereferencing inline, there is no implicit conversion C ++ असाइनमेंट में भी  के अन्य पॉइन्टर प्रकारों के अंतर्निहित रूपांतरण की स्वीकृति नहीं देता है।  यह  कम और यहां तक ​​कि अनपेक्षित कास्ट से बचने के लिए एक डिजाइन निर्णय था, हालांकि अधिकांश कंपाइलर अन्य कास्ट का सामना करते समय त्रुटियों की चेतावनी नहीं देते हैं। int x = 4; void* p1 = &x; int* p2 = p1;                    // this fails in C++: there is no implicit conversion from void* int* p3 = (int*)p1;              // C-style cast int* p4 = reinterpret_cast(p1); // C++ cast C ++ में,  (शून्य के संदर्भ में) पूरक करने के लिए   (पॉइन्टर को शून्य) नहीं है, क्योंकि संदर्भ उन चरों के लिए उपनामों की तरह गतिविधि करते हैं जिन्हें वे इंगित करते हैं, और कभी भी ऐसा वेरिएबल नहीं हो सकता है जिसका प्रकार   है।

पॉइंटर-से-मेंबर (सदस्य)
C ++ पॉइंटर्स में कक्षा के गैर स्थिर सदस्यों को परिभाषित किया जा सकता है। यदि कोई क्लास  एक सदस्य    है तब     प्रकार   .के सदस्य के लिए एक पॉइन्टर है। यह सदस्य ऑब्जेक्ट या फ़ंक्शन पॉइंटर  मेथड पॉइंटर्स हो सकता है। उनका उपयोग ऑपरेटरों के दाईं ओर    और   संबंधित सदस्य तक अभिगम्य के लिए किया जा सकता है। struct S { int a; int f const {return a;} }; S s1{}; S* ptrS = &s1; int S::* ptr = &S::a; // pointer to S::a int (S::* fp)const = &S::f; // pointer to S::f s1.*ptr = 1; std::cout << (s1.*fp) << "\n"; // prints 1 ptrS->*ptr = 2; std::cout << (ptrS->*fp) << "\n"; // prints 2

सूचक घोषणा सिंटैक्स अवलोकन
ये पॉइंटर डिक्लेरेशन (घोषणा) पॉइंटर डिक्लेरेशन के अधिकांश वेरिएंट को सुरक्षा करते हैं।  स्वभावतः ट्रिपल पॉइंटर्स होना संभव है, लेकिन ट्रिपल पॉइंटर के पीछे मुख्य सिद्धांत पहले से ही द्विक  पॉइंटर में सम्मिलित हैं।  g++ या क्लैंग का उपयोग करते समय इनमें से प्रत्येक प्रकार के लिए पद    के लिए समान होता है। char A5_A5_c [5][5];  /* array of arrays of chars */ char *A5_Pc [5];      /* array of pointers to chars */ char **PPc;           /* pointer to pointer to char ("double pointer") */ char (*PA5_c) [5];    /* pointer to array(s) of chars */ char *FPcvE;        /* function which returns a pointer to char(s) */ char (*PFcvE);      /* pointer to a function which returns a char */ char (*FPA5_cvE)[5]; /* function which returns pointer to an array of chars */ char (*A5_PFcvE[5]); /* an array of pointers to functions which return a char */ पॉइंटर्स-से-मेंबर से जुड़ी निम्नलिखित घोषणाएँ केवल C ++ में मान्य हैं:

class C; class D; char C::* M1Cc;             /* pointer-to-member to char */ char C::*A5_M1Cc [5];       /* array of pointers-to-member to char */ char* C::* M1CPc;           /* pointer-to-member to pointer to char(s) */ char C::** PM1Cc;           /* pointer to pointer-to-member to char */ char (*M1CA5_c) [5];        /* pointer-to-member to array(s) of chars */ char C::* FM1CcvE;        /* function which returns a pointer-to-member to char */ char D::* C::* M1CM1Dc;     /* pointer-to-member to pointer-to-member to pointer to char(s) */ char C::* C::* M1CMS_c;     /* pointer-to-member to pointer-to-member to pointer to char(s) */ char (C::* FM1CA5_cvE)[5]; /* function which returns pointer-to-member to an array of chars */ char (C::* M1CFcvE)       /* pointer-to-member-function which returns a char */

और  की   से अधिक प्राथमिकता है।

सी#
C # (प्रोग्रामिंग भाषा) में, पॉइंटर्स केवल कुछ शर्तों के अंतर्गत समर्थित होते हैं: पॉइंटर्स सहित कोड के किसी भी ब्लॉक को   कीवर्ड के साथ चिह्नित किया जाना चाहिए। ऐसे ब्लॉकों को चलाने के लिए सामान्य रूप से  उच्च सुरक्षा अनुमतियों की आवश्यकता होती है। सिंटैक्स अनिवार्य रूप से C ++ के समान है, और बताया गया एड्रैस या तो प्रबंधित कोड या प्रबंधित कोड मेमोरी हो सकता है। हालाँकि, प्रबंधित मेमोरी के लिए पॉइंटर्स (किसी प्रबंधित ऑब्जेक्ट के लिए कोई पॉइंटर) को    कीवर्ड का उपयोग करके घोषित किया जाना चाहिए, जो गारबेज संग्रहण (कंप्यूटर विज्ञान) को मेमोरी प्रबंधन के भाग के रूप में इंगित वस्तु को स्थानांतरित करने से रोकता है, जबकि पॉइन्टर स्कोप (विस्तार) में है, इस प्रकार पॉइन्टर एड्रैस को वैध रखता है।

इसका एक्सेप्शन  संरचना का उपयोग करने से है, जो  के समतुल्य एक सुरक्षित प्रबंधित है, और इसके लिए असुरक्षित कोड की आवश्यकता नहीं है। उदाहरण के लिए , से विधियों का उपयोग करते समय इस प्रारूप को प्रायः  प्रतिगमित किया जाता है: // Get 16 bytes of memory from the process's unmanaged memory IntPtr pointer = System.Runtime.InteropServices.Marshal.AllocHGlobal(16); // Do something with the allocated memory // Free the allocated memory System.Runtime.InteropServices.Marshal.FreeHGlobal(pointer); नेटवर्क समर्थित तकनीक रूप रेखा में    और   नामस्थान (जैसे   क्लास)  कई क्लास और विधियाँ सम्मिलित हैं, जो नेटवर्क समर्थित तकनीक प्रकारों  और पॉइन्टर (उदाहरण के लिए,  ) कई प्रबंधित कोड प्रकारों और पॉइंटर्स  और (उदाहरण के लिए,   या  को रूपांतरित करते हैं।) प्रबंधित कोड के साथ संचार की स्वीकृति देने के लिए परिवर्तित करते है। इस तरह के अधिकांश तरीकों में अप्रबंधित कोड के समान सुरक्षा स्वीकृति की आवश्यकता होती है, क्योंकि वे मेमोरी में यादृच्छिक स्थानों को प्रभावित कर सकते हैं।

कोबोल
COBOL प्रोग्रामिंग भाषा पॉइंटर्स टू वेरिएबल्स का समर्थन करती है। स्थिति या समूह (रिकॉर्ड) डेटा ऑब्जेक्ट घोषित किए गए  स्वाभाविक रूप से पॉइंटर-आधारित होते हैं, जहां प्रोग्राम के अंदर आवंटित एकमात्र मेमोरी डेटा आइटम के एड्रैस के लिए जगह होती है (सामान्य रूप से  एक मेमोरी शब्द)। प्रोग्राम सोर्स कोड में, ये डेटा आइटम किसी अन्य की तरह ही उपयोग किए जाते हैं   वेरिएबल, लेकिन उनकी सामग्री परोक्ष रूप से उनके माध्यम से पहुँचा जा सकता है   संकेत।

प्रत्येक पॉइंट-टू-डेटा ऑब्जेक्ट के लिए मेमोरी स्पेस सामान्य रूप से बाहरी सबरूटीन का उपयोग करके गतिशील मेमोरी आवंटन है बयान या एम्बेडेड विस्तारित भाषा निर्माण जैसे कि EXEC CICS | या एसक्यूएल | बयान।

COBOL के विस्तारित संस्करण भी घोषित पॉइन्टर वेरिएबल प्रदान करते हैं      खंड। ऐसे पॉइंटर वेरिएबल्स के मान स्थापित और संशोधित किए जाते हैं   और     बयान।

COBOL के कुछ विस्तारित संस्करण भी प्रदान करते हैं  वेरिएबल्स, जो फंक्शन पॉइंटर को संग्रहित करने में सक्षम हैं।

प्रोग्रामिंग भाषा/आई
प्रोग्रामिंग भाषा/आई भाषा सभी डेटा प्रकारों (संरचनाओं के संकेत सहित), पुनरावर्तन, कंप्यूटर मल्टीटास्किंग, स्ट्रिंग हैंडलिंग और व्यापक अंतर्निर्मित सबरूटीन्स के लिए पॉइंटर्स के लिए पूर्ण समर्थन प्रदान करती है। प्रोग्रामिंग भाषा/आई अपने समय की प्रोग्रामिंग भाषाओं की तुलना में अपेक्षाकृत अधिक आगे था। प्रोग्रामिंग भाषा/आई पॉइंटर्स टाइप नहीं किए गए हैं, और इसलिए पॉइंटर डीरेफरेंसिंग या समनुदेशन के लिए कोई कास्टिंग आवश्यक नहीं है। पॉइंटर के लिए डिक्लेरेशन सिंटैक्स है, जो xxx नाम के एक पॉइंटर को डिक्लेयर करता है। पॉइंटर्स का प्रयोग किया जाता है   वेरिएबल। एक आधारित वेरिएबल को एक डिफ़ॉल्ट लोकेटर के साथ घोषित किया जा सकता है (  या बिना , जहां xxx एक आधारित वेरिएबल है, जो एक तत्व वेरिएबल, एक संरचना, या एक सरणी हो सकता है, और पीपीपी डिफ़ॉल्ट पॉइन्टर है)। इस तरह के एक वेरिएबल को एक स्पष्ट पॉइन्टर संदर्भ के बिना संबोधित किया जा सकता है ( , या डिफ़ॉल्ट लोकेटर (पीपीपी), या किसी अन्य पॉइन्टर के लिए एक स्पष्ट संदर्भ के साथ संबोधित किया जा सकता है.

पॉइंटर अंकगणित प्रोग्रामिंग भाषा/आई मानक का भाग नहीं है, लेकिन कई कंपाइलर फॉर्म के भावों की स्वीकृति देते हैं. आईबीएम प्रोग्रामिंग भाषा/आई में बिल्टिन फ़ंक्शन भी है  अंकगणित करने के लिए। पॉइन्टर अंकगणित हमेशा बाइट्स में किया जाता है।

IBM Enterprise प्रोग्रामिंग भाषा/आई कम्पाइलर के पास टाइप किए गए पॉइंटर का एक नया रूप है जिसे a कहा जाता है.

डी
डी (प्रोग्रामिंग भाषा) C और C ++ का व्युत्पन्न है जो C पॉइंटर्स और C टाइपकास्टिंग का पूर्ण समर्थन करता है।

एफिल
एफिल (प्रोग्रामिंग भाषा) वस्तु-उन्मुख भाषा पॉइंटर अंकगणित के बिना मान और संदर्भ सिमैन्टिक को नियोजित करती है। फिर भी, पॉइन्टर क्लास प्रदान किए जाते हैं। वे पॉइन्टर अंकगणित, टाइपकास्टिंग, स्पष्ट मेमोरी प्रबंधन, गैर-एफिल सॉफ़्टवेयर के साथ इंटरफेसिंग और अन्य सुविधाओं की पेशकश करते हैं।

फोरट्रान
फोरट्रान फोरट्रान -90 ने दृढ़ता से टाइप की गई पॉइन्टर क्षमता की प्रारंभ की। फोरट्रान पॉइंटर्स में केवल एक साधारण मेमोरी एड्रेस से अधिक होता है। वे सरणी आयामों की निचली और ऊपरी सीमा, स्ट्राइड्स (उदाहरण के लिए, एकपक्षीय सरणी अनुभागों का समर्थन करने के लिए), और अन्य मेटाडेटा को भी समाहित करते हैं। एक संघ ऑपरेटर,  a का उपयोग   को एक वेरिएबल से जोड़ने के लिए किया जाता है जिसमें    विशेषता होती है। फोरट्रान -90   स्टेटमेंट का उपयोग पॉइंटर को मेमोरी के ब्लॉक से जोड़ने के लिए भी किया जा सकता है। उदाहरण के लिए, लिंक की गई सूची संरचना को परिभाषित करने और बनाने के लिए निम्न कोड का उपयोग किया जा सकता है: type real_list_t real :: sample_data(100) type (real_list_t), pointer :: next => null end type type (real_list_t), target :: my_real_list type (real_list_t), pointer :: real_list_temp real_list_temp => my_real_list do  read (1,iostat=ioerr) real_list_temp%sample_data if (ioerr /= 0) exit allocate (real_list_temp%next) real_list_temp => real_list_temp%next end do फोरट्रान-2003 प्रक्रिया पॉइंटर्स के लिए समर्थन जोड़ता है। साथ ही, C इंटरऑपरेबिलिटी (अंतर्संचालनीयता) फीचर के भाग के रूप में, फोरट्रान-2003 C-शैली पॉइंटर्स को फोरट्रान पॉइंटर्स और बैक में परिवर्तित करने के लिए आंतरिक फंक्शनों का समर्थन करता है।

गो
गो (प्रोग्रामिंग भाषा) में पॉइंटर्स होते हैं। इसकी घोषणा सिंटैक्स C के समान है, लेकिन इसके विपरीत लिखा गया है, प्रकार के साथ समाप्त होता है। C के विपरीत, गो में गारवेज संग्रहण है, और पॉइंटर अंकगणित को अस्वीकार करता है। संदर्भ प्रकार, जैसे C++ में सम्मिलित नहीं हैं। कुछ अंतर्निर्मित प्रकार, जैसे मानचित्र और चैनल, बॉक्सिंग होते हैं (अर्थात आंतरिक रूप से वे उत्परिवर्तनीय संरचनाओं के पॉइंटर होते हैं), और इनका उपयोग करके प्रारंभ किया जाता है और  फ़ंक्शन का उपयोग करके प्रारंभ किए जाते हैं। पॉइंटर्स और गैर-पॉइंटर्स के बीच एकीकृत सिंटैक्स के दृष्टिकोण में, एरो (तीर का चिन्ह)  ऑपरेटर को हटा दिया गया है: पॉइंटर पर डॉट ऑपरेटर अपनिर्देशन ऑब्जेक्ट के क्षेत्र या विधि को संदर्भित करता है। हालाँकि, यह केवल 1 स्तर के संकेत के साथ कार्य करता है।

जावा
जावा (प्रोग्रामिंग भाषा) में पॉइंटर्स का कोई स्पष्ट प्रतिनिधित्व नहीं है। इसके अतिरिक्त, संदर्भ (कंप्यूटर विज्ञान) का उपयोग करके अधिक जटिल डेटा संरचनाएं जैसे वस्तु-उन्मुख प्रोग्रामिंग और सरणी डेटा संरचना प्रयुक्त की जाती हैं। भाषा कोई स्पष्ट पॉइन्टर कुशलतापूर्वक प्रयोग ऑपरेटर प्रदान नहीं करती है। कोड के लिए अभी भी एक अशक्त संदर्भ (अशक्त पॉइन्टर) को हटाने का प्रयास करना संभव है, हालांकि, जिसके परिणामस्वरूप रन-टाइम एक्सेप्शन हैंडलिंग को मुक्त कर दिया जाता है। गैर-संदर्भित मेमोरी ऑब्जेक्ट्स द्वारा प्रग्रहण कर लिया गया स्थान स्वचालित रूप से गारवेज संग्रहण (कंप्यूटर विज्ञान) द्वारा रन-टाइम पर पुनर्प्राप्त किया जाता है।

मोडुला-2
पास्कल के रूप में पॉइंटर्स बहुत अधिक प्रयुक्त किए जाते हैं  प्रक्रिया कॉल में पैरामीटर है। मॉड्यूल-2 पास्कल की तुलना में और भी अधिक दृढ़ता से टाइप किया गया है, टाइप सिस्टम से बचने के कम तरीके हैं। मॉड्यूल -3 (जैसे मोडुला-3) के कुछ रूपों में गारवेज संग्रह सम्मिलित है।

ओबेरॉन
मोडुला-2 की तरह ही पॉइंटर्स भी उपलब्ध हैं। टाइप सिस्टम से बचने के लिए अभी भी कम तरीके हैं और इसलिए ओबेरॉन (प्रोग्रामिंग भाषा) और इसके वेरिएंट अभी भी मोडुला -2 या इसके वेरिएंट की तुलना में पॉइंटर्स के संबंध में अधिक सुरक्षित हैं। मॉड्यूला -3 के साथ, गारवेज संग्रहण भाषा विनिर्देश का एक भाग है।

पास्कल
पॉइंटर्स की विशेषता वाली कई भाषाओं के विपरीत, स्टैंडर्ड अंतरराष्ट्रीय मानकीकरण संगठन पास्कल (प्रोग्रामिंग भाषा) केवल पॉइंटर्स को गतिशील रूप से बनाए गए वेरिएबल्स को संदर्भित करने की स्वीकृति देता है जो अज्ञात हैं और उन्हें मानक स्थिर या स्थानीय वेरिएबल्स को संदर्भित करने की स्वीकृति नहीं देते हैं। इसमें पॉइन्टर अंकगणित नहीं है। पॉइंटर्स के पास एक संबद्ध प्रकार भी होना चाहिए और एक प्रकार का पॉइंटर किसी अन्य प्रकार के पॉइंटर के साथ अनुरूप नहीं है (उदाहरण के लिए एक पॉइंटर एक पूर्णांक के लिए एक पॉइंटर के साथ अनुरूप नहीं है)। यह अन्य पॉइन्टर कार्यान्वयनों के साथ अंतर्निहित प्रकार के सुरक्षा समस्याओ को समाप्त करने में सहायता करता है, विशेष रूप से जो प्रोग्रामिंग भाषा/आई या C (प्रोग्रामिंग भाषा) के लिए उपयोग किए जाते हैं। यह अन्य पॉइंटर्स के कारण होने वाले कुछ जोखिमों को भी दूर करता है, लेकिन गतिशील रूप से संदर्भित स्थान का उपयोग करके जाने की क्षमता  मानक प्रक्रिया (जिसका वही प्रभाव है   C (प्रोग्रामिंग भाषा) में पाया गया लाइब्रेरी फंक्शन) का अर्थ है कि डांगलिंग पॉइंटर्स का जोखिम पूरी तरह से समाप्त नहीं हुआ है।

हालांकि, कुछ व्यवसायिक और मुक्त स्रोत में पास्कल (या डेरिवेटिव) कंपाइलर कार्यान्वयन-जैसे मुक्त पास्कल, एम्बरकाडेरो डेल्फी में टर्बो पास्कल या वस्तु पास्कल- एक पॉइंटर को मानक स्थिर या स्थानीय वेरिएबल को संदर्भित करने की स्वीकृति है और इसे एक पॉइंटर प्रकार से दूसरे में निर्दिष्ट किया जा सकता है। इसके अतिरिक्त, पॉइंटर अंकगणित अप्रतिबंधित है: पॉइंटर से जोड़ना या घटाना किसी भी दिशा में बाइट्स की संख्या से चलता है, लेकिन इसका उपयोग करके  या   इसके साथ मानक प्रक्रियाएं पॉइंटर को उस डेटा प्रकार के आकार से ले जाती हैं जिसे इंगित करने के लिए घोषित किया जाता है।   नाम के अंतर्गत एक अनटाइप्ड पॉइंटर भी दिया गया है जो अन्य पॉइन्टर प्रकारों के साथ अनुरूप है।

पर्ल
पर्ल प्रोग्रामिंग भाषा पॉइंटर्स का समर्थन करती है, हालांकि पैक और अनपैक फ़ंक्शंस के रूप में संभव्यता ही कभी उपयोग किया जाता है। ये केवल संकलित ऑपरेटिंग सिस्टम पुस्तकालयों के साथ साधारण परस्पर क्रिया के लिए अभिप्रेत हैं। अन्य सभी स्थितियो में, पर्ल संदर्भ (कंप्यूटर विज्ञान) का उपयोग करता है, जो टाइप किए जाते हैं और पॉइन्टर अंकगणित के किसी भी रूप की स्वीकृति नहीं देते हैं। उनका उपयोग जटिल डेटा संरचनाओं के निर्माण के लिए किया जाता है।

यह भी देखें
* एड्रैस नियत
 * बाउंडेड पॉइंटर
 * बफर ओवरफ्लो
 * क्रे पॉइंटर
 * फैट पॉइन्टर
 * फंक्शन पॉइंटर
 * खतरा सूचक
 * इटरेटर
 * अपारदर्शी सूचक
 * पोइंटी
 * पॉइंटर स्विजल
 * संदर्भ (कंप्यूटर विज्ञान)
 * स्टेटिक प्रोग्राम विश्लेषण
 * संग्रहण उल्लंघन
 * टैग किए गए सूचक
 * वेरिएबल (कंप्यूटर विज्ञान)
 * शून्य आधारित संख्या

बाहरी संबंध

 * प्रोग्रामिंग भाषा/आई List Processing Paper from the June, 1967 issue of सेंट्रल अमेरिकन कॉमन मार्केट
 * cdecl.org A tool to convert pointer declarations to plain English
 * Over IQ.com A beginner level guide describing pointers in a plain English.
 * Pointers and Memory Introduction to pointers – Stanford Computer Science Education Library
 * Pointers in C programming A visual model for the beginners in C programming
 * 0pointer.de A terse list of minimum length source codes that dereference a null pointer in several different programming languages
 * "The C book" – containing pointer examples in ANSI C

Datatyp