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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

किसी भी मामले में, एक बार सूचक घोषित होने के बाद, अगला तार्किक कदम इसके लिए कुछ इंगित करना है:

<वाक्यविन्यास लैंग = सी> इंट ए = 5; इंट * पीआरटी = न्यूल;

पीटीआर = और ए; 

यह के पते का मान निर्दिष्ट करता है  को. उदाहरण के लिए, अगर  0x8130 के स्मृति स्थान पर संग्रहीत किया जाता है, फिर का मान   असाइनमेंट के बाद 0x8130 होगा। पॉइंटर को डिरेफेरेंस करने के लिए, एक तारांकन चिह्न का फिर से उपयोग किया जाता है:

इसका मतलब है की सामग्री लें  (जो 0x8130 है), उस पते को स्मृति में ढूंढें और उसका मान 8 पर सेट करें। अगर  बाद में फिर से एक्सेस किया जाता है, इसका नया मान 8 होगा।

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

<वाक्यविन्यास लैंग = सी> इंट ए = 5; इंट * पीआरटी = न्यूल; 


 * {| class="wikitable"

! Address !! Contents (यहां दिखाया गया पूर्ण सूचक 0x00000000 है।) का पता बता कर  को  :
 * 0x8130 || 0x00000005
 * 0x8134 || 0x00000000
 * }
 * 0x8134 || 0x00000000
 * }

<वाक्यविन्यास लैंग = सी> पीटीआर = और ए; 

निम्नलिखित स्मृति मान उत्पन्न करता है:


 * {| class="wikitable"

! Address !! Contents फिर dereferencing द्वारा  कोडिंग द्वारा:
 * 0x8130 || 0x00000005
 * 0x8134 || 0x00008130
 * }
 * 0x8134 || 0x00008130
 * }

<वाक्यविन्यास लैंग = सी> *पीआरटी = 8; 

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


 * {| class="wikitable"

! Address !! Contents स्पष्ट रूप से, पहुँचना  8 का मान देगा क्योंकि पिछले निर्देश ने सामग्री को संशोधित किया था   सूचक के माध्यम से.
 * 0x8130 || 0x00000008
 * 0x8134 || 0x00008130
 * }
 * 0x8134 || 0x00008130
 * }

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

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

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

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

<वाक्यविन्यास प्रकाश लैंग = सी> इंट सरणी [5]; /* 5 सन्निहित पूर्णांकों की घोषणा करता है */ int *ptr = सरणी; / * सरणियों को पॉइंटर्स के रूप में इस्तेमाल किया जा सकता है * / पीटीआर [0] = 1; / * पॉइंटर्स को सरणी सिंटैक्स के साथ अनुक्रमित किया जा सकता है * / 2 [सरणी] = 4; /* सबस्क्रिप्ट ऑपरेटर क्रमविनिमेय है */ 
 * (सरणी + 1) = 2; / * एरे को पॉइंटर सिंटैक्स के साथ डीरेफरेंस किया जा सकता है * /
 * (1 + सरणी) = 2; /* सूचक जोड़ क्रमविनिमेय है */

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

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

किसी सरणी के डिफ़ॉल्ट मानों को इस प्रकार घोषित किया जा सकता है:

<वाक्यविन्यास लैंग = सी> int सरणी [5] = {2, 4, 3, 1, 5}; 

अगर  32-बिट Endianness#Little-endian|little-endian मशीन पर पता 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 का मतलब 1 का आकार जोड़ना है, जो 4 बाइट है;
 * की सामग्री को डीरेफरेंस करने का मतलब है . स्मृति पता (0x1000) के रूप में सामग्री को ध्यान में रखते हुए, उस स्थान पर मान देखें (0x0002);
 * मतलब तत्व संख्या, 0-आधारित, का   जिसका अनुवाद किया गया है.

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

= सी लिंक की गई सूची === नीचे C में लिंक की गई सूची की एक उदाहरण परिभाषा दी गई है।

<वाक्यविन्यास लैंग = सी> / * खाली लिंक की गई सूची को NULL द्वारा दर्शाया गया है * या कुछ अन्य प्रहरी मूल्य * /
 * 1) खाली EMPTY_LIST परिभाषित करें

