सूचक स्पष्टीकरण के लिए सूचक

Question

मैं इस ट्यूटोरियल के बारे में बता रहा था कि एक पॉइंटर से पॉइंटर कैसे काम करता है ।

मुझे संबंधित मार्ग उद्धृत करें:

---

    int i = 5, j = 6, k = 7;
    int *ip1 = &i, *ip2 = &j;

अब हम सेट कर सकते हैं

    int **ipp = &ip1;

और ippकरने के लिए अंक ip1जो करने के लिए अंक i। *ippहै ip1, और **ippहै i, या 5. हम इस तरह से हमारे परिचित बॉक्स और तीर संकेतन के साथ स्थिति का वर्णन कर सकते हैं:

अगर हम कहते हैं

    *ipp = ip2;

हमने ippउस ( ip1) को इंगित करने के लिए इसकी एक प्रति सम्‍मिलित करने के लिए पॉइंटर बदल दिया है ip2, ताकि यह ( ip1) अब इस ओर इंगित करे j:

---

मेरा सवाल है: दूसरी तस्वीर में, ippअभी भी क्यों ip1नहीं की ओर इशारा कर रहा है ip2?

Comments

कृपया, ippइसे परिभाषित करते समय टाइप करें, ताकि आपका प्रश्न पूर्ण हो ;-)

— zmo

क्योंकि ऐसा ippकरने के लिए इशारा एक ही हैip1*ipp = ip2ip1 = ip2

— Grijesh Chauhan

क्या हम उस प्रकार के तार से दूर रहने वाले तारांकन लिखना बंद कर सकते हैं? int **ippकी तुलना में कहीं कम सहज है int** ipp, खासकर जब **ippप्रकार की घोषणाओं के बाहर एक पूरी तरह से अलग चीज का मतलब है।

— डार्कहॉग

@Darkhogg int **ippमेरे लिए काफी सहज लगता है। इसका मतलब है, मैं **ippएक बना रहा हूँ int। कौन सा सही है।

— isaहिसा isa

@ user54609 अर्थ और व्यक्तिगत अंतरंगता इसके अलावा, इस पर विचार करें: का प्रकार ippहै int**, इसलिए केवल int**जादुई के बजाय लिखें " impdereference एक int" समझ है ।

— मनु ३४३ Man२६

Answer 1

सूचक उपमा के बारे में एक सेकंड के लिए भूल जाइए। क्या एक सूचक वास्तव में होता है एक स्मृति पता है। &ऑपरेटर "के पते" है - यानी यह एक वस्तु की स्मृति में पता देता है। *ऑपरेटर आप वस्तु देता है एक सूचक के लिए, एक सूचक एक पते युक्त दिया अर्थात् संदर्भित करता है, यह है कि स्मृति पते पर वस्तु देता है। इसलिए जब आप ऐसा करते हैं *ipp = ip2, तो आप जो कर रहे हैं, वह *ippउस पते पर मौजूद वस्तु को प्राप्त ippहोता है , जिसमें वह होता है ip1और फिर ip1संग्रहीत मान पर असाइन किया जाता है ip2, जिसका पता है j।

बस
& -> का पता
*-> मान

Comments

& * इतना आसान कभी नहीं था

— रे

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

— लुकास ए।

Answer 2

क्योंकि आपने उस मान को इंगित किया है जिसके द्वारा ippनहीं के मूल्य को बदल दिया है ipp। तो, ippअभी भी ip1(के मूल्य ipp) को इंगित करता है , ip1का मूल्य अब के मूल्य के समान है ip2, इसलिए वे दोनों को इंगित करते हैं j।

यह:

*ipp = ip2;

के समान है:

ip1 = ip2;

Comments

के बीच अंतर को इंगित करने के लायक हो सकता है int *ip1 = &iऔर *ipp = ip2;, यदि आप intपहले बयान से हटाते हैं तो असाइनमेंट बहुत समान दिखते हैं, लेकिन *दो मामलों में बहुत अलग है।

— क्राउन

Answer 3

सी टैग में सबसे शुरुआती सवालों की तरह, इस सवाल का जवाब पहले सिद्धांतों पर जाकर दिया जा सकता है:

