Pointers in Data Structure in Hindi – पॉइंटर क्या है?

Srajan
⏰ 7 min read

सिलेबस के अनुसार DATA STRUCTURES के सभी टॉपिक यहाँ देखें — बिल्कुल फ्री

Table of Contents

Pointers in Data Structure in Hindi – पॉइंटर क्या है?

Endless Horse – Find End? Play Game पॉइंटर और वेरिएबल के बीच संबंध का चित्र a (int variable) 10 पता (Address): 1000 p (int *pointer) 1000 पता (Address): 2000 इशारा करता है Pointer p के अंदर variable a का address (1000) रखा है
  • Pointer (पॉइंटर) एक ऐसा variable है जिसमें किसी दूसरे variable का memory address store होता है। C और C++ में data structure बनाने के लिए यह सबसे ज़रूरी चीज़ों में से एक है।
  • सरल शब्दों में pointer को समझें तो यह किसी locker की चाबी पर लिखे नंबर जैसा है। चाबी में सामान नहीं होता, उस पर सिर्फ यह लिखा होता है कि सामान किस locker में रखा है।
  • इसका इस्तेमाल memory को सीधे access करने, program चलते समय dynamic memory लेने और function को डाटा की कॉपी की जगह उसका address देने के लिए किया जाता है।
  • कंप्यूटर की memory byte-by-byte बँटी होती है और हर byte का एक अलग address होता है। Pointer के साथ यही address, उसका data type और & व * operators जुड़े रहते हैं।
  • Array, string, linked list, stack, queue, tree और graph जैसे लगभग हर data structure के implementation में pointer का उपयोग होता है।
  • C में compiler pointer की सही-गलत जाँच नहीं करता, इसलिए उसे सही ढंग से संभालने की पूरी ज़िम्मेदारी programmer की होती है।
  • इसका अंतिम लक्ष्य कम memory और कम समय में ऐसे flexible data structures बनाना है, जिनका size program चलते समय बदल सके।
  • सबसे आम चुनौती गलत address पर पहुँच जाना है, जिससे segmentation fault, dangling pointer और memory leak जैसी समस्याएँ आती हैं।

Example of Pointer (उदाहरण)

ट्रेन के टिकट पर सीट का नंबर लिखा होता है। टिकट खुद सीट नहीं है और उस पर यात्री भी नहीं बैठा होता, वह सिर्फ यह बताता है कि सीट कहाँ है। यहाँ टिकट pointer है, सीट वह variable है जिसका address टिकट में लिखा है, और सीट पर बैठा यात्री उस variable की value है।

Declaring and Initializing Pointers in Hindi

किसी भी pointer को इस्तेमाल करने से पहले declare करना पड़ता है, और declare करने के बाद उसमें कोई सही address डालना (initialize करना) ज़रूरी है। Pointer की तीन अवस्थाएँ हो सकती हैं: जिसमें कोई तय address नहीं है, जो NULL है, और जो किसी valid variable की ओर इशारा करता है।

पॉइंटर की तीन अवस्थाओं का चित्र: Wild, NULL और Valid int *p; p ? Wild Pointer (कोई तय पता नहीं) int *p = NULL; p NULL NULL Pointer (कहीं भी इशारा नहीं) p = &a; p a 1000 10 Valid Pointer (a का address रखता है)

1. Pointer Declaration

Declaration में data type के बाद * लगाकर pointer का नाम लिखा जाता है। यह data type बताता है कि pointer किस प्रकार के variable का address रखेगा, और उस address से कितने bytes पढ़े जाएँगे। Pointer का अपना size data type पर नहीं, system पर निर्भर करता है। 64-bit system पर यह आमतौर पर 8 bytes का होता है।

data_type *pointer_name;

int    *p;     // int का pointer
float  *fp;    // float का pointer
char   *cp;    // char का pointer

एक ही लाइन में int *p, q; लिखने पर सिर्फ p pointer बनता है, q एक साधारण int variable रहता है।

2. Pointer Initialization

Initialization का मतलब pointer में किसी variable का address रखना है। Address निकालने के लिए & (address-of operator) का इस्तेमाल होता है। यह काम declaration के साथ भी हो सकता है और बाद में भी। Pointer में सिर्फ उसी type के variable का address रखना चाहिए जिस type का वह declare हुआ है, जैसे int pointer में float variable का address रखने पर warning या error मिलती है।