संरचना लिंक { शून्य * डेटा; /* इस लिंक का डेटा */ संरचना लिंक * अगला; /* अगला लिंक; EMPTY_LIST अगर कोई नहीं है */ }; 

यह सूचक-पुनरावर्ती परिभाषा अनिवार्य रूप से हास्केल (प्रोग्रामिंग भाषा) से संदर्भ-पुनरावर्ती परिभाषा के समान है:

<वाक्यविन्यास लैंग = हैकेल> डेटा लिंक ए = नील | विपक्ष ए (लिंक ए)  खाली सूची है, और  विपक्ष प्रकार का सेल है   दूसरे लिंक के साथ भी प्रकार का.

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

पास-दर-पता संकेत
का उपयोग कर पॉइंटर्स का उपयोग वेरिएबल्स को उनके पते से पास करने के लिए किया जा सकता है, जिससे उनका मान बदला जा सकता है। उदाहरण के लिए, निम्नलिखित सी (प्रोग्रामिंग भाषा) कोड पर विचार करें:

<वाक्यविन्यास लैंग = सी> / * कॉलिंग कोड को प्रभावित किए बिना फ़ंक्शन के भीतर int n की एक प्रति बदली जा सकती है * / शून्य पासबायवैल्यू (इंट एन) { एन = 12; }

/* इसके बजाय एक पॉइंटर m पास किया जाता है। m द्वारा इंगित मान की कोई प्रतिलिपि नहीं बनाई गई है */ शून्य पासबायएड्रेस (इंट * एम) { *एम = 14; }

पूर्णांक मुख्य (शून्य) { इंट एक्स = 3;

/* तर्क के रूप में x के मान की कॉपी पास करें */ पासबायवैल्यू (एक्स); // फ़ंक्शन के अंदर मान बदल दिया गया था, लेकिन x अभी भी यहां से 3 है

/* तर्क के रूप में x का पता पास करें */ पासबाय एड्रेस (&x); // x वास्तव में फ़ंक्शन द्वारा बदल दिया गया था और अब यहां 14 के बराबर है

वापसी 0; } 

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

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

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

<वाक्यविन्यास लैंग = सी> /* पार्ट्स इन्वेंट्री आइटम */ संरचना मद { इंट आईडी; /* भाग संख्या */ नौकरानी का नाम; /* नाम का हिस्सा  */ तैरने की लागत; /* लागत       */ };

/ * एक नया आइटम ऑब्जेक्ट आवंटित करें और आरंभ करें * / संरचना आइटम * Make_item (स्थिरांक चार * नाम) { संरचना आइटम * आइटम;

/* नए आइटम ऑब्जेक्ट के लिए मेमोरी का एक ब्लॉक आवंटित करें */ आइटम = मॉलोक (आकार (संरचना आइटम)); अगर (आइटम == न्यूल) वापसी शून्य;

/ * नए आइटम के सदस्यों को इनिशियलाइज़ करें * / मेमसेट (आइटम, 0, आकार (संरचना आइटम)); आइटम->आईडी = -1; आइटम-> नाम = न्यूल; आइटम->लागत = 0.0;

/* नए आइटम में नाम की एक कॉपी सेव करें */ आइटम-> नाम = मॉलोक (strlen (नाम) + 1); अगर (आइटम-> नाम == न्यूल) { मुक्त (आइटम); वापसी शून्य; }   strcpy (आइटम-> नाम, नाम);

/ * नव निर्मित आइटम ऑब्जेक्ट लौटाएं * / वापसी के लिए वस्तु; } 

नीचे दिया गया कोड बताता है कि मेमोरी ऑब्जेक्ट्स को गतिशील रूप से कैसे हटाया जाता है, यानी ढेर या मुफ्त स्टोर में लौटाया जाता है। मानक सी लाइब्रेरी मुफ्त | फ़ंक्शन प्रदान करती है पहले आवंटित मेमोरी ब्लॉक को हटाने और इसे वापस ढेर पर वापस करने के लिए।

