C/C++ में झूलना, शून्य, शून्य और जंगली सूचक

डैंगलिंग पॉइंटर

डैंगलिंग पॉइंटर एक मेमोरी लोकेशन की ओर इशारा करने वाला एक पॉइंटर है जिसे मुक्त (या हटा दिया गया) कर दिया गया है। ऐसे कई तरीके हैं जहां पॉइंटर लटकने वाले सूचक के रूप में कार्य करता है

फ़ंक्शन कॉल

जब स्थानीय चर स्थिर नहीं होता है तो स्थानीय चर की ओर इशारा करने वाला सूचक लटक जाता है।

int *show(void) {
   int n = 76; /* ... */ return &n;
}

आउटपुट

Output of this program will be garbage address.

स्मृति का आवंटन रद्द करना

#include <stdlib.h> #include <stdio.h> int main() {
   float *p = (float *)malloc(sizeof(float));
   //dynamic memory allocation. free(p);
   //after calling free() p becomes a dangling pointer p = NULL;
   //now p no more a dangling pointer.
}

वेरिएबल का दायरा खत्म हो गया है

int main() {
   int *p //some code// {
      int c; p=&c;
   }
   //some code//
   //p is dangling pointer here.
}

शून्य सूचक

सी में शून्य सूचक एक सूचक है जो किसी भी डेटा प्रकार से संबद्ध नहीं है। यह स्टोरेज में कुछ डेटा लोकेशन की ओर इशारा करता है यानी वेरिएबल्स के एड्रेस की ओर इशारा करता है। इसे सामान्य प्रयोजन सूचक भी कहा जाता है।

इसकी कुछ सीमाएँ हैं

इसके ठोस आकार के कारण शून्य सूचक का सूचक अंकगणित संभव नहीं है।

इसे संदर्भित के रूप में उपयोग नहीं किया जा सकता है।

यहां एक सरल उदाहरण दिया गया है

#include<stdlib.h>
int main() {
   int a = 7;
   float b = 7.6;
   void *p;
   p = &a;
      printf("Integer variable is = %d", *( (int*) p) );
   p = &b;
   printf("\nFloat variable is = %f", *( (float*) p) );
   return 0;
}

आउटपुट

Integer variable is = 7
Float variable is = 7.600000

एल्गोरिदम

Begin
   Initialize a variable a with integer value and variable b with float value.
   Declare a void pointer p.
   (int*)p = type casting of void.
   p = &b mean void pointer p is now float.
   (float*)p = type casting of void.
   Print the value.
End.

नल पॉइंटर

नल पॉइंटर एक पॉइंटर है जो कुछ भी इंगित नहीं करता है। नल पॉइंटर के कुछ उपयोग हैं:

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

यदि हम कोई मान्य मेमोरी एड्रेस पास नहीं करना चाहते हैं, तो फ़ंक्शन तर्क के लिए एक नल पॉइंटर पास करने के लिए।

किसी भी पॉइंटर वेरिएबल को एक्सेस करने से पहले नल पॉइंटर की जांच करने के लिए। ताकि, हम पॉइंटर से संबंधित कोड में एरर हैंडलिंग कर सकें। डीरेफरेंस पॉइंटर वेरिएबल तभी होता है जब वह NULL न हो।

उदाहरण

#include<iostream>
#include <stdio.h>
int main() {
   int *p= NULL;//initialize the pointer as null.
   printf("The value of pointer is %u",p);
   return 0;
}

आउटपुट

The value of pointer is 0.

जंगली सूचक

वाइल्ड पॉइंटर्स ऐसे पॉइंटर्स होते हैं जो कुछ मनमानी मेमोरी लोकेशन की ओर इशारा करते हैं। (न्यूल भी नहीं)

int main() {
   int *ptr; //wild pointer
   *ptr = 5;
}