• एक सूचक एक प्रकार का मूल्य है।
• एक चर में एक मान होता है।
• &ऑपरेटर एक सूचक में एक चर बदल जाता है।
• *ऑपरेटर एक चर में एक सूचक बदल जाता है।

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

तो हमारे पास चर हैं:

int i = 5, j = 6;
int *ip1 = &i, *ip2 = &j;

चर ip1 में एक सूचक होता है। &ऑपरेटर बदल जाता है iएक सूचक में और है कि सूचक मूल्य को सौंपा गया है ip1। तो ip1 शामिल करने के लिए एक सूचक i।

चर ip2 में एक सूचक होता है। &ऑपरेटर बदल जाता है jएक सूचक में और है कि सूचक को सौंपा गया है ip2। तो ip2 शामिल करने के लिए एक सूचक j।

int **ipp = &ip1;

चर ippमें एक सूचक होता है। &ऑपरेटर चर बदल जाता है ip1एक सूचक में और है कि सूचक मूल्य को सौंपा गया है ipp। तो ippएक सूचक होता है ip1।

आइए अब तक की कहानी समेटते हैं:

• i 5 शामिल हैं
• j 6 होते हैं
• ip1इसमें "सूचक i" होता है
• ip2इसमें "सूचक j" होता है
• ippइसमें "सूचक ip1" होता है

अब हम कहते हैं

*ipp = ip2;

*ऑपरेटर एक चर में एक सूचक वापस बदल जाता है। हम इसका मान प्राप्त करते हैं ipp, जो "सूचक है ip1और इसे एक चर में बदल देता है। ip1निश्चित रूप से क्या चर है?"

इसलिए यह कहने का एक और तरीका है

ip1 = ip2;

इसलिए हम इसका मूल्य प्राप्त करते हैं ip2। यह क्या है? "सूचक j"। हम उस पॉइंटर मान को असाइन करते हैं ip1, इसलिए ip1अब "पॉइंटर टू j" है

हमने केवल एक चीज़ बदली: मूल्य ip1:

• i 5 शामिल हैं
• j 6 होते हैं
• ip1इसमें "सूचक j" होता है
• ip2इसमें "सूचक j" होता है
• ippइसमें "सूचक ip1" होता है

क्यों ippअभी भी इंगित करता है ip1और नहीं ip2?

जब आप इसे असाइन करते हैं तो एक परिवर्तनशील परिवर्तन होता है। असाइनमेंट की गणना करें; वहाँ परिवर्तन से अधिक परिवर्तन नहीं हो सकता है वहाँ कार्य कर रहे हैं! आप निर्दिष्ट करने के द्वारा शुरू i, j, ip1, ip2और ipp। आप तब असाइन करते हैं *ipp, जैसा कि हमने देखा है कि इसका अर्थ "असाइन ip1" करना है। चूंकि आपने ippदूसरी बार असाइन नहीं किया था , इसलिए यह नहीं बदला!

यदि आप बदलना चाहते हैं ippतो आपको वास्तव में असाइन करना होगा ipp:

ipp = &ip2;

उदाहरण के लिए।

Answer 4

उम्मीद है कि इस कोड का टुकड़ा मदद कर सकता है।

#include <iostream>
#include <stdio.h>
using namespace std;

int main()
{
    int i = 5, j = 6, k = 7;
    int *ip1 = &i, *ip2 = &j;
    int** ipp = &ip1;
    printf("address of value i: %p\n", &i);
    printf("address of value j: %p\n", &j);
    printf("value ip1: %p\n", ip1);
    printf("value ip2: %p\n", ip2);
    printf("value ipp: %p\n", ipp);
    printf("address value of ipp: %p\n", *ipp);
    printf("value of address value of ipp: %d\n", **ipp);
    *ipp = ip2;
    printf("value ipp: %p\n", ipp);
    printf("address value of ipp: %p\n", *ipp);
    printf("value of address value of ipp: %d\n", **ipp);
}

यह आउटपुट:

Answer 5

मेरी बहुत ही निजी राय है कि तीर के साथ तस्वीरें इस तरह से इशारा करती हैं या जो संकेत को समझने में कठिन बनाती हैं। यह उन्हें कुछ सार, रहस्यमय संस्थाओं की तरह लगता है। वो नहीं हैं।