<वाक्यविन्यास लैंग = सी> /* आइटम ऑब्जेक्ट को हटा दें */ शून्य नष्ट_आइटम (संरचना मद * मद) { / * एक अशक्त वस्तु सूचक के लिए जाँच करें * / अगर (आइटम == न्यूल) वापस करना;

/* आइटम में सहेजी गई नाम स्ट्रिंग को हटाएं */ अगर (आइटम-> नाम! = न्यूल) { मुक्त (आइटम-> नाम); आइटम-> नाम = न्यूल; }

/ * आइटम ऑब्जेक्ट को स्वयं हटा दें * / मुक्त (आइटम); } 

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

microcontroller्स की प्रोग्रामिंग करते समय पॉइंटर्स को एड्रेस असाइन करना एक अमूल्य उपकरण है। नीचे एक सरल उदाहरण है जो एक प्रकार के int के सूचक को घोषित करता है और इसे हेक्साडेसिमल पते पर शुरू करता है, इस उदाहरण में निरंतर 0x7FFF:

<वाक्यविन्यास लैंग = सी> int *हार्डवेयर_पता = (int *)0x7FFF; 

80 के दशक के मध्य में, पीसी की वीडियो क्षमताओं तक पहुँचने के लिए BIOS का उपयोग धीमा था। प्रदर्शन-गहन अनुप्रयोग आमतौर पर हेक्साडेसिमल स्थिरांक 0xB8000 को 80 अहस्ताक्षरित 16-बिट int मानों की एक सरणी के लिए पॉइंटर में कास्ट करके सीधे रंग ग्राफिक्स एडेप्टर वीडियो मेमोरी तक पहुंचने के लिए उपयोग किया जाता है। प्रत्येक मान में निम्न बाइट में एक ASCII कोड और उच्च बाइट में एक रंग शामिल होता है। इस प्रकार, अक्षर 'A' को पंक्ति 5 में, कॉलम 2 को नीले रंग पर चमकीले सफेद रंग में रखने के लिए, निम्नलिखित कोड की तरह लिखा जाएगा:

<वाक्यविन्यास लैंग = सी>
 * 1) define VID ((अहस्ताक्षरित संक्षिप्त (*)[80])0xB8000)

शून्य फू (शून्य) { वीआईडी ​​[4] [1] = 0x1F00 | 'ए'; } 

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

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

उदाहरण के लिए, सी में

<वाक्यविन्यास लैंग = सी> इंट * पैसा; चार * बैग; 

एक पूर्णांक सूचक होगा और  एक चार सूचक होगा। निम्नलिखित जीएनयू कंपाइलर संग्रह के तहत असंगत सूचक प्रकार से असाइनमेंट की एक कंपाइलर चेतावनी उत्पन्न करेगा

<वाक्यविन्यास लैंग = सी> बैग = पैसा; 

क्योंकि  और   विभिन्न प्रकारों के साथ घोषित किए गए थे। कंपाइलर चेतावनी को दबाने के लिए, यह स्पष्ट किया जाना चाहिए कि आप वास्तव में टाइप रूपांतरण द्वारा असाइनमेंट करना चाहते हैं

<वाक्यविन्यास लैंग = सी> बैग = (चार *) पैसा; 

जो पूर्णांक सूचक को कास्ट करने के लिए कहता है  एक चार सूचक को और असाइन करें.

सी मानक के 2005 के एक मसौदे के लिए आवश्यक है कि एक प्रकार से दूसरे प्रकार से प्राप्त सूचक को कास्टिंग करने से दोनों प्रकारों के लिए संरेखण शुद्धता बनाए रखनी चाहिए (6.3.2.3 पॉइंटर्स, पैरा। 7): <वाक्यविन्यास लैंग = सी> चार * बाहरी_बफर = एबीसीडीईएफ; int *आंतरिक_डेटा;

आंतरिक_डाटा = (इंट *) बाहरी_बफर; // अपरिभाषित व्यवहार यदि परिणामी सूचक // ठीक से संरेखित नहीं है </वाक्यविन्यास हाइलाइट>

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

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

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

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

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

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

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

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

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

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

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

निम्न उदाहरण कोड झूलने वाले सूचक को दिखाता है:

<वाक्यविन्यास लैंग = सी> इंट फंक (शून्य) { चार * पी 1 = मॉलोक (आकार (चार)); /* (अपरिभाषित) हीप पर किसी स्थान का मान */ चार * पी 2; / * लटकना (अप्रारंभीकृत) सूचक * / *पी1 = 'ए'; /* यह ठीक है, यह मानते हुए कि malloc NULL नहीं लौटा है। */ *पी2 = 'बी'; / * यह अपरिभाषित व्यवहार का आह्वान करता है * / } </वाक्यविन्यास हाइलाइट>