int a = 10;
int *p;
p = &a;         // बाद में address देना

int *q = &a;    // declaration के साथ ही

3. NULL Pointer

जब pointer के पास अभी कोई valid address न हो, तो उसे NULL दे दिया जाता है। NULL एक macro है, जो stdio.h और stdlib.h जैसी header files में मिलता है, और इसका मतलब है कि pointer अभी किसी भी जगह की ओर इशारा नहीं कर रहा। इस्तेमाल से पहले p != NULL जाँच लेने से गलत access से बचा जा सकता है।

int *p = NULL;

if (p != NULL) {
    printf("%d", *p);
}

4. Wild Pointer

जिस pointer को declare तो कर दिया गया हो, पर कोई address न दिया गया हो, उसमें कोई भी बेकार (garbage) address पड़ा रहता है। ऐसे pointer को Wild Pointer कहते हैं। इसके ज़रिए value पढ़ने या लिखने पर program crash हो सकता है या दूसरे डाटा में गड़बड़ी हो सकती है।

int *p;        // कोई address तय नहीं
*p = 5;        // गलत: अनजान जगह पर लिखना

Accessing Variables Using Pointers in Hindi – पॉइंटर से वेरिएबल को एक्सेस करना

Pointer में सिर्फ address रखा होता है, इसलिए उस address पर रखे variable की value पढ़ने या बदलने के लिए एक अलग operator चाहिए। यह काम * (dereference या indirection operator) करता है। इन दोनों operators का काम इस तरह है:

Operator नाम काम उदाहरण
& Address-of Operator किसी variable का address बताता है &a
* Dereference Operator Pointer में रखे address पर जाकर वहाँ की value देता है *p

1. Dereferencing Operator

अगर p = &a है, तो *p का मतलब है "p में जो address है, उस पर रखी value", यानी a की value। ध्यान रहे कि int *p वाले declaration में * सिर्फ यह बताता है कि p एक pointer है, जबकि printf("%d", *p) जैसे expression में वही * value निकालने का काम करता है।

2. Reading and Modifying Value

*p से value पढ़ी भी जा सकती है और बदली भी जा सकती है। *p = 20; लिखने पर असल में a की value ही बदल जाती है, क्योंकि p और a एक ही memory location से जुड़े हैं। Pointer के नाम p से address मिलता है, जो &a के बराबर है, जबकि &p से खुद pointer p का अपना address मिलता है।

3. Pointer to Pointer

Pointer खुद भी एक variable है और memory में उसका भी एक address होता है, इसलिए उस address को रखने वाला दूसरा pointer बनाया जा सकता है। इसे Pointer to Pointer या double pointer कहते हैं और इसे int **pp = &p; लिखकर declare किया जाता है। **pp लिखने पर पहले p तक पहुँचा जाता है और फिर a तक।

पॉइंटर टू पॉइंटर का चित्र pp (int **) p (int *) a (int) 2000 1000 10 पता: 3000 पता: 2000 पता: 1000 **pp, *p और a, तीनों से एक ही value (10) मिलती है

4. Complete Program and Output

#include 

int main() {
    int a = 10;
    int *p = &a;      // p में a का address
    int **pp = &p;    // pp में p का address

    printf("Value of a     = %d\n", a);
    printf("Value via *p   = %d\n", *p);
    printf("Value via **pp = %d\n", **pp);

    *p = 20;            // p के ज़रिए a की value बदली
    printf("a after *p = 20 : %d\n", a);
    return 0;
}

Output:

Value of a     = 10
Value via *p   = 10
Value via **pp = 10
a after *p = 20 : 20

Pointer Arithmetic in Hindi – पॉइंटर अरिथमेटिक

Pointer arithmetic का मतलब pointer में रखे address को आगे या पीछे खिसकाना है। यह खिसकाव सीधे bytes में नहीं होता, बल्कि उस data type के elements की गिनती में होता है, और हर कदम की लंबाई pointer के data type के size के बराबर होती है।