आपके कंप्यूटर में सब कुछ की तरह, संकेत संख्या हैं । "पॉइंटर" नाम केवल कहने का एक फैंसी तरीका है "एक वैरिएबल जिसमें एक पता है"।

इसलिए, मुझे समझाएं कि कंप्यूटर वास्तव में कैसे काम करता है।

हमारे पास एक है int, इसका नाम iऔर मूल्य है 5. यह मेमोरी में संग्रहीत है। स्मृति में संग्रहीत सब कुछ की तरह, इसे एक पते की आवश्यकता होती है, या हम इसे खोजने में सक्षम नहीं होंगे। कहते हैं की सुविधा देता है iपता 0x12345678 पर समाप्त होता है और उसके साथी jऊपर मूल्य के साथ 6 समाप्त होता है बस इसे बाद। एक 32-बिट CPU को मान लें जहां int 4 बाइट्स है और पॉइंटर्स 4 बाइट्स हैं, तो इसके बाद वैरिएबल को भौतिक मेमोरी में संग्रहीत किया जाता है:

Address     Data           Meaning
0x12345678  00 00 00 05    // The variable i
0x1234567C  00 00 00 06    // The variable j

अब हम इन चरों पर इशारा करना चाहते हैं। हम एक सूचक को int int* ip1और एक को बनाते हैं int* ip2। कंप्यूटर में सब कुछ की तरह, ये पॉइंटर वैरिएबल मेमोरी में भी कहीं आवंटित किए जाते हैं। मान लें कि वे स्मृति में अगले आसन्न पते पर, तुरंत बाद समाप्त होते हैं j। हम पहले से आवंटित चर के पतों को समाहित करने के लिए संकेत निर्धारित करते हैं: ip1=&i;("आई 1 के पते की प्रतिलिपि ip1 में") और ip2=&j। लाइनों के बीच क्या होता है:

Address     Data           Meaning
0x12345680  12 34 56 78    // The variable ip1(equal to address of i)
0x12345684  12 34 56 7C    // The variable ip2(equal to address of j)

तो हमें जो मिला वो था अभी तक कुछ 4 बाइट की मेमोरी वाले नंबर। कहीं भी कोई रहस्यमय या जादुई तीर नहीं है।

वास्तव में, बस एक मेमोरी डंप को देखकर, हम यह नहीं बता सकते हैं कि पता 0x12345680 में एक है intया नहीं int*। अंतर यह है कि हमारा कार्यक्रम इस पते पर संग्रहीत सामग्री का उपयोग कैसे करता है। (हमारे कार्यक्रम का कार्य वास्तव में केवल सीपीयू को यह बताना है कि इन नंबरों का क्या करना है।)

फिर हम अप्रत्यक्ष के एक और स्तर के साथ जोड़ते हैं int** ipp = &ip1;। फिर, हमें बस स्मृति का एक हिस्सा मिलता है:

Address     Data           Meaning
0x12345688  12 34 56 80    // The variable ipp

पैटर्न परिचित लगता है। फिर भी एक नंबर वाले 4 बाइट्स का एक और हिस्सा।

अब, यदि हमारे पास उपरोक्त काल्पनिक छोटी रैम की मेमोरी डंप है, तो हम मैन्युअल रूप से जांच सकते हैं कि ये पॉइंटर्स कहां हैं। हम ippचर के पते पर क्या संग्रहीत है, इस पर झांकते हैं और सामग्री 0x12345680 पाते हैं। जो निश्चित रूप से पता है जहां ip1संग्रहीत है। हम उस पते पर जा सकते हैं, वहां की सामग्रियों की जांच कर सकते हैं, और उस पते का पता iलगा सकते हैं, और फिर अंत में हम उस पते पर जा सकते हैं और 5 नंबर का पता लगा सकते हैं।

इसलिए यदि हम ipp की सामग्री लेते हैं *ipp, तो हम पॉइंटर चर का पता प्राप्त करेंगे ip1। लिखकर *ipp=ip2हम ip2 को ip1 में कॉपी करते हैं, यह इसके बराबर है ip1=ip2। किसी भी स्थिति में हमें मिलेगा