यहाँ,  मेमोरी में कहीं भी इंगित कर सकता है, इसलिए असाइनमेंट कर रहा है   स्मृति के अज्ञात क्षेत्र को दूषित कर सकता है या विभाजन दोष को ट्रिगर कर सकता है।

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

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

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

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

उपयोग या डेटाटाइप
द्वारा परिभाषित प्रकार

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

<वाक्यविन्यास लैंग = सी> संरचना तत्व { संरचना तत्व * अगला; इंट वैल्यू; };

संरचना तत्व *सिर = शून्य; </वाक्यविन्यास हाइलाइट>

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

<वाक्यविन्यास लैंग = सी> // * सिर पर एक क्रमबद्ध सूची दी गई है, पहले तत्व आइटम डालें // स्थान जहां पहले के सभी तत्वों का मूल्य कम या समान है। शून्य सम्मिलित करें (संरचना तत्व ** सिर, संरचना तत्व * आइटम) { संरचना तत्व **पी; // पी एक तत्व के सूचक को इंगित करता है के लिए (पी = सिर; * पी! = न्यूल; पी = और (* पी) -> अगला) { अगर (आइटम-> मूल्य <= (* पी) -> मूल्य) तोड़ना; }   आइटम-> अगला = * पी; *पी = आइटम; }

// कॉलर यह करता है: सम्मिलित करें (और सिर, आइटम); </वाक्यविन्यास हाइलाइट>

इस मामले में, यदि का मान  से कम है , फोन करने वाले का   नए आइटम के पते पर ठीक से अपडेट किया गया है।

एक मूल उदाहरण argv तर्क में main function#C और C++|main function in C (और C++) में है, जो प्रोटोटाइप में दिया गया है —यह इसलिए है क्योंकि चर   स्वयं तार की एक सरणी (सरणियों की एक सरणी) के लिए एक सूचक है, इसलिए   0 वीं स्ट्रिंग के लिए एक सूचक है (सम्मेलन द्वारा कार्यक्रम का नाम), और   0वीं स्ट्रिंग का 0वां वर्ण है।

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