नया address = पुराना address + n × sizeof(data_type)
Pointer का प्रकार आमतौर पर Size p की शुरुआती value p + 1 के बाद
char *p 1 byte 1000 1001
short *p 2 bytes 1000 1002
int *p 4 bytes 1000 1004
float *p 4 bytes 1000 1004
double *p 8 bytes 1000 1008
पॉइंटर अरिथमेटिक में ऐरे के elements पर pointer की चाल का चित्र p 10 arr[0] 1000 p + 1 20 arr[1] 1004 p + 2 30 arr[2] 1008 p + 3 40 arr[3] 1012 p + 4 50 arr[4] 1016 int का size 4 bytes है, इसलिए हर कदम पर address 4 बढ़ता है

1. Increment and Decrement

p++ pointer को अगले element पर ले जाता है और p-- पिछले element पर। Int pointer का address 1000 हो तो p++ के बाद वह 1004 हो जाता है, यानी 1001 नहीं। Array के सभी elements पर एक-एक करके चलने के लिए यही तरीका अपनाया जाता है।

2. Addition and Subtraction of an Integer

p + n pointer को n elements आगे और p - n n elements पीछे ले जाता है। इसमें खुद p की value नहीं बदलती, सिर्फ नया address मिलता है। Array का नाम उसके पहले element का address होता है, इसीलिए arr[i] और *(arr + i) दोनों एक ही element को दर्शाते हैं।

3. Subtraction of Two Pointers

एक ही array के दो pointers को घटाने पर उनके बीच के elements की संख्या मिलती है, bytes की नहीं। जैसे &arr[4] और &arr[1] का अंतर 3 आता है। अलग-अलग arrays के pointers को घटाने का कोई मतलब नहीं बनता।

4. Comparison of Pointers

Pointers की आपस में ==, !=, <, >, <= और >= से तुलना हो सकती है। जब दोनों pointers एक ही array के हों, तो इससे पता चलता है कि कौन-सा element पहले आता है। while (p <= q) जैसे loop इसी पर आधारित होते हैं।

5. Operations Not Allowed

दो pointers को जोड़ना, गुणा करना या भाग देना मान्य नहीं है, क्योंकि दो addresses के जोड़ से कोई सार्थक address नहीं बनता। इसी तरह pointer में float या double मान जोड़ना भी गलत है। Pointer के साथ सिर्फ integer जोड़ा या घटाया जा सकता है।

6. Complete Program and Output

#include 

int main() {
    int arr[5] = {10, 20, 30, 40, 50};
    int *p = arr;          // arr[0] का address
    int *q = &arr[4];      // arr[4] का address

    printf("%d\n", *p);        // 10
    printf("%d\n", *(p + 2));  // 30

    p++;                       // अब p, arr[1] पर है
    printf("%d\n", *p);        // 20

    printf("%ld\n", (long)(q - p));  // 3
    return 0;
}

Output:

10
30
20
3

Array of Pointers in Hindi – पॉइंटर्स का ऐरे

Array of Pointers एक ऐसा array है जिसके हर element में एक pointer, यानी एक address रखा जाता है। इसका सामान्य रूप data_type *array_name[size]; है। इसका उपयोग तब होता है जब कई अलग-अलग variables, strings या arrays को एक ही नाम के नीचे संभालना हो।

1. Declaration and Meaning

int *ptr[3]; में [] का प्राथमिकता स्तर * से ऊपर है, इसलिए पहले ptr को 3 elements का array माना जाता है और फिर हर element को int का pointer। 64-bit system पर इस array को 3 × 8 = 24 bytes चाहिए, चाहे वे pointers जिन variables की ओर इशारा करें वे कितने भी बड़े हों।

2. Array of Pointers to Integers

नीचे के program में तीन अलग int variables के address एक array में रखे गए हैं, और loop चलाकर *ptr[i] से उनकी values निकाली गई हैं।

integer variables की ओर इशारा करने वाले पॉइंटर्स के ऐरे का चित्र ptr (int *ptr[3]) int variables ptr[0] 1000 10 a (पता 1000) ptr[1] 2000 20 b (पता 2000) ptr[2] 3000 30 c (पता 3000)
#include 

int main() {
    int a = 10, b = 20, c = 30;
    int *ptr[3];            // 3 int pointers का array
    int i;

    ptr[0] = &a;
    ptr[1] = &b;
    ptr[2] = &c;

    for (i = 0; i < 3; i++) {
        printf("%d ", *ptr[i]);
    }
    return 0;
}

Output:

10 20 30

3. Array of Pointers to Strings