Address     Data           Meaning
0x12345680  12 34 56 7C    // The variable ip1
0x12345684  12 34 56 7C    // The variable ip2

---

(ये उदाहरण एक बड़े एंडियन सीपीयू के लिए दिए गए थे)

Comments

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

— एरिक लिपर्ट

@EricLippert मुझे लगता है कि कोई भी वास्तविक स्मृति पते या डेटा ब्लॉक का उपयोग करके इस उदाहरण को अधिक सार बना सकता है। यदि यह एक तालिका थी, location, value, variableजहां कुछ ऐसा स्थान था , जहां स्थान 1,2,3,4,5और मूल्य था A,1,B,C,3, तो संकेत के संबंधित विचार को तीरों के उपयोग के बिना आसानी से समझाया जा सकता है, जो स्वाभाविक रूप से भ्रमित हैं। जो कुछ भी कार्यान्वयन के साथ चुनता है, कुछ स्थान पर एक मूल्य मौजूद है, और यह पहेली का टुकड़ा है जो तीर के साथ मॉडलिंग करते समय बाधक बन जाता है।

— दर्पण

@EricLippert मेरे अनुभव में, ज्यादातर सी-प्रोग्रामर होंगे जिन्हें समस्या को समझने में समस्या होती है, वे हैं जिन्हें सार, कृत्रिम मॉडल खिलाया गया था। अमूर्तता सहायक नहीं है, क्योंकि आज सी भाषा का पूरा उद्देश्य, यह हार्डवेयर के करीब है। यदि आप C सीख रहे हैं, लेकिन हार्डवेयर के करीब कोड लिखने का इरादा नहीं है, तो आप अपना समय बर्बाद कर रहे हैं । यदि आप कंप्यूटर काम करना नहीं चाहते हैं, तो जावा आदि एक बेहतर विकल्प है, लेकिन उच्च स्तरीय प्रोग्रामिंग करें।

— लंडिन

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

— लंडिन

@ लुंडिन: मैं तीर आरेखों का एक बड़ा प्रशंसक नहीं हूं; डेटा के रूप में एक तीर की धारणा एक मुश्किल है। मैं इसे अमूर्त रूप से सोचना पसंद करता हूं लेकिन तीर के बिना। &एक चर पर ऑपरेटर आप एक सिक्का है कि चर का प्रतिनिधित्व करता है देता है। *कि सिक्के पर ऑपरेटर आप चर वापस देता है। कोई तीर आवश्यक नहीं!

— एरिक लिपर्ट

Answer 6

असाइनमेंट पर ध्यान दें:

ipp = &ip1;

ippइंगित करने के लिए परिणाम ip1।

इतना के लिए ippबात करने के लिए करने के लिए ip2, हम समान तरीके से बदलना चाहिए,

ipp = &ip2;

जो हम स्पष्ट रूप से नहीं कर रहे हैं। इसके बजाय हम द्वारा बताए गए पते पर मूल्य बदल रहे हैं ipp।
फोलिंग करके

*ipp = ip2;

हम बस में संग्रहीत मूल्य की जगह ले रहे हैं ip1।

ipp = &ip1, का अर्थ है *ipp = ip1 = &i,
अब *ipp = ip2 = &j,।
तो, *ipp = ip2अनिवार्य रूप से के रूप में ही है ip1 = ip2।

Answer 7

ipp = &ip1;

बाद के किसी भी असाइनमेंट ने मान को नहीं बदला है ipp। यही कारण है कि यह अभी भी इंगित करता हैip1 ।

आप के साथ क्या करते हैं *ipp, यानी, ip1उस तथ्य को नहीं बदलता है जो ippइंगित करता है ip1।

Answer 8

मेरा सवाल है: दूसरी तस्वीर में, ipp अभी भी IP1 को इंगित करता है, लेकिन ip2 को नहीं?

आपने अच्छी तस्वीरें रखीं, मैं अच्छी आस्की कला बनाने की कोशिश करने जा रहा हूँ:

जैसे @ रॉबर्ट-एस-बार्न्स ने अपने जवाब में कहा: पॉइंटर्स के बारे में भूल जाओ , और जो इंगित करता है, लेकिन स्मृति के संदर्भ में सोचें। मूल रूप से, int*इसका मतलब है कि इसमें एक चर int**का पता होता है और इसमें एक चर का पता होता है जिसमें एक चर का पता होता है। तब आप मान या पते तक पहुँचने के लिए पॉइंटर के बीजगणित का उपयोग कर सकते हैं: &fooसाधन address of foo, और *fooसाधन value of the address contained in foo।

तो, जैसा कि संकेत स्मृति से निपटने के बारे में है, वास्तव में उस "मूर्त" बनाने का सबसे अच्छा तरीका यह दिखाना है कि संकेत बीजगणित स्मृति को क्या करता है।

तो, यहाँ आपके प्रोग्राम की मेमोरी (उदाहरण के उद्देश्य के लिए सरलीकृत) है:

name:    i   j ip1 ip2 ipp
addr:    0   1   2   3   4
mem : [   |   |   |   |   ]

जब आप अपना प्रारंभिक कोड करते हैं:

int i = 5, j = 6;
int *ip1 = &i, *ip2 = &j;

यहाँ आपकी स्मृति कैसी दिखती है:

name:    i   j ip1 ip2
addr:    0   1   2   3
mem : [  5|  6|  0|  1]

तुम वहाँ देख सकते हैं ip1और ip2के पते हो जाता है iऔर jऔरipp अभी भी मौजूद है नहीं करता है। यह मत भूलो कि पते केवल एक विशेष प्रकार के साथ संग्रहीत पूर्णांक हैं।

तब आप घोषणा करते हैं और ippइस तरह परिभाषित करते हैं:

int **ipp = &ip1;

तो यहाँ आपकी स्मृति है:

name:    i   j ip1 ip2 ipp
addr:    0   1   2   3   4
mem : [  5|  6|  0|  1|  2]

और फिर, आपके द्वारा संग्रहीत पते से बताए गए मान को बदल रहे हैं ipp, जो इस पते पर संग्रहीत है ip1:

*ipp = ip2;

कार्यक्रम की मेमोरी है

name:    i   j ip1 ip2 ipp
addr:    0   1   2   3   4
mem : [  5|  6|  1|  1|  2]

NB: जैसा int*कि एक विशेष प्रकार है, मैं हमेशा एक ही लाइन पर कई पॉइंटर्स घोषित करने से बचना पसंद करता हूं, जैसा कि मुझे लगता है कि int *x;याint *x, *y; अंकन को गुमराह किया जा सकता है। मैं लिखना पसंद करता हूंint* x; int* y;

HTH

Comments

आपके उदाहरण के साथ, प्रारंभिक मूल्य नहीं ip2होना चाहिए । 34

— Dipto

ओह, मैंने सिर्फ मेमोरी को बदल दिया है इसलिए यह घोषणा के क्रम से मेल खाता है। मुझे लगता है कि मैंने तय किया है कि ऐसा कर रहे हैं?

— zmo

Answer 9

क्योंकि जब आप कहेंगे

*ipp = ip2

आप ippस्मृति की दिशा इंगित करने के लिए ' द्वारा इंगित की गई वस्तु' कह रहे हैं जो ip2इंगित कर रही है।

तुम ippइशारा नहीं कर रहे हो ip2।

Answer 10

यदि आप *पॉइंटर ऑपरेटर को पॉइंटर में जोड़ते हैं , तो आप पॉइंटर से पॉइंटेड ऑब्जेक्ट पर रीडायरेक्ट करते हैं।

उदाहरण:

int i = 0;
int *p = &i; // <-- N.B. the pointer declaration also uses the `*`
             //     it's not the dereference operator in this context
*p;          // <-- this expression uses the pointed-to object, that is `i`
p;           // <-- this expression uses the pointer object itself, that is `p`

इसलिए:

*ipp = ip2; // <-- you change the pointer `ipp` points to, not `ipp` itself
            //     therefore, `ipp` still points to `ip1` afterwards.

Answer 11

यदि आप ippइंगित करना चाहते हैं ip2, तो आपको कहना होगा ipp = &ip2;। हालाँकि, यह ip1अभी भी इंगित करता है i।

Answer 12

