Table of Contents
- Pointers in Data Structure in Hindi – पॉइंटर क्या है?
- Declaring and Initializing Pointers in Hindi – पॉइंटर को डिक्लेयर और इनिशियलाइज़ करना
- Accessing Variables Using Pointers in Hindi – पॉइंटर से वेरिएबल को एक्सेस करना
- Pointer Arithmetic in Hindi – पॉइंटर अरिथमेटिक
- Array of Pointers in Hindi – पॉइंटर्स का ऐरे
- Row Major and Column Major Implementation of 2-D Array in Hindi – 2-D ऐरे का रो-मेजर और कॉलम-मेजर इम्प्लीमेंटेशन
- FAQs
Pointers in Data Structure in Hindi – पॉइंटर क्या है?
Endless Horse – Find End? Play Game- 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 की ओर इशारा करता है।
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 तक।
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 |
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 निकाली गई हैं।
#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 की अदला-बदली की जाती है।
#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] है।
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
data_type *name; लिखा जाता है, जैसे int *p;। Initialization में pointer को किसी variable का address दिया जाता है, जैसे p = &a;, या उसे NULL किया जाता है।
int *p = NULL; लिखकर बनाया जाता है, और इस्तेमाल से पहले p != NULL की जाँच कर ली जाती है।
* इस्तेमाल होता है। *p से p में रखे address पर मौजूद value पढ़ी जाती है, और *p = 20; से वही value बदल दी जाती है।
int **pp = &p; से declare किया जाता है और **pp से असली variable की value मिलती है।
int *ptr[3];। इसका आम उपयोग strings की सूची और jagged arrays में होता है।