Array of pointers का सबसे आम उपयोग strings की सूची रखने में होता है। char *names[3] के हर element में एक string के पहले character का address रहता है, और हर string अपनी ज़रूरत के हिसाब से ही जगह घेरती है। Strings को क्रम में लगाते समय पूरी string की कॉपी करने की जगह सिर्फ pointers की अदला-बदली की जाती है।

strings की ओर इशारा करने वाले पॉइंटर्स के ऐरे का चित्र names (char *names[3]) Strings (memory में) names[0] 4000 R a m \0 names[1] 4004 S h y a m \0 names[2] 4010 M o h a n \0
#include 

int main() {
    char *names[3] = {"Ram", "Shyam", "Mohan"};
    int i;

    for (i = 0; i < 3; i++) {
        printf("%s\n", names[i]);
    }
    return 0;
}

Output:

Ram
Shyam
Mohan

4. Array of Pointers vs Pointer to Array

इन दोनों के नाम मिलते-जुलते हैं, पर इनका मतलब बिल्कुल अलग है, और फ़र्क सिर्फ कोष्ठक (parentheses) से पैदा होता है।

आधार Array of Pointers Pointer to Array
Declaration int *p[5]; int (*p)[5];
मतलब 5 int pointers का array 5 int वाले एक पूरे array का pointer
Memory 5 pointers के बराबर जगह सिर्फ एक pointer के बराबर जगह
उपयोग Strings की सूची, jagged arrays 2-D array की किसी row तक पहुँचना

Row Major and Column Major Implementation of 2-D Array in Hindi – 2-D ऐरे का रो-मेजर और कॉलम-मेजर इम्प्लीमेंटेशन

RAM में डाटा एक सीधी कतार (linear) में रखा जाता है, जबकि 2-D array में rows और columns होते हैं। इसलिए 2-D array को memory में उतारने के लिए एक क्रम चुनना पड़ता है, और ऐसे दो क्रम हैं: Row Major और Column Major। चित्र में 3 × 4 के array के लिए दोनों क्रम दिखाए गए हैं, जिसमें मोटे बॉर्डर वाला element A[2][1] है।

2-D ऐरे के रो-मेजर और कॉलम-मेजर क्रम का चित्र A[3][4] – Logical View (तार्किक रूप) j=0 j=1 j=2 j=3 i=0 1 2 3 4 i=1 5 6 7 8 i=2 9 10 11 12 Row Major: पहले पूरी row 0, फिर row 1, फिर row 2 Column Major: पहले पूरा column 0, फिर column 1 और आगे मोटा बॉर्डर: A[2][1] (value 10) Row Major Order (पंक्ति के क्रम में) – address 4 bytes के अंतर पर 1 1000 2 1004 3 1008 4 1012 5 1016 6 1020 7 1024 8 1028 9 1032 10 1036 11 1040 12 1044 Column Major Order (स्तंभ के क्रम में) – address 4 bytes के अंतर पर 1 1000 5 1004 9 1008 2 1012 6 1016 10 1020 3 1024 7 1028 11 1032 4 1036 8 1040 12 1044

1. Row Major Order

इसमें पहले पहली row के सभी elements, फिर दूसरी row के, और इसी तरह आगे रखे जाते हैं। 3 × 4 के array में क्रम A[0][0], A[0][1], A[0][2], A[0][3], A[1][0] और इसी तरह चलता है। C और C++ यही तरीका अपनाते हैं।

2. Column Major Order

इसमें पहले पहले column के सभी elements, फिर दूसरे column के, और इसी तरह आगे रखे जाते हैं। उसी array में क्रम A[0][0], A[1][0], A[2][0], A[0][1] और इसी तरह बनता है। FORTRAN और MATLAB में यह तरीका इस्तेमाल होता है।

3. Formulas and Comparison

नीचे की table में m = rows की संख्या, n = columns की संख्या, w = एक element का size (bytes में), Base = array के पहले element का address, और LBr व LBc क्रमशः row और column की lower bound हैं। Lower bound 0 होने पर सूत्र छोटा हो जाता है।

आधार Row Major Column Major
Storage का क्रम Row के बाद row Column के बाद column
A[i][j] का address (0-based) Base + (i × n + j) × w Base + (j × m + i) × w
Lower bounds के साथ Base + [(i − LBr) × n + (j − LBc)] × w Base + [(j − LBc) × m + (i − LBr)] × w
भाषाएँ C, C++ FORTRAN, MATLAB
तेज़ traversal Row-wise, क्योंकि एक row के elements पास-पास रहते हैं Column-wise, क्योंकि एक column के elements पास-पास रहते हैं