बहुत शुरुआत की आपने,

ipp = &ip1;

अब इसे इस रूप में देखें,

*ipp = *&ip1 // Here *& becomes 1  
*ipp = ip1   // Hence proved 

Answer 13

प्रत्येक चर को इस तरह दर्शाया जाता है:

type  : (name, adress, value)

इसलिए आपके चरों का प्रतिनिधित्व इस तरह किया जाना चाहिए

int   : ( i ,  &i , 5 ); ( j ,  &j ,  6); ( k ,  &k , 5 )

int*  : (ip1, &ip1, &i); (ip1, &ip1, &j)

int** : (ipp, &ipp, &ip1)

के मान के रूप में ippहै &ip1तो inctruction:

*ipp = ip2;

addess पर मूल्य में परिवर्तन &ip1के मूल्य के ip2जो साधन, ip1बदल गई है:

(ip1, &ip1, &i) -> (ip1, &ip1, &j)

लेकिन फिर ippभी:

(ipp, &ipp, &ip1)

तो फिर ippभी &ip1इसका मतलब है कि यह अभी भी इंगित करता है ip1।

Answer 14

क्योंकि आप का पॉइंटर बदल रहा है *ipp। इसका मतलब

1. ipp (परिवर्तनीय नाम) ---- अंदर जाएं।
2. अंदर ippका पता हैip1 ।
3. अब *ippतो (अंदर के) में जाओ ip1।

अब हम पर हैं ip1। *ipp(यानी ip1) = ip2.
ip2सम्‍मिलित पते j.so ip1सामग्री को ip2 (यानी j का पता) से बदल दिया जाएगा, हम परिवर्तनशील नहीं हैं ipp। बस।

Answer 15

*ipp = ip2; का तात्पर्य:

ip2द्वारा इंगित चर को निरुपित करें ipp। तो यह इसके बराबर है:

ip1 = ip2;

यदि आप चाहते हैं कि पते में ip2संग्रहित किया जाए ipp, तो बस यह करें:

ipp = &ip2;

अब ippइशारा करता है ip2।

Answer 16

ipp( पॉइंटर टू पॉइंट ) पॉइंटर टू पॉइंटर टाइप ऑब्जेक्ट का मान रख सकते हैं । जब तुम करोगे

ipp = &ip2;  

तब चर (पॉइंटर)ipp का पताip2 होता है , जो कि पॉइंटर को पॉइंटर&ip2 के प्रकार का होता है । अब दूसरी तस्वीर का तीर इंगित करेगाippip2 ।

विकी का कहना है: ऑपरेटर एक भिन्नता ऑपरेटर सूचक चर पर चल रही है, और एक रिटर्न एल-मूल्य
* (चर) सूचक पते पर मूल्य के बराबर है। इसे पॉइंटर को सूचक कहा जाता है।

टाइप करने के लिए सूचक के L- मान के लिए इसे derefrence *पर ऑपरेटर को लागू करना । Dereferenced l- मूल्य टाइप पॉइंटर से है , यह एक प्रकार के डेटा का पता रख सकता है । बयान के बाद ippint*ippintint

ipp = &ip1;

ippका पता पकड़ रहा है ip1और *ipp(का इशारा करते हुए) का पता पकड़ रहा है i। आप कह सकते हैं कि *ippएक उपनाम है ip1। दोनों **ippऔर के *ip1लिए अन्य नाम हैं i।
ऐसा करके

 *ipp = ip2;  

*ippऔर ip2दोनों एक ही स्थान की ippओर इशारा करते हैं लेकिन फिर भी इशारा करते हैंip1 ।

*ipp = ip2;वास्तव में क्या होता है कि यह दोनों बिंदुओं को बनाने और एक ही वस्तु ( ) की ओर इशारा करते हुए ip2(के पते के रूप में j) ip1(के *ippलिए एक उपनाम के रूप में ) की सामग्री को कॉपी करता है । इसलिए, दूसरे आंकड़े में, का तीर और इंगित कर रहा है जबकि अभी भी इंगित कर रहा है क्योंकि के मूल्य को बदलने के लिए कोई संशोधन नहीं किया गया है ।ip1ip1ip2j
ip1ip2jippip1ipp