C भाषा में, Pointer एक वेरिएबल होता है जो दूसरी वेरिएबल का मेमोरी एड्रेस संदर्भित करता है। Pointer एक वेरिएबल होता है जो किसी वेरिएबल के मेमोरी एड्रेस को रखता है। Pointer को एक इंटीजर, फ्लोट, डबल, या किसी अन्य डेटा टाइप के साथ जोड़ा जा सकता है, लेकिन पॉइंटर अपने आप में डेटा नहीं होता।
जैसा कि आप जानते हैं, प्रत्येक वेरिएबल एक मेमोरी लोकेशन है और हर मेमोरी लोकेशन का अपना पता परिभाषित होता है जिसे एम्परसेंड (&) ऑपरेटर का उपयोग करके एक्सेस किया जा सकता है, जो मेमोरी में एक एड्रेस को दर्शाता है।
उदाहरण के लिए, यदि "x" एक इंटीजर वेरिएबल है जो मेमोरी एड्रेस 1000 पर संदर्भित होता है, तो "int *ptr" एक पॉइंटर होगा जो "x" के मेमोरी एड्रेस को संदर्भित करता है। इसका उपयोग करके, हम "x" के मान को "ptr" के माध्यम से भी प्राप्त कर सकते हैं।
इस प्रकार का कोड निम्नलिखित रूप से लिखा जा सकता है:
int x = 10;
int *ptr = &x; // ptr now holds the memory address of x
printf("Value of x is: %d\n", x);
printf("Value of x using pointer is: %d\n", *ptr); // accessing the value of x using pointer
printf("Address of x variable: %x\n", &ptr );
इस कोड के आउटपुट में, "Value of x is: 10" और "Value of x using pointer is: 10" और "Address of x variable: 1000 होगा। क्योकि उपर मेमोरी एड्रेस 1000 पर माना है।
Pointer का declaration करना
C भाषा में Pointer को डिक्लेअर करने के लिए अक्सर अस्तरिस्क () उपयोग किया जाता है। इसका संकेत देने के लिए अस्तरिस्क () पॉइंटर वेरिएबल के नाम के आगे लगाया जाता है। निम्नलिखित सिंटैक्स का उपयोग करके, आप C भाषा में पॉइंटर को डिक्लेअर कर सकते हैं:
<data_type> *<pointer_name>;
यहां, <data_type> पॉइंटर द्वारा संदर्भित होने वाली वेरिएबल के डेटा टाइप को निर्दिष्ट करता है और <pointer_name> पॉइंटर वेरिएबल का नाम होता है। उदाहरण के लिए, यदि आप एक इंटीजर पॉइंटर बनाना चाहते हैं जो एक इंटीजर वेरिएबल के संदर्भ में होगा, तो निम्नलिखित ढंग से डिक्लेअर किया जा सकता है:
int *ptr;
उदाहरण
int main() {
int x = 10; // integer variable
int *ptr; // integer pointer declaration
ptr = &x; // store address of x in pointer variable
printf("Value of x: %d\n", x); // output: 10
printf("Address of x: %p\n", &x); // output: some memory address
printf("Value of ptr: %p\n", ptr); // output: address of x
printf("Value stored at ptr: %d\n", *ptr); // output: value of x
return 0;
}
इसका उपयोग करके, आप पॉइंटर वेरिएबल के माध्यम से वेरिएबल के मान तक पहुंच सकते है।
Pointer का उपयोग
C भाषा में पॉइंटर का उपयोग करने के लिए, पहले पॉइंटर को वेरिएबल के एड्रेस से इनिशियलाइज़ किया जाना चाहिए। इसके बाद, आप पॉइंटर वेरिएबल को इस वेरिएबल के मान तक पहुंचने के लिए इस्तेमाल कर सकते हैं।
यदि पॉइंटर वेरिएबल पर उनके संदर्भ में होने वाले डेटा को लिखना है, तो आप इस्तेमाल कर सकते हैं:
*<pointer_name> = <value>;
यहां, <pointer_name> पॉइंटर वेरिएबल का नाम होता है और <value> जो आप उस वेरिएबल में लिखना चाहते हैं।
उदाहरण के लिए, यदि आप एक इंटीजर पॉइंटर बनाएं हैं जो एक इंटीजर वेरिएबल को संदर्भित करता है, तो आप उस वेरिएबल में डेटा लिखने के लिए निम्नलिखित सिंटैक्स का उपयोग कर सकते हैं:
int *ptr;
int x = 10;
ptr = &x; // store address of x in pointer variable
*ptr = 20; // change value of x to 20 through pointer variable
printf("Value of x: %d\n", x); // output: 20
यदि पॉइंटर वेरिएबल के माध्यम से वेरिएबल के मान को पढ़ना है, तो आप इस्तेमाल कर सकते हैं:
<value> = *<pointer_name>;
यहां, <pointer_name> पॉइंटर वेरिएबल का नाम होता है।
NULL pointer
C भाषा में, NULL pointer एक ऐसा pointer होता है जो कोई भी मान या एड्रेस नहीं संदर्भित करता है। इसका मतलब है कि NULL pointer एक खाली pointer होता है जो कोई भी वेरिएबल या ऑब्जेक्ट को संदर्भित नहीं करता है।
NULL pointer का मान सामान्य रूप से 0 होता है, लेकिन यह बेहतर होता है कि आप NULL पॉइंटर को संदर्भित करने के लिए सिर्फ NULL का उपयोग करें।
आप एक pointer वेरिएबल को NULL pointer से इनिशियलाइज़ कर सकते हैं जैसे निम्नलिखित उदाहरण में दिखाया गया है:
int *ptr = NULL;
इस तरह से, ptr एक NULL pointer होगा जो कोई वेरिएबल संदर्भित नहीं करता है।
एक NULL pointer को उनके संदर्भ में डेटा के लिए इस्तेमाल नहीं किया जा सकता है। यहां कुछ उदाहरण हैं जहां NULL pointer को उपयोग किया जा सकता है:
- Pointer को संदर्भित करने से पहले उसके मान को NULL से सेट करना।
- Pointer को एक फ़ंक्शन में भेजने से पहले उसके मान को NULL से सेट करना।
- Pointer को संदर्भित करने के बाद उसके मान को NULL से सेट करना, जिससे कि वह इस्तेमाल नहीं किया जा सकता।
Pointer arithmetic
C भाषा में Pointer Arithmetic का मतलब होता है कि pointer variables के वैद्यता पर आधारित arithmetic operations का उपयोग करके उनके मानों को बदलना। Pointer arithmetic में, एक pointer variable के द्वारा संदर्भित ऑब्जेक्ट के आगे या पीछे मूल्यों को बदला जाता है।
Pointer arithmetic का उपयोग इसलिए किया जाता है क्योंकि pointers बाइट या वर्ड ऑफसेट के लिए उपयोग किए जा सकते हैं। यदि ptr एक int pointer होता है, तो ptr++ एक int के आगे pointer को दर्शाता है। यदि ptr एक char pointer होता है, तो ptr++ एक char के आगे pointer को दर्शाता है।
Pointer Arithmetic के उदाहरण हैं:
int arr[5] = {10, 20, 30, 40, 50};
int *ptr = &arr[0];
// Increment pointer to point to next element
ptr++;
// Decrement pointer to point to previous element
ptr--;
// Access the value of the element pointer is pointing to
int x = *ptr;
// Add an integer to the pointer
ptr = ptr + 2;
// Subtract an integer from the pointer
ptr = ptr - 1;
यहां, ptr pointer variable arr[0] को संदर्भित करता है और pointer arithmetic का उपयोग करके उसे अन्य मानों के साथ संदर्भित करता है।
Ppointer का increment/Decrement
C भाषा में, pointer के increment या decrement को Pointer Arithmetic के माध्यम से किया जाता है।
Pointer increment का मतलब होता है कि pointer variable को उस ऑब्जेक्ट के आगे एक step आगे ले जाना। एक pointer variable को increment करने के लिए, इसके वर्तमान मान में pointer के विशिष्ट आकार के बाईं ओर का फील्ड के अगले मान के लिए pointer variable को बदला जाता है।
इसी तरह, pointer decrement का मतलब होता है कि pointer variable को उस ऑब्जेक्ट के पीछे एक step ले जाना है।
Pointer increment और decrement के उदाहरण निम्नलिखित हैं:
int arr[5] = {10, 20, 30, 40, 50};
int *ptr = &arr[0];
// increment pointer by one
ptr++;
// decrement pointer by one
ptr--;
// increment pointer by two
ptr += 2;
// decrement pointer by two
ptr -= 2;
यहां, ptr pointer variable arr[0] को संदर्भित करता है और Pointer Arithmetic का उपयोग करके pointer को अन्य मानों के साथ संदर्भित करता है।
C भाषा में Pointer Comparisons
C भाषा में, pointers के साथ तुलनाएँ (comparisons) किए जा सकते हैं। दो pointers को तुलना करने के लिए अलमारी तुलना अधिकारियों (comparison operators) (==, !=, <, >, <=, >=) का उपयोग किया जाता है।
Pointer comparisons में, तुलनाएँ pointer addresses पर आधारित होती हैं। जब दो pointers के addresses एक दूसरे से बड़े होते हैं, तो एक pointer दूसरे pointer से बड़ा होता है। अगर दो pointers के addresses बराबर होते हैं, तो वे समान होते हैं। इसी तरह, अगर एक pointer का address दूसरे pointer के address से कम होता है, तो एक pointer दूसरे pointer से छोटा होता है।
इस तरह, pointer comparisons के उदाहरण निम्नलिखित हैं:
int arr[5] = {10, 20, 30, 40, 50};
int *ptr1 = &arr[0];
int *ptr2 = &arr[3];
// compare two pointers
if (ptr1 == ptr2) {
printf("ptr1 and ptr2 are equal\n");
} else if (ptr1 < ptr2) {
printf("ptr1 is less than ptr2\n");
} else {
printf("ptr1 is greater than ptr2\n");
}
यहां, ptr1 और ptr2 pointers तुलनाएँ करते हुए comparison operators का उपयोग किया जाता है।
Pointer Asthmatic, comparisons का उदाहरण
एक उदाहरण के माध्यम से pointer arithmetic, comparisons, increment और decrement का समझना बेहद सरल होता है। निम्नलिखित कोड देखें:
#include <stdio.h>
int main() {
int arr[5] = {10, 20, 30, 40, 50};
int *ptr = arr; // initialize pointer to the first element of the array
// printing the array using pointer arithmetic
printf("Printing array using pointer arithmetic:\n");
for (int i = 0; i < 5; i++) {
printf("arr[%d] = %d\n", i, *(ptr + i));
}
// comparing two pointers
int *ptr1 = &arr[0];
int *ptr2 = &arr[3];
if (ptr1 == ptr2) {
printf("ptr1 and ptr2 are equal\n");
} else if (ptr1 < ptr2) {
printf("ptr1 is less than ptr2\n");
} else {
printf("ptr1 is greater than ptr2\n");
}
// incrementing and decrementing pointers
printf("Printing array using pointer increment:\n");
while (ptr <= &arr[4]) {
printf("Value: %d, Address: %p\n", *ptr, ptr);
ptr++;
}
printf("Printing array using pointer decrement:\n");
ptr--;
while (ptr >= arr) {
printf("Value: %d, Address: %p\n", *ptr, ptr);
ptr--;
}
return 0;
}
इस कोड में, पहले हम एक array arr बनाते हैं और उसे initialize करते हैं। फिर हम एक pointer ptr को arr के पहले एलीमेंट से initialize करते हैं।
इसके बाद, हम pointer arithmetic का उपयोग करके arr एरे के सभी एलिमेंट्स को print करते हैं। *(ptr + i) अभिव्यक्ति द्वारा, हम pointer ptr को इतर pointer से offset करते हुए अर्रे के अलग-अलग एलिमेंट पहुंचते हैं।
इसके बाद, हम दो pointers ptr1 और ptr2 को तुलना करते हैं। हम comparison operators का उपयोग करते हैं ताकि हम दो pointers को तुलना कर सकें।
अंत में, हम pointer को increment और decrement करते हुए उपयोग करते है।
Array of pointer
C भाषा में, एक array एक pointer की तरह काम करता है। इसका मतलब है कि एक array का पहला एलिमेंट एक pointer के रूप में दर्शाया जा सकता है।
जैसे कि, निम्नलिखित कोड में, हम एक एरे arr को बनाते हैं और उसे initialize करते हैं:
int arr[5] = {10, 20, 30, 40, 50};
इसके बाद, हम एक pointer ptr को arr के पहले एलिमेंट से initialize करते हैं:
int *ptr = &arr[0];
यहां &arr[0] एक pointer है जो arr एरे के पहले एलिमेंट को दर्शाता है। हम इस pointer को ptr में store करते हैं।
इसके बाद, हम pointer arithmetic का उपयोग करते हुए arr एरे के बाकी एलिमेंट्स को ptr के माध्यम से एक्सेस कर सकते हैं। निम्नलिखित कोड देखें:
for (int i = 0; i < 5; i++) {
printf("arr[%d] = %d\n", i, *(ptr + i));
}
इस कोड में, ptr pointer का पहला एलिमेंट arr[0] है। हम ptr pointer को i के साथ offset करते हुए, arr के अन्य एलिमेंट पहुंचते हैं। *(ptr + i) अभिव्यक्ति द्वारा, हम pointer ptr को इतर pointer से offset करते हुए अर्रे के अलग-अलग एलिमेंट पहुंचते हैं।
इस तरह, एक array एक pointer के रूप में काम करता है जो अपने पहले एलिमेंट को दर्शाता है।
Pointer to Pointer
C भाषा में, pointer भी pointers की तरह काम कर सकते हैं। इन्हें "Pointer to Pointer" या "Double Pointer" के नाम से जाना जाता है।
Pointer to Pointer एक variable होता है जो दूसरे pointer के address को store करता है। इसका एक उदाहरण निम्नलिखित है:
int a = 5;
int *ptr1 = &a;
int **ptr2 = &ptr1;
इस कोड में, a variable को 5 से initialize किया गया है। फिर ptr1 pointer को &a के साथ initialize किया गया है, जो a variable के address को दर्शाता है।
इसके बाद, एक और pointer ptr2 बनाया गया है, जो ptr1 pointer के address को store करता है। इस तरह, ptr2 pointer अब a variable के address को indirect करता है, जो ptr1 pointer के माध्यम से a variable के address को दर्शाता है।
Pointer to Pointer के जब हम pointer arithmetic का उपयोग करते हैं तो, हम ** operator का उपयोग करते हैं। निम्नलिखित कोड में, हम ptr2 pointer को उपयोग करके a variable को अपडेट करते हुए देख सकते हैं:
**ptr2 = 10;
printf("a = %d\n", a); // output: a = 10
इस उदाहरण में, **ptr2 अभिव्यक्ति द्वारा, हम a variable को update करते हैं। **ptr2 द्वारा, हम ptr2 pointer के address को indirect करते हुए ptr1 pointer के address को indirect करते हुए a variable के value को अपडेट करते हैं।
इस तरह, Pointer to Pointer उपयोग करते हुए, हम pointer को pointers की तरह काम करवा सकते हैं।
Passing pointers to functions
C भाषा में, pointer को function में argument के रूप में pass कर सकते हैं। Pointer को pass करने से, function को variable के address को पाने का मौका मिलता है जिससे उसके value को modify किया जा सकता है।
Pointer को function में pass करने के लिए, function definition में pointer का parameter declare किया जाता है। उदाहरण के लिए, निम्नलिखित कोड में, swap() function में x और y variables के addresses को pass किया गया है:
void swap(int *x, int *y) {
int temp = *x;
*x = *y;
*y = temp;
}
int main() {
int a = 10, b = 20;
swap(&a, &b);
printf("a = %d, b = %d", a, b); // output: a = 20, b = 10
return 0;
}
इस code में, swap() function definition में, int *x और int *y दो pointer arguments declare किए गए हैं। swap() function द्वारा, x और y pointers के माध्यम से, a और b variables के values को swap कर दिया जाता है।
main() function में, a और b variables को initialize किया जाता है। swap() function को &a और &b addresses के साथ call किया जाता है, जिससे swap() function के माध्यम से a और b variables के values को swap कर दिया जाता है।
इस तरह, pointer को function में pass करके, function को variable के address को पाने का मौका मिलता है जिससे variable को modify किया जा सकता है।
Return pointer from functions
C भाषा में, functions से pointer return करना संभव होता है। Pointer return करने से, function से प्राप्त करने वाले program को memory address मिलते हैं, जिसका program में उपयोग किया जा सकता है।
Pointer return करने के लिए, function definition में pointer type का return type declare किया जाता है। उदाहरण के लिए, निम्नलिखित कोड में, largest() function से maximum element के address को return किया गया है:
int* largest(int arr[], int size) {
int i;
int *max = &arr[0];
for (i = 1; i < size; i++) {
if (arr[i] > *max) {
max = &arr[i];
}
}
return max;
}
int main() {
int arr[] = { 10, 20, 30, 40, 50 };
int size = sizeof(arr)/sizeof(arr[0]);
int *p = largest(arr, size);
printf("Largest element is %d", *p); // output: Largest element is 50
return 0;
}
इस code में, largest() function definition में, int* return type declare किया गया है। largest() function द्वारा, arr array के element की value तुलना करते हुए, maximum element के address को max pointer में store किया जाता है।
main() function में, arr array को initialize किया जाता है। largest() function को arr array के साथ call किया जाता है, जिससे maximum element के address को p pointer में store कर लिया जाता है।
इस तरह, function से pointer return करके, function से प्राप्त करने वाले program को memory address मिलते हैं, जिसका program में उपयोग किया जा सकता है।
Pointers को functions में pass करने और return करने का उदाहरण
C भाषा में pointers को functions में pass करना और functions से pointers return करना एक अहम विषय है। इससे, functions में काम करते समय memory की efficiency बढ़ती है। निम्नलिखित कोड में, pointers को functions में pass करने और functions से pointers return करने के उदाहरण हैं:
#include <stdio.h>
#include <stdlib.h>
void swap(int *x, int *y) {
int temp = *x;
*x = *y;
*y = temp;
}
int *find_max(int arr[], int n) {
int i, *max = arr;
for (i = 1; i < n; i++) {
if (arr[i] > *max) {
max = &arr[i];
}
}
return max;
}
int main() {
int a = 10, b = 20;
int arr[] = {2, 4, 6, 8, 10};
int n = sizeof(arr)/sizeof(arr[0]);
int *max_ptr;
// Calling swap function
printf("Before swapping: a = %d, b = %d\n", a, b);
swap(&a, &b);
printf("After swapping: a = %d, b = %d\n", a, b);
// Calling find_max function
max_ptr = find_max(arr, n);
printf("Maximum element is: %d\n", *max_ptr);
return 0;
}
इस code में, swap() function definition में, int *x और int *y पॉइंटर प्रतीति को parameter के रूप में पास किया जाता है। swap() function को call करते समय, &a और &b pointers को argument के रूप में pass किया जाता है। जब swap() function call होता है, तो a और b के values के स्थानों पर pointer का use करके values को swap कर दिया जाता है।
इस code में, find_max() function definition में, int arr[] और int n को parameter के रूप में पास किया जाता है। find_max() function द्वारा arr array में सबसे बड़े element का address pointer max में संग्रहित किया जाता है। main() function में, arr array को initialize करके, find_max() function call किया जाता है।
Pointer का उदाहरण
एक उदाहरण के रूप में, हम एक बड़े साइज़ वाले एक एरे को कम साइज़ वाले एक नए एरे में कॉपी करना चाहते हैं। इसके लिए हम एक pointer का उपयोग करते हुए मूल एरे में से एक एक आइटम की जगह से दूसरे एरे में डालते हैं।
यहां एक उदाहरण दिया गया है:
#include <stdio.h>
void copy_array(int *arr1, int *arr2, int size) {
for (int i = 0; i < size; i++) {
*(arr2 + i) = *(arr1 + i);
}
}
int main() {
int arr1[] = {1, 2, 3, 4, 5};
int arr2[5];
copy_array(arr1, arr2, 5);
printf("Contents of arr2: ");
for (int i = 0; i < 5; i++) {
printf("%d ", *(arr2 + i));
}
return 0;
}
इस उदाहरण में, copy_array() function में हम arr1 और arr2 के pointers को pass करते हैं, जो एक-दूसरे के साथ कॉपी होते हैं। copy_array() function के भीतर हम एक for loop का उपयोग करते हुए arr1 से एक एक आइटम को लेकर arr2 में डालते हैं। इस तरह से, copy_array() function arr1 की सारी आइटम्स को arr2 में कॉपी करता है।
फिर main() function में, हम copy_array() function को call करते हैं और arr1 की सारी आइटम्स arr2 में कॉपी की जाती है। अंत में, हम arr2 की सारी आइटम्स को प्रिंट करते हैं।