4. Worked Examples

पहले उदाहरण में lower bound 0 है। int A[3][4] का Base address 1000 है, int का size 4 bytes है और A[2][1] का address निकालना है, यहाँ m = 3 और n = 4 है।

Row Major    : 1000 + (2 × 4 + 1) × 4 = 1000 + 36 = 1036
Column Major : 1000 + (1 × 3 + 2) × 4 = 1000 + 20 = 1020

दूसरे उदाहरण में lower bound 1 है। Array A[1..4][1..3] है, Base address 200 है, हर element 2 bytes का है और A[3][2] का address निकालना है, यहाँ m = 4 और n = 3 है।

Row Major    : 200 + [(3 − 1) × 3 + (2 − 1)] × 2 = 200 + 14 = 214
Column Major : 200 + [(2 − 1) × 4 + (3 − 1)] × 2 = 200 + 12 = 212

5. Accessing 2-D Array Using Pointers in C

C में 2-D array row major क्रम में रखा जाता है, इसलिए पहले element के pointer को एक-एक करके बढ़ाने पर elements row-by-row मिलते हैं। A[i][j] तक पहुँचने के लिए *(p + i * n + j) या *(*(A + i) + j) लिखा जा सकता है। यहाँ A + i पूरी row i की ओर इशारा करता है, *(A + i) उस row के पहले element का address देता है, और उसमें j जोड़कर * लगाने पर value मिलती है।

#include 

int main() {
    int A[3][4] = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};
    int *p = &A[0][0];
    int i;

    for (i = 0; i < 12; i++) {
        printf("%d ", *(p + i));
    }
    printf("\n%d\n", *(p + 2 * 4 + 1));    // A[2][1]
    printf("%d\n", *(*(A + 2) + 1));        // A[2][1]
    return 0;
}

Output:

1 2 3 4 5 6 7 8 9 10 11 12
10
10

FAQs

Pointer एक ऐसा variable है जिसमें किसी दूसरे variable का memory address रखा जाता है। इसकी मदद से memory को सीधे access किया जाता है और linked list, tree जैसे dynamic data structures बनाए जाते हैं।
Declaration में data_type *name; लिखा जाता है, जैसे int *p;। Initialization में pointer को किसी variable का address दिया जाता है, जैसे p = &a;, या उसे NULL किया जाता है।
NULL pointer वह pointer है जो अभी किसी valid address की ओर इशारा नहीं कर रहा। इसे int *p = NULL; लिखकर बनाया जाता है, और इस्तेमाल से पहले p != NULL की जाँच कर ली जाती है।
Pointer से variable तक पहुँचने के लिए dereference operator * इस्तेमाल होता है। *p से p में रखे address पर मौजूद value पढ़ी जाती है, और *p = 20; से वही value बदल दी जाती है।
जब एक pointer में दूसरे pointer का address रखा जाता है, तो उसे Pointer to Pointer कहते हैं। इसे int **pp = &p; से declare किया जाता है और **pp से असली variable की value मिलती है।
Pointer arithmetic में pointer के address को आगे-पीछे खिसकाया जाता है। Increment, decrement, integer का जोड़-घटाव, दो pointers का अंतर और तुलना मान्य हैं, जबकि दो pointers को जोड़ना, गुणा या भाग देना मान्य नहीं है। हर कदम data type के size जितना होता है।
यह ऐसा array है जिसके हर element में एक pointer रखा जाता है, जैसे int *ptr[3];। इसका आम उपयोग strings की सूची और jagged arrays में होता है।
2-D array को memory में रखने के दो क्रम हैं। Row Major में पूरी row एक के बाद एक रखी जाती है (C, C++), जबकि Column Major में पूरा column एक के बाद एक रखा जाता है (FORTRAN, MATLAB)।
0-based indexing में Row Major का सूत्र Base + (i × n + j) × w और Column Major का सूत्र Base + (j × m + i) × w है। यहाँ m rows, n columns और w एक element का size है।
Srajan

✍️ Srajan

SEO Executive | Content Research & Optimization | 1.5+ Years of Experience

•