<वाक्यविन्यास लैंग = सी> int sum(int n1, int n2) { // पूर्णांक मान लौटाने वाले दो पूर्णांक पैरामीटर वाला फ़ंक्शन वापसी n1 + n2; }

पूर्णांक मुख्य (शून्य) { इंट ए, बी, एक्स, वाई; इंट (* एफपी) (इंट, इंट); // फंक्शन पॉइंटर जो योग जैसे फ़ंक्शन को इंगित कर सकता है fp = ∑ // fp अब फंक्शन योग की ओर इशारा करता है एक्स = (*एफपी) (ए, बी); // तर्क ए और बी के साथ फ़ंक्शन योग को कॉल करता है वाई = योग (ए, बी); // तर्क ए और बी के साथ फ़ंक्शन योग को कॉल करता है } </वाक्यविन्यास हाइलाइट>

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

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

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

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

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

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

हालाँकि, BASIC की नई बोलियाँ, जैसे FreeBASIC या BlitzMax, में संपूर्ण संकेतक कार्यान्वयन हैं। FreeBASIC में, अंकगणित पर  पॉइंटर्स (सी के बराबर  ) के रूप में माना जाता है   सूचक एक बाइट चौड़ाई थी।   पॉइंटर्स को डीरेफरेंस नहीं किया जा सकता है, जैसा कि सी में भी है, बीच में कास्टिंग   और किसी अन्य प्रकार के संकेतक कोई चेतावनी उत्पन्न नहीं करेंगे।

<वाक्यविन्यास प्रकाश लैंग = ब्लिट्जमैक्स> पूर्णांक f = 257 के रूप में मंद किसी भी ptr g = @f के रूप में मंद पूर्णांक ptr i = g के रूप में मंद मुखर (* मैं = 257) मुखर ((जी + 4) = (@f + 1)) </वाक्यविन्यास हाइलाइट>

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

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

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

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

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

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

<वाक्यविन्यास लैंग = सी> इंट एक्स = 4; शून्य* p1 = &x; int* p2 = p1; // शून्य * अंतर्निहित रूप से int * में परिवर्तित: वैध C, लेकिन C ++ नहीं इंट ए = * पी 2; इंट बी = *(इंट*)पी1; // जब इनलाइन को डिफ्रेंसिंग करते हैं, तो कोई अंतर्निहित रूपांतरण नहीं होता है </वाक्यविन्यास हाइलाइट>

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

<वाक्यविन्यास लैंग = सीपीपी> इंट एक्स = 4; शून्य* p1 = &x; int* p2 = p1; // यह सी ++ में विफल रहता है: शून्य * से कोई अंतर्निहित रूपांतरण नहीं है int* p3 = (int*)p1; // सी-स्टाइल कास्ट int* p4 = reinterpret_cast<int*>(p1); // सी ++ कास्ट </वाक्यविन्यास हाइलाइट>

सी ++ में, नहीं है  (शून्य के संदर्भ में) पूरक करने के लिए   (सूचक को शून्य), क्योंकि संदर्भ उन चरों के लिए उपनामों की तरह व्यवहार करते हैं जिन्हें वे इंगित करते हैं, और कभी भी ऐसा चर नहीं हो सकता है जिसका प्रकार है.

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

<वाक्यविन्यास लैंग = सीपीपी> संरचना एस { इंट ए; int f const {वापसी a;} }; एस एस 1 {}; एस* ptrS = &s1;

int S::* ptr = &S::a; // पॉइंटर टू एस :: ए int (S::* fp)const = &S::f; // पॉइंटर टू एस :: एफ

s1.*ptr = 1; एसटीडी :: अदालत << (s1.*fp) << \n; // प्रिंट 1 ptrS->*ptr = 2; std::cout << (ptrS->*fp) << \n; // प्रिंट 2 </वाक्यविन्यास हाइलाइट>

पॉइंटर डिक्लेरेशन सिंटैक्स ओवरव्यू
ये पॉइंटर डिक्लेरेशन पॉइंटर डिक्लेरेशन के अधिकांश वेरिएंट को कवर करते हैं। बेशक ट्रिपल पॉइंटर्स होना संभव है, लेकिन ट्रिपल पॉइंटर के पीछे मुख्य सिद्धांत पहले से ही डबल पॉइंटर में मौजूद हैं। यहाँ प्रयुक्त नामकरण क्या अभिव्यक्ति है  g++ या बजना का उपयोग करते समय इनमें से प्रत्येक प्रकार के लिए बराबर होता है। <वाक्यविन्यास लैंग = सी> चार A5_A5_c [5][5]; / * वर्णों के सरणियों की सरणी * / चार *A5_Pc [5]; / * पॉइंटर्स की सरणी वर्णों के लिए * / चार ** पीपीसी; / * पॉइंटर टू पॉइंटर टू चार (डबल पॉइंटर) * / चार (*PA5_c) [5]; / * वर्णों की सरणी के लिए सूचक * / चार * एफपीसीवीई ; / * फ़ंक्शन जो चार (ओं) के लिए एक सूचक देता है * / चार (*PFcvE); / * एक फ़ंक्शन के लिए सूचक जो एक वर्ण लौटाता है * / चार (*FPA5_cvE ) [5]; / * फ़ंक्शन जो पॉइंटर को वर्णों की एक सरणी में लौटाता है * / चार (*A5_PFcvE [5]); / * कार्यों के लिए पॉइंटर्स की एक सरणी जो एक चार लौटाती है * / </वाक्यविन्यास हाइलाइट> पॉइंटर्स-टू-मेंबर से जुड़ी निम्नलिखित घोषणाएँ केवल C ++ में मान्य हैं: <वाक्यविन्यास लैंग = सीपीपी> कक्षा सी; कक्षा डी; चार सी :: * एम 1 सीसी; /* पॉइंटर-टू-मेंबर टू चार */ चार सी :: * ए 5_एम 1 सीसी [5]; / * पॉइंटर्स-टू-मेंबर टू चार की सरणी * / चार * सी :: * एम 1 सीपीसी; /* पॉइंटर-टू-मेंबर टू पॉइंटर टू चार(एस) */ चार सी :: ** PM1CC; /* पॉइंटर टू मेंबर टू पॉइंटर टू चार */ चार (*M1CA5_c) [5]; / * सूचक-से-सदस्य वर्णों की सरणी के लिए */ चार सी :: * FM1CcvE ; / * फ़ंक्शन जो एक पॉइंटर-टू-मेंबर को चार में लौटाता है * / चार डी :: * सी :: * एम 1 सीएम 1 डीसी; /* पॉइंटर-टू-मेंबर टू पॉइंटर-टू-मेंबर टू पॉइंटर टू चार(एस) */ चार सी :: * सी :: * M1CMS_c; /* पॉइंटर-टू-मेंबर टू पॉइंटर-टू-मेंबर टू पॉइंटर टू चार(एस) */ चार (सी::* FM1CA5_cvE)[5]; / * फ़ंक्शन जो पॉइंटर-टू-मेंबर को वर्णों की एक सरणी में लौटाता है * / char (C::* M1CFcvE) /* पॉइंटर-टू-मेंबर-फ़ंक्शन जो एक char लौटाता है */ चार (सी :: * A5_M1CFcvE [5]) ; / * पॉइंटर्स-टू-मेंबर-फ़ंक्शंस की एक सरणी जो एक चार लौटाती है * /

</वाक्यविन्यास हाइलाइट>  ई> और   से अधिक प्राथमिकता है.

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

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

<वाक्यविन्यास प्रकाश लैंग = csharp> // प्रक्रिया की अप्रबंधित मेमोरी से 16 बाइट्स मेमोरी प्राप्त करें IntPtr सूचक = System.Runtime.InteropServices.Marshal.AllocHGlobal (16);

// आवंटित मेमोरी के साथ कुछ करें

// आवंटित मेमोरी को मुक्त करें System.Runtime.InteropServices.Marshal.FreeHGlobal (सूचक); </वाक्यविन्यास हाइलाइट>

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

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

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

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

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

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

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

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

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

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

फोरट्रान
फोरट्रान | फोरट्रान -90 ने दृढ़ता से टाइप की गई सूचक क्षमता की शुरुआत की। फोरट्रान पॉइंटर्स में केवल एक साधारण मेमोरी एड्रेस से अधिक होता है। वे सरणी आयामों की निचली और ऊपरी सीमा, स्ट्राइड्स (उदाहरण के लिए, मनमाना सरणी अनुभागों का समर्थन करने के लिए), और अन्य मेटाडेटा को भी समाहित करते हैं। एक संघ संचालक,  a को जोड़ने के लिए प्रयोग किया जाता है   एक चर के लिए जिसमें a है   गुण। फोरट्रान -90   स्टेटमेंट का उपयोग पॉइंटर को मेमोरी के ब्लॉक से जोड़ने के लिए भी किया जा सकता है। उदाहरण के लिए, लिंक की गई सूची संरचना को परिभाषित करने और बनाने के लिए निम्न कोड का उपयोग किया जा सकता है: <वाक्यविन्यास लैंग = फोरट्रान> real_list_t टाइप करें वास्तविक :: नमूना_डेटा (100) प्रकार (real_list_t), सूचक :: अगला => अशक्त अंत प्रकार

प्रकार (real_list_t), लक्ष्य :: my_real_list प्रकार (real_list_t), सूचक :: real_list_temp

real_list_temp => my_real_list करना पढ़ें (1,iostat=ioerr) real_list_temp%sample_data if (ioerr /= 0) बाहर निकलें आवंटित (real_list_temp% अगला) real_list_temp => real_list_temp%next अंत करो </वाक्यविन्यास हाइलाइट>

फोरट्रान-2003 प्रक्रिया संकेतकों के लिए समर्थन जोड़ता है। साथ ही, सी इंटरऑपरेबिलिटी फीचर के हिस्से के रूप में, फोरट्रान-2003 सी-स्टाइल पॉइंटर्स को फोरट्रान पॉइंटर्स और बैक में परिवर्तित करने के लिए आंतरिक कार्यों का समर्थन करता है।

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

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

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

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

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

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

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

बाहरी संबंध

 * PL/I List Processing Paper from the June, 1967 issue of CACM
 * 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