सी, पायथन, जावास्क्रिप्ट, गो, रस्ट, सॉलिडिटी जैसी भाषाओं और कंप्यूटर साइंस के बुनियादी और गणित के उन्नत सिद्धांतों को हिंदी में पढ़ने के लिए संपर्क करें। हम वेबसाइट और सॉफ्टवेयर भी बनाते हैं।
आप किस ओर इशारा कर रहे हैं? (What are you pointing at?)
अगर आप सच में C में धमाल मचाना चाहते हैं, तो आपको समझना होगा कि C मेमोरी (memory) को कैसे संभालती है।
C भाषा आपको इस पर कहीं ज़्यादा नियंत्रण (control) देती है कि आपका प्रोग्राम कंप्यूटर की मेमोरी (memory) का इस्तेमाल कैसे करे। इस अध्याय में हम पर्दा हटाकर देखेंगे कि वेरिएबल (variable) को रीड (read) और राइट (write) करते समय असल में क्या होता है। आप सीखेंगे कि ऐरे (array) कैसे काम करते हैं, मेमोरी की कुछ गंदी गड़बड़ियों (SNAFU) से कैसे बचें, और सबसे ज़रूरी बात — आप देखेंगे कि पॉइंटर (pointer) और मेमोरी एड्रेसिंग (memory addressing) में महारत हासिल करना ही एक दमदार C प्रोग्रामर बनने की कुंजी है। 🚀
🧠 मेमोरी का नक्शा (memory map)
परत (layer)
मतलब
🟦 STACK (स्टैक)
फ़ंक्शन कॉल के लोकल वेरिएबल यहाँ रहते हैं
🟧 HEAP (हीप)
डायनामिक मेमोरी यहाँ मिलती है
🟩 GLOBALS (ग्लोबल)
ग्लोबल वेरिएबल
🟨 CONSTANTS (कॉन्स्टेंट)
स्थिर मान (constant values)
🟥 CODE (कोड)
आपके प्रोग्राम के निर्देश (instructions)
📑 इस अध्याय में क्या-क्या है
विषय
पेज
C कोड में पॉइंटर (pointer) शामिल हैं
42
मेमोरी (memory) में खुदाई
43
पॉइंटर के साथ पाल खोलो (Set sail with pointers)
44
वेरिएबल को पॉइंटर पास करके देखें
47
मेमोरी पॉइंटर (memory pointer) का इस्तेमाल
48
फ़ंक्शन को स्ट्रिंग (string) कैसे पास करें?
53
ऐरे वेरिएबल (array variable) पॉइंटर जैसे होते हैं…
54
कंप्यूटर क्या सोचता है जब वह आपका कोड चलाता है
55
लेकिन ऐरे वेरिएबल पूरी तरह पॉइंटर नहीं होते
59
ऐरे असल में 0 से क्यों शुरू होते हैं
61
पॉइंटर के टाइप (type) क्यों होते हैं
62
डेटा एंट्री (data entry) के लिए पॉइंटर का इस्तेमाल
65
scanf() से सावधान रहें
66
fgets() — scanf() का एक विकल्प
67
स्ट्रिंग लिटरल (string literal) कभी अपडेट नहीं हो सकते
<p align="center"><sub>📘 <i>Head First C</i> · डेविड ग्रिफिथ्स और डॉन ग्रिफिथ्स · पेज xii से 30 का हिंदी अनुवाद समाप्त</sub></p>
----------------
# 📘 Head First C — हिंदी अध्ययन-नोट्स
### PDF पेज 31 से 55 | Intro + Chapter 1 (Getting Started with C)
72
अगर स्ट्रिंग बदलनी है, तो उसकी कॉपी (copy) बनाएँ
74
मेमोरी याद करने का तरीका (Memory memorizer)
80
आपका C टूलबॉक्स (Your C Toolbox)
81
🏴☠️ चित्र के संवाद
⛵ "पाल में हवा भरी है, कप्तान!" (Wind in the sails, cap'n!)
🏖️ "कैन्कून (Cancun) की ओर चलो!" (Set sail for Cancun!)
🦜 "अरे वाह! स्प्रिंग ब्रेक (spring break)!" (Arr! Spring break!)
🔐 तिजोरी पर अक्षांश (latitude) का मान: 31
<sub>स्रोत: Head First C — डेविड ग्रिफिथ्स और डॉन ग्रिफिथ्स | पेज xi</sub>
लेखक: डेविड ग्रिफिथ्स और डॉन ग्रिफिथ्स
नोट: पारिभाषिक शब्द पहले देवनागरी में, फिर ब्रैकेट में रोमन में दिए गए हैं। कोड (code) जस का तस रखा गया है। "टूल" को टूल ही लिखा है।
📑 भाग 1 — विषय-सूची (table of contents)
📄 पेज xii
2.5 — स्ट्रिंग (strings)
स्ट्रिंग का सिद्धांत (String theory)
स्ट्रिंग को सिर्फ़ पढ़ने से कहीं ज़्यादा किया जा सकता है।
आप देख चुके हैं कि C में स्ट्रिंग (string) असल में char ऐरे (array) होती हैं। पर C आपको इनके साथ और क्या करने देती है? यहीं string.h काम आती है। string.h C स्टैंडर्ड लाइब्रेरी (Standard Library) का वह हिस्सा है जो स्ट्रिंग के साथ काम करने के लिए बना है। अगर आपको स्ट्रिंग जोड़नी हैं (concatenate), एक स्ट्रिंग की दूसरी में कॉपी (copy) बनानी है, या दो स्ट्रिंग की तुलना (compare) करनी है, तो string.h के फ़ंक्शन (functions) मदद के लिए हाज़िर हैं। इस अध्याय में आप स्ट्रिंग का ऐरे बनाना सीखेंगे, और फिर strstr() फ़ंक्शन से स्ट्रिंग के अंदर खोजना देखेंगे।
चित्र के लेबल: स्ट्रिंग खोजो 🔎 · दो स्ट्रिंग की तुलना करो ⚖️ · स्ट्रिंग की कॉपी बनाओ 📋 · स्ट्रिंग को छोटे टुकड़ों में काटो ✂️
विषय
पेज
फ्रैंक की बेताब खोज (Desperately seeking Frank)
84
ऐरे का ऐरे बनाओ (Create an array of arrays)
85
खोज-पाठ वाली स्ट्रिंग ढूँढो
86
strstr() फ़ंक्शन का इस्तेमाल
89
कोड रिव्यू (code review) का समय
94
ऐरे का ऐरे बनाम पॉइंटर (pointer) का ऐरे
98
आपका C टूलबॉक्स (Your C Toolbox)
101
📄 पेज xiii
3 — छोटे टूल बनाना (creating small tools)
एक काम करो और बढ़िया करो (Do one thing and do it well)
हर ऑपरेटिंग सिस्टम (operating system) में छोटे टूल होते हैं।
C में लिखे छोटे टूल (tools) ख़ास छोटे काम करते हैं, जैसे फ़ाइल पढ़ना-लिखना या डेटा फ़िल्टर (filter) करना। ज़्यादा जटिल काम करना हो तो कई टूल को आपस में जोड़ा भी जा सकता है। पर ये छोटे टूल बनते कैसे हैं? इस अध्याय में आप टूल बनाने के बुनियादी हिस्से देखेंगे: कमांड-लाइन ऑप्शन (command-line options) कैसे संभालें, सूचना की धाराएँ (streams) कैसे सँभालें, और रीडायरेक्शन (redirection) क्या है। यानी आप जल्दी ही टूल बनाने में माहिर हो जाएँगे।
चित्र के लेबल: स्टैंडर्ड इनपुट (Standard Input) कीबोर्ड से आता है · स्टैंडर्ड एरर (Standard Error) डिस्प्ले पर जाता है · स्टैंडर्ड आउटपुट (Standard Output) डिस्प्ले पर जाता है
विषय
पेज
छोटे टूल बड़ी समस्याएँ हल कर सकते हैं
104
प्रोग्राम ऐसे काम करना चाहिए
108
पर आप फ़ाइलें इस्तेमाल नहीं कर रहे…
109
आप रीडायरेक्शन (redirection) इस्तेमाल कर सकते हैं
110
स्टैंडर्ड एरर (Standard Error) से परिचय
120
डिफ़ॉल्ट रूप से स्टैंडर्ड एरर डिस्प्ले पर जाता है
121
fprintf() डेटा स्ट्रीम (data stream) में प्रिंट करता है
122
चलिए कोड को fprintf() के लिए अपडेट करें
123
छोटे टूल लचीले होते हैं
128
geo2json टूल को मत बदलो
129
अलग काम के लिए अलग टूल
130
इनपुट और आउटपुट को पाइप (pipe) से जोड़ो
131
bermuda टूल
132
पर अगर एक से ज़्यादा फ़ाइल में आउटपुट देना हो तो?
137
अपनी डेटा स्ट्रीम ख़ुद बनाओ
138
main() में और भी बहुत कुछ है
141
काम लाइब्रेरी (library) से करवाओ
149
आपका C टूलबॉक्स
156
📄 पेज xiv
4 — कई सोर्स फ़ाइलें इस्तेमाल करना (using multiple source files)
तोड़ो और फिर बनाओ (Break it down, build it up)
बड़ा प्रोग्राम बनाएँ, तो सोर्स फ़ाइल बड़ी नहीं होनी चाहिए।
सोचिए, किसी एंटरप्राइज़-स्तर (enterprise-level) के प्रोग्राम की एक ही सोर्स फ़ाइल (source file) को सँभालना कितना मुश्किल और समय खाने वाला होगा। इस अध्याय में आप सीखेंगे कि C आपको सोर्स कोड छोटे-छोटे सँभालने लायक टुकड़ों में तोड़ने देती है और फिर उन्हें जोड़कर एक विशाल प्रोग्राम बनाने देती है। साथ ही डेटा टाइप (data type) की बारीकियाँ भी सीखेंगे और अपने नए सबसे अच्छे दोस्त make से मिलेंगे।
चित्र के लेबल:gcc -c · gcc -o
विषय
पेज
डेटा टाइप के लिए आपकी त्वरित गाइड
162
बड़ी चीज़ छोटी चीज़ में मत ठूँसो
163
कास्टिंग (casting) से float को पूर्ण संख्या में बदलो
164
अरे नहीं… बेरोज़गार अभिनेता!
168
देखें कोड को क्या हुआ
169
कंपाइलर (compiler) को आश्चर्य पसंद नहीं
171
डिक्लेरेशन (declaration) को डेफ़िनिशन (definition) से अलग करो
173
अपनी पहली हेडर फ़ाइल (header file) बनाना
174
अगर साझा सुविधाएँ हैं…
182
कोड को अलग-अलग फ़ाइलों में बाँटा जा सकता है
183
पर्दे के पीछे कंपाइलेशन (compilation)
184
साझा कोड की अपनी हेडर फ़ाइल चाहिए
186
यह रॉकेट साइंस नहीं है… या है?
189
हर फ़ाइल दोबारा कंपाइल मत करो
190
पहले सोर्स को ऑब्जेक्ट फ़ाइलों (object files) में कंपाइल करो
191
फ़ाइलों का हिसाब रखना मुश्किल है
196
make टूल से बिल्ड (build) ऑटोमेट करो
198
make कैसे काम करता है
199
makefile से make को अपने कोड के बारे में बताओ
200
लिफ़्टऑफ़! 🚀
205
आपका C टूलबॉक्स
206
📄 पेज xv
🔬 C लैब 1 (C Lab 1): आर्डुइनो (Arduino)
कभी चाहा है कि आपके पौधे ख़ुद बता दें कि उन्हें पानी चाहिए? आर्डुइनो (Arduino) से यह हो सकता है! इस लैब में आप आर्डुइनो-चालित प्लांट मॉनिटर (plant monitor) बनाएँगे, पूरा C में कोड किया हुआ। 🌱
📄 पेज xvi
5 — स्ट्रक्ट, यूनियन और बिटफ़ील्ड (structs, unions, and bitfields)
अपनी संरचनाएँ ख़ुद बनाओ (Rolling your own structures)
जीवन की ज़्यादातर चीज़ें किसी सादे नंबर से कहीं जटिल होती हैं।
अब तक आपने C के बुनियादी डेटा टाइप (data types) देखे हैं। पर अगर आप नंबर और टेक्स्ट से आगे बढ़कर असल दुनिया की चीज़ों का मॉडल (model) बनाना चाहें तो? struct (स्ट्रक्ट) आपको अपनी संरचनाएँ (structures) लिखकर असल दुनिया की जटिलताएँ दर्शाने देते हैं। इस अध्याय में आप बुनियादी डेटा टाइप को मिलाकर struct बनाना सीखेंगे, और union (यूनियन) से ज़िंदगी की अनिश्चितताएँ भी सँभालेंगे। और अगर आपको सिर्फ़ "हाँ या ना" चाहिए, तो बिटफ़ील्ड (bitfields) आपके काम आ सकते हैं।
चित्र के लेबल: यह मर्टल (Myrtle) है… · …पर फ़ंक्शन को उसका क्लोन (clone) भेजा जाता है · कछुआ (Turtle) "t"
विषय
पेज
कभी-कभी बहुत सारा डेटा इधर-उधर भेजना पड़ता है
218
क्यूबिकल की बातचीत (Cubicle conversation)
219
struct से अपने संरचित डेटा टाइप बनाओ
220
बस उन्हें मछली दे दो
221
struct के फ़ील्ड "." ऑपरेटर (operator) से पढ़ो
222
क्या एक struct को दूसरे के अंदर रख सकते हैं?
227
struct को अपडेट कैसे करें?
236
कोड कछुए का क्लोन बना रहा है
238
आपको struct के लिए पॉइंटर चाहिए
239
(*t).age बनाम *t.age
240
कभी-कभी एक ही तरह की चीज़ को अलग-अलग डेटा टाइप चाहिए
246
union आपको मेमोरी की जगह दोबारा इस्तेमाल करने देता है
247
union का इस्तेमाल कैसे करें?
248
enum वेरिएबल (variable) एक प्रतीक (symbol) रखता है
255
कभी-कभी आपको बिट (bit) स्तर पर नियंत्रण चाहिए
261
बिटफ़ील्ड बिट की मनचाही संख्या रखते हैं
262
आपका C टूलबॉक्स
266
📄 पेज xvii
6 — डेटा स्ट्रक्चर और डायनामिक मेमोरी (data structures and dynamic memory)
पुल बनाना (Building bridges)
कभी-कभी एक अकेला struct काफ़ी नहीं होता।
जटिल डेटा ज़रूरतों के मॉडल के लिए अक्सर struct को आपस में जोड़ना पड़ता है। इस अध्याय में आप struct पॉइंटर (struct pointer) से कस्टम डेटा टाइप को बड़े और जटिल डेटा स्ट्रक्चर (data structures) में जोड़ना सीखेंगे। लिंक्ड लिस्ट (linked list) बनाकर आप मुख्य सिद्धांत समझेंगे। साथ ही आप हीप (heap) पर डायनामिक रूप से मेमोरी आवंटित (allocate) करके अपने डेटा स्ट्रक्चर को लचीली मात्रा का डेटा सँभालना सिखाएँगे, और काम पूरा होने पर उसे मुक्त (free) करना भी। और अगर सफ़ाई रखना मुश्किल हो जाए, तो valgrind आपकी कैसे मदद कर सकता है, यह भी सीखेंगे।
चित्र के लेबल: क्रैगी (Craggy) · शटर (Shutter) · हीप पर 4,204,853 पते पर 32 बाइट (bytes) डेटा · आइला नुबलार (Isla Nublar)
विषय
पेज
क्या आपको लचीला स्टोरेज (storage) चाहिए?
268
लिंक्ड लिस्ट डेटा की ज़ंजीरों जैसी होती हैं
269
लिंक्ड लिस्ट में इन्सर्ट (insert) हो सकता है
270
रिकर्सिव (recursive) स्ट्रक्चर बनाओ
271
C में द्वीप बनाओ…
272
लिस्ट में मान (values) डालना
273
डायनामिक स्टोरेज के लिए हीप इस्तेमाल करो
278
काम ख़त्म होने पर मेमोरी लौटा दो
279
malloc() से मेमोरी माँगो…
280
strdup() फ़ंक्शन से कोड ठीक करें
286
काम ख़त्म होने पर मेमोरी मुक्त करो
290
SPIES सिस्टम का अवलोकन
300
सॉफ़्टवेयर फ़ोरेंसिक्स (forensics): valgrind का इस्तेमाल
302
ज़्यादा सबूत जुटाने के लिए valgrind बार-बार चलाओ
303
सबूतों को देखो
304
फ़िक्स पर मुक़दमा (The fix on trial)
307
आपका C टूलबॉक्स
309
📄 पेज xviii
7 — उन्नत फ़ंक्शन (advanced functions)
अपने फ़ंक्शन को 11 तक चढ़ाओ (Turn your functions up to 11)
बुनियादी फ़ंक्शन बढ़िया हैं, पर कभी-कभी और चाहिए होता है।
अब तक आपने बुनियादी बातों पर ध्यान दिया। पर अगर आपको और ताक़त और लचीलापन चाहिए तो? इस अध्याय में आप सीखेंगे कि फ़ंक्शन को पैरामीटर (parameter) के रूप में पास करके अपने कोड का IQ कैसे बढ़ाएँ। आप तुलनात्मक फ़ंक्शन (comparator functions) से चीज़ें सॉर्ट (sort) करना सीखेंगे। और आख़िर में, वेरिएडिक फ़ंक्शन (variadic functions) से अपने कोड को सुपर-लचीला बनाना जानेंगे।
चित्र का लेबल: टेस्टिंग मशीन (Testing Machine)
विषय
पेज
मिस्टर राइट की तलाश…
312
फ़ंक्शन को कोड पास करो
316
find() को फ़ंक्शन का नाम बताना होगा
317
हर फ़ंक्शन का नाम उस फ़ंक्शन का पॉइंटर है…
318
…पर फ़ंक्शन का कोई डेटा टाइप नहीं है
319
फ़ंक्शन पॉइंटर (function pointers) कैसे बनाएँ
320
C स्टैंडर्ड लाइब्रेरी से सॉर्ट करवाओ
325
क्रम तय करने के लिए फ़ंक्शन पॉइंटर इस्तेमाल करो
326
"प्रिय जॉन" पत्रों को ऑटोमेट करना
334
फ़ंक्शन पॉइंटर का ऐरे बनाओ
338
अपने फ़ंक्शन को खिंचने वाला (streeeeeetchy) बनाओ
343
आपका C टूलबॉक्स
350
📄 पेज xix
8 — स्टैटिक और डायनामिक लाइब्रेरी (static and dynamic libraries)
बदली जा सकने वाला कोड (Hot-swappable code)
आप स्टैंडर्ड लाइब्रेरी (standard libraries) की ताक़त देख चुके हैं।
अब वह ताक़त अपने कोड के लिए इस्तेमाल करने का समय है। इस अध्याय में आप अपनी लाइब्रेरी बनाना और एक ही कोड को कई प्रोग्रामों में दोबारा इस्तेमाल करना सीखेंगे। साथ ही डायनामिक लाइब्रेरी (dynamic libraries) से रनटाइम (runtime) पर कोड साझा करना भी सीखेंगे। आप कोडिंग गुरुओं के राज़ जानेंगे, और अध्याय के अंत तक ऐसा कोड लिख पाएँगे जिसे आप आसानी से और कुशलता से बढ़ा और सँभाल सकें।
चित्र के लेबल: किशमिश, आटा, मक्खन, एंकोवी… · क्या यह पक्षी है? क्या यह विमान है? नहीं, यह मेटाडेटा (metadata) वाली रिलोकेटेबल ऑब्जेक्ट फ़ाइल (relocatable object file) है।
विषय
पेज
ऐसा कोड जिसे आप बैंक ले जा सकें
352
ऐंगल ब्रैकेट (angle brackets) स्टैंडर्ड हेडर के लिए हैं
354
पर अगर कोड साझा करना हो तो?
355
.h हेडर फ़ाइलें साझा करना
356
पूरा पाथनेम (pathname) देकर .o ऑब्जेक्ट फ़ाइलें साझा करो
357
आर्काइव (archive) में .o फ़ाइलें होती हैं
358
ar कमांड से आर्काइव बनाओ…
359
अंत में अपने दूसरे प्रोग्राम कंपाइल करो
360
Head First जिम (Gym) दुनिया भर में जा रहा है
365
कैलोरी की गणना
366
पर चीज़ें थोड़ी और जटिल हैं…
369
प्रोग्राम बहुत सारे टुकड़ों से बनते हैं…
370
डायनामिक लिंकिंग (dynamic linking) रनटाइम पर होती है
372
क्या .a को रनटाइम पर लिंक कर सकते हैं?
373
पहले एक ऑब्जेक्ट फ़ाइल बनाओ
374
आपकी डायनामिक लाइब्रेरी का नाम आपके प्लेटफ़ॉर्म (platform) पर निर्भर है
375
आपका C टूलबॉक्स
387
📄 पेज xx
🔬 C लैब 2 (C Lab 2): ओपनसीवी (OpenCV)
सोचिए आपका कंप्यूटर आपकी ग़ैरमौजूदगी में घर पर नज़र रख सके और बताए कि कौन चक्कर काट रहा था। इस लैब में आप ओपनसीवी (OpenCV) की चतुराई से C-चालित घुसपैठिया डिटेक्टर (intruder detector) बनाएँगे। 🕵️
📄 पेज xxi
9 — प्रोसेस और सिस्टम कॉल (processes and system calls)
सीमाएँ तोड़ना (Breaking boundaries)
अब लीक से हटकर सोचने का समय है।
आप देख चुके हैं कि कमांड लाइन पर छोटे टूल जोड़कर जटिल एप्लिकेशन बनाए जा सकते हैं। पर अगर आप अपने ही कोड के अंदर से दूसरे प्रोग्राम इस्तेमाल करना चाहें तो? इस अध्याय में आप सिस्टम सर्विस (system services) से प्रोसेस (processes) बनाना और नियंत्रित करना सीखेंगे। इससे आपके प्रोग्राम को ईमेल, वेब और आपके इंस्टॉल किए हर दूसरे टूल तक पहुँच मिलेगी। अध्याय के अंत तक आपके पास C से आगे जाने की ताक़त होगी।
चित्र के लेबल: यह आपकी न्यूज़हाउंड (newshound) प्रोसेस है · यह तीनों न्यूज़फ़ीड के लिए अलग-अलग प्रोसेस चलाता है · चाइल्ड प्रोसेस (child processes) सब एक साथ चलते हैं
विषय
पेज
सिस्टम कॉल (system calls) OS तक आपकी हॉटलाइन हैं
398
फिर किसी ने सिस्टम में सेंध लगा दी…
402
सिर्फ़ सुरक्षा ही समस्या नहीं है
403
exec() फ़ंक्शन आपको ज़्यादा नियंत्रण देते हैं
404
exec() के कई फ़ंक्शन हैं
405
ऐरे वाले फ़ंक्शन: execv(), execvp(), execve()
406
एनवायरनमेंट वेरिएबल (environment variables) पास करना
अगर प्रोसेस चलने के बाद उसे नियंत्रित करना हो तो? उसे डेटा भेजना हो? या उसका आउटपुट पढ़ना हो? इंटरप्रोसेस कम्युनिकेशन (interprocess communication) प्रोसेस को मिलकर काम पूरा करने देता है। हम आपको दिखाएँगे कि अपने कोड को सिस्टम के दूसरे प्रोग्राम से बात करवाकर उसकी ताक़त कई गुना कैसे बढ़ाएँ।
चित्र का कोड और संवाद:
#include <stdio.h>
int main()
{
char name[30];
printf("Enter your name: ");
fgets(name, 30, stdin);
printf("Hello %s\n", name);
return 0;
}
File Edit Window Help
> ./greetings
Enter your name: ^C
>
अगर आप Ctrl-C दबाएँ, तो प्रोग्राम चलना बंद हो जाता है। पर क्यों?
विषय
पेज
इनपुट और आउटपुट को रीडायरेक्ट करना
430
एक सामान्य प्रोसेस के अंदर झाँकना
431
रीडायरेक्शन बस डेटा स्ट्रीम बदल देता है
432
fileno() डिस्क्रिप्टर (descriptor) बताता है
433
कभी-कभी इंतज़ार करना पड़ता है…
438
अपने चाइल्ड के संपर्क में रहो
442
प्रोसेस को पाइप (pipes) से जोड़ो
443
केस स्टडी: ब्राउज़र में कहानियाँ खोलना
444
चाइल्ड में
445
पैरेंट (parent) में
445
ब्राउज़र में वेब पेज खोलना
446
प्रोसेस की मृत्यु
451
सिग्नल (signals) पकड़ना और अपना कोड चलाना
452
sigaction को sigaction() से रजिस्टर किया जाता है
453
सिग्नल हैंडलर (signal handler) के लिए कोड दोबारा लिखना
454
सिग्नल भेजने के लिए kill इस्तेमाल करो
457
अपने कोड को जगाने की घंटी (wake-up call) भेजना
458
आपका C टूलबॉक्स
466
📄 पेज xxiii
11 — सॉकेट और नेटवर्किंग (sockets and networking)
127.0.0.1 जैसा कोई घर नहीं (There's no place like 127.0.0.1)
अलग-अलग मशीनों के प्रोग्रामों को आपस में बात करनी पड़ती है।
आपने सीखा कि फ़ाइलों से I/O के ज़रिए कैसे बात करें और एक ही मशीन की प्रोसेस आपस में कैसे बात करती हैं। अब आप बाक़ी दुनिया तक पहुँचेंगे और ऐसे C प्रोग्राम लिखना सीखेंगे जो नेटवर्क पर, और दुनिया भर में, दूसरे प्रोग्रामों से बात कर सकें। अध्याय के अंत तक आप ऐसे प्रोग्राम बना पाएँगे जो सर्वर (server) की तरह चलें, और ऐसे भी जो क्लाइंट (client) की तरह चलें।
चित्र के लेबल: सर्वर (Server) · क्लाइंट और सर्वर के बीच एक संरचित बातचीत होती है जिसे प्रोटोकॉल (protocol) कहते हैं · टेलनेट क्लाइंट (Telnet client) · सर्वर कई क्लाइंट से एक साथ बात करेगा
विषय
पेज
इंटरनेट का "नॉक-नॉक" सर्वर
468
नॉक-नॉक सर्वर का अवलोकन
469
BLAB: सर्वर इंटरनेट से कैसे बात करते हैं
470
सॉकेट (socket) कोई आम डेटा स्ट्रीम नहीं है
472
कभी-कभी सर्वर ठीक से शुरू नहीं होता
476
आपकी माँ हमेशा एरर (error) जाँचने को क्यों कहती थीं
477
क्लाइंट से पढ़ना
478
सर्वर एक समय में सिर्फ़ एक व्यक्ति से बात कर सकता है
485
हर क्लाइंट के लिए एक प्रोसेस fork() कर सकते हैं
486
वेब क्लाइंट लिखना
490
क्लाइंट का राज चलता है
491
IP पते के लिए सॉकेट बनाओ
492
getaddrinfo() डोमेन के पते निकालता है
493
आपका C टूलबॉक्स
500
📄 पेज xxiv
12 — थ्रेड (threads)
यह एक समानांतर दुनिया है (It's a parallel world)
प्रोग्रामों को अक्सर एक साथ कई काम करने पड़ते हैं।
POSIX थ्रेड (POSIX threads) कोड के कई टुकड़ों को समानांतर (parallel) चलवाकर आपके कोड को ज़्यादा प्रतिक्रियाशील (responsive) बना सकते हैं। पर सावधान! थ्रेड ताक़तवर टूल हैं, पर आप नहीं चाहेंगे कि वे आपस में टकराएँ। इस अध्याय में आप ट्रैफ़िक सिग्नल और लेन मार्कर लगाना सीखेंगे ताकि कोड का जाम न लगे। अंत तक आप POSIX थ्रेड बनाना और संवेदनशील डेटा की अखंडता (integrity) बचाने के लिए सिंक्रोनाइज़ेशन (synchronization) की तरकीबें इस्तेमाल करना जान जाएँगे।
चित्र के लेबल: दोनों कारें दो थ्रेड हैं। दोनों एक ही साझा वेरिएबल (shared variable) तक पहुँचना चाहती हैं · ट्रैफ़िक सिग्नल दोनों थ्रेड को एक ही समय में साझा वेरिएबल तक पहुँचने से रोकते हैं
विषय
पेज
काम क्रमवार होते हैं… या नहीं…
502
…और प्रोसेस हमेशा जवाब नहीं होतीं
503
सरल प्रोसेस एक समय में एक ही काम करती हैं
504
अतिरिक्त स्टाफ़ रखो: थ्रेड इस्तेमाल करो
505
थ्रेड कैसे बनाएँ?
506
pthread_create से थ्रेड बनाओ
507
कोड थ्रेड-सेफ़ (thread-safe) नहीं है
512
आपको ट्रैफ़िक सिग्नल जोड़ने होंगे
513
ट्रैफ़िक सिग्नल की तरह म्यूटेक्स (mutex) इस्तेमाल करो
514
आपका C टूलबॉक्स
521
📄 पेज xxv
🔬 C लैब 3 (C Lab 3): ब्लास्टेरॉइड्स (Blasteroids)
इस लैब में आप अब तक के सबसे लोकप्रिय और लंबे समय तक चले वीडियो गेमों में से एक को श्रद्धांजलि देंगे। ब्लास्टेरॉइड्स (Blasteroids) लिखने का समय आ गया है! 🎮
📄 पेज xxvi
परिशिष्ट i (appendix i) — बचे-खुचे विषय (leftovers)
वे दस बातें जो हमने नहीं बताईं (The top ten things we didn't cover)
इतना सब होने के बाद भी थोड़ा और बाक़ी है।
कुछ बातें और हैं जो हमें लगता है आपको पता होनी चाहिए। इन्हें अनदेखा करना हमें ठीक नहीं लगा, भले ही इन्हें बस संक्षेप में बताना काफ़ी हो। और हम चाहते थे कि आपको ऐसी किताब मिले जिसे उठाने के लिए जिम में ख़ास ट्रेनिंग न लेनी पड़े। इसलिए किताब रखने से पहले इन छोटी-छोटी बातों को पढ़ लीजिए।
परिशिष्ट ii (appendix ii) — दोहराव का सार (Revision roundup)
कभी चाहा है कि C के सारे बढ़िया तथ्य एक जगह मिल जाएँ?
यह किताब में बताए सभी C विषयों और सिद्धांतों का सार है। इन्हें देखिए और परखिए कि क्या आपको सब याद हैं। हर तथ्य के साथ वह अध्याय भी लिखा है जहाँ से वह आया, ताकि याद दिलाने की ज़रूरत पड़े तो आसानी से वापस जा सकें। आप चाहें तो इन पन्नों को काटकर अपनी दीवार पर चिपका भी सकते हैं। ✂️
चित्र के कुछ नमूना तथ्य:
fork() मौजूदा प्रोसेस की नक़ल बनाता है। (अध्याय 10)
प्रोसेस पाइप (pipes) से आपस में बात कर सकती हैं। (अध्याय 10)
pipe() संचार का पाइप बनाता है। (अध्याय 10)
exit() प्रोग्राम को तुरंत रोक देता है। (अध्याय 10)
system() किसी स्ट्रिंग को कंसोल कमांड की तरह चलाता है। (अध्याय 9)
waitpid() किसी प्रोसेस के पूरा होने का इंतज़ार करता है। (अध्याय 10)
execl() = आर्गुमेंट (args) की सूची · execle() = args की सूची + एनवायरनमेंट · execlp() = args की सूची + सर्च पाथ · execv() = args का ऐरे · execve() = args का ऐरे + एनवायरनमेंट · execvp() = args का ऐरे + सर्च पाथ। (अध्याय 9)
नोट: परिशिष्ट वाले पन्नों का पेज नंबर (556) और बाक़ी ब्योरा किताब के अंत में है।
🚪 भाग 2 — परिचय (the intro): यह किताब कैसे इस्तेमाल करें
📄 पेज xxvii
"मुझे यक़ीन नहीं होता कि उन्होंने इसे C की किताब में डाल दिया।" 😮
इस हिस्से में हम उस सुलगते सवाल का जवाब देते हैं:
"तो उन्होंने इसे C की किताब में क्यों डाला?"
📄 पेज xxviii
👥 यह किताब किसके लिए है?
अगर आप इन सबका जवाब "हाँ" में दे सकते हैं:
✅ क्या आप किसी और प्रोग्रामिंग भाषा (programming language) में प्रोग्रामिंग करना पहले से जानते हैं?
✅ क्या आप C में महारत हासिल करना, सॉफ़्टवेयर की अगली बड़ी चीज़ बनाना, छोटी-मोटी दौलत कमाना और अपने निजी द्वीप पर रिटायर होना चाहते हैं? 🏝️
✅ क्या आप घंटों किसी का लेक्चर (lecture) सुनते रहने की बजाय, जो सीखते हैं उसे करके देखना और लागू करना पसंद करते हैं?
👉 तो यह किताब आपके लिए है।
🚫 किसे इस किताब से दूर रहना चाहिए?
अगर आप इनमें से किसी का भी जवाब "हाँ" में दे सकते हैं:
❌ क्या आप C का कोई त्वरित परिचय या संदर्भ (reference) किताब ढूँढ रहे हैं?
❌ क्या आप कुछ नया सीखने की बजाय 15 चिल्लाते बंदरों से अपने पैर के नाखून खिंचवाना पसंद करेंगे? क्या आपको लगता है कि C की किताब में सब कुछ होना चाहिए, भले ही पढ़ने वाला बोरियत से रो पड़े?
👉 तो यह किताब आपके लिए नहीं है।
💬 [मार्केटिंग विभाग की ओर से नोट: यह किताब क्रेडिट कार्ड रखने वाले हर व्यक्ति के लिए है… चेक भी चलेगा।]
🗨️ ठीक है, शायद यह थोड़ा दूर की कौड़ी है। पर कहीं से तो शुरू करना ही पड़ता है, है ना?
📄 पेज xxix
🧠 हमें पता है आप क्या सोच रहे हैं
"यह एक गंभीर C की किताब कैसे हो सकती है?"
"इतने सारे ग्राफ़िक्स (graphics) क्यों हैं?"
"क्या मैं इस तरह सच में सीख सकता हूँ?"
🗨️ आपका दिमाग सोचता है: "यह ज़रूरी है।"
हमें पता है आपका दिमाग क्या सोच रहा है
आपका दिमाग नएपन की चाहत रखता है। वह हमेशा खोजता, स्कैन (scan) करता और किसी असामान्य चीज़ का इंतज़ार करता रहता है। उसे बनाया ही ऐसे गया है, और इसी से आप ज़िंदा रहते हैं।
तो रोज़मर्रा की सामान्य, आम चीज़ों का आपका दिमाग क्या करता है? वह उन्हें रास्ते से हटाने की हर कोशिश करता है ताकि वे उसके असली काम में दख़ल न दें। उसका असली काम है उन चीज़ों को दर्ज करना जो मायने रखती हैं। वह उबाऊ चीज़ों को सहेजने की ज़हमत नहीं उठाता। वे "यह साफ़ तौर पर ज़रूरी नहीं है" वाले फ़िल्टर (filter) से आगे निकल ही नहीं पातीं।
आपका दिमाग कैसे जानता है कि क्या ज़रूरी है? मान लीजिए आप पैदल सैर पर हैं और अचानक आपके सामने एक बाघ कूद पड़ता है। आपके सिर और शरीर में क्या होता है?
न्यूरॉन (neurons) सक्रिय हो जाते हैं।
भावनाएँ उफ़ान पर आ जाती हैं।
रसायनों की बाढ़ आ जाती है।
और इसी से आपके दिमाग को पता चलता है…
⚠️ यह ज़रूरी होगा! इसे भूलना मत!
पर अब सोचिए आप घर या लाइब्रेरी में हैं। यह सुरक्षित, गर्म, बाघ-रहित जगह है। आप पढ़ रहे हैं। परीक्षा की तैयारी कर रहे हैं। या कोई कठिन तकनीकी विषय सीखने की कोशिश कर रहे हैं, जिसके बारे में आपके बॉस को लगता है कि एक हफ़्ता, ज़्यादा से ज़्यादा दस दिन लगेंगे।
🗨️ "बढ़िया। बस 600 और नीरस, सूखे, उबाऊ पन्ने बाक़ी हैं।"
बस एक समस्या है। आपका दिमाग आप पर बड़ा एहसान करने की कोशिश कर रहा है। वह पक्का कर रहा है कि यह साफ़ तौर पर बेकार सामग्री उसके सीमित संसाधनों को न भर दे। वे संसाधन बड़ी चीज़ें सहेजने के लिए बेहतर हैं। जैसे बाघ। जैसे आग का ख़तरा। जैसे यह कि आपको अपने फ़ेसबुक पेज पर वे पार्टी की तस्वीरें कभी नहीं डालनी चाहिए थीं। और अपने दिमाग को यह कहने का कोई आसान तरीक़ा नहीं है: "प्यारे दिमाग, बहुत शुक्रिया, पर चाहे यह किताब कितनी भी नीरस हो और चाहे मैं भावनात्मक रिक्टर स्केल (Richter scale) पर अभी कितना भी कम दर्ज हो रहा होऊँ, मैं सच में चाहता हूँ कि तुम यह सब याद रखो।"
🗨️ आपका दिमाग सोचता है: "इसे सहेजने लायक नहीं है।"
📄 पेज xxx
🎓 हम "Head First" पाठक को एक सीखने वाले की तरह देखते हैं
कुछ सीखने के लिए क्या चाहिए? पहले तो आपको उसे समझना होगा, फिर यह पक्का करना होगा कि आप उसे भूल न जाएँ। यह बात आपके दिमाग में तथ्य ठूँसने की नहीं है। संज्ञानात्मक विज्ञान (cognitive science), न्यूरोबायोलॉजी (neurobiology) और शैक्षिक मनोविज्ञान (educational psychology) के नवीनतम शोध के आधार पर, सीखने में पन्ने पर लिखे शब्दों से कहीं ज़्यादा लगता है। हमें पता है आपके दिमाग को क्या चालू करता है।
Head First के कुछ सीखने के मूल सिद्धांत
🖼️ इसे दृश्य (visual) बनाओ।
चित्र शब्दों से कहीं ज़्यादा याद रहते हैं और सीखने को बहुत ज़्यादा प्रभावी बनाते हैं (याद करने और उसे आगे लगाने वाले अध्ययनों में 89% तक सुधार)। इससे चीज़ें ज़्यादा समझ में भी आती हैं। शब्दों को उन ग्राफ़िक्स के भीतर या पास रखिए जिनसे वे जुड़े हैं, पन्ने के नीचे या किसी दूसरे पन्ने पर नहीं। तब सीखने वाले उस सामग्री से जुड़ी समस्याएँ हल करने में दोगुने तक सफल होंगे।
💬 बातचीत वाली और व्यक्तिगत शैली इस्तेमाल करो।
हाल के अध्ययनों में, जब सामग्री सीधे पाठक से बात करती थी, यानी औपचारिक लहजे की बजाय उत्तम पुरुष (first-person) की बातचीत वाली शैली में, तब छात्रों ने सीखने के बाद के टेस्ट में 40% तक बेहतर प्रदर्शन किया। भाषण देने की जगह कहानियाँ सुनाइए। आम बोलचाल की भाषा इस्तेमाल कीजिए। ख़ुद को ज़्यादा गंभीरता से मत लीजिए। आप किस पर ज़्यादा ध्यान देंगे: एक रोचक डिनर-पार्टी के साथी पर, या किसी लेक्चर पर?
🧩 सीखने वाले को ज़्यादा गहराई से सोचने पर मजबूर करो।
दूसरे शब्दों में, जब तक आप अपने न्यूरॉन को सक्रिय रूप से कसरत नहीं करवाते, आपके सिर में कुछ ख़ास नहीं होता। पाठक का प्रेरित, जुड़ा हुआ, जिज्ञासु और समस्याएँ हल करने, निष्कर्ष निकालने और नया ज्ञान बनाने के लिए प्रेरित होना ज़रूरी है। इसके लिए आपको चुनौतियाँ, अभ्यास और सोचने पर मजबूर करने वाले सवाल चाहिए, और ऐसी गतिविधियाँ जो दिमाग के दोनों हिस्सों और कई इंद्रियों को लगाएँ।
👀 पाठक का ध्यान पाओ, और उसे बनाए रखो।
हम सबको कभी न कभी ऐसा अनुभव हुआ है: "मैं सच में यह सीखना चाहता हूँ, पर पहले पन्ने के बाद जागा नहीं रह सकता।" आपका दिमाग उन चीज़ों पर ध्यान देता है जो आम से हटकर हों, दिलचस्प हों, अजीब हों, आँख खींचने वाली हों, अनपेक्षित हों। कोई नया, कठिन, तकनीकी विषय सीखना उबाऊ होना ज़रूरी नहीं है। अगर वह उबाऊ न हो तो आपका दिमाग उसे कहीं ज़्यादा तेज़ी से सीखेगा।
❤️ उनकी भावनाओं को छुओ।
अब हम जानते हैं कि किसी चीज़ को याद रखने की आपकी क्षमता काफ़ी हद तक उसकी भावनात्मक सामग्री पर निर्भर है। आपको वही याद रहता है जिसकी आपको परवाह होती है। आपको तब याद रहता है जब आप कुछ महसूस करते हैं। नहीं, हम एक लड़के और उसके कुत्ते की दिल तोड़ने वाली कहानियों की बात नहीं कर रहे। हम बात कर रहे हैं आश्चर्य, जिज्ञासा, मज़े, "ये क्या…?" जैसी भावनाओं की, और उस "मैं तो राजा हूँ!" वाले एहसास की जो तब आता है जब आप कोई पहेली सुलझाते हैं, कुछ ऐसा सीखते हैं जिसे बाक़ी सब कठिन मानते हैं, या यह समझते हैं कि आप कुछ ऐसा जानते हैं जो इंजीनियरिंग विभाग का "मैं तुमसे ज़्यादा तकनीकी हूँ" वाला बॉब नहीं जानता।
📄 पेज xxxi
🔍 मेटाकॉग्निशन (metacognition): सोचने के बारे में सोचना
अगर आप सच में सीखना चाहते हैं, और ज़्यादा जल्दी और ज़्यादा गहराई से सीखना चाहते हैं, तो इस पर ध्यान दीजिए कि आप ध्यान कैसे देते हैं। सोचिए कि आप कैसे सोचते हैं। जानिए कि आप कैसे सीखते हैं।
हममें से ज़्यादातर ने बचपन में मेटाकॉग्निशन या सीखने के सिद्धांत (learning theory) के कोर्स नहीं किए। हमसे सीखने की उम्मीद की गई, पर सीखना सिखाया शायद ही कभी गया।
🗨️ "सोचता हूँ अपने दिमाग को बहलाकर यह सब याद कैसे रखवाऊँ…"
पर हम मानकर चलते हैं कि अगर यह किताब आपके हाथ में है, तो आप सच में C में प्रोग्रामिंग सीखना चाहते हैं। और शायद आप ज़्यादा समय भी नहीं लगाना चाहते। अगर आप इस किताब में पढ़ी चीज़ें इस्तेमाल करना चाहते हैं, तो आपको जो पढ़ा वह याद रखना होगा। और उसके लिए उसे समझना ज़रूरी है। इस किताब से, या किसी भी किताब या सीखने के अनुभव से, सबसे ज़्यादा पाने के लिए अपने दिमाग की ज़िम्मेदारी लीजिए। सोचिए अपने दिमाग का इस सामग्री पर क्या असर हो रहा है।
तरकीब यह है कि आपका दिमाग इस नई सामग्री को बेहद ज़रूरी माने। आपकी भलाई के लिए निर्णायक। बाघ जितनी ज़रूरी। वरना आपको लगातार लड़ाई लड़नी पड़ेगी, जिसमें आपका दिमाग नई सामग्री को टिकने न देने की पूरी कोशिश करेगा।
तो आप अपने दिमाग से प्रोग्रामिंग को भूखे बाघ जैसा गंभीर कैसे मनवाएँ?
एक धीमा, उबाऊ तरीक़ा है, और एक तेज़, ज़्यादा असरदार तरीक़ा।
🐢 धीमा तरीक़ा है सरासर दोहराव। आप जानते ही हैं कि अगर आप एक ही चीज़ को अपने दिमाग में बार-बार ठोंकते रहें तो सबसे नीरस विषय भी सीखा और याद रखा जा सकता है। काफ़ी दोहराव के बाद आपका दिमाग कहता है: "इसे यह ज़रूरी नहीं लग रहा, पर यह एक ही चीज़ को बार-बार देख रहा है, तो शायद यह ज़रूरी होगी।"
🐇 तेज़ तरीक़ा है वह सब करना जो दिमाग की गतिविधि बढ़ाए, ख़ासकर अलग-अलग तरह की गतिविधि। पिछले पन्ने की बातें इस हल का बड़ा हिस्सा हैं, और ये सब साबित हो चुकी हैं कि आपके दिमाग को आपके पक्ष में काम करने में मदद करती हैं। उदाहरण के लिए, अध्ययन बताते हैं कि शब्दों को उन चित्रों के भीतर रखने से जिनका वे वर्णन करते हैं (न कि पन्ने में कहीं और, जैसे कैप्शन या मुख्य पाठ में), आपका दिमाग यह समझने की कोशिश करता है कि शब्द और चित्र कैसे जुड़े हैं, और इससे ज़्यादा न्यूरॉन सक्रिय होते हैं। ज़्यादा न्यूरॉन सक्रिय होना = आपके दिमाग के लिए यह समझने के ज़्यादा मौक़े कि यह ध्यान देने लायक चीज़ है, और शायद दर्ज करने लायक भी।
बातचीत वाली शैली इसलिए मदद करती है क्योंकि लोग तब ज़्यादा ध्यान देते हैं जब उन्हें लगता है कि वे बातचीत में हैं, क्योंकि उनसे उम्मीद की जाती है कि वे साथ चलें और अपनी बात रखें। मज़े की बात यह है कि आपके दिमाग को ज़रूरी नहीं कि इससे फ़र्क़ पड़े कि "बातचीत" आपके और किसी किताब के बीच है! दूसरी ओर, अगर लेखन शैली औपचारिक और सूखी हो, तो आपका दिमाग उसे वैसे ही महसूस करता है जैसे आप किसी ऐसे कमरे में बैठकर लेक्चर सुनते हैं जो निष्क्रिय श्रोताओं से भरा हो। जागने की कोई ज़रूरत नहीं।
पर चित्र और बातचीत वाली शैली तो बस शुरुआत हैं…
📄 पेज xxxii
🛠️ हमने यह किया
🖼️ हमने चित्र इस्तेमाल किए, क्योंकि आपका दिमाग पाठ के लिए नहीं, दृश्यों के लिए बना है। आपके दिमाग के हिसाब से एक चित्र सचमुच हज़ार शब्दों के बराबर होता है। और जहाँ पाठ और चित्र साथ काम करते हैं, वहाँ हमने पाठ को चित्र के भीतर रखा, क्योंकि आपका दिमाग तब ज़्यादा असरदार ढंग से काम करता है जब पाठ उस चीज़ के भीतर हो जिसका वह ज़िक्र करता है, कैप्शन में या मुख्य पाठ में कहीं दबा हुआ नहीं।
🔁 हमने दोहराव इस्तेमाल किया, यानी एक ही बात अलग-अलग तरीक़ों से, अलग-अलग माध्यमों में और कई इंद्रियों से कही, ताकि सामग्री आपके दिमाग के एक से ज़्यादा हिस्सों में दर्ज होने की संभावना बढ़े।
🎭 हमने अवधारणाओं और चित्रों को अनपेक्षित ढंग से इस्तेमाल किया, क्योंकि आपका दिमाग नएपन के लिए ट्यून है। और हमने ऐसे चित्र और विचार इस्तेमाल किए जिनमें कुछ न कुछ भावनात्मक पुट है, क्योंकि आपका दिमाग भावनाओं की जैव-रसायन पर ध्यान देने के लिए ट्यून है। जो आपको कुछ महसूस कराता है उसके याद रहने की संभावना ज़्यादा होती है, चाहे वह एहसास थोड़े हास्य, आश्चर्य या दिलचस्पी से ज़्यादा कुछ न हो।
🗣️ हमने व्यक्तिगत, बातचीत वाली शैली इस्तेमाल की, क्योंकि आपका दिमाग तब ज़्यादा ध्यान देने के लिए ट्यून है जब उसे लगे कि आप बातचीत में हैं, बजाय इसके कि आप निष्क्रिय होकर कोई प्रेज़ेंटेशन सुन रहे हैं। पढ़ते समय भी आपका दिमाग यही करता है।
✍️ हमने 80 से ज़्यादा गतिविधियाँ रखीं, क्योंकि आपका दिमाग तब ज़्यादा सीखने और याद रखने के लिए ट्यून है जब आप काम करते हैं, बजाय किसी चीज़ के बारे में पढ़ने के। और हमने अभ्यास ऐसे रखे जो चुनौतीपूर्ण हों पर किए जा सकें, क्योंकि ज़्यादातर लोग यही पसंद करते हैं।
🎨 हमने सीखने की कई शैलियाँ इस्तेमाल कीं, क्योंकि हो सकता है आप क़दम-दर-क़दम प्रक्रिया पसंद करें, जबकि कोई और पहले पूरी तस्वीर समझना चाहता हो, और कोई और बस एक उदाहरण देखना चाहे। पर आपकी अपनी पसंद चाहे जो हो, एक ही सामग्री को कई तरीक़ों से दिखाए जाने से सबको फ़ायदा होता है।
🧠 हमने आपके दिमाग के दोनों हिस्सों के लिए सामग्री रखी, क्योंकि आप अपने दिमाग का जितना ज़्यादा हिस्सा लगाएँगे, सीखने और याद रखने की संभावना उतनी बढ़ेगी, और आप उतनी देर ध्यान टिका पाएँगे। दिमाग के एक हिस्से के काम करने का अक्सर मतलब होता है कि दूसरे को आराम मिलता है, इसलिए आप ज़्यादा देर तक सीखने में उत्पादक रह सकते हैं।
👁️ हमने ऐसी कहानियाँ और अभ्यास रखे जो एक से ज़्यादा दृष्टिकोण दिखाते हैं, क्योंकि आपका दिमाग तब ज़्यादा गहराई से सीखने के लिए ट्यून है जब उसे आकलन और निर्णय करने पड़ें।
🏋️ हमने चुनौतियाँ रखीं, अभ्यासों के साथ, और ऐसे सवाल पूछकर जिनका हमेशा सीधा जवाब नहीं होता, क्योंकि आपका दिमाग तब सीखने और याद रखने के लिए ट्यून है जब उसे किसी चीज़ पर मेहनत करनी पड़े। सोचिए: आप जिम में लोगों को देखकर ही अपने शरीर को सुडौल नहीं बना सकते। पर हमने पूरी कोशिश की है कि जब आप मेहनत करें तो सही चीज़ों पर करें। यानी आप किसी कठिन उदाहरण को समझने में, या कठिन, शब्दजाल-भरे या ज़रूरत से ज़्यादा संक्षिप्त पाठ को खोलने में एक भी अतिरिक्त डेंड्राइट (dendrite) न खर्च करें।
🧑🤝🧑 हमने लोगों को रखा। कहानियों, उदाहरणों, चित्रों वग़ैरह में, क्योंकि, आख़िर, आप एक इंसान हैं। और आपका दिमाग चीज़ों से ज़्यादा लोगों पर ध्यान देता है।
📄 पेज xxxiii
🧠💪 आप अपने दिमाग को क़ाबू में करने के लिए क्या कर सकते हैं
हमने अपना हिस्सा कर दिया। बाक़ी आप पर है। ये सुझाव बस एक शुरुआत हैं। अपने दिमाग की सुनिए और समझिए कि आपके लिए क्या काम करता है और क्या नहीं। नई चीज़ें आज़माइए।
✂️ इसे काटकर अपने फ़्रिज पर चिपका लीजिए।
#
सुझाव
1
धीरे चलो। जितना ज़्यादा आप समझेंगे, उतना कम आपको रटना पड़ेगा। सिर्फ़ पढ़ो मत। रुककर सोचो। जब किताब आपसे कोई सवाल पूछे, तो सीधे जवाब पर मत कूदो। कल्पना करो कि कोई सचमुच आपसे सवाल पूछ रहा है। आप अपने दिमाग को जितनी गहराई से सोचने पर मजबूर करेंगे, सीखने और याद रखने की संभावना उतनी बेहतर होगी।
2
अभ्यास करो। अपने नोट्स ख़ुद लिखो। हमने अभ्यास रखे हैं, पर अगर हम उन्हें आपके लिए कर दें, तो यह वैसा होगा जैसे आपकी कसरत कोई और कर रहा हो। और सिर्फ़ अभ्यास देखो मत। पेंसिल इस्तेमाल करो। इसके बहुत सबूत हैं कि सीखते समय शारीरिक गतिविधि से सीखना बढ़ सकता है।
3
"कोई सवाल बेवक़ूफ़ाना नहीं होता" पढ़ो। यानी सारे। वे वैकल्पिक साइडबार (sidebar) नहीं हैं, वे मुख्य सामग्री का हिस्सा हैं! उन्हें मत छोड़ो।
4
इसे सोने से पहले आख़िरी चीज़ बनाओ। या कम से कम आख़िरी चुनौतीपूर्ण चीज़। सीखने का एक हिस्सा (ख़ासकर दीर्घकालिक स्मृति में पहुँचना) किताब रखने के बाद होता है। आपके दिमाग को ख़ुद अकेले समय चाहिए, ताकि वह और प्रोसेसिंग (processing) कर सके। अगर उस समय आप कुछ नया डाल दें, तो जो अभी सीखा उसमें से कुछ खो जाएगा।
5
इस पर बात करो। ज़ोर से। बोलने से दिमाग का एक अलग हिस्सा सक्रिय होता है। अगर आप कुछ समझने की कोशिश कर रहे हैं, या बाद में उसे याद रखने की संभावना बढ़ाना चाहते हैं, तो उसे ज़ोर से बोलिए। और बेहतर, किसी और को ज़ोर से समझाने की कोशिश कीजिए। आप ज़्यादा जल्दी सीखेंगे, और शायद ऐसे विचार भी पा जाएँगे जो पढ़ते समय आपको पता नहीं थे।
6
अपने दिमाग की सुनो। ध्यान दो कि आपका दिमाग ओवरलोड (overload) तो नहीं हो रहा। अगर आप ऊपर-ऊपर से पढ़ने लगें या अभी पढ़ा हुआ भूलने लगें, तो ब्रेक का समय है। एक सीमा के बाद और ठूँसकर आप तेज़ नहीं सीखेंगे, उलटे प्रक्रिया बिगड़ भी सकती है।
7
पानी पियो। ख़ूब सारा। आपका दिमाग तरल के अच्छे स्नान में सबसे बेहतर काम करता है। निर्जलीकरण (dehydration), जो प्यास लगने से पहले ही हो सकता है, संज्ञानात्मक क्षमता घटा देता है।
8
कुछ महसूस करो। आपके दिमाग को जानना होगा कि यह मायने रखता है। कहानियों से जुड़ो। तस्वीरों के अपने कैप्शन बनाओ। किसी बुरे चुटकुले पर कराहना भी कुछ भी न महसूस करने से बेहतर है।
9
ख़ूब कोड लिखो! C में प्रोग्रामिंग सीखने का सिर्फ़ एक तरीक़ा है: ख़ूब कोड लिखना। और यही आप इस किताब में करेंगे। कोडिंग एक कौशल है, और इसमें अच्छा बनने का एकमात्र तरीक़ा अभ्यास है। हम आपको ख़ूब अभ्यास देंगे: हर अध्याय में ऐसे अभ्यास हैं जो आपके सामने हल करने के लिए एक समस्या रखते हैं। उन्हें यूँ ही मत छोड़ो। सीखने का बहुत हिस्सा तब होता है जब आप अभ्यास हल करते हैं। हमने हर अभ्यास का हल भी दिया है। अटक जाओ तो हल झाँकने से डरो मत! (किसी छोटी चीज़ में उलझ जाना आसान है।) पर हल देखने से पहले समस्या ख़ुद हल करने की कोशिश करो। और अगले हिस्से पर जाने से पहले उसे चलता हुआ ज़रूर बना लो।
📄 पेज xxxiv
📖 मुझे पढ़ो (Read me)
यह सीखने का एक अनुभव है, संदर्भ पुस्तक नहीं। हमने जान-बूझकर वह सब हटा दिया है जो किताब के उस बिंदु पर जो भी हम सीख रहे हैं उसे सीखने में आड़े आ सकता था। और पहली बार में आपको शुरू से शुरू करना होगा, क्योंकि किताब मानकर चलती है कि आप पहले क्या देख और सीख चुके हैं।
🔹 हम मानते हैं कि आप C में नए हैं, प्रोग्रामिंग में नहीं।
हम मानते हैं कि आप पहले कुछ प्रोग्रामिंग कर चुके हैं। बहुत ज़्यादा नहीं, पर हम मानेंगे कि आपने किसी और भाषा, जैसे जावास्क्रिप्ट (JavaScript), में लूप (loops) और वेरिएबल (variables) जैसी चीज़ें देखी हैं। C असल में काफ़ी उन्नत भाषा है, इसलिए अगर आपने कभी प्रोग्रामिंग की ही नहीं, तो हो सकता है इसे शुरू करने से पहले आप कोई और किताब पढ़ना चाहें। हम Head First Programming से शुरू करने का सुझाव देंगे।
🔹 आपको अपने कंप्यूटर पर C कंपाइलर इंस्टॉल करना होगा।
पूरी किताब में हम GNU कंपाइलर कलेक्शन (Gnu Compiler Collection, gcc) इस्तेमाल करेंगे, क्योंकि यह मुफ़्त है और, सच कहें तो, हमें लगता है यह बहुत अच्छा कंपाइलर है। आपको पक्का करना होगा कि आपकी मशीन पर gcc इंस्टॉल है। अच्छी ख़बर यह है कि अगर आपके पास Linux कंप्यूटर है, तो gcc पहले से होना चाहिए। अगर आप Mac इस्तेमाल करते हैं, तो आपको Xcode/डेवलपर टूल (Developer tools) इंस्टॉल करने होंगे। ये Apple App Store से या सीधे Apple से डाउनलोड हो सकते हैं। अगर आप Windows मशीन पर हैं, तो आपके पास कुछ विकल्प हैं। साइगविन (Cygwin, http://www.cygwin.com) आपको UNIX वातावरण का पूरा सिमुलेशन देता है, gcc समेत। पर अगर आप ऐसे प्रोग्राम बनाना चाहते हैं जो सीधे-सादे Windows पर चलें, तो आप Windows के लिए Minimalist GNU (MinGW, http://www.mingw.org) इंस्टॉल करना चाहेंगे।
इस किताब का सारा कोड इन सभी ऑपरेटिंग सिस्टम पर चलने के लिए है, और हमने पूरी कोशिश की है कि ऐसा कुछ न लिखें जो सिर्फ़ एक ही तरह के कंप्यूटर पर चले। कभी-कभी कुछ अंतर होंगे, और हम उन्हें आपको बता देंगे।
🔹 हम कुछ बुनियादी C अवधारणाएँ सिखाकर शुरू करते हैं, और फिर तुरंत C को आपके काम में लगाने लगते हैं।
हम अध्याय 1 में C के बुनियादी तत्व कवर करते हैं। इस तरह, जब आप अध्याय 2 तक पहुँचेंगे, तब तक आप ऐसे प्रोग्राम बना रहे होंगे जो सचमुच कुछ असली, उपयोगी और (अरे बाप रे!) मज़ेदार करते हैं। किताब का बाक़ी हिस्सा आपके C कौशल पर आगे बनता है और आपको जल्दी ही C के नौसिखिए से कोडिंग के निंजा मास्टर (ninja master) में बदल देता है। 🥷
📄 पेज xxxv
🔹 अभ्यास वैकल्पिक नहीं हैं।
अभ्यास और गतिविधियाँ कोई अतिरिक्त चीज़ नहीं हैं, वे किताब की मुख्य सामग्री का हिस्सा हैं। कुछ याददाश्त के लिए हैं, कुछ समझने के लिए, और कुछ आपको जो सीखा उसे लागू करने में मदद करेंगे। अभ्यास मत छोड़िए।
🔹 दोहराव जान-बूझकर है, और ज़रूरी है।
Head First किताब में एक साफ़ अंतर यह है कि हम चाहते हैं कि आप सचमुच समझें। और हम चाहते हैं कि किताब ख़त्म करने पर आपको जो सीखा वह याद रहे। ज़्यादातर संदर्भ पुस्तकों का लक्ष्य याद रखना और दोहराना नहीं होता, पर यह किताब सीखने के बारे में है, इसलिए आप देखेंगे कि कुछ अवधारणाएँ एक से ज़्यादा बार आती हैं।
🔹 उदाहरण यथासंभव छोटे रखे गए हैं।
हमारे पाठक बताते हैं कि 200 पंक्तियों के उदाहरण में से वे दो पंक्तियाँ ढूँढना बहुत झुँझलाने वाला पाते हैं जो उन्हें समझनी हैं। इस किताब के ज़्यादातर उदाहरण सबसे छोटे संभव संदर्भ में दिखाए गए हैं, ताकि जो हिस्सा आप सीख रहे हैं वह साफ़ और सरल रहे। उम्मीद मत कीजिए कि सारे उदाहरण मज़बूत या पूरे होंगे। वे ख़ास तौर पर सीखने के लिए लिखे गए हैं और हमेशा पूरी तरह चालू नहीं होते।
🔹 "ब्रेन पावर" (Brain Power) अभ्यासों के जवाब नहीं दिए गए हैं।
उनमें से कुछ के लिए कोई सही जवाब नहीं है, और बाक़ी में, ब्रेन पावर गतिविधियों के सीखने के अनुभव का हिस्सा यह है कि आप ख़ुद तय करें कि आपके जवाब कब और क्या सही हैं। कुछ ब्रेन पावर अभ्यासों में आपको सही दिशा दिखाने वाले संकेत मिलेंगे।
📄 पेज xxxvi
👨🔬 तकनीकी समीक्षा टीम (The technical review team)
डेव किटाब्जियन के पास इलेक्ट्रिकल और कंप्यूटर इंजीनियरिंग में दो डिग्रियाँ हैं और फ़ॉर्च्यून 500 कंपनियों से लेकर हाई-टेक स्टार्टअप तक के ग्राहकों के लिए सूचना प्रणाली के समाधानों की सलाह, एकीकरण, डिज़ाइन और निर्माण का लगभग 20 साल का अनुभव है। काम के बाहर, डेव को गिटार और पियानो बजाना और अपनी पत्नी और तीन बच्चों के साथ समय बिताना पसंद है।
विंस मिलनर 20 साल से ज़्यादा समय से अलग-अलग प्लेटफ़ॉर्म पर C (और कई दूसरी भाषाओं) में डेवलपमेंट कर रहे हैं। जब वे गणित में अपनी मास्टर्स की पढ़ाई नहीं कर रहे होते, तो उन्हें छह साल के बच्चों से बोर्ड गेम में हारते और घर बदलने में नाकाम होते पाया जा सकता है। 😄
📄 पेज xxxvii
🙏 आभार (Acknowledgments)
हमारे संपादक: ब्रायन सॉयर (Brian Sawyer) का बहुत धन्यवाद कि उन्होंने पहले-पहल हमसे यह किताब लिखवाई। ब्रायन ने हर क़दम पर हम पर भरोसा किया, हमें नए विचार आज़माने की आज़ादी दी, और जब डेडलाइन (deadlines) नज़दीक आईं तो ज़्यादा घबराए नहीं।
O'Reilly टीम: इन लोगों का बड़ा शुक्रिया जिन्होंने रास्ते में हमारी मदद की: कैरन शेनर (Karen Shaner) को उनकी कमाल की चित्र-खोज की महारत और आम तौर पर पहिए चलते रखने के लिए; लॉरी पेट्रिकी (Laurie Petrycki) को बॉस्टन में हमारा पेट भरा और हमें प्रेरित रखने के लिए; ब्रायन जेप्सन (Brian Jepson) को हमें आर्डुइनो की अद्भुत दुनिया से मिलवाने के लिए; और शुरुआती रिलीज़ टीम को किताब के शुरुआती संस्करण डाउनलोड के लिए उपलब्ध कराने के लिए। अंत में, रेचल मोनाघन (Rachel Monaghan) और प्रोडक्शन टीम का धन्यवाद कि उन्होंने किताब को निर्माण प्रक्रिया से कुशलता से गुज़ारा और पर्दे के पीछे इतनी मेहनत की। आप लोग कमाल हैं।
परिवार, दोस्त और सहकर्मी: Head First के सफ़र में हमने बहुत दोस्त बनाए हैं। लू बार (Lou Barr), ब्रेट मैक्लॉफ़लिन (Brett McLaughlin) और सैंडर्स क्लाइनफ़ेल्ड (Sanders Kleinfeld) का विशेष धन्यवाद, हमें इतना कुछ सिखाने के लिए।
डेविड: एंडी पार्कर (Andy Parker), जो ब्रॉटन (Joe Broughton), कार्ल जैक्स (Carl Jacques), साइमन जोन्स (Simon Jones) और उन अनेक दोस्तों का धन्यवाद, जिन्होंने मुझसे बहुत कम सुना, क्योंकि मैं लिखने में व्यस्त था।
डॉन: मेरे परिवार और दोस्तों के शानदार सहयोगी नेटवर्क के बिना इस किताब पर काम बहुत मुश्किल होता। मम्मी-पापा, कार्ल, स्टीव, गिल, जैकी, जॉयस और पॉल का विशेष धन्यवाद। आपके हर सहयोग और प्रोत्साहन की मैंने सच में क़द्र की है।
"जिनके बिना नहीं" सूची: हमारी तकनीकी समीक्षा टीम ने हमें सही रास्ते पर रखने और यह पक्का करने में सचमुच उत्कृष्ट काम किया कि हमने जो कवर किया वह बिल्कुल सटीक हो। हम उन सभी लोगों के भी बेहद आभारी हैं जिन्होंने किताब के शुरुआती संस्करणों पर प्रतिक्रिया दी। हमें लगता है उसकी वजह से किताब बहुत, बहुत बेहतर है।
अंत में, कैथी सिएरा (Kathy Sierra) और बर्ट बेट्स (Bert Bates) का धन्यवाद, इस असाधारण किताबों की शृंखला को बनाने के लिए।
📄 पेज xxxviii
📚 सफ़ारी बुक्स ऑनलाइन (Safari® Books Online)
सफ़ारी बुक्स ऑनलाइन (Safari Books Online, www.safaribooksonline.com) एक ऑन-डिमांड (on-demand) डिजिटल लाइब्रेरी है, जो टेक्नोलॉजी और कारोबार के दुनिया के अग्रणी लेखकों से किताब और वीडियो दोनों रूपों में विशेषज्ञ सामग्री देती है। टेक्नोलॉजी पेशेवर, सॉफ़्टवेयर डेवलपर, वेब डिज़ाइनर, और कारोबारी तथा रचनात्मक पेशेवर सफ़ारी बुक्स ऑनलाइन को शोध, समस्या-समाधान, सीखने और प्रमाणन प्रशिक्षण के अपने प्राथमिक संसाधन के रूप में इस्तेमाल करते हैं।
सफ़ारी बुक्स ऑनलाइन संगठनों, सरकारी एजेंसियों और व्यक्तियों के लिए कई तरह के उत्पाद-मिश्रण और मूल्य कार्यक्रम देती है। सब्सक्राइबर (subscribers) को O'Reilly Media, Prentice Hall Professional, Addison-Wesley Professional, Microsoft Press, Sams, Que, Peachpit Press, Focal Press, Cisco Press, John Wiley & Sons, Syngress, Morgan Kaufmann, IBM Redbooks, Packt, Adobe Press, FT Press, Apress, Manning, New Riders, McGraw-Hill, Jones & Bartlett, Course Technology और दर्जनों और जैसे प्रकाशकों की हज़ारों किताबों, प्रशिक्षण वीडियो और प्रकाशन-पूर्व पांडुलिपियों तक एक पूरी तरह खोजने योग्य डेटाबेस (database) में पहुँच मिलती है। सफ़ारी बुक्स ऑनलाइन के बारे में और जानकारी के लिए कृपया ऑनलाइन देखें।
🌊 भाग 3 — अध्याय 1: C के साथ शुरुआत (getting started with c)
📄 पेज 1
1️⃣ C के साथ शुरुआत
गहरे पानी में कूदो (Diving in)
🗨️ क्या आपको गहरा नीला C पसंद नहीं? आ जाइए, पानी बहुत बढ़िया है! 🌊
क्या आप कंप्यूटर के दिमाग के अंदर झाँकना चाहते हैं?
किसी नए गेम के लिए तेज़ रफ़्तार कोड (high-performance code) लिखना है? आर्डुइनो (Arduino) प्रोग्राम करना है? या अपने iPhone ऐप में वह उन्नत थर्ड-पार्टी लाइब्रेरी (third-party library) इस्तेमाल करनी है? तो C मदद के लिए हाज़िर है। C ज़्यादातर दूसरी भाषाओं से कहीं निचले स्तर (lower level) पर काम करती है, इसलिए C को समझने से आपको बेहतर पता चलता है कि अंदर असल में क्या हो रहा है। C आपको दूसरी भाषाएँ बेहतर समझने में भी मदद कर सकती है। तो कूद पड़िए, अपना कंपाइलर (compiler) उठाइए, और आप जल्दी ही शुरू हो जाएँगे।
📄 पेज 2
⚙️ C कैसे काम करती है (how c works)
C छोटे और तेज़ प्रोग्रामों की भाषा है
C भाषा को छोटे और तेज़ प्रोग्राम बनाने के लिए डिज़ाइन किया गया है। यह ज़्यादातर दूसरी भाषाओं से निचले स्तर की है। इसका मतलब है कि यह ऐसा कोड बनाती है जो मशीनें असल में जो समझती हैं उसके कहीं क़रीब है।
C का काम करने का तरीक़ा
कंप्यूटर असल में सिर्फ़ एक भाषा समझते हैं: मशीन कोड (machine code), यानी 1 और 0 की बाइनरी (binary) धारा। आप कंपाइलर की मदद से अपने C कोड को मशीन कोड में बदलते हैं।
#include <stdio.h>
int main()
{
puts("C Rocks!");
return 0;
}
आप सबसे पहले एक सोर्स फ़ाइल (source file) बनाते हैं। सोर्स फ़ाइल में इंसान के पढ़ने लायक C कोड होता है।
2
कंपाइल (Compile)
आप अपना सोर्स कोड कंपाइलर से गुज़ारते हैं। कंपाइलर एरर (errors) जाँचता है, और जब संतुष्ट हो जाता है, तो सोर्स कोड कंपाइल कर देता है।
3
आउटपुट (Output)rocks
कंपाइलर एक नई फ़ाइल बनाता है जिसे एक्ज़ीक्यूटेबल (executable) कहते हैं। इस फ़ाइल में मशीन कोड होता है, यानी 1 और 0 की धारा जो कंप्यूटर समझता है। और यही वह प्रोग्राम है जिसे आप चला सकते हैं।
🪟 Windows में इसका नाम rocks की जगह rocks.exe होगा।
C वहाँ इस्तेमाल होती है जहाँ गति, जगह और पोर्टेबिलिटी (portability) मायने रखती हैं। ज़्यादातर ऑपरेटिंग सिस्टम C में लिखे हैं। ज़्यादातर दूसरी कंप्यूटर भाषाएँ भी C में लिखी हैं। और ज़्यादातर गेम सॉफ़्टवेयर C में लिखे हैं।
📐 C के तीन मानक (standards)
ANSI C — 1980 के दशक के आख़िर का, सबसे पुराने कोड में इस्तेमाल होता है।
C99 — 1999 का। इसमें बहुत सी चीज़ें ठीक की गईं।
C11 — मौजूदा मानक, 2011 में जारी। इसमें कुछ शानदार नई भाषा सुविधाएँ जुड़ीं।
अलग-अलग संस्करणों में अंतर बहुत बड़े नहीं हैं, और हम रास्ते में उन्हें बताते चलेंगे।
📄 पेज 3
🤔 अनुमान लगाओ कि ये कोड के टुकड़े क्या करते हैं
हर कोड टुकड़ा क्या करता है, इसका अंदाज़ा लगाओ। बताओ कि तुम्हें क्या लगता है कोड क्या करता है।
टुकड़ा 1
int card_count = 11;
if (card_count > 10)
puts("The deck is hot. Increase bet.");
टुकड़ा 2
int c = 10;
while (c > 0) {
puts("I must not write code in class");
c = c - 1;
}
टुकड़ा 3
/* Assume name shorter than 20 chars. */
char ex[20];
puts("Enter boyfriend's name: ");
scanf("%19s", ex);
printf("Dear %s.\n\n\tYou're history.\n", ex);
टुकड़ा 4
char suit = 'H';
switch(suit) {
case 'C':
puts("Clubs");
break;
case 'D':
puts("Diamonds");
break;
case 'H':
puts("Hearts");
break;
default:
puts("Spades");
}
📄 पेज 4
🔓 कोड के टुकड़ों का रहस्य खुला (fragments demystified)
घबराइए मत अगर अभी यह सब समझ नहीं आया। किताब में आगे हर चीज़ विस्तार से समझाई गई है।
टुकड़ा 1
int card_count = 11; // एक इंटीजर (integer) वेरिएबल बनाओ और उसे 11 पर सेट करो
if (card_count > 10) // क्या गिनती 10 से ज़्यादा है?
puts("The deck is hot. Increase bet."); // अगर हाँ, तो कमांड प्रॉम्प्ट पर संदेश दिखाओ
इंटीजर (integer) एक पूर्ण संख्या है।
puts कमांड प्रॉम्प्ट या टर्मिनल (terminal) पर एक स्ट्रिंग (string) दिखाता है।
टुकड़ा 2
int c = 10; // इंटीजर वेरिएबल बनाओ और 10 पर सेट करो
while (c > 0) { // जब तक मान धनात्मक (positive) है…
puts("I must not write code in class"); // …संदेश दिखाओ…
c = c - 1; // …और गिनती घटाओ
} // यह उस कोड का अंत है जिसे दोहराना है
ब्रेस (braces) { } एक ब्लॉक स्टेटमेंट (block statement) परिभाषित करते हैं।
टुकड़ा 3
/* Assume name shorter than 20 chars. */ // यह एक कमेंट (comment) है
char ex[20]; // 20 अक्षरों का ऐरे बनाओ
puts("Enter boyfriend's name: "); // स्क्रीन पर संदेश दिखाओ
scanf("%19s", ex); // यूज़र जो लिखे उसे ऐरे में रखो
printf("Dear %s.\n\n\tYou're history.\n", ex); // लिखे गए टेक्स्ट के साथ संदेश दिखाओ
"%19s" का मतलब है: "यूज़र जो भी टाइप करे, सब ex ऐरे में रख दो।"
%s की जगह अक्षरों की यह स्ट्रिंग यहाँ डाली जाएगी।
टुकड़ा 4
char suit = 'H'; // कैरेक्टर (character) वेरिएबल बनाओ; अक्षर H रखो
switch(suit) { // वेरिएबल का मान देखो
case 'C': // क्या यह 'C' है?
puts("Clubs"); // अगर हाँ, तो "Clubs" शब्द दिखाओ
break; // फिर बाक़ी जाँचें छोड़ दो
case 'D': // क्या यह 'D' है?
puts("Diamonds"); // अगर हाँ, तो "Diamonds" दिखाओ
break; // फिर बाक़ी जाँचें छोड़ दो
case 'H': // क्या यह 'H' है?
puts("Hearts"); // अगर हाँ, तो "Hearts" दिखाओ
break; // फिर बाक़ी जाँचें छोड़ दो
default: // नहीं तो…
puts("Spades"); // "Spades" दिखाओ
} // जाँचों का अंत
switch स्टेटमेंट एक ही वेरिएबल को कई अलग-अलग मानों के लिए जाँचता है।
📄 पेज 5
🧱 पर एक पूरा C प्रोग्राम कैसा दिखता है?
पूरा प्रोग्राम बनाने के लिए आपको अपना कोड एक C सोर्स फ़ाइल में लिखना होगा। C सोर्स फ़ाइलें किसी भी टेक्स्ट एडिटर (text editor) से बन सकती हैं, और उनके फ़ाइल नाम आम तौर पर .c पर ख़त्म होते हैं। यह बस एक परंपरा (convention) है, पर आपको इसका पालन करना चाहिए।
चलिए एक आम C सोर्स फ़ाइल देखें।
/*
* Program to calculate the number of cards in the shoe.
* This code is released under the Vegas Public License.
* (c)2014, The College Blackjack Team.
*/
#include <stdio.h>
int main()
{
int decks;
puts("Enter a number of decks");
scanf("%i", &decks);
if (decks < 1) {
puts("That is not a valid number of decks");
return 1;
}
printf("There are %i cards\n", (decks * 52));
return 0;
}
1️⃣ कमेंट (comment)
C प्रोग्राम आम तौर पर एक कमेंट से शुरू होते हैं। कमेंट फ़ाइल में कोड का उद्देश्य बताता है, और उसमें लाइसेंस या कॉपीराइट की जानकारी भी हो सकती है। यहाँ, या फ़ाइल में कहीं और, कमेंट डालना ज़रूरी नहीं है, पर यह अच्छी आदत है और ज़्यादातर C प्रोग्रामर यही उम्मीद करते हैं।
कमेंट /* से शुरू होता है।
ये * वैकल्पिक हैं। ये बस उसे सुंदर दिखाने के लिए हैं।
कमेंट */ पर ख़त्म होता है।
2️⃣ इन्क्लूड (include) सेक्शन
इसके बाद इन्क्लूड सेक्शन आता है। C बहुत, बहुत छोटी भाषा है और बाहरी लाइब्रेरी (external libraries) के बिना लगभग कुछ नहीं कर सकती। आपको कंपाइलर को बताना होगा कि कौन-सा बाहरी कोड इस्तेमाल करना है, और इसके लिए संबंधित लाइब्रेरी की हेडर फ़ाइलें (header files) शामिल करनी होती हैं। जो हेडर आप सबसे ज़्यादा देखेंगे वह stdio.h है। stdio लाइब्रेरी में वह कोड है जो आपको टर्मिनल से डेटा पढ़ने और उसमें लिखने देता है।
3️⃣ फ़ंक्शन (functions)
सोर्स फ़ाइल में सबसे आख़िर में फ़ंक्शन आते हैं। सारा C कोड फ़ंक्शन के अंदर चलता है। किसी भी C प्रोग्राम का सबसे ज़रूरी फ़ंक्शन main() फ़ंक्शन है। main() फ़ंक्शन आपके प्रोग्राम के सारे कोड की शुरुआती जगह है।
तो चलिए main() फ़ंक्शन को थोड़ा और विस्तार से देखें।
📄 पेज 6
🔍 main() फ़ंक्शन पास से
कंप्यूटर आपका प्रोग्राम main() फ़ंक्शन से चलाना शुरू करेगा। नाम ज़रूरी है: अगर आपके पास main() नाम का फ़ंक्शन नहीं है, तो आपका प्रोग्राम शुरू ही नहीं हो पाएगा।
main() फ़ंक्शन का रिटर्न टाइप (return type) int है। इसका क्या मतलब है? जब कंप्यूटर आपका प्रोग्राम चलाता है, तो उसे यह तय करने का कोई तरीक़ा चाहिए कि प्रोग्राम सफलतापूर्वक चला या नहीं। वह main() फ़ंक्शन का रिटर्न मान (return value) जाँचकर यह करता है। अगर आप अपने main() फ़ंक्शन से 0 लौटाने को कहते हैं, तो इसका मतलब है कि प्रोग्राम सफल रहा। अगर आप कोई और मान लौटाने को कहते हैं, तो इसका मतलब है कि कोई समस्या थी।
int main() // रिटर्न टाइप: main() फ़ंक्शन के लिए यह हमेशा int होना चाहिए
{ // प्रोग्राम यहाँ से शुरू होगा (क्योंकि फ़ंक्शन "main" कहलाता है)
// अगर कोई पैरामीटर होते, तो यहाँ बताए जाते
int decks;
puts("Enter a number of decks");
scanf("%i", &decks);
if (decks < 1) {
puts("That is not a valid number of decks");
return 1;
}
printf("There are %i cards\n", (decks * 52));
return 0;
} // फ़ंक्शन का बॉडी (body) हमेशा ब्रेस से घिरा होता है
फ़ंक्शन का नाम रिटर्न टाइप के बाद आता है। उसके बाद फ़ंक्शन पैरामीटर (parameters) आते हैं, अगर हों। अंत में फ़ंक्शन बॉडी होती है। फ़ंक्शन बॉडी ब्रेस से घिरी होनी चाहिए।
💻 अपने प्रोग्राम का एग्ज़िट स्टेटस (exit status) जाँचना है?
Linux या Mac पर टाइप करें: echo $?
Windows पर: echo %errorlevel%
🤓 गीक बिट्स (Geek Bits)
printf() फ़ंक्शन फ़ॉर्मैट किया हुआ आउटपुट दिखाने के लिए है। यह फ़ॉर्मैट वर्णों (format characters) को वेरिएबल के मानों से बदल देता है, इस तरह:
printf("%s says the count is %i", "Ben", 21);
पहला पैरामीटर यहाँ स्ट्रिंग के रूप में डाला जाएगा (%s)।
दूसरा पैरामीटर यहाँ इंटीजर के रूप में डाला जाएगा (%i)।
printf() को कॉल करते समय आप जितने चाहें पैरामीटर दे सकते हैं, पर हर एक के लिए मिलता-जुलता % फ़ॉर्मैट वर्ण ज़रूर रखें।
📄 पेज 7
🧲 कोड मैग्नेट (Code Magnets)
कॉलेज ब्लैकजैक टीम (College Blackjack Team) हॉस्टल के फ़्रिज पर कुछ कोड पर काम कर रही थी, पर किसी ने मैग्नेट गड़बड़ कर दिए! क्या आप मैग्नेट से कोड दोबारा जोड़ सकते हैं?
/*
* Program to evaluate face values.
* Released under the Vegas Public License.
* (c)2014 The College Blackjack Team.
*/
main()
{
char card_name[3];
puts("Enter the card_name: ");
scanf("%2s", card_name);
int val = 0;
if (card_name[0] == 'K') {
val = 10;
} else if (card_name[0] == 'Q') {
___
} else if (card_name[0] == ___ ) {
val = 10;
___
___ (card_name[0] == ___ ) {
___;
} else {
val = atoi(card_name);
}
printf("The card value is: %i\n", val);
___ 0;
}
उपलब्ध मैग्नेट:#include · #include · <stdio.h> · <stdlib.h> · int · 'J' · 'A' · val = 10 · val = 11 · else · if · return · ; · }
✏️ दो अक्षर कार्ड के नाम के लिए दर्ज करें।
✏️ atoi() टेक्स्ट को नंबर में बदलता है।
📄 पेज 8
✅ कोड मैग्नेट का हल (Code Magnets Solution)
/*
* Program to evaluate face values.
* Released under the Vegas Public License.
* (c)2014 The College Blackjack Team.
*/
#include <stdio.h>
#include <stdlib.h>
int main()
{
char card_name[3];
puts("Enter the card_name: ");
scanf("%2s", card_name);
int val = 0;
if (card_name[0] == 'K') {
val = 10;
} else if (card_name[0] == 'Q') {
val = 10;
} else if (card_name[0] == 'J') {
val = 10;
} else if (card_name[0] == 'A') {
val = 11;
} else {
val = atoi(card_name);
}
printf("The card value is: %i\n", val);
return 0;
}
❓ सवाल-जवाब
सवाल:card_name[0] का क्या मतलब है?
जवाब: यह यूज़र का टाइप किया पहला वर्ण (character) है। तो अगर वह 10 टाइप करे, तो card_name[0]1 होगा।
सवाल: क्या आप हमेशा कमेंट /* और */ से लिखते हैं?
जवाब: अगर आपका कंपाइलर C99 मानक को सपोर्ट करता है, तो आप कमेंट // से भी शुरू कर सकते हैं। कंपाइलर उस पंक्ति के बाक़ी हिस्से को कमेंट मानता है।
सवाल: मुझे कैसे पता चलेगा कि मेरा कंपाइलर कौन-सा मानक सपोर्ट करता है?
जवाब: अपने कंपाइलर का दस्तावेज़ (documentation) देखिए। gcc तीनों मानक सपोर्ट करता है: ANSI C, C99 और C11।
📄 पेज 9
▶️ पर प्रोग्राम चलाएँ कैसे?
C एक कंपाइल की जाने वाली (compiled) भाषा है। इसका मतलब है कि कंप्यूटर कोड को सीधे नहीं पढ़ेगा। इसके बजाय, आपको इंसान के पढ़ने लायक सोर्स कोड को मशीन के पढ़ने लायक मशीन कोड में बदलना, यानी कंपाइल करना होगा।
कोड कंपाइल करने के लिए आपको कंपाइलर नाम का प्रोग्राम चाहिए। सबसे लोकप्रिय C कंपाइलरों में से एक GNU कंपाइलर कलेक्शन (GNU Compiler Collection) यानी gcc है। gcc बहुत से ऑपरेटिंग सिस्टम पर उपलब्ध है, और यह C के अलावा बहुत सी भाषाएँ कंपाइल कर सकता है। और सबसे बढ़िया बात: यह पूरी तरह मुफ़्त है।
gcc से प्रोग्राम कंपाइल करने और चलाने का तरीक़ा:
1️⃣ सामने वाले पन्ने की कोड मैग्नेट वाली एक्सरसाइज़ का कोड cards.c नाम की फ़ाइल में सेव करें। (C सोर्स फ़ाइलें आम तौर पर .c पर ख़त्म होती हैं।)
2️⃣ कमांड प्रॉम्प्ट या टर्मिनल में gcc cards.c -o cards से कंपाइल करें।
cards.c को कंपाइल करके cards नाम की फ़ाइल में रखो।
3️⃣ Windows पर cards टाइप करके चलाएँ, और Mac और Linux मशीनों पर ./cards।
File Edit Window Help Compile
> ./cards
Enter the card_name:
(Windows पर यह cards.exe होगा।)
🤓 गीक बिट्स (Geek Bits)
ज़्यादातर मशीनों पर आप यह तरकीब इस्तेमाल करके अपना कोड कंपाइल और रन कर सकते हैं:
gcc zork.c -o zork && ./zork
यहाँ && का मतलब है: "और फिर, अगर यह सफल रहा, तो यह करो…"
Windows मशीन पर ./zork की जगह zork लिखें।
यह कमांड नया प्रोग्राम तभी चलाएगी जब वह सफलतापूर्वक कंपाइल हो जाए। अगर कंपाइल में कोई समस्या हो, तो यह प्रोग्राम चलाना छोड़ देगी और बस एरर स्क्रीन पर दिखा देगी।
✋ यह करो! अभी cards.c फ़ाइल बनाओ और उसे कंपाइल करो। जैसे-जैसे अध्याय आगे बढ़ेगा, हम इस पर और-और काम करेंगे।
📄 पेज 10
🚗 टेस्ट ड्राइव (Test Drive)
देखते हैं कि प्रोग्राम कंपाइल और रन होता है या नहीं। अपनी मशीन पर कमांड प्रॉम्प्ट या टर्मिनल खोलिए और आज़माइए।
File Edit Window Help 21
> gcc cards.c -o cards ← यह पंक्ति कोड कंपाइल करती है और cards प्रोग्राम बनाती है
> ./cards ← यह पंक्ति प्रोग्राम चलाती है (Windows पर ./ मत लिखो)
Enter the card_name:
Q ← यूज़र किसी कार्ड का नाम डालता है…
The card value is: 10 ← …और प्रोग्राम उसका मान दिखाता है
> ./cards ← प्रोग्राम को दोबारा चलाना
Enter the card_name:
A
The card value is: 11
> ./cards
Enter the card_name:
7
The card value is: 7
💡 याद रखो: आप कंपाइल और रन के चरण एक साथ जोड़ सकते हैं (तरीक़ा देखने के लिए पिछला पन्ना पलटो)।
🎉 प्रोग्राम काम करता है!
बधाई हो! आपने एक C प्रोग्राम कंपाइल और रन कर लिया है। gcc कंपाइलर ने cards.c का इंसान के पढ़ने लायक सोर्स कोड लिया और उसे cards प्रोग्राम में कंप्यूटर के पढ़ने लायक मशीन कोड में बदल दिया। अगर आप Mac या Linux मशीन इस्तेमाल कर रहे हैं, तो कंपाइलर ने मशीन कोड cards नाम की फ़ाइल में बनाया होगा। पर Windows पर सारे प्रोग्राम के नाम में .exe एक्सटेंशन (extension) होना ज़रूरी है, इसलिए फ़ाइल cards.exe कहलाएगी।
सवाल: Linux और Mac पर प्रोग्राम चलाते समय उसके आगे ./ क्यों लगाना पड़ता है?
जवाब: Unix-शैली के ऑपरेटिंग सिस्टम में प्रोग्राम तभी चलते हैं जब आप उस डायरेक्टरी (directory) को बताएँ जहाँ वे रहते हैं, या अगर उनकी डायरेक्टरी PATH एनवायरनमेंट वेरिएबल (environment variable) में सूचीबद्ध हो।
📄 पेज 11
🗨️ "रुको, मुझे समझ नहीं आया। जब हम यूज़र से कार्ड का नाम पूछते हैं, तो हम अक्षरों का ऐरे इस्तेमाल कर रहे हैं। अक्षरों का ऐरे???? क्यों? क्या हम स्ट्रिंग या कुछ और इस्तेमाल नहीं कर सकते???"
C भाषा स्ट्रिंग (strings) को सीधे सपोर्ट नहीं करती।
C ज़्यादातर दूसरी भाषाओं से ज़्यादा निचले स्तर की है, इसलिए स्ट्रिंग की जगह वह आम तौर पर उससे मिलती-जुलती चीज़ इस्तेमाल करती है: अकेले अक्षरों का ऐरे। अगर आपने दूसरी भाषाओं में प्रोग्रामिंग की है, तो आप ऐरे से ज़रूर मिले होंगे। ऐरे बस चीज़ों की एक सूची है जिसे एक ही नाम दिया गया हो। तो card_name बस एक वेरिएबल नाम है जिससे आप कमांड प्रॉम्प्ट पर डाले गए अक्षरों की सूची की ओर इशारा करते हैं। आपने card_name को दो अक्षरों का ऐरे बनाकर परिभाषित किया है, इसलिए आप पहले और दूसरे अक्षर को card_name[0] और card_name[1] के रूप में पुकार सकते हैं। यह कैसे काम करता है, यह देखने के लिए आइए कंप्यूटर की मेमोरी में थोड़ा गहरा गोता लगाएँ और देखें कि C टेक्स्ट को कैसे संभालती है…
🗨️ "पर कई C एक्सटेंशन लाइब्रेरी (extension libraries) हैं जो आपको स्ट्रिंग देती हैं।"
⚠️ ग़लती सुधारी (एरर फ़िक्स): किताब के इस पन्ने के पाठ में एक जगह वेरिएबल का नाम char_name[0] और char_name[1] छपा है। यह छपाई की चूक है। सही नाम card_name[0] और card_name[1] है, जो ऊपर वैसा ही लिखा गया है।
📄 पेज 12
🔬 स्ट्रिंग को बहुत क़रीब से (Strings Way Up Close)
स्ट्रिंग बस अक्षरों के ऐरे हैं। जब C ऐसी कोई स्ट्रिंग देखती है:
s = "Shatner"
तो वह उसे ऐसे पढ़ती है जैसे वह अलग-अलग अक्षरों का ऐरे हो। यह C में ऐरे परिभाषित करने का तरीक़ा है:
s = {'S', 'h', 'a', 't', 'n', 'e', 'r'}
s[0] s[1] s[2] ...
S h a ...
स्ट्रिंग का हर अक्षर ऐरे का बस एक तत्व (element) है, इसीलिए आप स्ट्रिंग के अलग-अलग अक्षरों को s[0] और s[1] जैसे इंडेक्स (index) से पुकार सकते हैं।
⚠️ स्ट्रिंग के सिरे से बाहर मत गिरो
पर जब C को स्ट्रिंग की सामग्री पढ़नी होती है तो क्या होता है? मान लीजिए उसे उसे प्रिंट करना है। कई भाषाओं में कंप्यूटर ऐरे के आकार का काफ़ी बारीकी से हिसाब रखता है, पर C ज़्यादातर भाषाओं से निचले स्तर की है और हमेशा ठीक-ठीक नहीं बता पाती कि ऐरे कितना लंबा है। अगर C को स्क्रीन पर स्ट्रिंग दिखानी है, तो उसे जानना होगा कि अक्षरों के ऐरे का अंत कब आता है। यह वह एक प्रहरी अक्षर (sentinel character) जोड़कर करती है:
'\0' ← C इसे देखकर रुकना जानती है
प्रहरी अक्षर स्ट्रिंग के अंत में जोड़ा गया एक अतिरिक्त अक्षर है जिसका मान \0 है। जब भी कंप्यूटर को स्ट्रिंग की सामग्री पढ़नी होती है, तो वह ऐरे के तत्वों से एक-एक करके गुज़रता है, जब तक \0 तक नहीं पहुँच जाता। इसका मतलब है कि जब कंप्यूटर यह देखता है:
s = "Shatner"
तो वह असल में उसे मेमोरी में ऐसे रखता है:
s[0] s[1] s[2] s[3] s[4] s[5] s[6] s[7]
S h a t n e r \0
\0 मान 0 वाला ASCII अक्षर है।
C कोडर इसे अक्सर NULL अक्षर कहते हैं।
इसीलिए हमारे कोड में card_name वेरिएबल को इस तरह परिभाषित करना पड़ा:
char card_name[3];
card_name स्ट्रिंग में बस एक या दो अक्षर ही दर्ज होंगे, पर क्योंकि स्ट्रिंग प्रहरी अक्षर पर ख़त्म होती हैं, हमें ऐरे में एक अतिरिक्त अक्षर की जगह रखनी पड़ती है।
📄 पेज 13
❓ सवाल-जवाब (There are no dumb questions)
सवाल: अक्षरों की गिनती 0 से क्यों शुरू होती है? 1 से क्यों नहीं?जवाब: इंडेक्स एक ऑफ़सेट (offset) है: यह इस बात का माप है कि अक्षर पहले अक्षर से कितनी दूर है।
सवाल: क्यों?जवाब: कंप्यूटर अक्षरों को मेमोरी के लगातार बाइटों (bytes) में रखता है। वह इंडेक्स से अक्षर की जगह का हिसाब लगा सकता है। अगर उसे पता है कि c[0] मेमोरी की जगह 1,000,000 पर है, तो वह जल्दी से गणना कर सकता है कि c[96] जगह 1,000,000 + 96 पर है।
सवाल: प्रहरी अक्षर क्यों चाहिए? क्या उसे नहीं पता कि स्ट्रिंग कितनी लंबी है?जवाब: आम तौर पर, नहीं पता होता। C ऐरे की लंबाई का हिसाब रखने में बहुत अच्छी नहीं है, और स्ट्रिंग बस एक ऐरे है।
सवाल: उसे ऐरे की लंबाई नहीं पता???जवाब: नहीं। कभी-कभी कंपाइलर कोड का विश्लेषण करके ऐरे की लंबाई निकाल सकता है, पर आम तौर पर C उम्मीद करती है कि आप अपने ऐरे का हिसाब रखेंगे।
सवाल: क्या सिंगल कोट (single quotes) और डबल कोट (double quotes) में फ़र्क़ पड़ता है?जवाब: हाँ। सिंगल कोट अकेले अक्षरों के लिए इस्तेमाल होते हैं, पर डबल कोट हमेशा स्ट्रिंग के लिए इस्तेमाल होते हैं।
सवाल: क्या मुझे अपनी स्ट्रिंग कोट (") से परिभाषित करनी चाहिए या अक्षरों के स्पष्ट ऐरे से?जवाब: आम तौर पर आप स्ट्रिंग को कोट से परिभाषित करेंगे। इन्हें स्ट्रिंग लिटरल (string literals) कहते हैं, और इन्हें टाइप करना आसान होता है।
सवाल: क्या स्ट्रिंग लिटरल और अक्षरों के ऐरे में कोई अंतर है?जवाब: बस एक: स्ट्रिंग लिटरल स्थिर (constant) होते हैं।
सवाल: इसका क्या मतलब है?जवाब: इसका मतलब है कि एक बार बन जाने के बाद आप अलग-अलग अक्षर बदल नहीं सकते।
सवाल: अगर मैं बदलने की कोशिश करूँ तो क्या होगा?जवाब: यह कंपाइलर पर निर्भर करता है, पर gcc आम तौर पर बस एरर (bus error) दिखाएगा।
सवाल: बस एरर? यह बस एरर क्या बला है?जवाब: C स्ट्रिंग लिटरल को मेमोरी में एक अलग ढंग से रखती है। बस एरर का मतलब बस इतना है कि आपका प्रोग्राम मेमोरी के उस हिस्से को अपडेट नहीं कर सकता।
😌 आसान ऑपरेशन (Painless Operations)
सारे बराबर के चिह्न बराबर नहीं होते।
C में बराबर का चिह्न (=) असाइनमेंट (assignment) यानी मान देने के लिए इस्तेमाल होता है। पर दोहरा बराबर का चिह्न (==) बराबरी जाँचने के लिए इस्तेमाल होता है।
teeth = 4; // teeth को मान 4 पर सेट करो
teeth == 4; // जाँचो कि क्या teeth का मान 4 है
अगर आप किसी वेरिएबल को बढ़ाना या घटाना चाहते हैं, तो += और -= असाइनमेंट से जगह बचा सकते हैं:
teeth += 2; // teeth में 2 जोड़ता है
teeth -= 2; // 2 दाँत घटाता है
और अगर आप किसी वेरिएबल को 1 से बढ़ाना या घटाना चाहते हैं, तो ++ और -- इस्तेमाल करें:
teeth++; // 1 से बढ़ाओ
teeth--; // 1 से घटाओ
📄 पेज 14
🎬 दो तरह के कमांड (Two types of command)
अब तक आपने जितने भी कमांड देखे हैं, वे इन दो श्रेणियों में से किसी एक में आते हैं।
🛠️ कुछ करो (Do something)
C के ज़्यादातर कमांड स्टेटमेंट (statements) होते हैं। सरल स्टेटमेंट कार्रवाइयाँ होते हैं; वे काम करते हैं और हमें बातें बताते हैं। आप ऐसे स्टेटमेंट देख चुके हैं जो वेरिएबल परिभाषित करते हैं, कीबोर्ड से इनपुट पढ़ते हैं, या स्क्रीन पर डेटा दिखाते हैं।
split_hand(); // यह एक सरल स्टेटमेंट है
कभी-कभी आप स्टेटमेंट को एक साथ समूहित करके ब्लॉक स्टेटमेंट (block statements) बनाते हैं। ब्लॉक स्टेटमेंट ब्रेस से घिरे कमांडों के समूह होते हैं।
{ // ये कमांड एक ब्लॉक स्टेटमेंट बनाते हैं
deal_first_card(); // क्योंकि वे ब्रेस से घिरे हैं
deal_second_card();
cards_in_hand = 2;
}
🔀 कुछ तभी करो जब कुछ सच हो (Do something only if something is true)
if जैसे कंट्रोल स्टेटमेंट (control statements) कोड चलाने से पहले एक शर्त (condition) जाँचते हैं:
if (value_of_hand <= 16) // यह शर्त है
hit(); // अगर शर्त सच है तो यह स्टेटमेंट चलाओ
else
stand(); // अगर शर्त झूठ है तो यह स्टेटमेंट चलाओ
if स्टेटमेंट को आम तौर पर शर्त सच होने पर एक से ज़्यादा काम करने पड़ते हैं, इसलिए उन्हें अक्सर ब्लॉक स्टेटमेंट के साथ इस्तेमाल किया जाता है:
if (dealer_card == 6) { // दोनों कमांड तभी चलेंगे जब शर्त सच हो
double_down(); // कमांड एक ही ब्लॉक स्टेटमेंट के अंदर
hit(); // समूहित हैं
}
🤔 क्या आपको ब्रेस चाहिए?
ब्लॉक स्टेटमेंट आपको स्टेटमेंट के पूरे समूह को ऐसे बरतने देते हैं जैसे वह एक ही स्टेटमेंट हो। C में if शर्त इस तरह काम करती है:
if (countdown == 0)
do_this_thing();
if शर्त एक ही स्टेटमेंट चलाती है। तो अगर आप if में कई स्टेटमेंट चलाना चाहें तो? अगर आप स्टेटमेंट की सूची को ब्रेस में लपेट दें, तो C उन्हें ऐसे बरतेगी जैसे वे बस एक ही स्टेटमेंट हों:
if (x == 2) {
call_whitehouse();
sell_oil();
x = 0;
}
C कोडर अपना कोड छोटा और चुस्त रखना पसंद करते हैं, इसलिए ज़्यादातर if शर्तों और while लूप में ब्रेस छोड़ देते हैं। तो यह लिखने की बजाय:
if (x == 2) {
puts("Do something");
}
ज़्यादातर C प्रोग्रामर यह लिखते हैं:
if (x == 2)
puts("Do something");
📄 पेज 15
📝 अब तक का कोड (Here's the code so far)
/*
* Program to evaluate face values.
* Released under the Vegas Public License.
* (c)2014 The College Blackjack Team.
*/
#include <stdio.h>
#include <stdlib.h>
int main()
{
char card_name[3];
puts("Enter the card_name: ");
scanf("%2s", card_name);
int val = 0;
if (card_name[0] == 'K') {
val = 10;
} else if (card_name[0] == 'Q') {
val = 10;
} else if (card_name[0] == 'J') {
val = 10;
} else if (card_name[0] == 'A') {
val = 11;
} else {
val = atoi(card_name);
}
printf("The card value is: %i\n", val);
return 0;
}
💭 मुझे एक ख़याल आया। क्या यह जाँच सकता है कि कार्ड का मान किसी ख़ास दायरे (range) में है या नहीं? यह काम का हो सकता है…
📄 पेज 16
🃏 कार्ड गिनती पर एक गुप्त संदेश
💬 "अरे, कैसे हो? तुम मुझे समझदार आदमी लगते हो। और मैं जानता हूँ, क्योंकि मैं भी समझदार आदमी हूँ! सुनो, मेरे हाथ एक पक्की चीज़ लगी है, और मैं अच्छा आदमी हूँ, इसलिए तुम्हें भी बताऊँगा। देखो, मैं कार्ड गिनने (card counting) का विशेषज्ञ हूँ। कैपो दी तुत्ति कैपी (Capo di tutti capi)। तुम पूछोगे कार्ड गिनना क्या है? मेरे लिए तो यह करियर है!
गंभीरता से, कार्ड गिनना ब्लैकजैक खेलते समय अपने जीतने की संभावना बढ़ाने का तरीक़ा है। ब्लैकजैक में, अगर शू (shoe) में ऊँचे मान वाले बहुत से कार्ड बचे हों, तो संभावना खिलाड़ी के पक्ष में झुकी होती है। यानी तुम्हारे पक्ष में!
कार्ड गिनने से तुम्हें पता रहता है कि ऊँचे मान वाले कितने कार्ड बचे हैं। मान लो तुम 0 की गिनती से शुरू करते हो।
फिर डीलर रानी (Queen) चलता है। यह ऊँचा कार्ड है। डेक में एक कार्ड कम हो गया, तो तुम गिनती में से एक घटा देते हो:
रानी ➜ गिनती − 1
पर अगर वह नीचा कार्ड हो, जैसे 4, तो गिनती एक बढ़ जाती है:
चार ➜ गिनती + 1
ऊँचे कार्ड हैं 10 और तस्वीर वाले कार्ड (जैक, रानी, बादशाह)। नीचे कार्ड हैं 3, 4, 5 और 6।
हर नीचे कार्ड और हर ऊँचे कार्ड पर यह करते रहो, जब तक गिनती सचमुच ऊँची न हो जाए, तब तुम अपनी अगली बाज़ी पर नक़द लगाओ और बा-दा-बिंग! जल्द ही तुम्हारे पास मेरी तीसरी बीवी से भी ज़्यादा पैसा होगा!
अगर और सीखना चाहते हो, तो आज ही मेरे ब्लैकजैक पत्राचार स्कूल (Blackjack Correspondence School) में दाख़िला लो। कार्ड गिनने के साथ-साथ ये भी सीखो:
अपनी बाज़ी का मान अधिकतम करने के लिए केली क्राइटेरियन (Kelly Criterion) कैसे इस्तेमाल करें
कैसिनो बॉस की मार से कैसे बचें
रेशमी सूट से कैनोली के दाग़ कैसे छुड़ाएँ
प्लेड (plaid) के साथ क्या पहनें
और जानकारी के लिए संपर्क करें: कज़िन विन्नी (Cousin Vinny), द्वारा ब्लैकजैक पत्राचार स्कूल।"
📄 पेज 17
🃏 कार्ड गिनती? C में?
कार्ड गिनना ब्लैकजैक में जीतने की संभावना बढ़ाने का एक तरीक़ा है। जैसे-जैसे कार्ड बँटते हैं, चलती हुई गिनती (running count) रखकर खिलाड़ी जान सकता है कि बड़ी बाज़ी लगाने का सबसे अच्छा समय कब है और छोटी बाज़ी का कब। यह एक ताक़तवर तकनीक है, पर असल में काफ़ी सरल है।
इसके लिए हमारा प्लान:
🃏 कार्ड का मूल्यांकन (evaluate) करो।(हमारे पास पहले से ऐसा कोड है।)
❓ क्या यह 3 और 6 के बीच है (दोनों सहित)? → गिनती 1 बढ़ाओ।(हम इसके लिए एक वेरिएबल इस्तेमाल कर सकते हैं।)
❓ नहीं तो… क्या यह 10, J, Q या K है? → गिनती 1 घटाओ।
🤔 "हमें यहाँ कुछ मानों की जाँच करनी है… या शायद नहीं?""हम कैसे जाँचें कि यह >= 3 और <= 6 है? क्या यह दो जाँचें हैं?"
C में इसे लिखना कितना मुश्किल होगा? आप एक अकेली जाँच (single test) करना देख चुके हैं, पर कार्ड गिनने के एल्गोरिदम (algorithm) को कई शर्तें जाँचनी होंगी: आपको जाँचना होगा कि संख्या >= 3 भी है और <= 6 भी।
आपको ऐसे ऑपरेशन का एक सेट चाहिए जो आपको शर्तों को जोड़ने दे।
📄 पेज 18
🔗 बूलियन (booleans) में बराबर से ज़्यादा है
अब तक आपने ऐसे if स्टेटमेंट देखे हैं जो सिर्फ़ एक शर्त के सच होने की जाँच करते हैं, पर अगर आप कई शर्तें जाँचना चाहें तो? या यह जाँचना चाहें कि कोई एक शर्त सच नहीं है?
&& जाँचता है कि दोनों शर्तें सच हैं (और, "and")
और (and) ऑपरेटर (&&) तभी सच होता है जब उसे दी गई दोनों शर्तें सच हों।
if ((dealer_up_card == 6) && (hand == 11))
double_down();
इस कोड के चलने के लिए दोनों शर्तों का सच होना ज़रूरी है।
and ऑपरेटर कुशल है: अगर पहली शर्त झूठ है, तो कंप्यूटर दूसरी शर्त का मूल्यांकन करने की ज़हमत नहीं उठाता। वह जानता है कि अगर पहली शर्त झूठ है, तो पूरी शर्त झूठ ही होगी।
|| जाँचता है कि दो में से कोई एक शर्त सच है (या, "or")
या (or) ऑपरेटर (||) तब सच होता है जब उसे दी गई कोई भी एक शर्त सच हो।
if (cupcakes_in_fridge || chips_on_table)
eat_food();
कोई भी एक सच हो सकती है।
अगर पहली शर्त सच है, तो कंप्यूटर दूसरी शर्त का मूल्यांकन करने की ज़हमत नहीं उठाता। वह जानता है कि अगर पहली शर्त सच है, तो पूरी शर्त सच ही होगी।
! शर्त का मान पलट देता है (नहीं, "not")
!नॉट (not) ऑपरेटर है। यह किसी शर्त का मान उलट देता है।
if (!brad_on_phone) // ! का मतलब है "नहीं"
answer_phone();
🤓 गीक बिट्स (Geek Bits)
C में बूलियन मान (boolean values) संख्याओं से दर्शाए जाते हैं। C के लिए, संख्या 0 का मतलब "झूठ" (false) है। पर "सच" (true) का मान क्या है? 0 के बराबर न होने वाली हर चीज़ को सच माना जाता है। तो ऐसा C कोड लिखने में कोई बुराई नहीं:
int people_moshing = 34;
if (people_moshing)
take_off_glasses();
असल में, C प्रोग्राम अक्सर इसे यह जाँचने का शॉर्टहैंड (shorthand) तरीक़ा बनाकर इस्तेमाल करते हैं कि कुछ 0 नहीं है।
📄 पेज 19
✍️ अभ्यास: कार्ड गिनती वाला प्रोग्राम
आपको प्रोग्राम को इस तरह बदलना है कि वह कार्ड गिनने के लिए इस्तेमाल हो सके। जब कार्ड का मान 3 से 6 के बीच हो, तो उसे एक संदेश दिखाना होगा। और जब कार्ड 10, जैक, रानी या बादशाह हो, तो एक अलग संदेश दिखाना होगा।
int main()
{
char card_name[3];
puts("Enter the card_name: ");
scanf("%2s", card_name);
int val = 0;
if (card_name[0] == 'K') {
val = 10;
} else if (card_name[0] == 'Q') {
val = 10;
} else if (card_name[0] == 'J') {
val = 10;
} else if (card_name[0] == 'A') {
val = 11;
} else {
val = atoi(card_name);
}
/* Check if the value is 3 to 6 */
if ______
puts("Count has gone up");
/* Otherwise check if the card was 10, J, Q, or K */
else if ______
puts("Count has gone down");
return 0;
}
📜 मानकों की विनम्र गाइड (The Polite Guide to Standards)
ANSI C मानक में सच (true) और झूठ (false) का कोई मान नहीं है। C प्रोग्राम मान 0 को झूठ और बाक़ी हर मान को सच मानते हैं। C99 मानक आपको अपने प्रोग्राम में true और false शब्द इस्तेमाल करने देता है, पर कंपाइलर उन्हें वैसे भी क्रमशः 1 और 0 मानों की तरह ही देखता है।
📄 पेज 20
✅ अभ्यास का हल: गिनती वाला कार्ड
आपको प्रोग्राम को इस तरह बदलना था कि वह कार्ड गिनने के लिए इस्तेमाल हो सके। जब कार्ड का मान 3 से 6 हो तो उसे एक संदेश दिखाना था, और जब कार्ड 10, जैक, रानी या बादशाह हो तो एक अलग संदेश।
int main()
{
char card_name[3];
puts("Enter the card_name: ");
scanf("%2s", card_name);
int val = 0;
if (card_name[0] == 'K') {
val = 10;
} else if (card_name[0] == 'Q') {
val = 10;
} else if (card_name[0] == 'J') {
val = 10;
} else if (card_name[0] == 'A') {
val = 11;
} else {
val = atoi(card_name);
}
/* Check if the value is 3 to 6 */
if ((val > 2) && (val < 7))
puts("Count has gone up");
/* Otherwise check if the card was 10, J, Q, or K */
else if (val == 10)
puts("Count has gone down");
return 0;
}
💡 इस शर्त को लिखने के कई तरीक़े हैं।
💡 क्या आपने देखा कि इसके लिए बस एक ही शर्त चाहिए थी?
❓ सवाल-जवाब
सवाल: बस & और | क्यों नहीं?जवाब: आप चाहें तो & और | इस्तेमाल कर सकते हैं। & और | ऑपरेटर हमेशा दोनों शर्तों का मूल्यांकन करेंगे, पर && और || अक्सर दूसरी शर्त को छोड़ सकते हैं।
सवाल: तो & और | ऑपरेटर मौजूद ही क्यों हैं?जवाब: क्योंकि वे सिर्फ़ तार्किक शर्तों का मूल्यांकन करने से ज़्यादा कुछ करते हैं। वे किसी संख्या के अलग-अलग बिट (bits) पर बिटवाइज़ ऑपरेशन (bitwise operations) करते हैं।
सवाल: हैं? इसका क्या मतलब?जवाब: देखिए, 6 & 4 बराबर 4 होता है, क्योंकि अगर आप जाँचें कि 6 (बाइनरी में 110) और 4 (बाइनरी में 100) में कौन-से बाइनरी अंक साझा हैं, तो आपको 4 (100) मिलता है।
📄 पेज 21
🚗 टेस्ट ड्राइव (Test Drive)
देखते हैं कि अब प्रोग्राम को कंपाइल और रन करने पर क्या होता है:
File Edit Window Help FiveOfSpades
> gcc cards.c -o cards && ./cards ← यह पंक्ति कोड कंपाइल और रन करती है
Enter the card_name:
Q
Count has gone down
> ./cards ← हम इसे कई बार चलाते हैं ताकि
Enter the card_name: अलग-अलग मान-दायरे जाँच सकें
8
> ./cards
Enter the card_name:
3
Count has gone up
>
(8 पर कोई संदेश नहीं आता, क्योंकि 8 न तो 3 से 6 के बीच है और न ही 10।)
कोड काम करता है। कई शर्तों को बूलियन ऑपरेटर से जोड़कर, आप किसी एक मान की जगह मानों का पूरा दायरा जाँच रहे हैं। अब आपके पास कार्ड गिनने की बुनियादी संरचना तैयार है।
🗨️ कंप्यूटर कहता है कार्ड नीचा था। गिनती बढ़ गई! बाज़ी बढ़ाओ! बाज़ी बढ़ाओ!
📡 गुप्त संचार उपकरण (Stealthy communication device)
📄 पेज 22
🎤 कंपाइलर का पर्दाफ़ाश (The Compiler Exposed)
इस हफ़्ते का इंटरव्यू: "gcc ने हमारे लिए आख़िर क्या किया है?"
Head First: सबसे पहले मैं gcc का धन्यवाद करना चाहूँगा कि आपने अपने बहुत व्यस्त कार्यक्रम से हमसे बात करने का समय निकाला।
gcc: कोई बात नहीं, दोस्त। मदद करके ख़ुशी हुई।
Head First:gcc, आप कई भाषाएँ बोल सकते हैं, क्या यह सच है?
gcc: मैं संचार के साठ लाख से ज़्यादा रूपों में धाराप्रवाह हूँ…
Head First: सच में?
gcc: बस मज़ाक कर रहा था। पर हाँ, मैं कई भाषाएँ बोलता हूँ। C, ज़ाहिर है, पर साथ ही C++ और Objective-C भी। मैं Pascal, Fortran, PL/I वग़ैरह में भी काम चला लेता हूँ। अरे हाँ, मुझे थोड़ी Go भी आती है…
Head First: और हार्डवेयर के मोर्चे पर, आप बहुत, बहुत सारे प्लेटफ़ॉर्म के लिए मशीन कोड बना सकते हैं?
gcc: लगभग किसी भी प्रोसेसर के लिए। आम तौर पर जब कोई हार्डवेयर इंजीनियर किसी नए तरह का प्रोसेसर बनाती है, तो पहली चीज़ों में से एक जो वह चाहती है, वह यह कि मेरा कोई रूप उस पर चल जाए।
Head First: आपने इतना अविश्वसनीय लचीलापन कैसे हासिल किया?
gcc: मेरा राज़, शायद, यह है कि मेरे व्यक्तित्व के दो पहलू हैं। मेरा एक फ़्रंटएंड (frontend) है, मेरा वह हिस्सा जो किसी तरह का सोर्स कोड समझता है।
Head First: यानी किसी भाषा में लिखा हुआ, जैसे C?
gcc: बिल्कुल। मेरा फ़्रंटएंड उस भाषा को एक मध्यवर्ती कोड (intermediate code) में बदल सकता है। मेरे सभी भाषाओं के फ़्रंटएंड एक ही तरह का कोड बनाते हैं।
Head First: आप कहते हैं आपके व्यक्तित्व के दो पहलू हैं?
gcc: मेरा एक बैकएंड (backend) भी है: उस मध्यवर्ती कोड को मशीन कोड में बदलने की प्रणाली, जो कई प्लेटफ़ॉर्म पर समझा जा सके। इसके साथ मुझे लगभग हर उस ऑपरेटिंग सिस्टम के ख़ास एक्ज़ीक्यूटेबल फ़ाइल फ़ॉर्मैट की जानकारी भी है जिसका आपने कभी नाम सुना हो…
Head First: फिर भी आपको अक्सर महज़ एक अनुवादक बताया जाता है। क्या आपको यह उचित लगता है? ज़रूर आप सिर्फ़ यही नहीं हैं।
gcc: अरे, मैं सीधे-सादे अनुवाद से थोड़ा ज़्यादा ही करता हूँ। उदाहरण के लिए, मैं अक्सर कोड में एरर पकड़ सकता हूँ।
Head First: जैसे?
gcc: मैं साफ़-साफ़ चीज़ें जाँच सकता हूँ, जैसे ग़लत वर्तनी वाले वेरिएबल नाम। पर मैं बारीक चीज़ें भी ढूँढता हूँ, जैसे वेरिएबल की दोबारा परिभाषा। या अगर प्रोग्रामर वेरिएबल का नाम किसी मौजूदा फ़ंक्शन के नाम पर रख दे, तो मैं चेतावनी दे सकता हूँ, वग़ैरह।
Head First: तो आप कोड की गुणवत्ता भी जाँचते हैं?
gcc: अरे हाँ। और सिर्फ़ गुणवत्ता नहीं, प्रदर्शन (performance) भी। अगर मुझे किसी लूप के अंदर कोड का ऐसा हिस्सा मिले जो लूप के बाहर भी उतनी ही अच्छी तरह काम करे, तो मैं उसे बहुत चुपचाप खिसका सकता हूँ।
Head First: आप तो बहुत कुछ करते हैं!
gcc: मुझे लगता है कि मैं करता हूँ। पर चुपचाप।
Head First:gcc, आपका बहुत धन्यवाद।
📄 पेज 23
🎭 कंपाइलर बनो (BE the Compiler)
इस पन्ने की हर C फ़ाइल एक पूरी सोर्स फ़ाइल है। आपका काम है कंपाइलर बनकर तय करना कि क्या इनमें से हर फ़ाइल कंपाइल होगी, और अगर नहीं तो क्यों नहीं। अतिरिक्त बोनस अंकों के लिए, बताइए कि आपको क्या लगता है हर कंपाइल हुई फ़ाइल चलने पर क्या आउटपुट देगी, और क्या आपको लगता है कि कोड इरादे के मुताबिक़ काम कर रहा है।
A
#include <stdio.h>
int main()
{
int card = 1;
if (card > 1)
card = card - 1;
if (card < 7)
puts("Small card");
else {
puts("Ace!");
}
return 0;
}
B
#include <stdio.h>
int main()
{
int card = 1;
if (card > 1) {
card = card - 1;
if (card < 7)
puts("Small card");
else
puts("Ace!");
}
return 0;
}
C
#include <stdio.h>
int main()
{
int card = 1;
if (card > 1) {
card = card - 1;
if (card < 7)
puts("Small card");
} else
puts("Ace!");
return 0;
}
D
#include <stdio.h>
int main()
{
int card = 1;
if (card > 1) {
card = card - 1;
if (card < 7)
puts("Small card");
else
puts("Ace!");
return 0;
}
📄 पेज 24
✅ कंपाइलर बनो: हल (BE the Compiler Solution)
फ़ाइल
नतीजा
A
कोड कंपाइल होता है। प्रोग्राम "Small card" दिखाता है। पर यह ठीक से काम नहीं करता क्योंकि else ग़लत if से जुड़ा है।
B
कोड कंपाइल होता है। प्रोग्राम कुछ नहीं दिखाता और असल में ठीक से काम नहीं कर रहा, क्योंकि else ग़लत if से मिलाया गया है।
C
कोड कंपाइल होता है। प्रोग्राम "Ace!" दिखाता है और सही ढंग से लिखा गया है।
D
कोड कंपाइल नहीं होगा, क्योंकि ब्रेस मेल नहीं खाते (ब्रेस सही ढंग से बंद नहीं हुए)।
🔎 जाँच का तर्क (कोड चलाकर देखने पर):
A:card = 1, तो card > 1 झूठ है; दूसरा ifcard < 7 सच पाता है और "Small card" दिखाता है। असली इरादा "Ace!" दिखाने का था।
B:card > 1 झूठ है, तो पूरा ब्लॉक छूट जाता है और कुछ नहीं छपता।
C:else बाहरी if से जुड़ा है, इसलिए "Ace!" छपता है। यही सही है।
D: अंतिम } ग़ायब है, इसलिए कंपाइल नहीं होता।
📄 पेज 25
🔄 कोड अब कैसा दिखता है?
int main()
{
char card_name[3];
puts("Enter the card_name: ");
scanf("%2s", card_name);
int val = 0;
if (card_name[0] == 'K') {
val = 10;
} else if (card_name[0] == 'Q') {
val = 10;
} else if (card_name[0] == 'J') {
val = 10;
} else if (card_name[0] == 'A') {
val = 11;
} else {
val = atoi(card_name);
}
/* Check if the value is 3 to 6 */
if ((val > 2) && (val < 7))
puts("Count has gone up");
/* Otherwise check if the card was 10, J, Q, or K */
else if (val == 10)
puts("Count has gone down");
return 0;
}
💭 हम्म… क्या इस if स्टेटमेंट की शृंखला के साथ हम कुछ कर सकते हैं? ये सब एक ही मान card_name[0] की जाँच कर रहे हैं, और इनमें से ज़्यादातर val वेरिएबल को 10 पर सेट कर रहे हैं। मुझे सोचना पड़ेगा कि क्या C में इसे कहने का कोई ज़्यादा कुशल तरीक़ा है।
C प्रोग्रामों को अक्सर एक ही मान को कई बार जाँचना पड़ता है और हर स्थिति के लिए बहुत मिलता-जुलता कोड चलाना पड़ता है।
अब, आप if स्टेटमेंट की शृंखला इस्तेमाल कर सकते हैं, और शायद वह बिल्कुल ठीक रहेगा। पर C आपको इस तरह का तर्क लिखने का एक वैकल्पिक तरीक़ा देती है।
🔀 C switch स्टेटमेंट से तार्किक जाँचें कर सकती है।
📄 पेज 26
🔀 पुराना "स्विचरू" (Pulling the ol' switcheroo)
कभी-कभी सशर्त तर्क (conditional logic) लिखते समय आपको एक ही वेरिएबल का मान बार-बार जाँचना पड़ता है। आपको ढेर सारे if स्टेटमेंट लिखने से बचाने के लिए, C भाषा आपको एक और विकल्प देती है: switch स्टेटमेंट।
switch स्टेटमेंट कुछ-कुछ if स्टेटमेंट जैसा है, सिवाय इसके कि यह एक वेरिएबल के कई मानों की जाँच कर सकता है:
switch(train) {
case 37:
winnings = winnings + 50; // अगर train == 37, तो winnings में 50 जोड़ो, फिर अंत तक छोड़ो
break;
case 65:
puts("Jackpot!");
winnings = winnings + 80; // अगर train == 65, तो winnings में 80 जोड़ो
// और उसके बाद winnings में 20 भी जोड़ो; फिर अंत तक छोड़ो
case 12:
winnings = winnings + 20; // अगर train == 12, तो बस winnings में 20 जोड़ो
break;
default:
winnings = 0; // train के किसी भी और मान के लिए winnings को शून्य कर दो
}
जब कंप्यूटर switch स्टेटमेंट पर पहुँचता है, तो वह देखता है कि उसे कौन-सा मान दिया गया, और फिर मेल खाता case ढूँढता है। जब उसे वह मिल जाता है, तो वह उसके बाद आने वाला सारा कोड तब तक चलाता है जब तक वह break स्टेटमेंट तक न पहुँच जाए। कंप्यूटर तब तक चलता रहता है जब तक उसे switch स्टेटमेंट से बाहर निकलने (break) को न कहा जाए।
⚠️ break छूट जाने से आपका कोड बग (bug) वाला हो सकता है।
ज़्यादातर C प्रोग्राम हर case सेक्शन के अंत में break रखते हैं ताकि कोड समझना आसान रहे, भले ही इससे थोड़ी कुशलता कम हो जाए।
📄 पेज 27
✍️ अभ्यास: switch से दोबारा लिखो
चलिए आपके cards प्रोग्राम का वह हिस्सा फिर से देखें:
int val = 0;
if (card_name[0] == 'K') {
val = 10;
} else if (card_name[0] == 'Q') {
val = 10;
} else if (card_name[0] == 'J') {
val = 10;
} else if (card_name[0] == 'A') {
val = 11;
} else {
val = atoi(card_name);
}
क्या आपको लगता है कि आप इस कोड को switch स्टेटमेंट से दोबारा लिख सकते हैं? अपना जवाब नीचे लिखिए:
______________________________________________
📄 पेज 28
✅ हल: switch वाला कोड
आपको कोड को switch स्टेटमेंट से दोबारा लिखना था।
int val = 0;
switch(card_name[0]) {
case 'K':
case 'Q':
case 'J':
val = 10;
break;
case 'A':
val = 11;
break;
default:
val = atoi(card_name);
}
📌 ध्यान रखने वाली बातें
switch स्टेटमेंट if स्टेटमेंट की शृंखला की जगह ले सकते हैं।
switch स्टेटमेंट एक ही मान की जाँच करते हैं।
कंप्यूटर पहले मेल खाते case स्टेटमेंट से कोड चलाना शुरू करेगा।
वह तब तक चलता रहेगा जब तक break तक न पहुँच जाए या switch स्टेटमेंट के अंत तक न पहुँच जाए।
जाँचिए कि आपने break सही जगहों पर लगाए हैं, वरना आपके switch में बग होंगे।
❓ सवाल-जवाब
सवाल: मैं if की बजाय switch स्टेटमेंट क्यों इस्तेमाल करूँ?जवाब: अगर आप एक ही वेरिएबल पर कई जाँचें कर रहे हैं, तो आप switch स्टेटमेंट इस्तेमाल करना चाहेंगे।
सवाल: switch स्टेटमेंट इस्तेमाल करने के क्या फ़ायदे हैं?जवाब: कई हैं। पहला: स्पष्टता। यह साफ़ दिखता है कि कोड का पूरा ब्लॉक एक अकेले वेरिएबल को प्रोसेस कर रहा है। अगर आपके पास बस if स्टेटमेंट की शृंखला हो तो यह उतना स्पष्ट नहीं होता। दूसरा: आप अलग-अलग case के लिए कोड के हिस्से दोबारा इस्तेमाल करने के लिए फ़ॉल-थ्रू तर्क (fall-through logic) इस्तेमाल कर सकते हैं।
सवाल: क्या switch स्टेटमेंट को वेरिएबल ही जाँचना होता है? क्या वह मान नहीं जाँच सकता?जवाब: हाँ, जाँच सकता है। switch स्टेटमेंट बस यह देखेगा कि दो मान बराबर हैं।
सवाल: क्या मैं switch स्टेटमेंट में स्ट्रिंग जाँच सकता हूँ?जवाब: नहीं, आप switch स्टेटमेंट से अक्षरों की स्ट्रिंग या किसी भी तरह का ऐरे नहीं जाँच सकते। switch स्टेटमेंट सिर्फ़ एक अकेला मान जाँचेगा।
⚠️ ग़लती सुधारी (एरर फ़िक्स): किताब के पन्ने के कोड में case के अक्षर घुमावदार कोट (‘K’) में छपे हैं। असली C कोड में ये सीधे कोट ('K') होने चाहिए, वरना कंपाइल नहीं होगा। ऊपर सही रूप दिया गया है।
📄 पेज 29
🔁 कभी-कभी एक बार काफ़ी नहीं होता…
🗨️ "दो कार्ड??? हाय राम…"
आपने C भाषा के बारे में बहुत कुछ सीख लिया है, पर अभी भी कुछ ज़रूरी बातें बाक़ी हैं। आपने देखा है कि कई अलग-अलग स्थितियों के लिए प्रोग्राम कैसे लिखें, पर एक बुनियादी चीज़ है जिसे हमने अभी तक सच में नहीं देखा। अगर आप चाहें कि आपका प्रोग्राम कोई काम बार-बार, बार-बार, और बार-बार करे तो?
🔂 C में while लूप (loops) इस्तेमाल करना
लूप एक ख़ास तरह का कंट्रोल स्टेटमेंट है। कंट्रोल स्टेटमेंट तय करता है कि कोड का कोई हिस्सा चलेगा या नहीं, पर लूप स्टेटमेंट तय करता है कि कोड का कोई हिस्सा कितनी बार चलेगा।
C में सबसे बुनियादी तरह का लूप while लूप है। while लूप कोड को बार-बार, बार-बार चलाता है, जब तक कोई शर्त सच बनी रहे।
while (<some condition>) { // बॉडी चलाने से पहले यह शर्त जाँचता है
... /* Do something here */ // बॉडी ब्रेस के बीच है
}
अगर आपकी बॉडी में बस एक पंक्ति है, तो आपको ब्रेस की ज़रूरत नहीं।
बॉडी के अंत में पहुँचने पर, कंप्यूटर जाँचता है कि लूप की शर्त अब भी सच है या नहीं। अगर है, तो बॉडी का कोड फिर चलता है।
while (more_balls)
keep_juggling();
🔄 क्या आप do while करते हैं?
while लूप का एक और रूप है जो लूप की शर्त लूप बॉडी चलने के बाद जाँचता है। इसका मतलब है कि लूप कम से कम एक बार ज़रूर चलता है। इसे do...while लूप कहते हैं:
do {
/* Buy lottery ticket */
} while(have_not_won);
📄 पेज 30
🔢 लूप अक्सर एक जैसी संरचना के होते हैं… (for loops)
जब भी आपको कोड का कोई हिस्सा दोहराना हो, आप while लूप इस्तेमाल कर सकते हैं, पर अक्सर आपके लूप की संरचना एक जैसी होगी:
🔹 लूप से पहले कुछ सरल करो, जैसे काउंटर (counter) सेट करना।
🔹 लूप पर एक सरल टेस्ट कंडीशन (test condition) रखो।
🔹 लूप के अंत में कुछ करो, जैसे काउंटर अपडेट करना।
उदाहरण के लिए, यह एक while लूप है जो 1 से 10 तक गिनता है:
int counter = 1; // यह लूप का स्टार्टअप कोड है
while (counter < 11) { // यह लूप की शर्त है
printf("%i green bottles, hanging on a wall\n", counter);
counter++; // यह लूप अपडेट कोड है, जो लूप बॉडी के अंत में चलता है
}
📝 याद रखो: counter++ का मतलब है "counter वेरिएबल को एक से बढ़ाओ।"
इस तरह के लूप में वह कोड होता है जो लूप के लिए वेरिएबल तैयार करता है, कोई ऐसी शर्त जो लूप के हर बार चलने पर जाँची जाती है, और अंत में कोई ऐसा कोड जो काउंटर या उससे मिलती-जुलती चीज़ अपडेट करता है।
✨ …और for लूप इसे आसान बना देता है
क्योंकि यह पैटर्न (pattern) इतना आम है, C के डिज़ाइनरों ने इसे थोड़ा संक्षिप्त बनाने के लिए for लूप बनाया। कोड का वही टुकड़ा for लूप से लिखने पर यह दिखता है:
int counter;
for (counter = 1; counter < 11; counter++) {
printf("%i green bottles, hanging on a wall\n", counter);
}
counter = 1 → यह लूप वेरिएबल को इनिशियलाइज़ (initialize) करता है।
counter < 11 → यह टेस्ट कंडीशन है जो हर बार लूप चलने से पहले जाँची जाती है।
counter++ → यह वह कोड है जो हर लूप के बाद चलेगा।
क्योंकि लूप बॉडी में सिर्फ़ एक पंक्ति है, आप असल में इन ब्रेस को छोड़ सकते थे।
for लूप C में असल में बहुत इस्तेमाल होते हैं, while लूप जितने, या उससे भी ज़्यादा। ये न सिर्फ़ कोड को थोड़ा छोटा करते हैं, बल्कि दूसरे C प्रोग्रामरों के लिए पढ़ना भी आसान होते हैं, क्योंकि लूप को नियंत्रित करने वाला सारा कोड, यानी counter वेरिएबल का मान नियंत्रित करने वाली चीज़ें, अब for स्टेटमेंट में समाई हैं और लूप बॉडी से बाहर निकाल ली गई हैं।
⚠️ ग़लती सुधारी (एरर फ़िक्स): किताब के इस पन्ने की एक टिप्पणी में "text condition" छपा है। असल में यह "test condition" (टेस्ट कंडीशन, यानी जाँच की शर्त) है, और ऊपर इसी रूप में लिखा गया है।
✍️ नोट्स कैसे बने हैं: यह किताब का शब्दशः अनुवाद नहीं है। हर पेज की हर बात, हर कोड, हर सवाल-जवाब और हर चित्र की बात अपने शब्दों में हिंदी (हिंग्लिश) में समझाई गई है। कुछ छोड़ा नहीं गया है। पारिभाषिक शब्द हिंदी लिपि में लिखे हैं और कोष्ठक में रोमन रूप दिया है। "टूल" को टूल ही लिखा है।
🔧 एरर-फ़िक्स: किताब के कोड और बातों में जहाँ गड़बड़ मिली, उसे पेज 55 के बाद वाले हिस्से "🛠️ एरर और सुधार" में ठीक करके दिखाया है।
🗺️ पेज-नंबर का नक्शा
PDF फ़ाइल के पेज और किताब पर छपे पेज नंबर अलग हैं, इसलिए पहले यह तालिका देख लें।
PDF पेज
किताब पर छपा नंबर
विषय
31
xxix
हम जानते हैं आप क्या सोच रहे हैं
32
xxx
इस किताब का उपयोग कैसे करें (सीखने के सिद्धांत)
33
xxxi
मेटाकॉग्निशन (metacognition)
34
xxxii
हमने क्या किया
35
xxxiii
आप क्या कर सकते हैं (9 सुझाव)
36
xxxiv
Read me (पहले ज़रूरी बातें)
37
xxxv
Read me (बाकी बातें)
38
xxxvi
टेक्निकल रिव्यू टीम
39
xxxvii
आभार (Acknowledgments)
40
xxxviii
Safari Books Online
41
1
Chapter 1 की शुरुआत: Diving in
42
2
C कैसे काम करती है
43
3
कोड के टुकड़े पहचानो
44
4
टुकड़ों का खुलासा
45
5
पूरा C प्रोग्राम कैसा दिखता है
46
6
main() फ़ंक्शन
47
7
Code Magnets (सवाल)
48
8
Code Magnets (हल)
49
9
प्रोग्राम कैसे चलाएँ
50
10
Test Drive
51
11
C में string क्यों नहीं है
52
12
Strings की गहराई
53
13
सवाल-जवाब + Painless Operations
54
14
दो तरह के कमांड
55
15
अब तक का कोड
भाग A — Intro (PDF पेज 31–40)
📄 पेज 31 — "हम जानते हैं आप क्या सोच रहे हैं"
पेज की शुरुआत उन तीन सवालों से होती है जो इस किताब को हाथ में लेते ही आपके मन में आ सकते हैं:
"क्या यह वाकई एक गंभीर C की किताब है?"
"इतने सारे चित्र क्यों हैं?"
"क्या मैं इस तरीके से सच में सीख पाऊँगा?"
आपका दिमाग क्या सोचता है
दिमाग को नई और असामान्य चीज़ें पसंद हैं। वह हमेशा कुछ अलग ढूँढता रहता है। यह उसकी बनावट है और इसी से इंसान ज़िंदा रहता आया है।
जो चीज़ें रोज़मर्रा की, साधारण और उबाऊ हैं, उन्हें दिमाग सहेजता ही नहीं। वे एक "यह ज़ाहिर तौर पर ज़रूरी नहीं है" वाले फ़िल्टर पर ही रुक जाती हैं।
दिमाग कैसे तय करता है कि क्या ज़रूरी है? किताब का उदाहरण: आप पहाड़ों में घूम रहे हैं और अचानक सामने बाघ आ जाता है। तब न्यूरॉन (neuron) तेज़ी से सक्रिय होते हैं, भावनाएँ चरम पर पहुँचती हैं और शरीर में रसायन बहने लगते हैं। इसी से दिमाग समझ लेता है: "यह ज़रूरी है, इसे भूलना मत!"
अब उलटी स्थिति सोचिए। आप घर या लाइब्रेरी में बैठे हैं, जगह सुरक्षित है, कोई बाघ नहीं है, और आप परीक्षा या किसी कठिन तकनीकी विषय की तैयारी कर रहे हैं। मुश्किल यह है कि दिमाग "आपकी भलाई" के लिए इस पढ़ाई को गैर-ज़रूरी मानकर रोक देता है, ताकि उसकी सीमित क्षमता बाघ, आग और ऐसी बड़ी बातों के लिए बची रहे।
दिमाग को सीधे कहने का कोई आसान तरीका नहीं है कि "भाई, यह किताब कितनी भी बोरिंग लगे और इससे मुझे कोई खास भावना न भी हो रही हो, फिर भी यह सब याद रखना ज़रूरी है।"
🖼️ पेज पर बने चित्र: एक कार्टून में दिमाग कहता है "यह ज़रूरी है" (बाघ वाली स्थिति) और दूसरे में "यह सहेजने लायक नहीं है" (किताब वाली स्थिति)। साथ में एक पाठक का मज़ाक है: "बढ़िया, अभी 600 और नीरस, सूखे, उबाऊ पेज बाकी हैं।"
📄 पेज 32 — "इस किताब का उपयोग कैसे करें"
किताब कहती है कि "Head First" शैली में लेखक पाठक को सीखने वाले इंसान की तरह देखते हैं। सीखने के लिए पहले चीज़ को समझना (get it) पड़ता है, फिर पक्का करना पड़ता है कि वह भूले नहीं। यह सिर्फ़ तथ्य दिमाग में ठूँसना नहीं है। यह तरीका संज्ञानात्मक विज्ञान (cognitive science), न्यूरोबायोलॉजी (neurobiology) और शिक्षा-मनोविज्ञान (educational psychology) के ताज़ा शोध पर आधारित है।
🧠 Head First के सीखने के सिद्धांत
सिद्धांत
किताब क्या कहती है
इसे दृश्य बनाओ (Make it visual)
शब्दों की तुलना में चित्र ज़्यादा याद रहते हैं और सीखना कहीं ज़्यादा समझने लायक हो जाता है। याद रखने और ज्ञान को लागू करने वाले अध्ययनों में लगभग 89% तक सुधार बताया गया है। शब्दों को चित्र के अंदर या बिल्कुल पास रखने पर पाठक, पेज के नीचे या दूसरे पेज पर रखे शब्दों की तुलना में, संबंधित समस्याएँ हल करने में दोगुना तक बेहतर होते हैं।
बातचीत वाली, निजी शैली
कुछ अध्ययनों में, जब सामग्री सीधे पाठक से "मैं/तुम" में बात करती थी, तो परीक्षा के बाद के सीखने वाले टेस्ट में छात्रों ने 40% तक बेहतर प्रदर्शन किया, औपचारिक लहजे की तुलना में। इसलिए यहाँ कहानियाँ हैं, भाषण नहीं। लहजा आम बोलचाल का है। खुद को ज़्यादा गंभीर न लें। सवाल: आप किसकी बात ज़्यादा ध्यान से सुनेंगे, एक मज़ेदार डिनर-पार्टी के साथी की या एक लेक्चर की?
पाठक को गहराई से सोचने पर मजबूर करो
अगर आप अपने न्यूरॉन सक्रिय नहीं करते तो दिमाग में कुछ खास नहीं होता। पाठक को प्रेरित, जुड़ा हुआ, जिज्ञासु और नई जानकारी पैदा करने के लिए उत्साहित होना चाहिए। इसके लिए चुनौतियाँ, अभ्यास और उकसाने वाले सवाल चाहिए, और ऐसी गतिविधियाँ जिनमें दिमाग के दोनों हिस्से और कई इंद्रियाँ लगें।
पाठक का ध्यान खींचो और बनाए रखो
हम सबको यह अनुभव है: "मैं सच में यह सीखना चाहता हूँ, पर पहले पेज के बाद आँखें बंद होने लगती हैं।" दिमाग उन चीज़ों पर ध्यान देता है जो असामान्य, अजीब, आँख-पकड़ू और अप्रत्याशित हों। कोई नया, कठिन तकनीकी विषय उबाऊ होना ज़रूरी नहीं है। दिमाग को उबाऊ न लगे तो वह बहुत जल्दी सीखता है।
भावनाओं को छुओ
किसी बात को याद रख पाना काफ़ी हद तक उसकी भावनात्मक सामग्री पर निर्भर करता है। जिस चीज़ की आपको परवाह है, वह याद रहती है। किताब साफ़ करती है कि यह दुखभरी कहानियों की बात नहीं है। यहाँ भावना का मतलब है हैरानी, जिज्ञासा, मज़ा, "अरे यह क्या?" और वह एहसास "मैं तो छा गया!" जो पहेली हल होने, कुछ कठिन सीखने, या यह जानने पर होता है कि आपको वह चीज़ आती है जो इंजीनियरिंग वाले "बॉब" को नहीं आती।
🖼️ पेज पर एक कार्टून भी है जहाँ "इंजीनियरिंग वाले बॉब" का ज़िक्र मज़ाक में आता है।
📄 पेज 33 — मेटाकॉग्निशन (Metacognition): सोचने के बारे में सोचना
अगर आप तेज़ी से और गहराई से सीखना चाहते हैं तो ध्यान दें कि आप ध्यान कैसे देते हैं, सोचें कि आप सोचते कैसे हैं, और जानें कि आप सीखते कैसे हैं।
हममें से ज़्यादातर लोगों ने बचपन में मेटाकॉग्निशन या सीखने के सिद्धांत की कोई क्लास नहीं ली। हमसे उम्मीद थी कि हम सीखेंगे, पर सीखना सिखाया कम ही गया।
किताब मान लेती है कि आप C प्रोग्रामिंग सीखना चाहते हैं और ज़्यादा वक़्त नहीं लगाना चाहते। जो पढ़ें वह इस्तेमाल करना है तो उसे याद रखना होगा, और याद रखने के लिए समझना होगा। इसलिए अपने दिमाग की ज़िम्मेदारी खुद लें।
असली ट्रिक: दिमाग को नई सामग्री "बहुत ज़रूरी" लगे, बाघ जितनी ज़रूरी। वरना वह बार-बार इस सामग्री को चिपकने से रोकने की लड़ाई लड़ता रहेगा।
प्रोग्रामिंग को "भूखे बाघ" जैसा कैसे बनाएँ?
तरीका
कैसे काम करता है
🐢 धीमा और उबाऊ तरीका: बार-बार दोहराना
कितना भी नीरस विषय हो, एक ही चीज़ को बार-बार दिमाग में ठोकते रहने से वह याद हो जाता है। दिमाग सोचता है, "इसे यह खास नहीं लगता, पर यह एक ही चीज़ को बार-बार देख रहा है, तो शायद ज़रूरी होगी।"
🐇 तेज़ और असरदार तरीका: दिमाग की गतिविधि बढ़ाओ
खासकर अलग-अलग तरह की गतिविधि। पिछले पेज की सारी बातें इसी का हिस्सा हैं और ये सब दिमाग को आपके पक्ष में काम करवाने के लिए साबित हो चुकी हैं।
दो उदाहरण दिए गए हैं:
शब्द चित्र के अंदर। जब शब्द उसी चित्र के भीतर रखे जाएँ जिसे वे समझाते हैं (कैप्शन या बॉडी टेक्स्ट में अलग नहीं), तो दिमाग को शब्द और चित्र का रिश्ता समझने की कोशिश करनी पड़ती है। इससे ज़्यादा न्यूरॉन सक्रिय होते हैं। ज़्यादा न्यूरॉन सक्रिय होने का मतलब है कि दिमाग को यह समझने का ज़्यादा मौक़ा मिलता है कि "यह चीज़ ध्यान देने और शायद सहेजने लायक है।"
बातचीत वाली शैली। जब लोगों को लगता है कि वे बातचीत में हैं तो उन्हें साथ चलना और अपना पक्ष रखना पड़ता है, इसलिए वे ज़्यादा ध्यान देते हैं। मज़े की बात यह है कि दिमाग को फ़र्क नहीं पड़ता कि "बातचीत" आपके और एक किताब के बीच है। औपचारिक और सूखी भाषा में दिमाग को ऐसा लगता है जैसे वह एक हॉल में बैठा निष्क्रिय श्रोता है जिसे भाषण सुनाया जा रहा हो, यानी जागे रहने की कोई ज़रूरत नहीं।
पेज का अंत: "पर चित्र और बातचीत की शैली तो बस शुरुआत है…"
🖼️ चित्र में एक पात्र सोच रहा है: "मैं सोचता हूँ कैसे अपने दिमाग को चकमा देकर यह सब याद करवाऊँ…"
📄 पेज 34 — "हमने यह किया"
लेखकों ने अपनी तरफ़ से जो-जो तरकीबें अपनाईं, वे ये हैं:
चित्र इस्तेमाल किए, क्योंकि दिमाग दृश्यों के लिए बना है, पाठ के लिए नहीं। एक चित्र सचमुच हज़ार शब्दों के बराबर है। शब्द चित्र के भीतर रखे गए, ताकि वे जिस चीज़ के बारे में हैं उसी के अंदर हों।
पुनरावृत्ति (redundancy): एक ही बात अलग-अलग तरीकों से, अलग माध्यमों में और कई इंद्रियों से कही गई, ताकि वह दिमाग के एक से ज़्यादा हिस्सों में दर्ज हो।
अनपेक्षित तरीके से अवधारणाएँ और चित्र, क्योंकि दिमाग नयापन ढूँढता है। साथ ही थोड़ी भावनात्मक सामग्री वाले चित्र और विचार, क्योंकि दिमाग भावनाओं की जैव-रसायनी पर ध्यान देता है। जो चीज़ आपको कुछ महसूस कराती है, वह ज़्यादा याद रहती है, भले वह थोड़ा हास्य, हैरानी या दिलचस्पी ही क्यों न हो।
निजी, बातचीत वाली शैली, क्योंकि जब दिमाग को लगता है कि आप बातचीत में हैं तो वह ज़्यादा ध्यान देता है, भले आप पढ़ ही रहे हों।
80 से ज़्यादा गतिविधियाँ, क्योंकि करने से ज़्यादा सीखा और याद रखा जाता है, पढ़ने से कम। अभ्यास ऐसे रखे गए कि मुश्किल हों पर किए जा सकें, क्योंकि ज़्यादातर लोग यही पसंद करते हैं।
कई तरह की सीखने की शैलियाँ। कोई चरण-दर-चरण तरीका पसंद करता है, कोई पहले बड़ी तस्वीर, कोई सिर्फ़ उदाहरण। आपकी जो भी पसंद हो, एक ही सामग्री अलग-अलग रूपों में देखने से सबको फ़ायदा होता है।
दिमाग के दोनों हिस्सों के लिए सामग्री। जितना ज़्यादा दिमाग लगे, उतना सीखना और याद रखना बढ़ता है और ध्यान ज़्यादा देर टिकता है। एक हिस्सा काम करे तो दूसरे को आराम मिलता है, इसलिए आप लंबे समय तक सीखने में उत्पादक रह सकते हैं।
ऐसी कहानियाँ और अभ्यास जिनमें एक से ज़्यादा दृष्टिकोण हों, क्योंकि जब दिमाग को आकलन और निर्णय करने पड़ते हैं तब वह ज़्यादा गहराई से सीखता है।
चुनौतियाँ, जिनमें अभ्यास और ऐसे सवाल हैं जिनका सीधा-सादा जवाब नहीं होता। दिमाग तब सीखता और याद रखता है जब उसे किसी चीज़ पर मेहनत करनी पड़ती है। जिम में दूसरों को देखकर शरीर फिट नहीं होता। पर लेखकों ने कोशिश की है कि आपकी मेहनत सही चीज़ों पर लगे, न कि कठिन उदाहरण, भारी शब्दजाल या बहुत संक्षिप्त पाठ को समझने में।
लोग: कहानियों, उदाहरणों और चित्रों में इंसान लिए गए, क्योंकि आप भी इंसान हैं और दिमाग चीज़ों की तुलना में इंसानों पर ज़्यादा ध्यान देता है।
📄 पेज 35 — "आप क्या कर सकते हैं: अपने दिमाग को काबू में लाने के 9 सुझाव"
लेखकों का हिस्सा पूरा हुआ, अब बाकी आप पर है। ये सुझाव सिर्फ़ शुरुआत हैं। अपने दिमाग की सुनिए और देखिए क्या आपके लिए काम करता है। नई चीज़ें आज़माइए। किताब कहती है कि इस पेज को काटकर फ़्रिज पर चिपका लीजिए।
#
सुझाव
मतलब
1
धीरे चलो।
जितना ज़्यादा समझोगे, उतना कम रटना पड़ेगा। सिर्फ़ पढ़ो मत, रुककर सोचो। जब किताब कोई सवाल पूछे तो सीधे जवाब पर मत कूदो। कल्पना करो कि कोई सचमुच तुमसे पूछ रहा है। जितनी गहराई से दिमाग को सोचने पर मजबूर करोगे, सीखने और याद रखने की संभावना उतनी बढ़ेगी।
2
अभ्यास करो, अपने नोट्स लिखो।
अभ्यास लेखकों ने दिए हैं, पर अगर वे खुद हल कर देते तो यह वैसा होता जैसे कोई और आपकी जगह वर्कआउट कर दे। सिर्फ़ अभ्यास देखो मत, पेंसिल इस्तेमाल करो। काफ़ी सबूत हैं कि सीखते समय शारीरिक गतिविधि सीखना बढ़ाती है।
3
"There Are No Dumb Questions" ज़रूर पढ़ो।
मतलब सारे। ये वैकल्पिक साइडबार नहीं हैं, मुख्य सामग्री का हिस्सा हैं। इन्हें छोड़ो मत।
4
इसे सोने से पहले की आख़िरी चीज़ बनाओ।
या कम से कम आख़िरी कठिन चीज़। सीखने का एक हिस्सा (खासकर लंबे समय की स्मृति में पहुँचना) किताब रखने के बाद होता है। दिमाग को अपने आप प्रोसेस करने का समय चाहिए। उस बीच कुछ नया डाल दिया तो अभी सीखी कुछ चीज़ें खो जाएँगी।
5
इसके बारे में बोलो, ज़ोर से।
बोलने से दिमाग का अलग हिस्सा सक्रिय होता है। कुछ समझना हो या बाद में याद रखना हो तो उसे बोलकर कहो। और बेहतर: किसी दूसरे को ज़ोर से समझाओ। तुम तेज़ी से सीखोगे, और ऐसे विचार भी मिल सकते हैं जो पढ़ते वक़्त पता नहीं थे।
6
पानी पियो। खूब सारा।
दिमाग तरल के अच्छे "स्नान" में सबसे बढ़िया काम करता है। निर्जलीकरण (dehydration) प्यास लगने से पहले ही हो सकता है और सोचने-समझने की क्षमता घटा देता है।
7
अपने दिमाग की सुनो।
ध्यान दो कि दिमाग पर ज़्यादा बोझ तो नहीं पड़ रहा। अगर तुम ऊपर-ऊपर से पढ़ने लगे हो या अभी पढ़ा हुआ भूल रहे हो, तो ब्रेक का समय है। एक हद के बाद और ठूँसने से तेज़ नहीं सीखोगे, उलटा प्रक्रिया बिगड़ सकती है।
8
कुछ महसूस करो।
दिमाग को पता होना चाहिए कि यह मायने रखता है। कहानियों से जुड़ो। तस्वीरों के लिए अपने कैप्शन बनाओ। बुरे जोक पर कराहना भी कुछ न महसूस करने से बेहतर है।
9
खूब सारा कोड लिखो!
C सीखने का सिर्फ़ एक ही तरीका है: बहुत कोड लिखना। कोडिंग एक कौशल है और इसमें माहिर होने का रास्ता सिर्फ़ अभ्यास है। हर अध्याय में हल करने के लिए अभ्यास हैं, उन्हें छोड़ो मत, क्योंकि सीखने का बहुत सारा हिस्सा उन्हें हल करने में होता है। हर अभ्यास का हल भी दिया गया है। अटक जाओ तो झाँकने से डरो मत (छोटी चीज़ों पर अटकना आसान है), पर पहले खुद हल करने की कोशिश करो। और अगला हिस्सा शुरू करने से पहले कोड को चलता हुआ ज़रूर बना लो।
📄 पेज 36 — "Read me" (पढ़ो मुझे) — भाग 1
यह किताब एक सीखने का अनुभव है, रेफ़रेंस बुक (reference book) नहीं। जानबूझकर वह सब हटाया गया है जो सीखने में बाधा बन सकता था। और पहली बार पढ़ते समय शुरू से ही शुरू करना ज़रूरी है, क्योंकि किताब मानकर चलती है कि आप पिछला सब देख और सीख चुके हैं।
✅ किताब की मान्यताएँ और ज़रूरतें
आप C में नए हैं, प्रोग्रामिंग में नहीं। मान लिया गया है कि आप थोड़ी-बहुत प्रोग्रामिंग कर चुके हैं, यानी लूप (loop) और वेरिएबल (variable) जैसी चीज़ें किसी दूसरी भाषा, जैसे JavaScript, में देखी हैं। C असल में काफ़ी उन्नत भाषा है। अगर आपने कभी प्रोग्रामिंग नहीं की तो पहले कोई और किताब पढ़ें। किताब का सुझाव: Head First Programming।
अपने कंप्यूटर पर C कंपाइलर (compiler) इंस्टॉल करना होगा। किताब में हर जगह Gnu Compiler Collection (gcc) इस्तेमाल हुआ है, क्योंकि यह मुफ़्त है और लेखकों के मुताबिक बहुत अच्छा कंपाइलर है।
आपका सिस्टम
क्या करें
🐧 Linux
gcc पहले से मौजूद होना चाहिए।
🍎 Mac
Xcode / Developer टूल इंस्टॉल करें। Apple App Store से या सीधे Apple से डाउनलोड किए जा सकते हैं।
🪟 Windows
दो विकल्प हैं: Cygwin (UNIX जैसा पूरा वातावरण, gcc समेत) या MinGW (Minimalist GNU for Windows), अगर आप ऐसे प्रोग्राम चाहते हैं जो सीधे-सादे Windows पर चलें।
किताब का सारा कोड सभी ऑपरेटिंग सिस्टम पर चलने के लिए लिखा गया है। कुछ भी सिर्फ़ एक तरह के कंप्यूटर पर चलने वाला लिखने से बचा गया है। कभी-कभार फ़र्क होगा तो किताब बता देगी।
पहले कुछ बुनियादी C अवधारणाएँ, फिर तुरंत C को काम में लगाना। Chapter 1 में C की बुनियाद है, ताकि Chapter 2 तक पहुँचते-पहुँचते आप ऐसे प्रोग्राम बना रहे हों जो सचमुच कुछ करें, काम के हों और (किताब के शब्दों में) "मज़ेदार" भी। आगे की किताब इन्हीं कौशलों पर बनती है और आपको C के नौसिखिए से कोडिंग ninja बना देती है।
📄 पेज 37 — "Read me" — भाग 2
गतिविधियाँ वैकल्पिक नहीं हैं। अभ्यास और गतिविधियाँ ऊपर से जोड़ी गई चीज़ें नहीं, किताब की मुख्य सामग्री हैं। कुछ याददाश्त के लिए हैं, कुछ समझने के लिए और कुछ सीखी हुई चीज़ को लागू करने के लिए। इन्हें न छोड़ें।
दोहराव जानबूझकर है और ज़रूरी है। Head First किताब का एक बड़ा फ़र्क यह है कि लेखक चाहते हैं कि आप सचमुच समझें और किताब ख़त्म करने के बाद भी सीखा हुआ आपको याद रहे। ज़्यादातर रेफ़रेंस बुक का लक्ष्य याददाश्त नहीं होता, पर यह किताब सीखने के लिए है, इसलिए कुछ अवधारणाएँ एक से ज़्यादा बार आएँगी।
उदाहरण जितने हो सकें उतने छोटे हैं। पाठकों ने बताया कि 200 लाइन के उदाहरण में दो ज़रूरी लाइनें ढूँढना झुँझलाहट भरा होता है। इसलिए ज़्यादातर उदाहरण कम से कम संदर्भ में दिखाए गए हैं ताकि जो सीखना है वह साफ़ और सरल रहे। यह उम्मीद न रखें कि सारे उदाहरण मज़बूत (robust) या पूरे होंगे। वे सीखने के लिए लिखे गए हैं, हमेशा पूरी तरह चलने लायक नहीं।
"Brain Power" अभ्यासों के जवाब नहीं हैं। कुछ के लिए कोई सही जवाब होता ही नहीं, और कुछ में सीखने का हिस्सा यह है कि आप खुद तय करें कि आपका जवाब कब और क्या सही है। कुछ Brain Power अभ्यासों में सही दिशा का संकेत (hint) मिलेगा।
📄 पेज 38 — टेक्निकल रिव्यू टीम
किताब की तकनीकी समीक्षा करने वाले दो लोग:
Dave Kitabjian: इलेक्ट्रिकल और कंप्यूटर इंजीनियरिंग में दो डिग्रियाँ। करीब 20 साल का अनुभव: सलाह देना, इंटीग्रेशन, आर्किटेक्चर और ग्राहकों के लिए सूचना-प्रणाली बनाना। ग्राहक Fortune 500 कंपनियों से लेकर हाई-टेक स्टार्टअप तक रहे हैं। काम के बाहर गिटार और पियानो बजाते हैं और पत्नी तथा तीन बच्चों के साथ समय बिताते हैं।
Vince Milner: 20 साल से ज़्यादा से C (और कई अन्य भाषाओं) में अलग-अलग प्लेटफ़ॉर्म पर डेवलपमेंट कर रहे हैं। गणित में मास्टर्स की पढ़ाई कर रहे हैं। (मज़ाक में लिखा है कि वे छह साल के बच्चों से बोर्ड गेम में हार जाते हैं और घर बदलने में असफल रहते हैं।)
📄 पेज 39 — आभार (Acknowledgments)
संपादक Brian Sawyer: किताब लिखने का न्योता देने के लिए धन्यवाद। हर कदम पर भरोसा किया, नए विचार आज़माने की आज़ादी दी और डेडलाइन पास आने पर ज़्यादा घबराए नहीं।
O'Reilly टीम: Karen Shaner (तस्वीरें ढूँढने और सब कुछ सुचारू रखने के लिए), Laurie Petrycki (बोस्टन में खिलाने-पिलाने और प्रेरित रखने के लिए), Brian Jepson (Arduino की दुनिया से परिचय के लिए), अर्ली रिलीज़ टीम (किताब के शुरुआती संस्करण डाउनलोड के लिए देने पर), और Rachel Monaghan तथा प्रोडक्शन टीम (किताब को प्रोडक्शन से निकालने के लिए)।
परिवार, मित्र, सहकर्मी: Lou Barr, Brett McLaughlin और Sanders Kleinfeld का विशेष धन्यवाद। David ने अपने मित्रों (Andy Parker, Joe Broughton, Carl Jacques, Simon Jones आदि) को धन्यवाद दिया। Dawn ने माता-पिता और परिवार-मित्रों (Mum और Dad, Carl, Steve, Gill, Jacqui, Joyce, Paul) को धन्यवाद दिया।
"Without-whom" सूची: तकनीकी रिव्यू टीम, और अर्ली रिलीज़ पर फ़ीडबैक देने वाले पाठक। अंत में Kathy Sierra और Bert Bates का शुक्रिया, जिन्होंने इस असाधारण किताब-श्रृंखला (Head First series) को बनाया।
📄 पेज 40 — Safari Books Online
यह एक विज्ञापन-नुमा पेज है। Safari Books Online एक ऑन-डिमांड डिजिटल लाइब्रेरी है, जिसमें तकनीक और व्यापार के विशेषज्ञ लेखकों की किताबें और वीडियो मिलते हैं। इसे टेक्नोलॉजी प्रोफ़ेशनल, सॉफ़्टवेयर डेवलपर, वेब डिज़ाइनर और क्रिएटिव लोग रिसर्च, समस्या-समाधान, सीखने और सर्टिफ़िकेशन ट्रेनिंग के लिए इस्तेमाल करते हैं। संगठनों, सरकारी एजेंसियों और व्यक्तियों के लिए अलग-अलग पैकेज और मूल्य-योजनाएँ हैं। सब्सक्राइबर को हज़ारों किताबें, ट्रेनिंग वीडियो और प्रकाशन-पूर्व पांडुलिपियाँ एक खोजने योग्य डेटाबेस में मिलती हैं। इसमें O'Reilly Media, Prentice Hall, Addison-Wesley, Microsoft Press, Cisco Press, John Wiley & Sons, Manning, McGraw-Hill जैसे दर्जनों प्रकाशकों की सामग्री शामिल बताई गई है। (पढ़ाई की दृष्टि से इस पेज में सीखने लायक कुछ नहीं है।)
भाग B — Chapter 1: Getting Started with C (PDF पेज 41–55)
📄 पेज 41 — "Diving in" (गोता लगाओ)
अध्याय की शुरुआत इस सवाल से होती है: क्या आप कंप्यूटर के दिमाग के अंदर झाँकना चाहते हैं? अगर आप इनमें से कुछ करना चाहते हैं तो C आपकी मदद करेगी:
किसी नए गेम के लिए हाई-परफ़ॉर्मेंस कोड लिखना
Arduino प्रोग्राम करना
अपने iPhone ऐप में कोई उन्नत थर्ड-पार्टी लाइब्रेरी इस्तेमाल करना
मुख्य बात: C ज़्यादातर भाषाओं की तुलना में निचले स्तर (lower level) पर काम करती है, इसलिए C समझने से आपको पता चलता है कि असल में अंदर क्या हो रहा है। और C सीखने से दूसरी भाषाएँ भी बेहतर समझ आती हैं। इसलिए कंपाइलर उठाइए और शुरू हो जाइए। 🖼️ पन्ने पर गहरे नीले रंग का बड़ा "C" है, जिसके बारे में मज़ाक है: "आ जाओ, पानी बढ़िया है!"
📄 पेज 42 — C छोटे और तेज़ प्रोग्रामों की भाषा है
C को छोटे और तेज़ प्रोग्राम बनाने के लिए डिज़ाइन किया गया है।
यह ज़्यादातर भाषाओं से निचले स्तर की है। इसका मतलब, यह ऐसा कोड बनाती है जो उस भाषा के काफ़ी करीब है जिसे मशीन असल में समझती है।
⚙️ C कैसे काम करती है
कंप्यूटर असल में सिर्फ़ एक भाषा समझते हैं: मशीन कोड (machine code), यानी 1 और 0 की बाइनरी धारा। आप अपना C कोड कंपाइलर (compiler) की मदद से मशीन कोड में बदलते हैं।
तीन चरण, जो पेज के उदाहरण rocks.c से दिखाए गए हैं (प्रोग्राम puts से "C Rocks!" छापता है):
चरण
नाम
क्या होता है
1️⃣
Source (सोर्स)
आप एक सोर्स फ़ाइल (source file) बनाते हैं। उसमें इंसान के पढ़ने लायक C कोड होता है।
2️⃣
Compile (कंपाइल)
आप सोर्स कोड को कंपाइलर से गुज़ारते हैं। कंपाइलर एरर जाँचता है और जब संतुष्ट होता है तो कोड को कंपाइल कर देता है। उदाहरण का कमांड: gcc rocks.c -o rocks।
3️⃣
Output (आउटपुट)
कंपाइलर एक नई फ़ाइल बनाता है जिसे एक्ज़ीक्यूटेबल (executable) कहते हैं। इसमें मशीन कोड होता है, यानी 1 और 0 की धारा जिसे कंप्यूटर समझता है। यही वह प्रोग्राम है जिसे आप चला सकते हैं।
🪟 Windows पर: एक्ज़ीक्यूटेबल का नाम rocks की जगह rocks.exe होगा।
🌍 C कहाँ इस्तेमाल होती है?
C वहाँ इस्तेमाल होती है जहाँ गति (speed), जगह (space) और पोर्टेबिलिटी (portability) अहम हैं। ज़्यादातर ऑपरेटिंग सिस्टम C में लिखे हैं। ज़्यादातर दूसरी प्रोग्रामिंग भाषाएँ भी C में लिखी गई हैं। और ज़्यादातर गेम सॉफ़्टवेयर भी C में लिखे जाते हैं।
📚 C के तीन स्टैंडर्ड (standard)
स्टैंडर्ड
कब
विशेषता
ANSI C
1980 के दशक के अंत में
सबसे पुराने कोड में इस्तेमाल होता है।
C99
1999
बहुत सी चीज़ें सुधारी गईं।
C11
2011 (किताब के समय का मौजूदा स्टैंडर्ड)
कुछ बढ़िया नई भाषा-सुविधाएँ जुड़ीं।
स्टैंडर्ड्स के बीच फ़र्क बहुत बड़े नहीं हैं, और किताब आगे जहाँ ज़रूरी होगा वहाँ बता देगी।
📄 पेज 43 — "अंदाज़ा लगाओ यह कोड क्या करता है"
यह पेज एक सोचने वाला अभ्यास है। हर कोड-टुकड़े के बारे में अपना अंदाज़ा लिखना है कि वह क्या करता है। पेज 44 पर जवाब हैं, पर पहले खुद सोचना है। (सही-ग़लत का दबाव नहीं है, बस दिमाग को चलाना है।)
चारों टुकड़े ये हैं:
int card_count = 11;
if (card_count > 10)
puts("The deck is hot. Increase bet.");
int c = 10;
while (c > 0) {
puts("I must not write code in class");
c = c - 1;
}
/* Assume name shorter than 20 chars. */
char ex[20];
puts("Enter boyfriend's name: ");
scanf("%19s", ex);
printf("Dear %s.\n\n\tYou're history.\n", ex);
char suit = 'H';
switch(suit) {
case 'C':
puts("Clubs");
break;
case 'D':
puts("Diamonds");
break;
case 'H':
puts("Hearts");
break;
default:
puts("Spades");
}
📄 पेज 44 — टुकड़ों का खुलासा (Fragments Demystified)
किताब कहती है कि अगर अभी सब समझ न आए तो चिंता न करें, आगे सब विस्तार से आएगा। यहाँ हर टुकड़े की हिंदी व्याख्या:
🃏 टुकड़ा 1 — if (शर्त)
एक int वेरिएबल card_count बनाओ और उसका मान 11 रखो। (integer एक पूर्ण संख्या होती है।)
जाँचो: क्या गिनती 10 से ज़्यादा है?
अगर हाँ, तो कमांड प्रॉम्प्ट या टर्मिनल पर संदेश दिखाओ। (puts एक string स्क्रीन पर दिखाता है।)
🔁 टुकड़ा 2 — while (लूप)
एक integer वेरिएबल c बनाओ और उसे 10 पर सेट करो।
जब तक यह मान धनात्मक (positive) है...
...संदेश दिखाओ...
...और गिनती एक घटाओ।
} वह जगह है जहाँ दोहराया जाने वाला कोड ख़त्म होता है। ब्रेसेस (braces) { } मिलकर एक ब्लॉक स्टेटमेंट (block statement) बनाते हैं।
नतीजा: संदेश कुल 10 बार छपेगा।
⌨️ टुकड़ा 3 — इनपुट और आउटपुट
/* ... */ एक कमेंट (comment) है।
char ex[20] 20 अक्षरों का ऐरे (array) बनाता है।
puts स्क्रीन पर संदेश दिखाता है।
scanf("%19s", ex) का मतलब: "यूज़र जो भी टाइप करे, उसे ex ऐरे में रख दो।" (19 इसलिए कि एक जगह आख़िर में \0 के लिए बचानी है, यह पेज 52 पर समझ आएगा।)
printf एक संदेश दिखाता है जिसमें यूज़र का टाइप किया हुआ टेक्स्ट शामिल है। %s की जगह वही स्ट्रिंग बैठा दी जाती है।
🎴 टुकड़ा 4 — switch
switch एक ही वेरिएबल को कई अलग-अलग मानों से जाँचता है।
एक char वेरिएबल suit बनाओ और उसमें अक्षर H रखो।
वेरिएबल का मान देखो।
क्या यह 'C' है? अगर हाँ, "Clubs" दिखाओ और बाकी जाँचें छोड़ दो (break इसी का काम करता है)।
क्या यह 'D' है? अगर हाँ, "Diamonds" दिखाओ और बाकी जाँचें छोड़ दो।
क्या यह 'H' है? अगर हाँ, "Hearts" दिखाओ और बाकी जाँचें छोड़ दो।
वरना (default) "Spades" दिखाओ।
जाँचों का अंत।
नतीजा: suit में 'H' है, इसलिए "Hearts" छपेगा।
📝 Brain Power का जवाब (पेज 43): टुकड़ा 1 → "The deck is hot. Increase bet." छपेगा। टुकड़ा 2 → वही वाक्य 10 बार। टुकड़ा 3 → नाम पूछेगा, फिर "Dear <नाम>." के बाद दो नई लाइनें, एक टैब और "You're history." छापेगा। टुकड़ा 4 → "Hearts"।
📄 पेज 45 — एक पूरा C प्रोग्राम कैसा दिखता है?
पूरा प्रोग्राम बनाने के लिए कोड को C सोर्स फ़ाइल में लिखना होता है। यह किसी भी टेक्स्ट एडिटर से बन सकती है और फ़ाइल का नाम आम तौर पर .c पर ख़त्म होता है। यह सिर्फ़ एक परंपरा (convention) है, पर इसका पालन करना चाहिए।
किताब का नमूना प्रोग्राम "शू में कार्डों की गिनती" निकालता है (शू ब्लैकजैक का वह डिब्बा है जिसमें कई ताश-गड्डियाँ रखी होती हैं):
/*
* Program to calculate the number of cards in the shoe.
* This code is released under the Vegas Public License.
* (c)2014, The College Blackjack Team.
*/
#include <stdio.h>
int main()
{
int decks;
puts("Enter a number of decks");
scanf("%i", &decks);
if (decks < 1) {
puts("That is not a valid number of decks");
return 1;
}
printf("There are %i cards\n", (decks * 52));
return 0;
}
तीन हिस्से
हिस्सा
क्या है
1️⃣ कमेंट
C प्रोग्राम आम तौर पर कमेंट से शुरू होता है। कमेंट /* से शुरू और */ पर ख़त्म होता है। बीच की पंक्तियों के आगे जो * हैं वे वैकल्पिक हैं, सिर्फ़ सुंदरता के लिए। कमेंट में फ़ाइल का मक़सद और लाइसेंस/कॉपीराइट की जानकारी हो सकती है। कमेंट डालना ज़रूरी नहीं, पर अच्छी आदत है और ज़्यादातर C प्रोग्रामर यही उम्मीद करते हैं।
2️⃣ include सेक्शन
C एक बहुत छोटी भाषा है और बाहरी लाइब्रेरी (library) के बिना लगभग कुछ नहीं कर सकती। कंपाइलर को बताना पड़ता है कि कौन-सा बाहरी कोड इस्तेमाल होगा, और इसके लिए संबंधित लाइब्रेरी की हेडर फ़ाइलें (header files) include करते हैं। सबसे ज़्यादा दिखने वाली हेडर stdio.h है। stdio लाइब्रेरी में वह कोड है जो टर्मिनल से डेटा पढ़ने और लिखने देता है।
3️⃣ फ़ंक्शन
सोर्स फ़ाइल में सबसे आख़िर में फ़ंक्शन (function) आते हैं। सारा C कोड फ़ंक्शनों के अंदर चलता है। किसी भी C प्रोग्राम का सबसे ज़रूरी फ़ंक्शन main() है। यह आपके प्रोग्राम में सारे कोड का शुरुआती बिंदु है।
कोड का मतलब
int decks; एक integer वेरिएबल बनाता है।
scanf("%i", &decks) यूज़र से पूर्ण संख्या लेकर decks में रखता है (& का मतलब आगे चलकर समझाया जाएगा)।
अगर decks < 1 है तो प्रोग्राम गलत-संख्या का संदेश देता है और return 1 करके बंद हो जाता है, यानी "कुछ गड़बड़ हुई।"
वरना printf से कुल कार्ड छापता है (decks × 52, क्योंकि एक गड्डी में 52 पत्ते होते हैं) और return 0 करता है।
📄 पेज 46 — main() फ़ंक्शन को करीब से
कंप्यूटर आपका प्रोग्राम main() फ़ंक्शन से चलाना शुरू करता है। नाम ज़रूरी है। अगर main() नाम का फ़ंक्शन नहीं होगा तो प्रोग्राम शुरू ही नहीं हो पाएगा।
main() का रिटर्न टाइप (return type)int होता है, और main के लिए यह हमेशा int ही होना चाहिए।
रिटर्न मान क्यों?
कंप्यूटर को यह तय करना होता है कि प्रोग्राम सफलतापूर्वक चला या नहीं। वह यह main() फ़ंक्शन के रिटर्न मान (return value) को देखकर जाँचता है:
main() क्या लौटाता है
मतलब
0
प्रोग्राम सफल रहा ✅
कोई और मान
कोई समस्या हुई ❌
फ़ंक्शन की बनावट
पहले रिटर्न टाइप (int)
फिर फ़ंक्शन का नाम (main)
फिर पैरामीटर (parameters), अगर हों। यहाँ कोई नहीं है, इसलिए कुछ लिखा नहीं गया।
अंत में फ़ंक्शन की बॉडी (body), जो हमेशा ब्रेसेस { } से घिरी होती है।
🤓 Geek Bits — printf()
printf()फ़ॉर्मेट किया हुआ आउटपुट (formatted output) दिखाता है। यह फ़ॉर्मेट अक्षरों (format characters, जो % से शुरू होते हैं) की जगह वेरिएबलों के मान बैठा देता है। किताब का उदाहरण:
printf("%s says the count is %i", "Ben", 21);
पहला पैरामीटर %s की जगह स्ट्रिंग की तरह बैठता है (यहाँ "Ben")।
दूसरा पैरामीटर %i की जगह integer की तरह बैठता है (यहाँ 21)।
नतीजा: Ben says the count is 21
आप printf() को जितने चाहें उतने पैरामीटर दे सकते हैं, पर ध्यान रहे कि हर पैरामीटर के लिए मेल खाता % फ़ॉर्मेट अक्षर हो।
📄 पेज 47 — Code Magnets (अभ्यास)
परिस्थिति: College Blackjack Team हॉस्टल के फ़्रिज पर कोड पर काम कर रही थी, पर किसी ने मैग्नेट इधर-उधर कर दिए! आपको मैग्नेट से कोड दोबारा जोड़ना है।
प्रोग्राम का मक़सद: ताश के पत्ते का मान (face value) निकालना। यूज़र दो अक्षर डालता है (कार्ड का नाम)।
क्या कमी थी / जोड़ना था:
दो #include लाइनें: <stdio.h> और <stdlib.h>
int (main के आगे)
val = 10 और val = 11 (अलग-अलग कार्डों के लिए)
'J' और 'A' वाली शर्तें
else, if, और अंत में return 0;
टिप्पणी: atoi का काम टेक्स्ट को संख्या में बदलना है।
(हल अगले पेज पर है।)
📄 पेज 48 — Code Magnets का हल
यह वही पूरा cards.c प्रोग्राम है जिसे आगे पेज 49 पर कंपाइल करेंगे:
/*
* Program to evaluate face values.
* Released under the Vegas Public License.
* (c)2014 The College Blackjack Team.
*/
#include <stdio.h>
#include <stdlib.h>
int main()
{
char card_name[3];
puts("Enter the card_name: ");
scanf("%2s", card_name);
int val = 0;
if (card_name[0] == 'K') {
val = 10;
} else if (card_name[0] == 'Q') {
val = 10;
} else if (card_name[0] == 'J') {
val = 10;
} else if (card_name[0] == 'A') {
val = 11;
} else {
val = atoi(card_name);
}
printf("The card value is: %i\n", val);
return 0;
}
प्रोग्राम का तर्क
राजा (K), रानी (Q) और जैक (J) का मान 10 है।
इक्का (A) का मान 11 है।
बाकी सब के लिए atoi(card_name), यानी लिखे हुए अंक को असली संख्या में बदलना (2 → 2, 10 → 10)। atoi का इस्तेमाल करने के लिए stdlib.h include किया गया है।
❓ पेज के सवाल-जवाब
सवाल: card_name[0] का क्या मतलब है?
जवाब: यूज़र ने जो पहला अक्षर टाइप किया, वही। अगर यूज़र "10" टाइप करे तो card_name[0] का मान '1' होगा।
सवाल: क्या कमेंट हमेशा /* और */ से लिखते हो?
जवाब: अगर आपका कंपाइलर C99 स्टैंडर्ड सपोर्ट करता है तो कमेंट // से भी शुरू कर सकते हैं। कंपाइलर उस लाइन के बाक़ी हिस्से को कमेंट मानता है।
सवाल: मुझे कैसे पता चले कि मेरा कंपाइलर कौन-सा स्टैंडर्ड सपोर्ट करता है?
जवाब: अपने कंपाइलर का डॉक्यूमेंटेशन देखें। gcc तीनों स्टैंडर्ड सपोर्ट करता है: ANSI C, C99 और C11।
📄 पेज 49 — पर प्रोग्राम को चलाएँ कैसे?
C एक कंपाइल की जाने वाली भाषा (compiled language) है। यानी कंप्यूटर कोड को सीधे नहीं पढ़ता। आपको इंसान के पढ़ने लायक सोर्स कोड को मशीन के पढ़ने लायक मशीन कोड में बदलना (कंपाइल करना) पड़ता है। इसके लिए आपको कंपाइलर चाहिए। सबसे लोकप्रिय C कंपाइलरों में से एक GNU Compiler Collection (gcc) है। यह कई ऑपरेटिंग सिस्टम पर मिलता है, C के अलावा कई भाषाएँ कंपाइल कर सकता है और पूरी तरह मुफ़्त है।
तीन चरण
चरण
क्या करें
1️⃣
पिछले पेज के Code Magnets वाला कोड cards.c नाम की फ़ाइल में सेव करें। (C सोर्स फ़ाइलें आम तौर पर .c पर ख़त्म होती हैं।)
2️⃣
कमांड प्रॉम्प्ट या टर्मिनल में चलाएँ: gcc cards.c -o cards। यह cards.c को कंपाइल करके cards नाम की फ़ाइल बनाता है।
3️⃣
चलाएँ: Windows पर cards टाइप करें, Mac और Linux पर ./cards। (Windows पर फ़ाइल cards.exe होगी।)
🤓 Geek Bits — कंपाइल और रन एक साथ
ज़्यादातर मशीनों पर यह ट्रिक चलती है (उदाहरण फ़ाइल zork.c):
gcc zork.c -o zork && ./zork
&& का मतलब है "और फिर, अगर यह सफल रहा तो, यह करो।"
यह कमांड नया प्रोग्राम तभी चलाएगा जब कंपाइल सफल हो। कंपाइल में समस्या हुई तो प्रोग्राम चलाना छोड़ देगा और स्क्रीन पर सिर्फ़ एरर दिखाएगा।
Windows पर ./zork की जगह zork लिखें।
✅ Do this! (अभी करें)
cards.c फ़ाइल अभी बनाइए और कंपाइल कीजिए। जैसे-जैसे अध्याय आगे बढ़ेगा, इसी पर बार-बार काम होगा।
📄 पेज 50 — Test Drive
कमांड प्रॉम्प्ट या टर्मिनल खोलकर देखिए प्रोग्राम कंपाइल और रन होता है या नहीं।
> gcc cards.c -o cards
> ./cards
Enter the card_name:
Q
The card value is: 10
> ./cards
Enter the card_name:
A
The card value is: 11
> ./cards
Enter the card_name:
7
The card value is: 7
पहली लाइन कोड को कंपाइल करके cards प्रोग्राम बनाती है।
दूसरी लाइन उसे चलाती है (Windows पर ./ न लगाएँ)।
यूज़र ताश के पत्ते का नाम डालता है और प्रोग्राम उसका मान दिखा देता है। Q → 10, A → 11, 7 → 7।
यह कमांड बार-बार दोबारा चलाया जा सकता है।
याद रखें: कंपाइल और रन के चरणों को एक साथ जोड़ा जा सकता है (पिछले पेज की && ट्रिक)।
🎉 प्रोग्राम चल गया!
बधाई हो, आपने C प्रोग्राम कंपाइल करके चला लिया। gcc ने cards.c का इंसानी-पठनीय सोर्स कोड लेकर कंप्यूटर-पठनीय मशीन कोड वाला cards प्रोग्राम बना दिया। Mac या Linux पर फ़ाइल का नाम cards होगा, पर Windows पर हर प्रोग्राम का .exe एक्सटेंशन होना ज़रूरी है, इसलिए वहाँ cards.exe बनेगी।
❓ सवाल-जवाब
सवाल: Linux और Mac पर प्रोग्राम चलाने से पहले ./ क्यों लगाना पड़ता है?
जवाब: Unix जैसे ऑपरेटिंग सिस्टम में प्रोग्राम तभी चलता है जब आप उसकी डायरेक्टरी बताएँ, या उसकी डायरेक्टरी PATH एनवायरनमेंट वेरिएबल (environment variable) में दर्ज हो। ./ का मतलब है "मौजूदा डायरेक्टरी (current directory) में वाला।"
पाठक की उलझन: "कार्ड का नाम पूछते समय हम कैरेक्टर का ऐरे इस्तेमाल कर रहे हैं। ऐसा क्यों? हम सीधे string या कुछ और क्यों नहीं ले सकते?"
जवाब
C भाषा में string (स्ट्रिंग) टाइप डिब्बे से बाहर नहीं मिलता।
C ज़्यादातर भाषाओं की तुलना में निचले स्तर की है। इसलिए स्ट्रिंग की जगह यह आम तौर पर कुछ मिलता-जुलता इस्तेमाल करती है: अलग-अलग अक्षरों का ऐरे।
अगर आपने पहले किसी भाषा में प्रोग्रामिंग की है तो ऐरे से पाला पड़ा होगा। ऐरे बस चीज़ों की एक सूची है जिसे एक नाम दे दिया जाता है।
card_name वह वेरिएबल है जिससे आप कमांड प्रॉम्प्ट पर टाइप किए गए अक्षरों की सूची को पुकारते हैं।
आपने card_name को दो-अक्षर का ऐरे मानकर बनाया, इसलिए पहले और दूसरे अक्षर को card_name[0] और card_name[1] से पुकार सकते हैं। (किताब के टेक्स्ट में यहाँ char_name[0] और char_name[1] छप गया है, यह टाइपो है। देखें नीचे "एरर और सुधार"।)
किताब आगे बढ़कर कंप्यूटर की मेमोरी में झाँकेगी कि C टेक्स्ट को कैसे संभालती है।
🖼️ साइड नोट: C की कई एक्सटेंशन लाइब्रेरी ऐसी हैं जो स्ट्रिंग देती हैं।
📄 पेज 52 — Strings की गहराई
मुख्य बात: स्ट्रिंग बस कैरेक्टर के ऐरे हैं। जब C किसी ऐसी स्ट्रिंग को देखती है (उदाहरण "Shatner"), तो वह उसे अलग-अलग अक्षरों के ऐरे की तरह पढ़ती है: S, h, a, t, n, e, r। हर अक्षर ऐरे का एक तत्व (element) है, इसीलिए अलग अक्षर को इंडेक्स (index) से पुकार सकते हैं: s[0], s[1], s[2]...
⚠️ स्ट्रिंग के अंत से बाहर मत गिरो
जब C को स्ट्रिंग की सामग्री पढ़नी होती है (जैसे स्क्रीन पर छापनी हो), तब समस्या यह है कि कई भाषाओं में कंप्यूटर ऐरे का आकार ट्रैक करता है, पर C निचले स्तर की भाषा है और हमेशा नहीं बता सकती कि ऐरे कितना लंबा है।
अगर C स्ट्रिंग स्क्रीन पर दिखाए तो उसे पता होना चाहिए कि कैरेक्टर ऐरे कहाँ ख़त्म हो रहा है। यह काम सेंटिनल कैरेक्टर (sentinel character) करता है।
🛑 सेंटिनल कैरेक्टर '\0': स्ट्रिंग के अंत में एक अतिरिक्त कैरेक्टर जोड़ा जाता है जिसका मान \0 होता है। जब भी कंप्यूटर को स्ट्रिंग पढ़नी होती है, वह ऐरे के तत्वों से एक-एक करके गुज़रता है जब तक \0 न आ जाए। C जानती है कि \0 देखते ही रुकना है।
बात
विवरण
\0 क्या है
ASCII कैरेक्टर जिसका मान 0 है
दूसरा नाम
C प्रोग्रामर इसे अक्सर NULL कैरेक्टर कहते हैं
"Shatner" मेमोरी में कैसे रहता है?
अक्षर: S, h, a, t, n, e, r, \0। यानी कुल 8 तत्व: s[0] से s[7] तक। 7 अक्षर और 1 सेंटिनल।
इसी वजह से char card_name[3];
card_name में सिर्फ़ एक या दो अक्षर रिकॉर्ड होने हैं, पर चूँकि स्ट्रिंग सेंटिनल कैरेक्टर पर ख़त्म होती है, इसलिए ऐरे में एक अतिरिक्त जगह रखनी पड़ती है। इसीलिए आकार 2 नहीं, 3 है। (यही कारण है कि scanf में %2s लिखा गया, यानी ज़्यादा से ज़्यादा 2 अक्षर पढ़ो और तीसरी जगह \0 के लिए छोड़ दो।)
📄 पेज 53 — सवाल-जवाब और "Painless Operations"
❓ "There Are No Dumb Questions"
1. अक्षरों की गिनती 1 की जगह 0 से क्यों शुरू होती है?
इंडेक्स एक ऑफ़सेट (offset) है। यानी वह माप कि पहले अक्षर से वह अक्षर कितनी दूरी पर है। पहला अक्षर खुद से 0 दूर है।
2. और ऐसा क्यों?
कंप्यूटर अक्षरों को मेमोरी के लगातार बाइटों (consecutive bytes) में रखता है। इंडेक्स से वह अक्षर की जगह की गणना कर सकता है। मसलन, अगर c[0] मेमोरी की जगह 1,000,000 पर है, तो वह जल्दी से निकाल लेता है कि c[96] जगह 1,000,000 + 96 पर है।
3. स्ट्रिंग की लंबाई कंप्यूटर को पता नहीं होती क्या? सेंटिनल क्यों चाहिए?
आम तौर पर नहीं। C ऐरे की लंबाई याद रखने में कमज़ोर है, और स्ट्रिंग बस एक ऐरे है।
4. "इसे पता ही नहीं कि ऐरे कितने लंबे हैं???"
नहीं। कभी-कभी कंपाइलर कोड का विश्लेषण करके ऐरे की लंबाई निकाल सकता है, पर आम तौर पर C चाहती है कि आप खुद अपने ऐरे का हिसाब रखें।
5. क्या सिंगल कोट (') और डबल कोट (") में फ़र्क पड़ता है?
हाँ। सिंगल कोट अकेले कैरेक्टर के लिए, डबल कोट हमेशा स्ट्रिंग के लिए।
6. स्ट्रिंग को कोट (") से बनाऊँ या कैरेक्टर के साफ़ ऐरे की तरह?
आम तौर पर आप कोट से बनाते हैं। इन्हें स्ट्रिंग लिटरल (string literal) कहते हैं और ये टाइप करने में आसान होते हैं।
7. स्ट्रिंग लिटरल और कैरेक्टर ऐरे में कोई फ़र्क है क्या?
सिर्फ़ एक: स्ट्रिंग लिटरल स्थिर (constant) होते हैं। यानी बन जाने के बाद उनके अलग-अलग अक्षर बदले नहीं जा सकते।
8. बदलने की कोशिश करूँ तो क्या होगा?
यह कंपाइलर पर निर्भर है, पर gcc आम तौर पर "bus error" दिखाता है। (किताब के मुताबिक़; असली व्यवहार के बारे में नीचे सुधार वाला हिस्सा देखें।)
9. यह bus error क्या बला है?
C स्ट्रिंग लिटरल को मेमोरी में अलग तरीके से रखती है। bus error का मतलब बस इतना है कि आपका प्रोग्राम मेमोरी के उस टुकड़े को अपडेट नहीं कर सकता।
😌 Painless Operations — "सारे बराबर के निशान बराबर नहीं होते"
लिखावट
मतलब
उदाहरण
=
असाइनमेंट (assignment): मान रखना
teeth = 4; यानी teeth का मान 4 कर दो
==
बराबरी की जाँच (equality test)
teeth == 4; यानी जाँचो कि teeth का मान 4 है या नहीं
+=
वेरिएबल में जोड़ना (जगह बचाने वाला तरीका)
teeth += 2; यानी teeth में 2 जोड़ो
-=
वेरिएबल से घटाना
teeth -= 2; यानी teeth से 2 घटाओ
++
मान 1 बढ़ाना
teeth++;
--
मान 1 घटाना
teeth--;
📄 पेज 54 — दो तरह के कमांड
अब तक जितने कमांड देखे, वे इन दो श्रेणियों में से किसी एक में आते हैं।
1️⃣ कुछ करो (Do something)
C के ज़्यादातर कमांड स्टेटमेंट (statements) हैं। साधारण स्टेटमेंट क्रियाएँ हैं: वे कुछ करते हैं और हमें कुछ बताते हैं। आप वेरिएबल बनाने, कीबोर्ड से इनपुट पढ़ने या स्क्रीन पर डेटा दिखाने वाले स्टेटमेंट देख चुके हैं। एक साधारण स्टेटमेंट (simple statement) का उदाहरण: split_hand();
कभी-कभी आप कई स्टेटमेंट को एक साथ जोड़कर ब्लॉक स्टेटमेंट (block statement) बनाते हैं। ये ब्रेसेस { } से घिरे कमांडों के समूह होते हैं। किताब का उदाहरण: दो कार्ड बाँटने वाले फ़ंक्शन और cards_in_hand = 2;। ब्रेसेस में घिरे होने के कारण ये मिलकर एक ब्लॉक स्टेटमेंट बनाते हैं।
2️⃣ कुछ तभी करो जब कोई चीज़ सही हो
कंट्रोल स्टेटमेंट (control statement), जैसे if, कोड चलाने से पहले एक शर्त (condition) जाँचते हैं:
if (value_of_hand <= 16)
hit();
else
stand();
कोष्ठक में शर्त है।
शर्त सही (true) हो तो if वाला स्टेटमेंट चलेगा।
शर्त ग़लत (false) हो तो else वाला चलेगा।
if को आम तौर पर शर्त सही होने पर एक से ज़्यादा काम करने पड़ते हैं, इसलिए इन्हें अक्सर ब्लॉक स्टेटमेंट के साथ इस्तेमाल करते हैं। उदाहरण: अगर dealer का कार्ड 6 है, तो double_down(); hit();दोनों चलेंगे, क्योंकि वे एक ब्लॉक में हैं।
🧱 क्या ब्रेसेस ज़रूरी हैं?
ब्लॉक स्टेटमेंट आपको स्टेटमेंटों के पूरे समूह को एक ही स्टेटमेंट की तरह इस्तेमाल करने देते हैं।
if शर्त एक ही स्टेटमेंट चलाती है। अगर कई स्टेटमेंट चलाने हों, तो उन्हें ब्रेसेस में लपेट दें और C उन्हें एक स्टेटमेंट की तरह मानेगी।
C प्रोग्रामर कोड छोटा और चुस्त रखना पसंद करते हैं, इसलिए if और while में ब्रेसेस छोड़ देना आम है। जैसे ब्रेसेस वाला if (x == 2) { puts("Do something"); } लिखने की जगह ज़्यादातर प्रोग्रामर सिर्फ़ if (x == 2) के नीचे अकेली लाइन puts("Do something"); लिख देते हैं।
📄 पेज 55 — अब तक का कोड ("Here's the code so far")
इस पेज पर पेज 48 वाला cards.c ही दोबारा दिखाया गया है। उसमें कोई नई बात नहीं जुड़ी है, इसलिए यहाँ वही कोड दोबारा नहीं छाप रहा हूँ।
🖼️ पेज के किनारे एक पात्र की सोच: "मेरे दिमाग में एक विचार आया। क्या यह जाँच सकता है कि कार्ड का मान किसी ख़ास दायरे (range) में है या नहीं? यह काम का हो सकता है…"
यह अगले पेजों की भूमिका बनाता है, यानी if में दायरे की शर्तें लगाना। वह किताब के पेज 56 से आगे आएगा, जो आपकी माँगी सीमा (31–55) से बाहर है।
🛠️ एरर और सुधार
किताब के कोड और टेक्स्ट में जहाँ गड़बड़ या कमी मिली, उसे यहाँ ठीक किया गया है। सुधार "ऊपर वाली लाइन / नीचे वाली लाइन" के तरीके से बताए हैं, ताकि पूरा कोड दोबारा न छापना पड़े।
🔴 एरर 1 — cards.c: छोटे अक्षर नहीं पहचानता
समस्या: यूज़र k, q, j या a छोटे अक्षर में टाइप करे तो प्रोग्राम इन्हें पहचानता नहीं। ये else में चले जाते हैं और atoi("k") का नतीजा 0 आता है, यानी "The card value is: 0"।
सुधार:
#include <stdlib.h> वाली लाइन के नीचे यह लाइन जोड़ें:
#include <ctype.h>
int val = 0; वाली लाइन के नीचे और पहले if के ऊपर यह लाइन जोड़ें:
char first = toupper((unsigned char)card_name[0]);
चारों शर्तों में card_name[0] की जगह first लिखें। K, Q, J, A वाली चारों if / else if लाइनों में। atoi(card_name) वाली लाइन जैसी है वैसी रहेगी।
🔴 एरर 2 — cards.c: अमान्य इनपुट पर गलत मान
समस्या: यूज़र X या 99 या 1 टाइप करे तो भी प्रोग्राम "The card value is: ..." छाप देता है (X के लिए 0, 99 के लिए 99, 1 के लिए 1)। असली ताश में अंक वाले पत्ते सिर्फ़ 2 से 10 के होते हैं।
सुधार:val = atoi(card_name); वाली लाइन के नीचे और } के ऊपर यह जोड़ें:
if (val < 2 || val > 10) {
puts("That is not a valid card name");
return 1;
}
🔴 एरर 3 — scanf का नतीजा नहीं जाँचा गया
समस्या: अगर scanf कुछ पढ़ ही न पाए (जैसे यूज़र ने बिना कुछ टाइप किए इनपुट बंद कर दिया), तो card_name में कचरा रह सकता है।
सुधार:scanf("%2s", card_name); वाली लाइन को हटाकर उसकी जगह यह लिखें:
🔴 एरर 4 — पेज 45 के decks प्रोग्राम में बिना शुरुआती मान का वेरिएबल
समस्या:int decks; बिना मान के बना है। अगर यूज़र संख्या की जगह अक्षर टाइप करे (जैसे abc), तो scanf कुछ भी नहीं भरता और decks में कचरा मान रह जाता है। प्रोग्राम का व्यवहार तब अनिश्चित हो जाता है।
सुधार:int decks; को बदलकर लिखें:
int decks = 0;
अब बुरे इनपुट पर decks शून्य रहेगा और if (decks < 1) वाली जाँच उसे पकड़ लेगी।
🟡 सुधार 5 — int main() की जगह int main(void)
किताब int main() लिखती है। C में खाली कोष्ठक का मतलब है "पैरामीटर की संख्या तय नहीं", जबकि int main(void) साफ़ कहता है कि कोई पैरामीटर नहीं। आधुनिक अच्छी आदत यही है। दोनों चलते हैं, पर (void) बेहतर है।
🟡 सुधार 6 — पेज 51 का टाइपो
पेज 51 के टेक्स्ट में लिखा है char_name[0] और char_name[1]। सही नाम card_name[0] और card_name[1] है। char_name नाम का कोई वेरिएबल किसी कोड में नहीं बना है।
🟡 सुधार 7 — "bus error" वाली बात
पेज 53 कहता है कि स्ट्रिंग लिटरल बदलने पर gcc आम तौर पर bus error दिखाता है। असल में:
Linux पर यह आम तौर पर "Segmentation fault" होता है।
Mac पर अक्सर "Bus error" दिखता है।
C मानक के हिसाब से स्ट्रिंग लिटरल बदलना अनिश्चित व्यवहार (undefined behavior) है, यानी कुछ भी हो सकता है।
बदलने लायक स्ट्रिंग चाहिए तो लिटरल की जगह ऐरे बनाइए, जैसे char s[] = "Shatner";। इसमें लिटरल की कॉपी आपके अपने ऐरे में बनती है और उसके अक्षर बदले जा सकते हैं।
🟡 सुधार 8 — if में बिना ब्रेसेस की आदत का ख़तरा (पेज 54 के लिए मेरी टिप्पणी)
किताब बताती है कि ज़्यादातर C प्रोग्रामर ब्रेसेस छोड़ देते हैं। यह सच है, पर शुरुआती सीखने वालों के लिए ब्रेसेस हमेशा लगाना सुरक्षित है। बिना ब्रेसेस के if के नीचे बाद में एक और लाइन जोड़ दी जाए, तो वह नई लाइन if का हिस्सा नहीं बनती। वह हर हाल में चलती है, चाहे शर्त सही हो या ग़लत। इससे चुपचाप चलने वाले बग (bug) बनते हैं।
🟡 सुधार 9 — Windows के कंपाइलर (पेज 36 के लिए मेरी टिप्पणी)
किताब 2012 की है और Cygwin तथा MinGW बताती है। ये आज भी काम करते हैं, पर नए सीखने वाले के लिए MSYS2 (MinGW-w64) या WSL (Windows Subsystem for Linux) ज़्यादा आसान रास्ते हैं। WSL में असली Linux मिलता है जहाँ gcc सीधे apt से इंस्टॉल हो जाता है। किताब के सारे कमांड वहाँ बिना बदलाव के चलेंगे, यहाँ तक कि ./cards भी।
🟢 सुधार 10 — C के स्टैंडर्ड (पेज 42 के लिए मेरी टिप्पणी)
किताब C11 को "मौजूदा" कहती है। उसके बाद C17 (2018 में जारी) और C23 आ चुके हैं। नया gcc बिना कुछ बताए आम तौर पर GNU का C17 वाला रूप इस्तेमाल करता है। किताब का सारा कोड इन पर बिना बदलाव के चलता है। कंपाइलर को किसी ख़ास स्टैंडर्ड में चलाने के लिए -std=c11 जैसा विकल्प देते हैं, जैसे gcc -std=c11 cards.c -o cards।
✅ त्वरित दोहराव (Quick Revision)
विषय
एक लाइन में
C क्या है
निचले स्तर की भाषा, छोटे और तेज़ प्रोग्राम
कंपाइल का काम
सोर्स कोड → मशीन कोड (एक्ज़ीक्यूटेबल)
gcc कमांड
gcc file.c -o name
चलाना
Windows: name, Mac/Linux: ./name
कंपाइल + रन
gcc a.c -o a && ./a
स्टैंडर्ड
ANSI C, C99, C11
प्रोग्राम के 3 हिस्से
कमेंट, #include, फ़ंक्शन
main()
शुरुआती बिंदु; int लौटाता है; 0 = सफल
printf
%s, %i से मान डालता है; हर पैरामीटर के लिए एक फ़ॉर्मेट अक्षर
string
असल में char का ऐरे, अंत में \0
ऐरे का इंडेक्स
0 से शुरू (ऑफ़सेट)
' और "
अकेला कैरेक्टर / स्ट्रिंग
स्ट्रिंग लिटरल
स्थिर (constant), बदला नहीं जा सकता
= और ==
असाइनमेंट / बराबरी की जाँच
+=, -=, ++, --
जोड़ना, घटाना, 1 बढ़ाना, 1 घटाना
स्टेटमेंट
साधारण, ब्लॉक { }, और कंट्रोल (if, while)
📌 ये नोट्स Head First C (David Griffiths और Dawn Griffiths, O'Reilly) के PDF पेज 31–55 पर आधारित हैं और सिर्फ़ निजी अध्ययन के लिए हैं।
📘 Head First C — हिंदी अध्ययन-नोट्स
PDF पेज 56 से 80 | Chapter 1 का बाकी हिस्सा (Card Counter बनाना, switch, loops, functions)
✍️ नोट्स कैसे बने हैं: यह शाब्दिक अनुवाद नहीं है। हर पेज की हर बात, हर कोड, हर सवाल-जवाब और हर अभ्यास अपने शब्दों में हिंदी (हिंग्लिश) में समझाया गया है। पारिभाषिक शब्द हिंदी लिपि में हैं और कोष्ठक में रोमन रूप है। "टूल" को टूल ही लिखा है।
🔧 एरर-फ़िक्स: किताब के कोड और बातों में जो गड़बड़ मिली, वह आख़िरी हिस्से "🛠️ एरर और सुधार" में "ऊपर / नीचे वाली लाइन" के तरीके से ठीक की गई है।
✅ जाँच: Mixed Messages के सारे जवाब और अंतिम card_counter.c प्रोग्राम मैंने gcc पर चलाकर जाँचे हैं।
🗺️ पेज-नंबर का नक्शा
PDF पेज
किताब पर छपा नंबर
विषय
56
16
Blackjack Correspondence School का "पत्र" (card counting का नियम)
57
17
C में card counting? दो शर्तें कैसे जाँचें
58
18
Booleans: &&, ||, !
59
19
अभ्यास: card counting वाला कोड
60
20
अभ्यास का हल + & और | का फ़र्क
61
21
Test Drive
62
22
gcc का इंटरव्यू
63
23
BE the Compiler (अभ्यास)
64
24
BE the Compiler (हल)
65
25
अब तक का कोड; switch का विचार
66
26
switch स्टेटमेंट
67
27
अभ्यास: switch में बदलो
68
28
हल + सवाल-जवाब
69
29
while और do...while लूप
70
30
for लूप
71
31
break और continue + AT&T की घटना
72
32
फ़ंक्शन लिखना
73
33
void फ़ंक्शन + चेन्ड असाइनमेंट
74
34
Mixed Messages (अभ्यास)
75
35
अभ्यास: चलता हुआ count
76
36
Mixed Messages (हल)
77
37
चलता हुआ count (हल)
78
38
Test Drive: card counter चल गया
79
39
सवाल-जवाब + मुख्य बिंदु
80
40
अध्याय का C Toolbox
📄 पेज 56 — Blackjack Correspondence School का "पत्र"
यह पेज एक हास्य-पत्र की शक्ल में है। लिखने वाला खुद को माफ़िया-अंदाज़ का आदमी बताता है। वह पाठक से बड़ी आत्मीयता से बात करता है ("तुम स्मार्ट आदमी लगते हो") और उसे ब्लैकजैक में कार्ड काउंटिंग (card counting) की तरकीब सिखाने का न्योता देता है। पत्र का मज़ाक अलग है, पर इसमें असली नियम छिपा है जो आगे पूरे अध्याय का प्रोग्राम बनेगा।
🃏 कार्ड काउंटिंग का नियम (पत्र के हिसाब से)
कार्ड काउंटिंग जीतने की संभावना सुधारने का एक तरीका है।
अगर शू (shoe, यानी वह डिब्बा जिसमें ताश की गड्डियाँ रखी होती हैं) में ऊँचे मान वाले पत्ते बहुत बचे हों, तो मौक़ा खिलाड़ी के पक्ष में झुक जाता है।
जब कोई नीचा पत्ता आए, तो गिनती 1 बढ़ाओ। (उदाहरण: 4 आया → count + 1)
जब कोई ऊँचा पत्ता आए, तो गिनती 1 घटाओ। (उदाहरण: क्वीन आई → count − 1)
कारण: ऊँचा पत्ता निकल गया तो शू में ऊँचे पत्ते एक कम हो गए, और नीचा पत्ता निकला तो ऊँचे पत्तों का अनुपात बढ़ गया।
ऐसा हर पत्ते के लिए करते रहो। जब गिनती काफ़ी ऊँची हो जाए, तब बड़ा दाँव लगाओ।
😄 पत्र के मज़ाक (सीखने वाली कोई बात नहीं)
पत्र के अंत में स्कूल के "कोर्स" की सूची है: Kelly Criterion से दाँव का आकार तय करना, कैसिनो के पिट-बॉस से पिटने से बचना, रेशमी सूट से कैनोली के दाग छुड़ाना, और प्लेड (plaid) के साथ क्या पहनना है। संपर्क: "Cousin Vinny, Blackjack Correspondence School।" यह सब सिर्फ़ मनोरंजन है।
📄 पेज 57 — "कार्ड काउंटिंग? C में?"
किताब कहती है कि कार्ड काउंटिंग असल में बहुत सीधी तकनीक है। आप दाँव लगाने का सही और ग़लत समय पहचानने के लिए चलती हुई गिनती (running count) रखते हैं।
इसे C प्रोग्राम में कैसे बाँधें?
पेज पर एक छोटा फ़्लो-चार्ट है:
कार्ड का मूल्यांकन करो (evaluate the card)। यह कोड हमारे पास पहले से है (val निकालने वाला हिस्सा)।
क्या मान 3 से 6 के बीच (दोनों शामिल) है? अगर हाँ, गिनती 1 बढ़ाओ।
नहीं तो क्या कार्ड 10, J, Q या K है? अगर हाँ, गिनती 1 घटाओ।
गिनती रखने के लिए एक वेरिएबल (variable) काफ़ी है।
🤔 असली सवाल
"हम कैसे जाँचें कि मान >= 3और<= 6 है? क्या यह दो अलग जाँचें हैं?"
अब तक आपने सिर्फ़ एक शर्त वाली जाँच देखी थी। इस एल्गोरिद्म (algorithm) में कई शर्तें एक साथ चाहिए, यानी शर्तों को जोड़ने वाले ऑपरेशन (operations) चाहिए। अगला पेज यही सिखाता है।
📄 पेज 58 — बूलियन (boolean) सिर्फ़ बराबरी तक नहीं
अब तक आपने ऐसे if देखे जो एक शर्त जाँचते थे। अब सीखेंगे: कई शर्तें एक साथ कैसे जाँचें, या किसी शर्त का उलटा कैसे जाँचें।
🔗 && — AND (और)
दोनों शर्तें सही हों तभी पूरा नतीजा सही होता है।
किताब का उदाहरण: अगर dealer का खुला पत्ता 6 है और आपके हाथ का जोड़ 11 है, तब double_down() चलाओ।
💡 शॉर्ट-सर्किट (short-circuit):&& कुशल है। अगर पहली शर्त ग़लत निकली तो कंप्यूटर दूसरी जाँचता ही नहीं, क्योंकि पूरा नतीजा तो ग़लत ही होगा।
🔀 || — OR (या)
दोनों में से कोई एक भी सही हो तो नतीजा सही।
उदाहरण: फ़्रिज में कपकेक हों या मेज़ पर चिप्स हों, तो eat_food()।
💡 यहाँ भी शॉर्ट-सर्किट है। अगर पहली शर्त सही निकली तो दूसरी जाँची ही नहीं जाती।
❗ ! — NOT (नहीं)
किसी शर्त का मान पलट देता है।
उदाहरण: अगर brad_on_phoneनहीं है (!brad_on_phone), तो फ़ोन उठाओ।
🤓 Geek Bits — C में बूलियन कैसे हैं?
C में बूलियन मान संख्याओं से दिखाए जाते हैं।
0 का मतलब false (ग़लत)।
true का कोई ख़ास मान नहीं है। जो भी चीज़ 0 के बराबर नहीं है, वह true मानी जाती है।
इसलिए ऐसा कोड बिल्कुल ठीक है: int people_moshing = 34; if (people_moshing) ..., यानी 34 शून्य नहीं है तो शर्त सही।
C प्रोग्राम अक्सर इसे "यह 0 नहीं है क्या?" जाँचने के शॉर्टहैंड की तरह इस्तेमाल करते हैं।
अगर कार्ड का मान 3 से 6 हो, तो एक संदेश दिखे (गिनती बढ़ी)।
अगर कार्ड 10, J, Q या K हो, तो दूसरा संदेश दिखे (गिनती घटी)।
कोड वही है, बस आख़िर में दो अधूरी जगहें हैं: एक if के बाद ख़ाली शर्त, और एक else if के बाद ख़ाली शर्त। संदेश तैयार हैं: "Count has gone up" और "Count has gone down"। कमेंट बताते हैं: "जाँचो कि मान 3 से 6 है" और "वरना जाँचो कि कार्ड 10, J, Q या K है।"
📖 "The Polite Guide to Standards" (मानकों की शिष्ट गाइड)
ANSI C में true और false के लिए कोई मान तय नहीं है। C 0 को false और बाकी हर मान को true मानती है।
C99 आपको प्रोग्राम में true और false शब्द लिखने देता है। फिर भी कंपाइलर इन्हें पर्दे के पीछे 1 और 0 ही मानता है। (इस बात में एक कमी है, देखें नीचे "एरर और सुधार" का सुधार 4।)
📄 पेज 60 — अभ्यास का हल
जवाब
पहली शर्त (3 से 6): (val > 2) && (val < 7)
दूसरी शर्त (10, J, Q, K): val == 10
देखा आपने? किताब पूछती है: क्या आपने पकड़ा कि इसके लिए सिर्फ़ एक ही शर्त चाहिए थी (&& से जुड़ी)? और दूसरी शर्त को सिर्फ़ val == 10 लिखना काफ़ी था, क्योंकि K, Q और J का val पहले ही 10 बन चुका है। इस शर्त को लिखने के कई तरीके हो सकते हैं (जैसे val >= 3 && val <= 6)।
❓ सवाल-जवाब
सवाल: && और || की जगह सिर्फ़ & और | क्यों नहीं?
जवाब: आप & और | इस्तेमाल कर सकते हैं। फ़र्क यह है कि & और |हमेशा दोनों शर्तें जाँचते हैं, जबकि && और || अक्सर दूसरी शर्त छोड़ सकते हैं (शॉर्ट-सर्किट)।
सवाल: तो & और | हैं ही क्यों?
जवाब: क्योंकि ये सिर्फ़ तार्किक शर्तें नहीं जाँचते। ये किसी संख्या के अलग-अलग बिटों पर बिटवाइज़ ऑपरेशन (bitwise operations) करते हैं।
सवाल: मतलब क्या?
जवाब: उदाहरण: 6 & 4 का नतीजा 4 है। 6 बाइनरी में 110 है और 4 बाइनरी में 100। दोनों में जो अंक एक साथ 1 हैं वे बचते हैं, यानी 100, जो 4 है।
📄 पेज 61 — Test Drive
> gcc cards.c -o cards && ./cards
तीन बार चलाकर तीनों दायरे जाँचे गए:
इनपुट
नतीजा
Q
Count has gone down (गिनती घटी)
8
कुछ नहीं छपता (8 न 3–6 में है, न 10 है)
3
Count has gone up (गिनती बढ़ी)
निष्कर्ष: कोड चलता है। एक ही नहीं, कई शर्तों को बूलियन ऑपरेटर से जोड़कर आपने मानों का पूरा दायरा (range) जाँच लिया। अब card counter का बुनियादी ढाँचा तैयार है।
🖼️ कार्टून में एक खिलाड़ी कान में छिपा "स्टेल्थ संचार उपकरण" लगाए है और कंप्यूटर कहता है "कार्ड नीचा था, गिनती बढ़ी, दाँव बढ़ाओ! दाँव बढ़ाओ!"
📄 पेज 62 — कंपाइलर का इंटरव्यू: "gcc ने हमारे लिए आज तक क्या किया है?"
यह मज़ेदार इंटरव्यू है, पर इसमें gcc के बारे में असली जानकारी है।
विषय
gcc का जवाब (सार)
कितनी भाषाएँ?
मज़ाक में "छह मिलियन से ज़्यादा रूपों में धाराप्रवाह"। असल में: C, C++, Objective-C, Pascal, Fortran, PL/I और थोड़ी-बहुत Go।
कितने प्लेटफ़ॉर्म?
लगभग हर प्रोसेसर के लिए मशीन कोड बना सकता है। जब कोई हार्डवेयर इंजीनियर नया प्रोसेसर बनाता है, तो उसकी पहली इच्छाओं में से एक होती है कि वहाँ gcc किसी रूप में चल जाए।
इतनी लचीलापन कैसे?
gcc के दो हिस्से हैं: फ़्रंटएंड (frontend) और बैकएंड (backend)।
फ़्रंटएंड
किसी एक प्रकार की सोर्स भाषा (जैसे C) को समझता है और उसे इंटरमीडिएट कोड (intermediate code) में बदल देता है। हर भाषा का फ़्रंटएंड एक ही तरह का इंटरमीडिएट कोड बनाता है।
बैकएंड
उस इंटरमीडिएट कोड को अलग-अलग प्लेटफ़ॉर्म पर समझ आने वाले मशीन कोड में बदलता है। साथ ही लगभग हर ऑपरेटिंग सिस्टम के एक्ज़ीक्यूटेबल फ़ाइल-फ़ॉर्मेट जानता है।
"सिर्फ़ अनुवादक"?
gcc कहता है कि वह अनुवाद से कुछ ज़्यादा करता है।
एरर पकड़ना
साफ़ गलतियाँ (जैसे वेरिएबल के नाम की वर्तनी ग़लत होना), और बारीक चीज़ें जैसे वेरिएबल को दोबारा परिभाषित करना, या किसी वेरिएबल का नाम पहले से मौजूद फ़ंक्शन के नाम पर रख देना। इन पर प्रोग्रामर को चेतावनी देता है।
गुणवत्ता और प्रदर्शन
अगर किसी लूप के अंदर ऐसा कोड मिले जो लूप के बाहर भी उतना ही ठीक काम करता, तो gcc उसे चुपचाप बाहर खिसका देता है, यानी तेज़ी बढ़ाता है।
अंत में इंटरव्यू लेने वाला कहता है "आप तो बहुत कुछ करते हैं!" और gcc जवाब देता है कि वह ऐसा सोचना चाहता है, पर "चुपचाप।"
📄 पेज 63 — BE the Compiler (अभ्यास)
नियम: पेज पर चार पूरे सोर्स फ़ाइलें (A, B, C, D) हैं। आपको कंपाइलर बनकर तय करना है कि हर फ़ाइल कंपाइल होगी या नहीं, और अगर नहीं तो क्यों नहीं। अतिरिक्त अंक के लिए: अगर कंपाइल होती है तो आउटपुट क्या होगा, और क्या कोड उसी तरह काम कर रहा है जैसा इरादा था।
चारों फ़ाइलों में int card = 1; है और वही if (card > 1) वगैरह। फ़र्क सिर्फ़ ब्रेसेस { } और else की जगह का है।
📄 पेज 64 — BE the Compiler (हल)
फ़ाइल
कंपाइल?
आउटपुट
क्या ठीक काम कर रही है?
A
✅ हाँ
Small card
❌ नहीं। elseग़लत if से जुड़ गया है।
B
✅ हाँ
कुछ नहीं
❌ नहीं। यहाँ भी else ग़लत if से जुड़ा है।
C
✅ हाँ
Ace!
✅ हाँ, ठीक लिखा है।
D
❌ नहीं
(चलेगा ही नहीं)
ब्रेसेस मेल नहीं खाते (एक } कम है)।
🧠 इससे सीख: "dangling else" (लटकता else)
else हमेशा सबसे पास वाले if से जुड़ता है, भले ही आपने कोड को इंडेंट (indent) करके उसे ऊपर वाले if के नीचे दिखाया हो। कंपाइलर इंडेंटेशन नहीं देखता, सिर्फ़ ब्रेसेस देखता है।
फ़ाइल A में पहला if ब्रेसेस के बिना है, इसलिए बॉडी सिर्फ़ card = card - 1; है। फिर अलग if (card < 7) शुरू होता है और else उसी से जुड़ जाता है। इसलिए card 1 ही रहता है और 1 < 7 है, तो "Small card" छपता है।
फ़ाइल B में सारा कुछ ब्रेसेस के अंदर है, पर card > 1 ग़लत है (card = 1), तो अंदर का कोई भी puts चलता ही नहीं। प्रोग्राम कुछ नहीं छापता। यहाँ else भीतरी if (card < 7) से जुड़ा है, यानी बाहर वाली "शर्त ग़लत हो तो Ace!" वाली मंशा पूरी नहीं होती।
फ़ाइल C में else को बाहरी if के ब्रेसेस के तुरंत बाद लिखा गया है, इसलिए वह सही if से जुड़ता है। card > 1 ग़लत है, तो "Ace!" छपता है।
फ़ाइल D में if (card > 1) { शुरू तो हुआ पर बंद नहीं हुआ, इसलिए कंपाइल एरर आता है।
📄 पेज 65 — अब तक का कोड, और एक नया विचार
इस पेज पर पेज 60 वाला कोड ही दोबारा दिखाया गया है (शर्तों समेत), इसलिए उसे यहाँ दोहरा नहीं रहा हूँ।
💡 पात्र की सोच
"क्या if की इस लंबी कतार के साथ कुछ किया जा सकता है? वे सब एक ही मानcard_name[0] को जाँच रहे हैं और ज़्यादातर val को 10 कर रहे हैं। मुझे लगता है C में इसे कहने का कोई ज़्यादा कुशल तरीका होगा।"
मुख्य बात: C प्रोग्रामों को अक्सर एक ही मान को कई बार जाँचना पड़ता है और हर स्थिति के लिए लगभग मिलता-जुलता कोड चलाना पड़ता है। if की कतार से यह चल जाता है, पर C एक वैकल्पिक तरीका देती है: switch स्टेटमेंट।
📄 पेज 66 — switch स्टेटमेंट ("पुराना switcheroo")
जब आपको एक ही वेरिएबल का मान बार-बार जाँचना पड़े, तो ढेर सारे if लिखने की जगह switch इस्तेमाल करते हैं। यह if जैसा है, पर एक ही वेरिएबल के कई मानों को जाँच सकता है।
किताब का उदाहरण (वेरिएबल train, इनाम winnings)
train का मान
क्या होता है
37
winnings में 50 जोड़ो, फिर break से अंत पर कूद जाओ।
65
"Jackpot!" छापो, winnings में 80 जोड़ो, और break न होने के कारण नीचे वाले case 12 का कोड भी चला दो, यानी 20 और जोड़ो, फिर break।
12
सिर्फ़ 20 जोड़ो, फिर break।
बाकी कोई भी (default)
winnings को 0 कर दो।
⚙️ switch काम कैसे करता है
कंप्यूटर switch में दिया गया मान देखता है।
फिर मेल खाता case ढूँढता है।
मिलते ही उसके बाद का सारा कोड चलाता जाता है जब तक break न आ जाए।
यानी कंप्यूटर तब तक चलता रहता है जब तक उसे switch से बाहर निकलने (break) को न कहा जाए। इसे फ़ॉल-थ्रू (fall-through) कहते हैं।
⚠️ गायब break से कोड में बग आ सकते हैं। ज़्यादातर C प्रोग्राम हर case के अंत में break लगाते हैं, ताकि कोड समझना आसान रहे, भले ही थोड़ी दक्षता घट जाए।
📄 पेज 67 — अभ्यास: if की कतार को switch में बदलो
काम:cards.c का वह हिस्सा देखिए जहाँ val तय होता है (K, Q, J → 10, A → 11, बाक़ी atoi)। इसे switch स्टेटमेंट से दोबारा लिखिए। जवाब नीचे ख़ाली जगह में लिखना है। (हल अगले पेज पर है।)
📄 पेज 68 — हल और सवाल-जवाब
✅ हल
switch का रूप: switch(card_name[0]) के भीतर:
case 'K':, case 'Q':, case 'J':एक के बाद एक बिना break के लिखे गए हैं, और उनके बाद एक ही कोड val = 10; और break;। यानी फ़ॉल-थ्रू का फ़ायदा उठाकर तीनों पत्तों को एक ही कोड से निपटाया गया।
case 'A': → val = 11; और break;
default: → val = atoi(card_name); (यहाँ break की ज़रूरत नहीं क्योंकि यह आख़िरी है।)
📝 पेज के बुलेट-बिंदु
switch स्टेटमेंट if की कतार की जगह ले सकता है।
switchएक ही मान को जाँचता है।
कंप्यूटर पहले मेल खाते case से कोड चलाना शुरू करता है।
वह तब तक चलता है जब तक break आए या switch का अंत हो।
जाँच लें कि break सही जगहों पर हैं, वरना switch बग वाले होंगे।
❓ सवाल-जवाब
सवाल: if की जगह switch क्यों इस्तेमाल करूँ?
जवाब: जब आप एक ही वेरिएबल पर कई जाँचें कर रहे हों, तब switch सही रहता है।
सवाल: switch के फ़ायदे क्या हैं?
जवाब: (1) स्पष्टता: साफ़ दिखता है कि कोड का पूरा ब्लॉक एक ही वेरिएबल को संभाल रहा है। if की कतार में यह उतना साफ़ नहीं होता। (2) फ़ॉल-थ्रू तर्क: अलग-अलग case के लिए कोड का हिस्सा दोबारा इस्तेमाल किया जा सकता है।
सवाल: क्या switch को वेरिएबल ही जाँचना ज़रूरी है? क्या वह कोई सीधा मान नहीं जाँच सकता?
जवाब: जाँच सकता है। switch बस यह देखता है कि दो मान बराबर हैं या नहीं।
सवाल: क्या switch में स्ट्रिंग जाँच सकते हैं?
जवाब: नहीं। आप switch से कैरेक्टर की स्ट्रिंग या किसी भी प्रकार का ऐरे नहीं जाँच सकते। switch केवल एक अकेला मान जाँचता है।
📄 पेज 69 — "कभी-कभी एक बार काफ़ी नहीं होता…"
🖼️ कार्टून में दो कार्ड एक साथ आ जाने पर पात्र घबराता है, यानी प्रोग्राम को एक बार नहीं, बार-बार चलना चाहिए।
अब तक आपने कई स्थितियों के लिए प्रोग्राम लिखना सीखा, पर एक बुनियादी चीज़ बाकी है: अगर प्रोग्राम को कोई काम बार-बार करना हो तो?
🔁 while लूप (loop)
लूप एक ख़ास तरह का कंट्रोल स्टेटमेंट है। सामान्य कंट्रोल स्टेटमेंट तय करता है कि कोड चलेगा या नहीं। लूप तय करता है कि कोड कितनी बार चलेगा।
सबसे बुनियादी लूप while है। यह कोड को बार-बार चलाता है जब तक शर्त सही बनी रहे।
बनावट: while (<शर्त>) { ... }। शर्त की जाँच बॉडी चलाने से पहले होती है। बॉडी ब्रेसेस के बीच होती है।
बॉडी में सिर्फ़ एक लाइन हो तो ब्रेसेस ज़रूरी नहीं।
बॉडी के अंत पर पहुँचकर कंप्यूटर फिर जाँचता है कि शर्त अब भी सही है या नहीं। सही हो तो बॉडी फिर चलती है।
किताब का उदाहरण: while (more_balls) keep_juggling();, यानी जब तक गेंदें बची हैं, जगलिंग करते रहो।
🔂 do...while लूप
while की एक दूसरी शक्ल है जो शर्त की जाँच बॉडी चलने के बाद करती है।
इसलिए इसकी बॉडी कम से कम एक बार हमेशा चलती है।
किताब का उदाहरण: लॉटरी टिकट ख़रीदो (do { ... }), और फिर while (have_not_won);, यानी जब तक जीते नहीं, ख़रीदते रहो। (ध्यान दें: अंत में सेमीकोलन ; लगता है।)
📄 पेज 70 — for लूप
लूपों की आम बनावट
अक्सर लूप इसी ढाँचे के होते हैं:
लूप से पहले कोई सरल काम (जैसे काउंटर सेट करना)।
लूप की एक सरल शर्त।
लूप के अंत में कोई काम (जैसे काउंटर अपडेट करना)।
उदाहरण: 1 से 10 तक गिनना
while से:
लूप शुरू होने से पहले int counter = 1; (startup कोड)
शर्त: counter < 11 (loop condition)
बॉडी में printf से "%i green bottles, hanging on a wall" छापना, फिर अंत में counter++ (update कोड)।
✨ for इसे आसान बना देता है
यह ढाँचा इतना आम है कि C के रचनाकारों ने इसे संक्षिप्त करने के लिए for लूप बनाया। बनावट:
for (शुरुआती-कोड; शर्त; अपडेट-कोड) { बॉडी }
पहला हिस्सा: लूप वेरिएबल को शुरू (initialize) करता है।
दूसरा हिस्सा: शर्त, जो हर बार लूप चलने से पहले जाँची जाती है।
तीसरा हिस्सा: वह कोड जो हर चक्कर के बाद चलता है।
बॉडी में सिर्फ़ एक लाइन हो तो ब्रेसेस छोड़े जा सकते हैं।
for क्यों पसंद किया जाता है?
C में for लूप उतने ही या उससे ज़्यादा इस्तेमाल होते हैं जितने while।
कोड थोड़ा छोटा हो जाता है।
दूसरे C प्रोग्रामरों के लिए पढ़ना आसान होता है, क्योंकि लूप को नियंत्रित करने वाला सारा कोड (काउंटर के मान का नियंत्रण) अब for की लाइन में है, बॉडी से बाहर निकालकर।
📝 साइड नोट में लिखा है कि हर for लूप की बॉडी में कुछ होना चाहिए। (देखें नीचे सुधार 12।)
📄 पेज 71 — break और continue
🛑 break — लूप से बाहर निकलो
लूप आम तौर पर शुरू या अंत में शर्त जाँचते हैं। अगर बीच में कहीं से निकलना हो तो कोड को दोबारा बनाया जा सकता है, पर कभी-कभी break से तुरंत निकल जाना ज़्यादा सरल है।
उदाहरण: जब तक भूख लगी है, केक खाओ। पर अगर मिचली (queasy) महसूस हो, तो break से तुरंत लूप से बाहर, और उसके बाद वाली drink_coffee() नहीं चलेगी।
break आपको मौजूदा लूप से सीधे बाहर निकाल देता है, लूप की बॉडी में उसके बाद की हर चीज़ को छोड़कर।
यह लूपों और switch स्टेटमेंटों, दोनों से बाहर निकालने के काम आता है।
📌 याद रखें कि break करते समय आप किससे बाहर निकल रहे हैं।
break कभी-कभी लूप ख़त्म करने का सबसे सरल और अच्छा तरीका होता है, पर बहुत ज़्यादा इस्तेमाल से कोड पढ़ना थोड़ा मुश्किल हो सकता है।
⏭️ continue — लूप की शुरुआत पर लौटो
बॉडी का बचा हुआ हिस्सा छोड़कर सीधे लूप की शर्त पर लौटना हो, तो continue इस्तेमाल करो।
उदाहरण: जब तक भूख लगी है, अगर अभी लंच का समय नहीं हुआ (not_lunch_yet) तो continue, यानी eat_cake() छोड़कर फिर से जाँचो।
😱 Tales from the Crypt — "breakif को नहीं तोड़ता"
15 जनवरी 1990 को AT&T की लंबी दूरी की टेलीफ़ोन व्यवस्था ठप हो गई। 60,000 लोगों की फ़ोन सेवा चली गई।
कारण: एक डेवलपर ने एक्सचेंजों के C कोड में if स्टेटमेंट से बाहर निकलने के लिए break का इस्तेमाल करने की कोशिश की।
पर breakif से बाहर नहीं निकालता। नतीजा यह हुआ कि प्रोग्राम कोड का एक पूरा हिस्सा छोड़ गया और बग आ गया, जिससे नौ घंटे में 7 करोड़ फ़ोन कॉल बाधित हुईं।
सीख:break सिर्फ़ लूप और switch के लिए है।
📄 पेज 72 — फ़ंक्शन लिखना (Writing Functions Up Close)
नए लूपों को आज़माने से पहले फ़ंक्शनों पर एक छोटा चक्कर। अब तक हर प्रोग्राम में आपने एक ही फ़ंक्शन बनाया है: main()।
main() की बनावट (दोहराव)
int : यह फ़ंक्शन int मान लौटाता है।
main : फ़ंक्शन का नाम।
() : कोष्ठकों के बीच कुछ नहीं, यानी कोई पैरामीटर नहीं।
{ ... } : बॉडी, यानी वह हिस्सा जो काम करता है। इस उदाहरण में puts एक पंक्ति छापता है।
अंत में return 0; : काम पूरा होने पर मान लौटाते हैं।
अपना खुद का फ़ंक्शन: larger()
लगभग हर C फ़ंक्शन यही रूप लेता है। किताब का उदाहरण:
#include <stdio.h>
int larger(int a, int b)
{
if (a > b)
return a;
return b;
}
int main()
{
int greatest = larger(100, 1000);
printf("%i is the greatest!\n", greatest);
return 0;
}
larger() का रिटर्न टाइप int है, यानी वह एक पूर्ण संख्या लौटाता है।
यह दो आर्ग्युमेंट (arguments) लेता है: a और b, दोनों int।
main() के भीतर उसे बुलाया (call) जाता है: larger(100, 1000)। जो मान लौटे वह greatest में रखा जाता है।
आर्ग्युमेंट (या पैरामीटर) असल में एक लोकल वेरिएबल (local variable) है जिसे अपना मान उस कोड से मिलता है जो फ़ंक्शन को बुलाता है।
larger() में a और b में जो बड़ा है उसका मान लौटाया जाता है।
आउटपुट: 1000 is the greatest!
larger() और main() में फ़र्क यह है कि larger()आर्ग्युमेंट लेता है।
📖 Polite Guide to Standards
main() का रिटर्न टाइप int है, इसलिए अंत में return स्टेटमेंट होना चाहिए।
अगर आप return छोड़ दें तो भी कोड कंपाइल हो जाएगा, पर कंपाइलर चेतावनी (warning) दे सकता है।
C99 कंपाइलर अगर आप भूल जाएँ तो आपके लिए return स्टेटमेंट ख़ुद जोड़ देता है।
C99 स्टैंडर्ड में कंपाइल करने के लिए किताब -std=99 बताती है। (यह छपाई की गलती है, देखें सुधार 3।)
📄 पेज 73 — void फ़ंक्शन और चेन्ड असाइनमेंट
🕳️ void फ़ंक्शन
ज़्यादातर C फ़ंक्शन कोई मान लौटाते हैं। पर कभी-कभी ऐसा फ़ंक्शन चाहिए जिसके पास लौटाने लायक कुछ न हो। वह कुछ गणना नहीं करता, बस कुछ करता है।
सामान्यतः फ़ंक्शन में return स्टेटमेंट होना चाहिए, पर अगर रिटर्न टाइप void दे दें तो ज़रूरी नहीं।
किताब का उदाहरण: void complain(), जो puts से शिकायत छापता है। इसमें return लिखने की कोई ज़रूरत नहीं।
void का मतलब है "कोई फ़र्क नहीं पड़ता", यानी आपने C कंपाइलर को बता दिया कि आपको मान लौटाने की परवाह नहीं।
❓ सवाल-जवाब
सवाल: अगर void फ़ंक्शन बनाऊँ तो क्या उसमें return नहीं हो सकता?
जवाब: आप return स्टेटमेंट रख सकते हैं, पर कंपाइलर शायद चेतावनी देगा। साथ ही void फ़ंक्शन में return डालने का कोई मतलब भी नहीं है।
सवाल: सच में? क्यों नहीं?
जवाब: क्योंकि अगर आप अपने void फ़ंक्शन का मान पढ़ने की कोशिश करेंगे, तो कंपाइलर आपका कोड कंपाइल करने से मना कर देगा। (यानी उससे कोई मान लेकर किसी वेरिएबल में रखना मना है।)
⛓️ चेन्ड असाइनमेंट (Chaining Assignments)
C में लगभग हर चीज़ का रिटर्न मान होता है, सिर्फ़ फ़ंक्शन कॉल का नहीं। यहाँ तक कि असाइनमेंट का भी।
असाइनमेंट x = 4 ख़ुद एक मान रखता है, और वह वही मान है जो असाइन हुआ: 4।
इसलिए y = (x = 4); से x और y दोनों 4 हो जाते हैं।
कोष्ठक हटाकर इसे छोटा लिख सकते हैं: y = x = 4;
ऐसी चेन्ड असाइनमेंट आपको ऐसे कोड में अक्सर दिखेंगी जहाँ कई वेरिएबलों को एक ही मान देना हो।
📄 पेज 74 — Mixed Messages (अभ्यास)
नियम: एक छोटा C प्रोग्राम है, जिसमें x = 0, y = 0 से शुरू होकर while (x < 5) लूप चलता है। लूप के भीतर एक कोड-ब्लॉक ग़ायब है। फिर printf("%i%i ", x, y); और x = x + 1; आते हैं। आपको पाँच उम्मीदवार कोड-ब्लॉक को उनके सही आउटपुट से मिलाना है। सारी आउटपुट-पंक्तियाँ इस्तेमाल नहीं होंगी, और कोई आउटपुट एक से ज़्यादा बार भी आ सकता है। (नीचे हल है।)
📄 पेज 75 — अभ्यास: चलता हुआ count (running count)
काम:while लूप का इस्तेमाल करके प्रोग्राम को ऐसा बनाओ कि वह खेल की चलती गिनती रखे:
हर कार्ड के बाद count दिखाए।
अगर खिलाड़ी X टाइप करे तो प्रोग्राम रुक जाए।
अगर खिलाड़ी 11 या 24 जैसा ग़लत मान टाइप करे तो एरर संदेश दिखे।
दिए गए कोड में ख़ाली जगहें और संकेत:
while ( के बाद की शर्त ख़ाली है। संकेत: "तुम्हें X दर्ज होने पर रुकना है।"
case 'X': के बाद क्या करना है, यह ख़ाली है। संकेत: "यहाँ क्या करोगे?"
default: में val की जाँच करनी है। संकेत: "अगर val 1 से 10 के दायरे में नहीं है तो एरर दिखाओ, और लूप की बाकी बॉडी छोड़कर दोबारा कोशिश करो।"
शर्तों के आगे संकेत: count में 1 जोड़ो (count++), count से 1 घटाओ (count--)।
📄 पेज 76 — Mixed Messages का हल
मैंने इन पाँचों को असली प्रोग्राम में चलाकर जाँचा है। हर लूप में x और y का printf हर चक्कर के बाद छपता है।
उम्मीदवार कोड
आउटपुट
y = x - y;
00 11 21 32 42
y = y + x;
00 11 23 36 410
y = y + 2; और फिर if (y > 4) y = y - 1;
02 14 25 36 47
x = x + 1; और फिर y = y + x;
11 34 59
if (y < 5) { x = x + 1; if (y < 3) x = x - 1; } और फिर y = y + 2;
02 14 36 48
🧮 एक उदाहरण समझिए (चौथा उम्मीदवार)
शुरू: x = 0, y = 0।
चक्कर 1: x बढ़कर 1, y = 0 + 1 = 1। छपा "11"। फिर x 2 हो गया।
चक्कर 2: x बढ़कर 3, y = 1 + 3 = 4। छपा "34"। फिर x 4 हो गया।
चक्कर 3: x बढ़कर 5, y = 4 + 5 = 9। छपा "59"। फिर x 6 हो गया और लूप रुक गया।
बाकी आउटपुट-पंक्तियाँ (22 46, 02 14 26 38, 11 21 32 42 53) किसी भी उम्मीदवार से नहीं मिलतीं, यानी वे "इस्तेमाल नहीं होने वाली" पंक्तियाँ हैं।
📄 पेज 77 — चलता हुआ count (हल)
यह अब तक का सबसे पूरा प्रोग्राम है। नीचे मैं इसे सुधार के साथ पूरा दे रहा हूँ (किताब वाले रूप के फ़र्क "एरर और सुधार" हिस्से में बताए हैं)। इसी को card_counter.c नाम से सेव करें:
#include <stdio.h>
#include <stdlib.h>
int main()
{
char card_name[3] = "";
int count = 0;
while (card_name[0] != 'X') {
puts("Enter the card_name: ");
scanf("%2s", card_name);
int val = 0;
switch (card_name[0]) {
case 'K':
case 'Q':
case 'J':
val = 10;
break;
case 'A':
val = 11;
break;
case 'X':
continue;
default:
val = atoi(card_name);
if ((val < 1) || (val > 10)) {
puts("I don't understand that value!");
continue;
}
}
if ((val > 2) && (val < 7)) {
count++;
} else if (val == 10) {
count--;
}
printf("Current count: %i\n", count);
}
return 0;
}
🔍 कोड कैसे काम करता है
while (card_name[0] != 'X'): जब तक पहला अक्षर X नहीं है, लूप चलता रहेगा। यही "X से रुको" वाली शर्त है।
int count = 0;: चलती गिनती, शून्य से शुरू।
हर चक्कर में कार्ड का नाम पूछा जाता है और switch से val तय होता है।
case 'X': continue;: यहाँ break से काम नहीं चलेगा। break सिर्फ़ switch से बाहर निकालता, while से नहीं। हमें चाहिए कि लूप की शर्त दोबारा जाँची जाए। continue यही करता है। शर्त अब ग़लत निकलेगी (क्योंकि पहला अक्षर X है) और लूप ख़त्म हो जाएगा।
default: में atoi से संख्या निकाली जाती है और फिर (val < 1) || (val > 10) से जाँचा जाता है कि मान दायरे से बाहर तो नहीं। बाहर हो तो एरर संदेश छापकर continue, यानी count वाला हिस्सा छोड़कर नया कार्ड माँगो। यहाँ भी break नहीं चलता, क्योंकि हम लूप में बने रहना चाहते हैं।
आख़िर में पुरानी गिनती वाली शर्तें: (val > 2) && (val < 7) हो तो count++, वरना val == 10 हो तो count--। फिर हर कार्ड के बाद Current count छपता है।
किताब की टिप्पणी है कि यह शर्त लिखने का सिर्फ़ एक तरीका है।
"I don't understand that value!" (गिनती नहीं बदली)
6
3
5
4
3
5
X
प्रोग्राम ख़त्म
मैंने सुधरे हुए कोड को यही इनपुट देकर चलाया और नतीजे ऐसे ही आए।
🎉 card counting प्रोग्राम काम करता है! आपने अपना पहला पूरा C प्रोग्राम बना लिया। C के स्टेटमेंट, लूप और शर्तों की ताक़त से एक पूरा चलता हुआ card counter तैयार हुआ।
🖼️ कार्टून: खिलाड़ी कहता है "गिनती ऊँची होने पर बड़ा दाँव लगाकर मैंने तो दौलत बना ली!"
⚖️ डिस्क्लेमर: किताब बताती है कि कंप्यूटर से card counting कई राज्यों में ग़ैर-क़ानूनी है और कैसिनो वाले कड़ा रुख़ अपना सकते हैं, इसलिए इसे सिर्फ़ सीखने तक रखें।
💡 Windows पर ./ न लगाएँ।
📄 पेज 79 — सवाल-जवाब और मुख्य बिंदु
❓ "There Are No Dumb Questions"
सवाल: C को कंपाइल क्यों करना पड़ता है? JavaScript जैसी भाषाएँ तो कंपाइल नहीं होतीं?
जवाब: C को कोड तेज़ बनाने के लिए कंपाइल किया जाता है। हालाँकि कुछ भाषाएँ बिना कंपाइल के चलती हैं, JavaScript और Python जैसी कुछ भाषाएँ भी अपनी रफ़्तार बढ़ाने के लिए अक्सर किसी तरह का छिपा हुआ कंपाइलेशन इस्तेमाल करती हैं।
सवाल: क्या C++ बस C का एक और संस्करण है?
जवाब: नहीं। C++ को शुरू में C के विस्तार के तौर पर बनाया गया था, पर अब वह उससे कुछ ज़्यादा है। C++ और Objective-C दोनों ऑब्जेक्ट ओरिएंटेशन (object orientation) को C के साथ इस्तेमाल करने के लिए बने थे।
सवाल: ऑब्जेक्ट ओरिएंटेशन क्या है? क्या इस किताब में सीखेंगे?
जवाब: यह जटिलता से निपटने की तकनीक है। किताब इसे ख़ास तौर पर नहीं देखेगी।
सवाल: C तो JavaScript, Java, C# आदि जैसी दिखती है।
जवाब: C का वाक्य-विन्यास (syntax) बहुत संक्षिप्त है और इसने कई दूसरी भाषाओं को प्रभावित किया है।
सवाल: gcc का मतलब क्या है?
जवाब: Gnu Compiler Collection।
सवाल: "Collection" क्यों? क्या एक से ज़्यादा हैं?
जवाब: Gnu Compiler Collection कई भाषाओं को कंपाइल कर सकता है, हालाँकि C अब भी वह भाषा है जिसके साथ वह सबसे ज़्यादा इस्तेमाल होता है।
सवाल: क्या ऐसा लूप बना सकता हूँ जो हमेशा चलता रहे?
जवाब: हाँ। अगर लूप की शर्त का मान 1 हो, तो लूप हमेशा चलेगा।
सवाल: क्या हमेशा चलने वाला लूप बनाना अच्छा विचार है?
जवाब: कभी-कभी। अनंत लूप (infinite loop) अक्सर ऐसे प्रोग्रामों में इस्तेमाल होता है जैसे नेटवर्क सर्वर, जो रोके जाने तक एक ही काम बार-बार करते हैं। पर ज़्यादातर कोडर लूप ऐसे बनाते हैं कि वे कभी तो रुकें।
📌 पेज के मुख्य बिंदु (Bullet Points)
while लूप कोड तब तक चलाता है जब तक उसकी शर्त सही है।
do-while लूप भी ऐसा ही है, पर कोड को कम से कम एक बार चलाता है।
for लूप कुछ ख़ास तरह के लूपों को लिखने का ज़्यादा संक्षिप्त तरीका है।
break से आप किसी भी समय लूप से बाहर निकल सकते हैं।
continue से आप किसी भी समय लूप की शर्त पर लौट सकते हैं।
return स्टेटमेंट फ़ंक्शन से मान लौटाता है।
void फ़ंक्शनों को return स्टेटमेंट की ज़रूरत नहीं।
C की ज़्यादातर एक्सप्रेशन (expression) का मान होता है।
असाइनमेंट का भी मान होता है, इसलिए आप उन्हें चेन कर सकते हैं (x = y = 0)।
📄 पेज 80 — आपका C Toolbox (अध्याय 1 का सार)
अध्याय 1 पूरा हुआ और C की बुनियाद अब आपके टूलबॉक्स (toolbox) में है। (किताब कहती है कि पूरी सूची के लिए Appendix ii देखें।) टूलबॉक्स के बिंदु:
बिंदु
मतलब
Simple statements
साधारण स्टेटमेंट कमांड होते हैं।
Block statements
{ और } (ब्रेसेस) से घिरे होते हैं।
if
कुछ सही हो तो कोड चलाता है।
#include
बाहरी कोड शामिल करता है, जैसे इनपुट और आउटपुट के लिए।
&& और ||
शर्तों को आपस में जोड़ने के लिए।
gcc
सबसे लोकप्रिय C कंपाइलर।
count++
count में 1 जोड़ना।
count--
count से 1 घटाना।
switch
किसी वेरिएबल के कई मानों की कुशलता से जाँच।
main()
हर प्रोग्राम को main() फ़ंक्शन चाहिए।
&& कमांड-लाइन पर
प्रोग्राम को तभी चलाने के लिए जब वह कंपाइल हो जाए।
-o
आउटपुट फ़ाइल का नाम बताता है।
सोर्स फ़ाइल
नाम .c पर ख़त्म होना चाहिए।
कंपाइल
चलाने से पहले अपने C प्रोग्राम को कंपाइल करना ज़रूरी है।
while
शर्त सही रहने तक कोड दोहराता है।
for
लूप लिखने का ज़्यादा संक्षिप्त तरीका।
do-while
कोड को कम से कम एक बार चलाता है।
🛠️ एरर और सुधार
किताब के कोड और बातों में जो गड़बड़ मिली, उसे यहाँ ठीक किया गया है। सुधार "ऊपर वाली लाइन / नीचे वाली लाइन" के तरीके से हैं।
🔴 एरर 1 — कोड में घुमावदार (curly) कोट: कंपाइल नहीं होगा
कहाँ: पेज 68 के switch हल में case ‘K’: जैसे अक्षर, और पेज 77 में card_name[0] != ‘X’ तथा puts(“I don't understand that value!")। इन जगहों पर घुमावदार कोट (‘ ’ “ ”) छप गए हैं। किताब की छपाई में ऐसा हो गया है, पर C कंपाइलर इन्हें कोट मानता ही नहीं और एरर देता है (जैसे "stray '\342' in program")।
सुधार: कोड में हमेशा सीधे कोट लिखें: कैरेक्टर के लिए 'K' (सिंगल कोट), स्ट्रिंग के लिए "..." (डबल कोट)। ऊपर पेज 77 में दिया कोड इसी तरह सुधरा हुआ है। अगर आप किताब से कोड उतारते हैं, तो हर ‘, ’, “, ” को सीधे कोट से बदलिए। (टेक्स्ट एडिटर में "smart quotes" बंद रखें।)
🔴 एरर 2 — card_name बिना शुरुआती मान के जाँचा गया
कहाँ: पेज 77। while (card_name[0] != 'X') की पहली जाँच तब होती है जब scanf ने अभी कुछ भरा ही नहीं है। यानी card_name में कचरा मान पड़ा है (अनिश्चित व्यवहार)। संयोग से अगर वहाँ 'X' पड़ा हो, तो प्रोग्राम बिना कुछ पूछे ही ख़त्म हो जाएगा।
सुधार:char card_name[3]; वाली लाइन को हटाकर उसकी जगह यह लिखें:
char card_name[3] = "";
(यही बदलाव पेज 77 वाले कोड में किया जा चुका है।)
🔴 एरर 3 — -std=99 ग़लत है
कहाँ: पेज 72 की "Polite Guide to Standards" में C99 में कंपाइल करने के लिए -std=99 लिखा है।
सुधार: सही विकल्प -std=c99 है। जैसे: gcc -std=c99 card_counter.c -o card_counter। C11 के लिए -std=c11।
🔴 एरर 4 — true / false लिखने के लिए हेडर चाहिए
कहाँ: पेज 59 कहता है कि C99 में प्रोग्राम में true और false शब्द लिख सकते हैं।
सुधार: इनके लिए #include <stdbool.h> चाहिए। उसके बिना true, false और bool पहचाने ही नहीं जाएँगे। इसे जोड़ने के लिए #include <stdio.h> वाली लाइन के नीचे यह लाइन डालें:
#include <stdbool.h>
(C23 में ये शब्द भाषा में पहले से हैं।)
🟡 सुधार 5 — void फ़ंक्शन और return (पेज 73)
किताब कहती है कि void फ़ंक्शन में return डालने पर चेतावनी आ सकती है। थोड़ी बारीकी: return; (बिना मान के)void फ़ंक्शन में बिल्कुल जायज़ है और बीच में से फ़ंक्शन ख़त्म करने के काम आता है। चेतावनी या एरर तब आता है जब आप return के साथ मान दें, जैसे return 5;।
🟡 सुधार 6 — सीमा-जाँच में 1 भी मान्य निकल जाता है (पेज 77)
असली ताश में अंक वाले पत्ते 2 से 10 तक होते हैं, पर कोड val < 1 पर एरर देता है, इसलिए 1 मान्य हो जाता है। (Ace तो A से अलग संभल चुका है।) असर: 1 डालने पर "Current count" छपता है और गिनती नहीं बदलती।
सुधार:if ((val < 1) || (val > 10)) { वाली लाइन में 1 को 2 कर दें:
if ((val < 2) || (val > 10)) {
🟡 सुधार 7 — छोटे अक्षर x, k, q, j, a नहीं पहचाने जाते
यूज़र x (छोटा) टाइप करे तो प्रोग्राम रुकेगा नहीं, उलटा "I don't understand that value!" छापेगा। सुधार:
#include <stdlib.h> वाली लाइन के नीचे जोड़ें: #include <ctype.h>
switch (card_name[0]) { वाली लाइन को हटाकर यह लिखें: switch (toupper((unsigned char)card_name[0])) {
while (card_name[0] != 'X') की जगह: while (toupper((unsigned char)card_name[0]) != 'X')
🟡 सुधार 8 — scanf का नतीजा जाँचना
scanf("%2s", card_name); वाली लाइन के ऊपर नई कुछ न जोड़ें। उस लाइन को ही बदलकर यह लिखें, ताकि इनपुट बंद होने (जैसे Ctrl+D) पर प्रोग्राम अनंत लूप में न फँसे:
if (scanf("%2s", card_name) != 1) {
break;
}
(यहाँ break लूप से निकालता है, क्योंकि यह switch के बाहर है।)
🟡 सुधार 9 — switch का फ़ॉल-थ्रू और चेतावनी (पेज 66)
पेज 66 के case 65 में जानबूझकर break छोड़ा गया है। नए gcc में -Wextra के साथ "this statement may fall through" चेतावनी आती है। जानबूझकर की गई फ़ॉल-थ्रू को दिखाने के लिए case 12: वाली लाइन के ऊपर एक कमेंट लगाने की आदत डालें: /* fall through */।
🟡 सुधार 10 — int main() की जगह int main(void) (पेज 72–77)
पिछले नोट्स की तरह यहाँ भी int main(void) बेहतर है, क्योंकि खाली () का मतलब "पैरामीटर अनिर्दिष्ट" है। दोनों चलते हैं।
🟡 सुधार 11 — चेतावनियाँ चालू रखें (पेज 62 के gcc इंटरव्यू से जुड़ा, मेरी टिप्पणी)
gcc बताता है कि वह बहुत-सी गलतियाँ पकड़ता है, पर कई चेतावनियाँ डिफ़ॉल्ट में बंद हैं। सीखते समय हमेशा -Wall -Wextra लगाएँ: gcc -Wall -Wextra card_counter.c -o card_counter। इससे ऊपर के कई बग (जैसे बिना मान वाला वेरिएबल) कंपाइल के समय ही दिख जाते हैं।
🟢 सुधार 12 — for की बॉडी (पेज 70 की साइड-टिप्पणी)
किताब कहती है "हर for लूप की बॉडी में कुछ होना चाहिए।" बारीकी: बॉडी ख़ाली स्टेटमेंट ; भी हो सकती है। जैसे ऐसा लूप जिसका सारा काम for की लाइन में ही हो जाए। पर शुरुआत में बॉडी में असली काम रखना ही ठीक है, और ग़लती से for (...); के अंत में सेमीकोलन लग जाना एक आम बग है (लूप ख़ाली चलकर ख़त्म हो जाता है और बॉडी अलग से एक बार चलती है)।
🟢 सुधार 13 — BE the Compiler के हल का अक्षर-क्रम (पेज 64)
PDF से निकाले गए टेक्स्ट में हल के अक्षर (B, D) बिखरे दिखते हैं। मैंने नतीजे कोड के आधार पर तय किए हैं, जो ऊपर पेज 64 की तालिका में हैं: ब्रेसेस पूरे हों तो फ़ाइल कंपाइल होगी (A, B, C), और जिसमें } कम है (D) वह नहीं।
🟢 सुधार 14 — फ़ाइल का नाम (पेज 78)
पहले अभ्यासों में फ़ाइल cards.c थी, पर यहाँ कमांड में card_counter.c है। अंतिम प्रोग्राम को card_counter.c नाम से अलग सेव करें, ताकि cards.c वाला पुराना रूप बचा रहे।
✅ त्वरित दोहराव (Quick Revision)
विषय
एक लाइन में
card counting
3–6 आए तो count + 1, 10/J/Q/K आए तो count − 1
&&
दोनों शर्तें सही, पहली ग़लत हो तो दूसरी नहीं जाँचता
||
कोई एक सही, पहली सही हो तो दूसरी नहीं जाँचता
!
शर्त उलटता है
बूलियन
0 = false, बाक़ी सब true
& / |
बिटवाइज़ ऑपरेशन (6 & 4 = 4)
dangling else
else सबसे पास वाले if से जुड़ता है
switch
एक ही मान की कई जाँचें, break ज़रूरी, फ़ॉल-थ्रू संभव
while
पहले शर्त, फिर बॉडी
do...while
पहले बॉडी, फिर शर्त; कम से कम एक बार
for
शुरुआत; शर्त; अपडेट, तीनों एक लाइन में
break
लूप या switch से बाहर
continue
लूप की शर्त पर वापस
फ़ंक्शन
रिटर्न टाइप, नाम, आर्ग्युमेंट, बॉडी
void
कोई मान नहीं लौटाता
चेन्ड असाइनमेंट
x = y = 0, क्योंकि असाइनमेंट का भी मान होता है
continue बनाम break (switch में)
लूप में बने रहना हो तो continue
📌 ये नोट्स Head First C (David Griffiths और Dawn Griffiths, O'Reilly) के PDF पेज 56–80 पर आधारित हैं और सिर्फ़ निजी अध्ययन के लिए हैं।
📘 Head First C — हिंदी अध्ययन-नोट्स
PDF पेज 81 से 105 | Chapter 2: Memory and Pointers (मेमोरी और पॉइंटर)
✍️ नोट्स कैसे बने हैं: यह शाब्दिक अनुवाद नहीं है। हर पेज की हर बात, हर कोड, हर सवाल-जवाब और हर अभ्यास अपने शब्दों में हिंदी (हिंग्लिश) में समझाया गया है। पारिभाषिक शब्द हिंदी लिपि में हैं और कोष्ठक में रोमन रूप है। "टूल" को टूल ही लिखा है।
🔧 एरर-फ़िक्स: किताब के कोड और बातों में जो गड़बड़ मिली, वह आख़िरी हिस्से "🛠️ एरर और सुधार" में "ऊपर / नीचे वाली लाइन" के तरीके से ठीक की गई है।
✅ जाँच: इस हिस्से के सारे कोड-उदाहरण (southeast, fortune_cookie, Mating Game, skip, 3[doses], sizeof) मैंने gcc पर चलाकर देखे हैं। नतीजे किताब से मेल खाते हैं।
🐢 किताब की सलाह: पॉइंटर एक सरल विचार है, पर इसे धीरे-धीरे समझना पड़ता है। बीच-बीच में ब्रेक लें।
🗺️ पेज-नंबर का नक्शा
PDF पेज
किताब पर छपा नंबर
विषय
81
41
Chapter 2 की शुरुआत: "तुम किस ओर इशारा कर रहे हो?"
82
42
C कोड में पॉइंटर (introducing pointers)
83
43
मेमोरी में खुदाई: stack, globals, & ऑपरेटर
84
44
पॉइंटर के साथ नाव खेना: Bermuda Rectangle गेम
85
45
go_south_east() का पहला रूप
86
46
Test Drive: जहाज़ हिला ही नहीं; C मान की कॉपी भेजती है
87
47
पॉइंटर पास करके देखो + सवाल-जवाब
88
48
पॉइंटर इस्तेमाल करने की तीन बातें (&, *)
89
49
Compass Magnets (अभ्यास)
90
50
Compass Magnets (हल)
91
51
Test Drive + मुख्य बिंदु
92
52
"There Are No Dumb Questions"
93
53
स्ट्रिंग फ़ंक्शन को कैसे दें; sizeof की पहेली
94
54
ऐरे वेरिएबल पॉइंटर जैसे हैं
95
55
कंप्यूटर कोड चलाते समय क्या सोचता है
96
56
मुख्य बिंदु + सवाल-जवाब
97
57
The Mating Game (अभ्यास)
98
58
The Mating Game (हल)
99
59
ऐरे वेरिएबल पूरी तरह पॉइंटर नहीं + pointer decay
100
60
Five-Minute Mystery: The Case of the Lethal List
101
61
ऐरे 0 से क्यों शुरू होते हैं + pointer arithmetic
102
62
अभ्यास का हल + पॉइंटर के टाइप क्यों
103
63
Five-Minute Mystery का हल
104
64
मुख्य बिंदु + सवाल-जवाब
105
65
डेटा एंट्री के लिए पॉइंटर: scanf()
📄 पेज 81 — Chapter 2: "तुम किस ओर इशारा कर रहे हो?"
अध्याय का नाम है Memory and Pointers (मेमोरी और पॉइंटर)।
मुख्य बात: अगर आप C में सचमुच दमदार बनना चाहते हैं, तो आपको समझना होगा कि C मेमोरी को कैसे संभालती है।
C आपको इस पर ज़्यादा नियंत्रण देती है कि आपका प्रोग्राम कंप्यूटर की मेमोरी (memory) का इस्तेमाल कैसे करे।
इस अध्याय में आप "ढक्कन हटाकर" देखेंगे कि वेरिएबल पढ़ने और लिखने पर असल में क्या होता है।
आप सीखेंगे कि ऐरे (array) कैसे काम करते हैं, मेमोरी की कुछ बुरी गड़बड़ियों (SNAFU) से कैसे बचें, और सबसे ज़्यादा यह कि पॉइंटर (pointer) और मेमोरी एड्रेसिंग (memory addressing) में माहिर होना C के उस्ताद बनने की कुंजी है।
🖼️ पेज पर एक कार्टून है। उसमें एक पात्र मज़ाक में कहता है कि "शुक्र है मेरा boyfriend variable read-only मेमोरी में नहीं है।" (यह एक मज़ाक है जो आगे read-only मेमोरी वाली बात से जुड़ेगा।)
📄 पेज 82 — "C कोड में पॉइंटर होते हैं" (Introducing Pointers)
C में सबसे बुनियादी चीज़ों में से एक पॉइंटर है।
📌 पॉइंटर (pointer) क्या है? डेटा के किसी टुकड़े का पता (address) जो मेमोरी में है।
पॉइंटर C में दो कारणों से इस्तेमाल होते हैं
कारण 1️⃣ — पूरी कॉपी भेजने की जगह बस पॉइंटर भेजो।
किताब का हास्य-उदाहरण: आपको कोई जानकारी चाहिए। एक आदमी Encyclopedia Britannica का भारी-भरकम पूरा सेट उठाकर लाता है ("जवाब यहीं है, तुम्हारे लिए कॉपी लाया हूँ")। दूसरा बस इतना कहता है "पेज 241 देख लो।" पेज 241 पॉइंटर है, यानी जानकारी की जगह। भारी कॉपी उठाने से बेहतर है कि जगह बता दी जाए।
कारण 2️⃣ — दो कोड के टुकड़े एक ही डेटा पर काम करें, अलग-अलग कॉपी पर नहीं।
उदाहरण: एक पात्र कहता है "तुम्हें लंच रूम में छोड़े गए बर्थडे कार्ड पर दस्तख़त करने थे", यानी सबके दस्तख़त एक ही कार्ड पर चाहिए। दूसरा पात्र कहता है "मुझे तो यह वाला पसंद है, इस पर बिल्ली के बच्चे हैं।" यानी अलग-अलग कार्ड बनने से गड़बड़ होती है।
🌀 पॉइंटर उलझाते क्यों हैं?
पॉइंटर अप्रत्यक्षता (indirection) का एक रूप हैं। अगर सावधान न रहें तो आप मेमोरी में पॉइंटरों के पीछे दौड़ते-दौड़ते खो सकते हैं। पॉइंटर सीखने की तरकीब: धीरे चलो।
🧘 Relax
पेज के कोने में सलाह है: इस अध्याय को जल्दबाज़ी में न पढ़ें। पॉइंटर सरल विचार है, पर समझने के लिए समय चाहिए। बार-बार ब्रेक लें, खूब पानी पिएँ, और अटक जाएँ तो नहाकर आराम करें।
📄 पेज 83 — मेमोरी में खुदाई (Digging into Memory)
पॉइंटर समझने के लिए पहले कंप्यूटर की मेमोरी में उतरना पड़ेगा।
🧱 मेमोरी के हिस्से (sections)
जब भी आप कोई वेरिएबल declare करते हैं, कंप्यूटर मेमोरी में उसके लिए जगह बनाता है। पेज पर मेमोरी के कई हिस्से दिखाए गए हैं: Stack, Heap, Globals, Constants, Code।
हिस्सा
क्या रहता है
Stack (स्टैक)
जो वेरिएबल किसी फ़ंक्शन के भीतर declare हों (जैसे main() के अंदर)।
Globals (ग्लोबल)
जो वेरिएबल किसी भी फ़ंक्शन के बाहर declare हों।
Heap, Constants, Code
इनका ज़िक्र सिर्फ़ चित्र में है। इनके बारे में किताब आगे बताएगी।
📍 उदाहरण
किताब के उदाहरण में:
int y = 1; फ़ंक्शन के बाहर है, इसलिए yglobals में रहता है। उसका पता 1,000,000 और मान 1।
main() के भीतर int x = 4; है, इसलिए xstack में रहता है। उसका पता 4,100,000 और मान 4।
(ये संख्याएँ सिर्फ़ समझाने के लिए चुनी गई हैं।)
कंप्यूटर शायद x के लिए स्टैक में 4,100,000 जैसा कोई पता चुन ले। जब आप x में 4 रखते हैं, तो कंप्यूटर उस पते पर 4 सहेज लेता है।
🔎 & ऑपरेटर: पता निकालना
किसी वेरिएबल का मेमोरी पता जानना हो तो & ऑपरेटर लगाओ:
&x का मतलब है x का पता।
printf("x is stored at %p\n", &x);: यहाँ %p पतों को फ़ॉर्मेट करने के लिए है।
नमूना आउटपुट: x is stored at 0x3E8FA0। यह 4,100,000 का हेक्स (hex, आधार 16) रूप है।
आपके कंप्यूटर पर पता अलग आएगा।
💡 वेरिएबल का पता यह बताता है कि मेमोरी में वह कहाँ मिलेगा। इसीलिए पते को पॉइंटर भी कहते हैं, क्योंकि वह मेमोरी में वेरिएबल की ओर इशारा करता है।
याद रखने की बात (पेज के निचले बॉक्स):
फ़ंक्शन के भीतर declare किया वेरिएबल आम तौर पर stack में रहता है।
फ़ंक्शन के बाहर declare किया वेरिएबल globals में रहता है।
📄 पेज 84 — "पॉइंटर के साथ पाल चढ़ाओ" (Set sail with pointers)
एक कल्पना: आप एक गेम बना रहे हैं जिसमें खिलाड़ियों को Bermuda Rectangle (बरमूडा त्रिकोण का मज़ाकिया चौकोर रूप) में अपना जहाज़ चलाना है।
गेम को बहुत सारी चीज़ें संभालनी होंगी: स्कोर, जान (lives), और खिलाड़ियों की मौजूदा जगह।
पूरा गेम एक विशाल कोड के टुकड़े में नहीं लिखना। इसके बजाय कई छोटे फ़ंक्शन बनाने हैं जो हर एक कुछ काम का करे।
किताब मज़े के लिए फ़ंक्शनों के नाम गिनाती है, जैसे acquire_facial_hair(), go_south(), eat_rat(), speaks_in_present_tense(), go_north_west(), go_south_east(), die_of_scurvy() और make_one_sequel_too_many()।
🧭 पॉइंटर से इसका क्या लेना-देना? पहले बिना पॉइंटर की चिंता किए कोड शुरू करते हैं। आप वेरिएबल वैसे ही इस्तेमाल करेंगे जैसे अब तक करते आए। गेम का एक बड़ा हिस्सा जहाज़ को घुमाना है, तो एक नेविगेशन फ़ंक्शन की गहराई में उतरते हैं।
गेम खिलाड़ी की जगह अक्षांश (latitude) और देशांतर (longitude) से रखता है।
latitude: खिलाड़ी कितना उत्तर या दक्षिण में है।
longitude: खिलाड़ी पूर्व या पश्चिम में कहाँ है।
अगर खिलाड़ी दक्षिण-पूर्व जाना चाहे, तो उसका latitude घटेगा और longitude बढ़ेगा।
पहला प्रयास
go_south_east() नाम का फ़ंक्शन lat और lon आर्ग्युमेंट लेता है, फिर lat को 1 घटाता है और lon को 1 बढ़ाता है। इसका रिटर्न टाइप void है। main() में जहाज़ को [32, -64] पर रखा है और go_south_east(latitude, longitude); को बुलाकर नई जगह छापता है ("Avast! Now at: [...]")।
#include <stdio.h>
void go_south_east(int lat, int lon)
{
lat = lat - 1;
lon = lon + 1;
}
int main()
{
int latitude = 32;
int longitude = -64;
go_south_east(latitude, longitude);
printf("Avast! Now at: [%i, %i]\n", latitude, longitude);
return 0;
}
उम्मीद थी कि जहाज़ [31, -63] पर पहुँचेगा। पर किताब पूछती है: "क्या यह कोड चलेगा? क्यों या क्यों नहीं?" (सोचिए, जवाब अगले पेज पर है।)
जहाज़ की जगह बिल्कुल नहीं बदली। (🖼️ कार्टून में मज़ाक में पात्र कहता है "हम तो बीच समुद्र में फँस गए, कप्तान!")
🧠 क्यों? C आर्ग्युमेंट मान (value) की कॉपी की तरह भेजती है
किताब तीन चरणों में समझाती है (उदाहरण longitude का है):
शुरुआत में main() में एक लोकल वेरिएबल longitude है, जिसका मान -64 है। (किताब के चित्र में यहाँ 32 लिखा है, पर वह छपाई की गलती है। देखें सुधार 7।)
जब कंप्यूटर go_south_east() को बुलाता है, तो वह longitude वेरिएबल का मानlon आर्ग्युमेंट में कॉपी कर देता है। यह बस longitude से lon में एक असाइनमेंट जैसा है। फ़ंक्शन को बुलाते समय आप वेरिएबल नहीं, सिर्फ़ उसका मान भेजते हैं।
जब go_south_east()lon का मान बदलता है, तो वह सिर्फ़ अपनी लोकल कॉपी बदल रहा होता है। जब नियंत्रण main() में लौटता है, तब longitude अब भी अपने पुराने मान पर है।
❓ तो अगर C फ़ंक्शन ऐसे ही बुलाती है, तो ऐसा फ़ंक्शन कैसे लिखें जो किसी वेरिएबल को अपडेट करे? आसान है, पॉइंटर इस्तेमाल करो…
📄 पेज 87 — "वेरिएबल की जगह उसका पॉइंटर भेजो"
💡 विचार
वेरिएबलों के मान भेजने की जगह उनके पते (addresses) भेज दें तो?
अगर latitude स्टैक की मेमोरी में 4,100,000 पर है, और हम फ़ंक्शन को यही जगह-संख्या 4,100,000 बता दें, तो फ़ंक्शन:
वहाँ जाकर मौजूदा मान पढ़ सकता है (32),
और उसे बदल भी सकता है, यानी मूल latitude वेरिएबल की सामग्री अपडेट कर सकता है।
फ़ंक्शन को बस इतना करना है:
मेमोरी जगह 4,100,000 की सामग्री पढ़ना।
मान में से 1 घटाना।
नया मान उसी जगह 4,100,000 में वापस रखना।
इस तरह फ़ंक्शन मूल वेरिएबल अपडेट करता है, इसलिए main() में लौटने पर कंप्यूटर अपडेट हुई जगह छाप सकता है।
🤝 पॉइंटर मेमोरी साझा करना आसान बनाते हैं
यह पॉइंटर इस्तेमाल करने की मुख्य वजहों में से एक है: फ़ंक्शनों को मेमोरी साझा करने देना। एक फ़ंक्शन का बनाया हुआ डेटा दूसरा फ़ंक्शन बदल सकता है, बशर्ते उसे पता हो कि वह मेमोरी में कहाँ है।
❓ सवाल-जवाब
सवाल: मैंने अपनी मशीन पर वेरिएबल का पता छापा, वह 4,100,000 नहीं आया। क्या मैंने कुछ ग़लत किया?
जवाब: नहीं। आपका प्रोग्राम वेरिएबलों के लिए जो जगह इस्तेमाल करता है वह हर मशीन पर अलग होगी।
सवाल: लोकल वेरिएबल stack में और ग्लोबल कहीं और क्यों रहते हैं?
जवाब: लोकल और ग्लोबल वेरिएबल का इस्तेमाल अलग तरह से होता है। ग्लोबल वेरिएबल की सिर्फ़ एक कॉपी होती है। पर अगर आप ऐसा फ़ंक्शन लिखें जो ख़ुद को बुलाता है, तो एक ही लोकल वेरिएबल के कई उदाहरण (instances) बन सकते हैं। (यानी स्टैक पर बार-बार जगह बनती है।)
सवाल: मेमोरी के बाकी हिस्से किसलिए हैं?
जवाब: जैसे-जैसे आप किताब में आगे बढ़ेंगे, पता चलता जाएगा।
📄 पेज 88 — पॉइंटर इस्तेमाल करने की तीन बातें
पॉइंटर से डेटा पढ़ने और लिखने के लिए तीन चीज़ें आनी चाहिए।
1️⃣ वेरिएबल का पता निकालना
& ऑपरेटर से (जैसे &x)। %p फ़ॉर्मेट पता हेक्स (base 16) रूप में छापता है। पर पता मिलने के बाद आप उसे कहीं रखना भी चाहेंगे। इसके लिए चाहिए पॉइंटर वेरिएबल।
📌 पॉइंटर वेरिएबल बस एक ऐसा वेरिएबल है जो मेमोरी का पता रखता है। जब आप इसे declare करें, तो बताना पड़ता है कि पते पर किस तरह का डेटा रखा है।
उदाहरण: int x = 4; के बाद int *address_of_x = &x;
यहाँ int * का मतलब "ऐसे पते के लिए पॉइंटर वेरिएबल जिस पर int रखा है।"
&x से वेरिएबल का पता (4,100,000) निकलता है।
2️⃣ किसी पते की सामग्री पढ़ना
पता हो तो वहाँ रखा डेटा पढ़ने के लिए * ऑपरेटर लगाओ:
int value_stored = *address_of_x;
यह address_of_x में दिए पते की सामग्री पढ़ेगा।
नतीजा 4 होगा, यानी वह मान जो मूल रूप से x में रखा था।
🔄 * और & एक-दूसरे के उलट हैं।
&: डेटा लेता है और बताता है कि वह कहाँ रखा है।
*: पता लेता है और बताता है कि वहाँ क्या रखा है।
पॉइंटरों को कभी-कभी references भी कहते हैं, इसलिए * ऑपरेटर के बारे में कहते हैं कि वह पॉइंटर को dereference करता है।
3️⃣ किसी पते की सामग्री बदलना
अगर आपके पास पॉइंटर वेरिएबल है और उस पते का डेटा बदलना है, तो * ऑपरेटर फिर से इस्तेमाल करें, पर इस बार असाइनमेंट के बाईं ओर:*address_of_x = 99;
इससे मूल x वेरिएबल की सामग्री बदलकर 99 हो जाती है।
अब आपको पता है कि मेमोरी की जगह की सामग्री कैसे पढ़ें और लिखें। अब go_south_east() को ठीक करने का समय है।
📄 पेज 89 — Compass Magnets (अभ्यास)
काम:go_south_east() को ऐसे ठीक करो कि वह पॉइंटर से सही डेटा अपडेट करे। सोचो:
फ़ंक्शन को किस तरह का डेटा भेजना है?
जहाज़ की जगह अपडेट करने के लिए कौन-से ऑपरेटर चाहिए?
संकेत: "ints के पते रखने के लिए किस तरह के आर्ग्युमेंट चाहिए?" और याद रखो: तुम वेरिएबलों के पते भेजने वाले हो।
मैग्नेटों में हैं: int, int *, *lat, *lon, lat, lon, &lat, &lon, &latitude, &longitude, *latitude, *longitude वगैरह। ख़ाली जगहें go_south_east( के आर्ग्युमेंटों में, उसकी बॉडी के असाइनमेंटों में और main() में फ़ंक्शन-कॉल के आर्ग्युमेंटों में हैं।
📄 पेज 90 — Compass Magnets का हल
यह वही पूरा southeast.c है:
#include <stdio.h>
void go_south_east(int *lat, int *lon)
{
*lat = *lat - 1;
*lon = *lon + 1;
}
int main()
{
int latitude = 32;
int longitude = -64;
go_south_east(&latitude, &longitude);
printf("Avast! Now at: [%i, %i]\n", latitude, longitude);
return 0;
}
🔍 हल की व्याख्या
आर्ग्युमेंट पॉइंटर रखेंगे, इसलिए उनका टाइप int * है।
*lat दो काम करता है: पुराना मान पढ़ता है और नया मान सेट करता है। यानी *lat = *lat - 1; का मतलब "lat के पते पर जो है उसमें से 1 घटाकर वहीं रख दो।"
main() में latitude और longitude के पते& से निकालकर भेजने हैं: &latitude, &longitude।
जहाज़ अब सही तरह दक्षिण-पूर्व गया। (🖼️ कार्टून: "हवा चल पड़ी, कप्तान! कैंकुन की ओर चलो!")
🎉 कोड काम करता है। फ़ंक्शन पॉइंटर आर्ग्युमेंट लेता है, इसलिए वह मूल latitude और longitude वेरिएबल अपडेट कर सकता है। यानी अब आप ऐसे फ़ंक्शन बना सकते हैं जो सिर्फ़ मान लौटाते नहीं, बल्कि जिन मेमोरी जगहों के पते उन्हें दिए जाएँ, उन्हें बदल भी सकते हैं।
📌 पेज के मुख्य बिंदु
वेरिएबलों को मेमोरी में जगह (storage) दी जाती है।
& ऑपरेटर वेरिएबल का पता ढूँढता है।
लोकल वेरिएबल stack में रहते हैं।
* ऑपरेटर किसी मेमोरी पते की सामग्री पढ़ सकता है।
ग्लोबल वेरिएबल globals सेक्शन में रहते हैं।
पॉइंटर बस ऐसे वेरिएबल हैं जो मेमोरी के पते रखते हैं।
* किसी मेमोरी पते की सामग्री सेट भी कर सकता है।
📄 पेज 92 — "There Are No Dumb Questions"
सवाल: क्या पॉइंटर असली पते की जगहें हैं? या किसी और तरह का संदर्भ (reference)?
जवाब: ये प्रोसेस की मेमोरी में असली संख्यात्मक पते हैं।
सवाल: इसका क्या मतलब?
जवाब: हर प्रोसेस (process) को मेमोरी का एक सरल रूप दिया जाता है, जो उसे बाइटों की एक लंबी कतार जैसा दिखता है।
सवाल: और मेमोरी असल में ऐसी नहीं है?
जवाब: असलियत ज़्यादा जटिल है। पर विवरण प्रोसेस से छिपाए जाते हैं, ताकि ऑपरेटिंग सिस्टम प्रोसेस को मेमोरी में इधर-उधर खिसका सके, या उसे उतारकर कहीं और दोबारा लोड कर सके।
सवाल: मेमोरी बाइटों की लंबी सूची नहीं है क्या?
जवाब: कंप्यूटर शायद अपनी असली (physical) मेमोरी को ज़्यादा जटिल ढंग से रखता है। मशीन आम तौर पर मेमोरी-पतों को मेमोरी चिप के अलग-अलग बैंकों (banks) में बाँटती है।
सवाल: क्या मुझे यह समझना ज़रूरी है?
जवाब: ज़्यादातर प्रोग्रामों के लिए आपको चिंता करने की ज़रूरत नहीं कि मशीन अपनी मेमोरी कैसे सजाती है।
सवाल: %p फ़ॉर्मेट पता हेक्स में क्यों दिखाता है?
जवाब: इंजीनियर आम तौर पर मेमोरी पतों को इसी तरह लिखते हैं।
सवाल: पॉइंटर छापने के लिए %p ही क्यों?
जवाब: ज़रूरी नहीं। ज़्यादातर आधुनिक मशीनों पर आप %li भी इस्तेमाल कर सकते हैं, पर कंपाइलर चेतावनी दे सकता है। (असल में %p ही सुरक्षित है, देखें सुधार 3।)
सवाल: अगर किसी मेमोरी जगह की सामग्री पढ़ने को dereferencing कहते हैं, तो क्या पॉइंटर को "references" कहना चाहिए?
जवाब: कभी-कभी कोडर पॉइंटर को references कहते हैं, क्योंकि वे किसी मेमोरी जगह का संदर्भ देते हैं। पर C++ प्रोग्रामर "reference" शब्द एक थोड़े अलग विचार के लिए रखते हैं।
सवाल: C++ भी देखेंगे क्या?
जवाब: नहीं। यह किताब सिर्फ़ C पर है।
📄 पेज 93 — स्ट्रिंग फ़ंक्शन को कैसे दें? और sizeof की पहेली
🍪 स्ट्रिंग भेजना
आप सरल मान तो फ़ंक्शन को भेजना जानते हैं। अगर स्ट्रिंग भेजनी हो? पिछले अध्याय के हिसाब से स्ट्रिंग char का ऐरे है। इसलिए फ़ंक्शन ऐसे बनाया जा सकता है:
void fortune_cookie(char msg[]): फ़ंक्शन को char ऐरे मिलेगा।
बॉडी में printf("Message reads: %s\n", msg);
कॉल करने वाला कोड: char quote[] = "Cookies make you fat"; और fortune_cookie(quote);
msg आर्ग्युमेंट ऐरे की तरह परिभाषित है, पर लंबाई नहीं दी गई, क्योंकि पहले से पता नहीं कि स्ट्रिंग कितनी लंबी होगी।
📏 sizeof ऑपरेटर
C में sizeof नाम का ऑपरेटर है जो बताता है कि कोई चीज़ मेमोरी में कितने बाइट लेती है। इसे डेटा टाइप के साथ या डेटा के साथ बुला सकते हैं:
sizeof(int): ज़्यादातर मशीनों पर 4 लौटाएगा।
sizeof("Turtles!"): 9 लौटाएगा, यानी 8 अक्षर और 1 \0 अंत का कैरेक्टर।
😳 अजीब बात
अगर fortune_cookie() के भीतर sizeof(msg) छापें:
Message reads: Cookies make you fat
msg occupies 8 bytes
पूरी स्ट्रिंग की लंबाई (21 बाइट) की जगह 8 आया! (कुछ मशीनों पर 4 भी आ सकता है।)
किताब की पहेली:sizeof(msg) पूरी स्ट्रिंग से छोटा क्यों है? msg असल में क्या है? अलग-अलग मशीनों पर अलग साइज़ क्यों आता है? (जवाब अगले पेज पर।)
📄 पेज 94 — ऐरे वेरिएबल पॉइंटर जैसे होते हैं
🏷️ ऐरे वेरिएबल = शुरुआत का पता
जब आप ऐरे बनाते हैं, तो ऐरे वेरिएबल को ऐरे की शुरुआत के पॉइंटर की तरह इस्तेमाल किया जा सकता है।
char quote[] = "Cookies make you fat"; देखकर कंप्यूटर:
स्टैक पर हर अक्षर (और अंत के \0) के लिए जगह बनाता है।
पर वह पहले अक्षर का पताquote वेरिएबल से जोड़ भी देता है।
कोड में जब भी quote इस्तेमाल होता है, कंप्यूटर उसकी जगह पहले अक्षर का पता बैठा देता है।
यानी ऐरे वेरिएबल पॉइंटर जैसा ही है। उदाहरण: printf("The quote string is stored at: %p\n", quote);। नमूना आउटपुट: 0x7fff69d4bdd7।
🎭 फ़ंक्शन को पॉइंटर ही मिला था
यही कारण है कि fortune_cookie() में अजीब चीज़ हुई। आपको लगा कि आप फ़ंक्शन को स्ट्रिंग दे रहे हैं, पर असल में पॉइंटर दिया जा रहा था। msg असल में पॉइंटर वेरिएबल है जो संदेश की ओर इशारा करता है।
इसीलिए sizeof(msg) ने गड़बड़ नतीजा दिया। वह सिर्फ़ पॉइंटर का आकार लौटा रहा था:
32-बिट ऑपरेटिंग सिस्टम पर पॉइंटर 4 बाइट लेता है।
64-बिट ऑपरेटिंग सिस्टम पर पॉइंटर 8 बाइट लेता है।
📄 पेज 95 — कोड चलाते समय कंप्यूटर क्या सोचता है
तीन चरणों में कंप्यूटर की "सोच":
फ़ंक्शन देखता है।void fortune_cookie(char msg[]) देखकर सोचता है: "लगता है इस फ़ंक्शन में ऐरे भेजना चाहते हैं। यानी फ़ंक्शन को ऐरे वेरिएबल का मान मिलेगा, जो एक पता होगा। इसलिए msgchar का पॉइंटर होगा।"
फ़ंक्शन की सामग्री देखता है। "मैं संदेश छाप सकता हूँ क्योंकि मुझे पता है कि वह msg से शुरू होता है। और sizeof(msg)? यह पॉइंटर वेरिएबल है, इसलिए जवाब 8 बाइट है, क्योंकि पॉइंटर रखने में मुझे उतनी ही मेमोरी लगती है।"
फ़ंक्शन को बुलाता है।char quote[] = "Cookies make you fat"; fortune_cookie(quote); में "quote ऐरे है और मुझे quote वेरिएबल fortune_cookie() को देना है। मैं msg आर्ग्युमेंट को उस पते पर सेट कर दूँगा जहाँ quote ऐरे मेमोरी में शुरू होता है।"
📄 पेज 96 — मुख्य बिंदु और सवाल-जवाब
📌 मुख्य बिंदु
ऐरे वेरिएबल को पॉइंटर की तरह इस्तेमाल किया जा सकता है।
ऐरे वेरिएबल ऐरे के पहले तत्व की ओर इशारा करता है।
अगर आप फ़ंक्शन के आर्ग्युमेंट को ऐरे declare करें, तो उसे पॉइंटर की तरह माना जाएगा।
sizeof डेटा के टुकड़े द्वारा लिया गया स्थान लौटाता है।
आप डेटा टाइप के साथ भी sizeof बुला सकते हैं, जैसे sizeof(int)।
sizeof(पॉइंटर): 32-बिट OS पर 4, 64-बिट पर 8।
❓ सवाल-जवाब
सवाल: क्या sizeof एक फ़ंक्शन है?
जवाब: नहीं, यह ऑपरेटर है।
सवाल: फ़र्क क्या है?
जवाब: ऑपरेटर को कंपाइलर निर्देशों के एक क्रम में बदल देता है। पर अगर कोड कोई फ़ंक्शन बुलाता है, तो उसे कोड के अलग टुकड़े पर कूदना पड़ता है।
सवाल: क्या sizeof की गणना प्रोग्राम कंपाइल होते समय होती है?
जवाब: हाँ। कंपाइलर कंपाइल के समय ही स्टोरेज का आकार तय कर सकता है।
सवाल: क्या पॉइंटर वेरिएबल भी मेमोरी में रहता है?
जवाब: हाँ। पॉइंटर वेरिएबल बस एक संख्या रखने वाला वेरिएबल है।
सवाल: अलग-अलग मशीनों पर पॉइंटर का आकार अलग क्यों?
जवाब: 32-बिट ऑपरेटिंग सिस्टम पर मेमोरी पता 32-बिट संख्या की तरह रखा जाता है। इसीलिए उसे 32-बिट सिस्टम कहते हैं। 32 बिट = 4 बाइट। इसलिए 64-बिट सिस्टम पता रखने के लिए 8 बाइट लेता है।
सवाल: क्या मैं पॉइंटर वेरिएबल का पता निकाल सकता हूँ?
जवाब: हाँ, & ऑपरेटर से।
सवाल: क्या पॉइंटर को सामान्य संख्या में बदल सकता हूँ?
जवाब: ज़्यादातर सिस्टमों पर हाँ। C कंपाइलर आम तौर पर long डेटा टाइप का आकार मेमोरी पते के बराबर रखते हैं। इसलिए अगर p पॉइंटर है और उसे long वेरिएबल a में रखना हो, तो a = (long)p लिख सकते हैं। (बाद के अध्याय में देखेंगे।)
सवाल: "ज़्यादातर सिस्टमों पर"? यानी गारंटी नहीं?
जवाब: गारंटी नहीं है। (देखें सुधार 4।)
📄 पेज 97 — The Mating Game (अभ्यास)
एक मज़ेदार गेम-शो की शक्ल में पहेली। तीन उम्मीदवार (Contestant 1, 2, 3) हैं और भाग्यशाली महिला को एक चुनना है। आपको कोड देखकर लिखना है कि वह कौन-से नंबर के उम्मीदवार को चुनेगी।
#include <stdio.h>
int main()
{
int contestants[] = {1, 2, 3};
int *choice = contestants;
contestants[0] = 2;
contestants[1] = contestants[2];
contestants[2] = *choice;
printf("I'm going to pick contestant number %i\n", contestants[2]);
return 0;
}
(पहले खुद हल कीजिए। हल अगले पेज पर है।)
📄 पेज 98 — The Mating Game का हल
जवाब: उम्मीदवार नंबर 2।
कदम-दर-कदम
लाइन
ऐरे की हालत
int contestants[] = {1, 2, 3};
{1, 2, 3}
int *choice = contestants;
choice अब contestants ऐरे का पता है (ऐरे वेरिएबल पॉइंटर की तरह)।
contestants[0] = 2;
{2, 2, 3}
contestants[1] = contestants[2];
{2, 3, 3}
contestants[2] = *choice;
*choice का मतलब contestants[0] है, और उसका मान अब 2 है। इसलिए {2, 3, 2}
इसलिए contestants[2] == *choice == contestants[0] == 2, और छपता है 2। (किताब कहती है कि choice अब contestants ऐरे का पता है।)
📄 पेज 99 — ऐरे वेरिएबल पूरी तरह पॉइंटर नहीं हैं
ऐरे वेरिएबल को पॉइंटर की तरह इस्तेमाल तो कर सकते हैं, पर कुछ फ़र्क हैं। इसे समझने के लिए यह कोड लें: char s[] = "How big is it?"; और char *t = s;
1️⃣ sizeof(ऐरे) ऐरे का आकार देता है
sizeof(पॉइंटर) 4 या 8 देता है, पर अगर आप ऐरे वेरिएबल पर sizeof बुलाएँ, तो C इतनी समझदार है कि समझ जाती है कि आप जानना चाहते हैं ऐरे मेमोरी में कितना बड़ा है।
sizeof(s) का नतीजा 15 है (14 अक्षर + \0)।
sizeof(t) का नतीजा 4 या 8 है (पॉइंटर का आकार)।
2️⃣ ऐरे का पता… ऐरे ही है
पॉइंटर वेरिएबल बस एक वेरिएबल है जो मेमोरी पता रखता है। पर ऐरे वेरिएबल पर & लगाने पर नतीजा ऐरे वेरिएबल के बराबर निकलता है।
&s == s: "s ऐरे का पता क्या है?" जवाब: बस s ही।
&t != t: &t का मतलब "t वेरिएबल का पता क्या है?", जो t में रखे पते से अलग है।
3️⃣ ऐरे वेरिएबल कहीं और इशारा नहीं कर सकता
पॉइंटर वेरिएबल बनाने पर मशीन उसे रखने के लिए 4 या 8 बाइट देती है। पर ऐरे बनाने पर कंप्यूटर ऐरे के लिए जगह देता है, ऐरे वेरिएबल को रखने के लिए कोई मेमोरी नहीं देता। कंपाइलर बस ऐरे की शुरुआत का पता उसकी जगह बैठा देता है।
चूँकि ऐरे वेरिएबल के पास अपना स्टोरेज नहीं है, इसलिए आप उसे किसी और चीज़ की ओर मोड़ नहीं सकते।s = t;कंपाइल एरर देगा।
🍂 Pointer decay (पॉइंटर में क्षय)
ऐरे वेरिएबल और पॉइंटर वेरिएबल थोड़े अलग हैं, इसलिए ऐरे को पॉइंटर को देते समय सावधान रहें।
अगर आप ऐरे को पॉइंटर वेरिएबल में रखें, तो पॉइंटर सिर्फ़ ऐरे का पता रखेगा।
पॉइंटर को ऐरे के आकार के बारे में कुछ नहीं पता, यानी थोड़ी जानकारी खो गई। इसे decay (क्षय) कहते हैं।
जब भी आप ऐरे को फ़ंक्शन में भेजते हैं, वह पॉइंटर में decay हो जाता है, इसलिए यह अपरिहार्य है। पर आपको ट्रैक रखना चाहिए कि आपके कोड में ऐरे कहाँ decay हुए, क्योंकि इससे बहुत बारीक बग आ सकते हैं।
📄 पेज 100 — Five-Minute Mystery: "The Case of the Lethal List"
यह एक जासूसी कहानी है जिसमें C का एक राज़ छिपा है। (कहानी हास्य-शैली में है, इसका सार ही काफ़ी है।)
कहानी: 94 साल के अमीर मालिक Amory Mumford III अपने बाग़ में मृत मिले, शायद दिल के दौरे से। डॉक्टर को शक है कि दिल की दवा की ओवरडोज़ थी। जासूस उनकी 27 साल की नई विधवा Bubbles से मिलता है। वह कहती है कि उसके पति दवा के मामले में हमेशा सावधान थे। वह दवा-डिस्पेंसर का कोड दिखाती है:
int doses[] = {1, 3, 2, 1000};
वह कहती है कि पुलिस का आरोप है कि उसने डिस्पेंसर को दोबारा प्रोग्राम किया, पर वह तकनीक में कमज़ोर है। उसने पुलिस को मिली एक प्रति भी दी, जिसमें लिखा था:
printf("Issue dose %i", 3[doses]);
जासूस हैरान है: 3[doses] का क्या मतलब?3 कोई ऐरे तो है नहीं! Bubbles कहती है "मैं यह कभी नहीं लिख सकती। और वैसे भी 3 की खुराक इतनी बुरी नहीं, है न?" जासूस सोचता है कि 3 की खुराक बूढ़े को मार नहीं सकती थी, पर शायद इस कोड में जितना दिखता है उससे ज़्यादा कुछ है…
(रहस्य का हल पेज 103 पर है। पहले पेज 101–102 पढ़ लें।)
📄 पेज 101 — ऐरे 0 से क्यों शुरू होते हैं? (Pointer arithmetic)
🔢 ऐरे वेरिएबल = पहले तत्व का पता
इसलिए ऐरे का पहला तत्व दो तरह से पढ़ा जा सकता है: ब्रैकेट वाले तरीके से या * ऑपरेटर से। उदाहरण: int drinks[] = {4, 2, 3}; में drinks[0] == *drinks। दोनों लाइनें "1st order: %i drinks\n" छापती हैं और बराबर हैं।
➕ पॉइंटर अंकगणित (pointer arithmetic)
पता सिर्फ़ एक संख्या है, इसलिए पॉइंटर के मान में जोड़ा जा सकता है और अगला पता मिल सकता है। इसलिए इंडेक्स 2 वाला तत्व दो तरह से पढ़ सकते हैं: drinks[2], या *(drinks + 2) (पहले तत्व के पते में 2 जोड़कर)।
drinks → पहला तत्व (4)
drinks + 1 → दूसरा तत्व (2)
drinks + 2 → तीसरा तत्व (3)
📌 सामान्य नियम:drinks[i] और *(drinks + i)बराबर हैं। इसीलिए ऐरे इंडेक्स 0 से शुरू होते हैं: इंडेक्स बस वह संख्या है जो पहले तत्व के पते में जोड़ी जाती है ताकि तत्व की जगह मिले।
(यह पिछले अध्याय के उस सवाल का जवाब है कि "गिनती 0 से क्यों?")
💔 अभ्यास: "टूटे दिल को पॉइंटर अंकगणित से जोड़ो"
skip() फ़ंक्शन को संदेश के पहले छह अक्षर छोड़कर बाकी छापना है। फ़ंक्शन void skip(char *msg) में puts(...) की जगह ख़ाली है। संदेश: char *msg_from_amy = "Don't call me"; और कॉल skip(msg_from_amy);। यानी फ़ंक्शन को संदेश 'c' अक्षर से आगे छापना है। सवाल: सातवें अक्षर से छापने के लिए यहाँ कौन-सा एक्सप्रेशन चाहिए? (हल अगले पेज पर।)
📄 पेज 102 — अभ्यास का हल और "पॉइंटर के टाइप क्यों होते हैं"
✅ हल
puts(msg + 6); की ज़रूरत थी। अगर msg पॉइंटर में 6 जोड़ें, तो वह सातवें अक्षर पर पहुँचेगा। msg शुरू में D की ओर इशारा करता है, और msg + 6 अक्षर c की ओर।
अगर पॉइंटर बस पते हैं, तो पॉइंटर वेरिएबलों के टाइप क्यों हैं? सारे पॉइंटर एक ही "सामान्य" वेरिएबल में क्यों न रखें?
कारण: पॉइंटर अंकगणित चालाक है।
char पॉइंटर में 1 जोड़ो तो पॉइंटर बिल्कुल अगले मेमोरी पते पर जाता है। पर यह इसलिए कि char 1 बाइट लेता है।
पर int पॉइंटर? int आम तौर पर 4 बाइट लेते हैं, इसलिए int पॉइंटर में 1 जोड़ने पर कंपाइल किया हुआ कोड असल में पते में 4 जोड़ देता है।
चित्र में अलग टाइप दिखाए गए हैं: int*, long*, char*, short*। हर तरह के डेटा के लिए अलग पॉइंटर टाइप है।
प्रयोग: int nums[] = {1, 2, 3}; और nums तथा nums + 1 दोनों के पते %p से छापें। नमूना आउटपुट में पते 0x7fff66ccedac और 0x7fff66ccedb0 आए, यानी दोनों में 4 बाइट का फ़र्क। (याद रखिए, पते हेक्स में छपे हैं: ac से b0 तक चार का फ़ासला है।)
💡 पॉइंटर के टाइप इसलिए हैं ताकि कंपाइलर को पता रहे कि पॉइंटर अंकगणित में कितना समायोजन (adjust) करना है।
📄 पेज 103 — Five-Minute Mystery का हल
पिछली बार: जासूस बॉब Bubbles से पूछताछ कर रहा था जिसके पति को संदिग्ध कोड की वजह से ओवरडोज़ मिली थी। क्या वह कोड की अपराधी थी या सिर्फ़ मोहरा?
जासूस: मुझे पहले ही खटका था। उसने Bubbles को हथकड़ी पहना दी, और कारण में कहा कि उसके "हैकर मैनीक्योर" और उँगलियों के गट्ठों से साफ़ है कि वह कीबोर्ड पर काफ़ी समय बिताती है। फिर कोड समझाया:
int doses[] = {1, 3, 2, 1000};printf("Issue dose %i", 3[doses]);
राज़: तुम जानती थीं कि doses जैसे ऐरे वेरिएबल को पॉइंटर की तरह इस्तेमाल कर सकते हैं। जासूस ने कागज़ पर चार रूप लिखे, जो सब बराबर हैं:
(doses + 3 और 3 + doses में जोड़ का क्रम बदलने से कोई फ़र्क नहीं पड़ता, इसलिए 3[doses] भी वही तत्व है।) यह कोड 1,000 की घातक खुराक देता था, और अब Bubbles वहाँ जा रही है जहाँ वह C का सिंटैक्स कभी दोबारा भ्रष्ट तरीके से इस्तेमाल नहीं कर पाएगी।
🔑 सीख:a[i], *(a + i), *(i + a) और i[a], चारों एक ही चीज़ हैं। (पर i[a] लिखना सिर्फ़ मज़ाक या पहेली के लिए ठीक है, असली कोड में न लिखें।)
📄 पेज 104 — मुख्य बिंदु और सवाल-जवाब
📌 मुख्य बिंदु
ऐरे वेरिएबल को पॉइंटर की तरह इस्तेमाल किया जा सकता है…
…पर ऐरे वेरिएबल पूरी तरह वैसे नहीं हैं।
sizeof ऐरे और पॉइंटर वेरिएबलों के लिए अलग नतीजा देता है।
ऐरे वेरिएबल किसी और चीज़ की ओर इशारा नहीं कर सकते।
ऐरे वेरिएबल को पॉइंटर को देने पर वह decay होता है।
ऐरे पॉइंटर अंकगणित की वजह से शून्य से शुरू होते हैं।
पॉइंटर वेरिएबलों के टाइप इसलिए हैं ताकि वे पॉइंटर अंकगणित को समायोजित कर सकें।
❓ सवाल-जवाब
सवाल: क्या मुझे पॉइंटर अंकगणित सचमुच समझना ज़रूरी है?
जवाब: कुछ कोडर पॉइंटर अंकगणित से बचते हैं क्योंकि इसमें ग़लती करना आसान है। पर इससे डेटा के ऐरे को कुशलता से प्रोसेस किया जा सकता है।
सवाल: क्या C पॉइंटर अंकगणित समायोजित करते समय sizeof इस्तेमाल करता है?
जवाब: व्यावहारिक रूप से हाँ। sizeof भी कंपाइल के समय हल होता है, और sizeof तथा पॉइंटर अंकगणित दोनों अलग-अलग डेटा टाइप के लिए एक जैसे आकार इस्तेमाल करते हैं।
सवाल: C पॉइंटर अंकगणित की गणना कब समायोजित करता है?
जवाब: जब कंपाइलर एक्ज़ीक्यूटेबल बना रहा होता है। वह वेरिएबल का टाइप देखता है और जोड़-घटाव को अंतर्निहित वेरिएबल के आकार से गुणा कर देता है।
सवाल: थोड़ा और समझाइए…
जवाब: अगर कंपाइलर देखता है कि आप int ऐरे के साथ काम कर रहे हैं और उसमें 2 जोड़ रहे हैं, तो वह 2 को int की लंबाई 4 से गुणा करेगा और पते में 8 जोड़ेगा।
सवाल: क्या पॉइंटर में से संख्याएँ घटा सकता हूँ?
जवाब: हाँ, पर ध्यान रखें कि ऐरे के लिए आवंटित जगह की शुरुआत से पहले न चले जाएँ।
सवाल: क्या पॉइंटरों को गुणा कर सकता हूँ?
जवाब: नहीं।
📄 पेज 105 — डेटा एंट्री के लिए पॉइंटर: scanf()
⌨️ स्ट्रिंग लेना
यूज़र से कीबोर्ड पर स्ट्रिंग लेना आप scanf() से जानते हैं:
char name[40]; में नाम रखेंगे।
printf("Enter your name: "); और scanf("%39s", name);
scanf39 अक्षर तक पढ़ेगा, और 40वीं जगह स्ट्रिंग के अंत का \0 रहेगा।
🔍 scanf() कैसे काम करता है?
यह एक char पॉइंटर लेता है, और यहाँ आप उसे ऐरे वेरिएबल दे रहे हैं। अब शायद अंदाज़ा हो गया होगा कि वह पॉइंटर क्यों लेता है। scanf() ऐरे की सामग्री अपडेट करने वाला है। जिन फ़ंक्शनों को किसी वेरिएबल को अपडेट करना होता है, उन्हें वेरिएबल का मान नहीं, उसका पता चाहिए।
🔢 संख्याएँ लेना
संख्या वाले वेरिएबल में डेटा भरने के लिए संख्या वाले वेरिएबल का पॉइंटर देना होता है:
int age;, printf("Enter your age: ");, scanf("%i", &age);
%i का मतलब यूज़र int मान डालेगा।
& ऑपरेटर से int का पता लें।
क्योंकि आप संख्या वाले वेरिएबल का पता देते हैं, scanf() उस वेरिएबल की सामग्री अपडेट कर सकता है।
🧾 फ़ॉर्मेट कोड
printf() जैसे ही फ़ॉर्मेट कोड scanf() में भी चलते हैं:
कोड
क्या लेता है
%i
एक integer
%29s
29 अक्षर तक (साथ में '\0')
%f
एक फ़्लोटिंग-पॉइंट (floating-point) संख्या
👤 एक बार में कई चीज़ें
scanf() से एक साथ एक से ज़्यादा जानकारी भी ले सकते हैं। उदाहरण (name_test):
#include <stdio.h>
int main()
{
char first_name[20];
char last_name[20];
printf("Enter first and last name: ");
scanf("%19s %19s", first_name, last_name);
printf("First: %s Last:%s\n", first_name, last_name);
return 0;
}
यह पहला नाम, फिर एक ख़ाली जगह, फिर दूसरा नाम पढ़ता है।
दोनों नाम अलग-अलग ऐरे में रखे जाते हैं।
नमूना: इनपुट Sanders Kleinfeld पर आउटपुट First: Sanders Last: Kleinfeld।
🛠️ एरर और सुधार
किताब के कोड और बातों में जो गड़बड़ मिली, वह यहाँ ठीक की गई है। सुधार "ऊपर वाली लाइन / नीचे वाली लाइन" के तरीके से हैं, ताकि पूरा कोड दोबारा न छापना पड़े।
🔴 एरर 1 — sizeof का नतीजा %i से छापना (पेज 93)
समस्या:sizeof का नतीजा size_t टाइप का होता है (बिना चिह्न वाली संख्या, 64-बिट मशीन पर 8 बाइट)। किताब उसे %i (साधारण int) से छापती है। gcc -Wall के साथ चेतावनी देता है, और अलग मशीनों पर छपा मान गलत भी आ सकता है।
सुधार:printf("msg occupies %i bytes\n", sizeof(msg)); वाली लाइन में %i की जगह %zu लिखें:
printf("msg occupies %zu bytes\n", sizeof(msg));
(%zusize_t के लिए बना फ़ॉर्मेट है। यह C99 से उपलब्ध है।)
🔴 एरर 2 — sizeof(msg) पर चेतावनी (पेज 93–94)
समस्या: आधुनिक gcc ऐसे कोड पर साफ़ चेतावनी देता है: "'sizeof' on array function parameter 'msg' will return size of 'char *'"। यानी gcc ख़ुद बता देता है कि वही गड़बड़ हो रही है जो किताब पेज 93 पर दिखा रही है। जब मैंने यह कोड चलाया तो sizeof(msg) 8 आया और sizeof(quote) 21।
सुधार: इसे गड़बड़ न समझें, यह अच्छी बात है। फ़ंक्शन के भीतर स्ट्रिंग की लंबाई चाहिए तो sizeof की जगह strlen(msg) (<string.h> से) इस्तेमाल करें, या लंबाई अलग आर्ग्युमेंट से भेजें।
🟡 सुधार 3 — पते छापने के लिए %p ही सही (पेज 83, 92, 94, 102)
पेज 92 कहता है कि %li भी चलता है। पर Windows 64-बिट पर long सिर्फ़ 4 बाइट का होता है, जबकि पता 8 बाइट का है, इसलिए %li से पता कट जाएगा। हमेशा %p इस्तेमाल करें। सख़्ती से सही C में आर्ग्युमेंट को (void *) में बदलना भी चाहिए:
printf("x is stored at %p\n", &x); वाली लाइन को हटाकर यह लिखें:
printf("x is stored at %p\n", (void *)&x);
🟡 सुधार 4 — पॉइंटर को संख्या में बदलना (पेज 96)
किताब a = (long)p बताती है और ख़ुद कहती है कि गारंटी नहीं है। सही और पोर्टेबल तरीका uintptr_t है:
#include <stdio.h> वाली लाइन के नीचे जोड़ें: #include <stdint.h>
a = (long)p; की जगह लिखें: uintptr_t a = (uintptr_t)p;
uintptr_t ऐसा पूर्ण-संख्या टाइप है जो पॉइंटर को पूरा रख सकने के लिए बना है।
🟡 सुधार 5 — स्ट्रिंग लिटरल के लिए const char * (पेज 101–102)
char *msg_from_amy = "Don't call me"; में स्ट्रिंग लिटरल (constant) है, जिसे बदला नहीं जा सकता (पिछले अध्याय का bus error / segmentation fault वाला मामला)। इसलिए पॉइंटर को const बनाना सुरक्षित आदत है, ताकि गलती से बदलने की कोशिश कंपाइल के समय ही पकड़ी जाए। दोनों जगह बदलाव:
void skip(char *msg) को बदलकर: void skip(const char *msg)
🟡 सुधार 6 — scanf("%i") और दशमलव संख्या (पेज 105)
%i यूज़र के लिखे अंकों को आधार के हिसाब से पढ़ता है: 010 को ऑक्टल (8) और 0x1A को हेक्स (26) समझ लेता है। उम्र जैसी साधारण दशमलव संख्या के लिए %d सुरक्षित है। scanf("%i", &age); वाली लाइन में %i को %d कर दें। साथ ही नतीजे की जाँच करना अच्छी आदत है:
if (scanf("%d", &age) != 1) {
puts("That is not a number");
return 1;
}
(यही आदत scanf("%39s", name) के लिए भी अपनाएँ।)
🟡 सुधार 7 — पेज 86 के चित्र में गलत संख्या
पेज 86 के चित्र में main() का longitude "32" दिखता है, जबकि कोड में longitude = -64 है और 32 तो latitude का मान है। यह छपाई की गलती है। सही: longitude का मान -64। (सिद्धांत, कि lon कॉपी है और मूल वेरिएबल नहीं बदलता, वही रहता है।)
🟡 सुधार 8 — 3[doses] पर सावधानी (पेज 103)
किताब का "doses[3] == *(doses + 3) == *(3 + doses) == 3[doses]" वाला सूत्र एक बराबरी का कथन है, C का एक्सप्रेशन नहीं (इसे जस का तस printf में मत रखिए)। और 3[doses] असली कोड में लिखना बुरी आदत है, क्योंकि पढ़ने वाले को भ्रम होगा। मैंने चारों रूप चलाकर देखे, चारों ने 1000 ही दिया।
🟡 सुधार 9 — स्टैक के पते (पेज 83)
किताब के "4,100,000" जैसे पते सिर्फ़ समझाने के लिए चुने गए हैं। असली 64-बिट Linux/Mac पर स्टैक के पते अक्सर 0x7ffc... जैसे बहुत ऊँचे आते हैं, जैसा किताब ख़ुद पेज 94 और 102 के आउटपुट में दिखाती है। चिंता न करें, पते हर बार और हर मशीन पर बदलते हैं।
🟢 सुधार 10 — &s == s की तुलना (पेज 99)
&s == s का दावा मान के लिहाज़ से सही है (दोनों एक ही पता हैं), पर दोनों के टाइप अलग हैं: &s का टाइप "15 अक्षरों के ऐरे का पॉइंटर" है और s का टाइप (decay के बाद) char *। कुछ कंपाइलर इस तुलना पर चेतावनी देते हैं। मैंने (void *) में बदलकर तुलना की और नतीजा &s == s सही (1) तथा &t != t (0) आया।
🟢 सुधार 11 — "पॉइंटर को references कहते हैं" (पेज 88)
किताब कहती है "पॉइंटरों को कभी-कभी references कहते हैं।" इसे हल्के में लें। C में सही शब्द पॉइंटर है। "reference" C++ में एक अलग विचार है, जैसा पेज 92 में ख़ुद किताब बताती है। परीक्षा या साक्षात्कार में C के लिए पॉइंटर और dereference ही कहें।
🟢 सुधार 12 — go_south_east() के पहले रूप की चेतावनी (पेज 85)
पहले वाले रूप में lat और lon बदले जाते हैं पर कहीं इस्तेमाल नहीं होते। gcc -Wall के साथ "set but not used" जैसी चेतावनी दे सकता है। इसी से पहले संकेत मिल जाता है कि फ़ंक्शन असल में कुछ नहीं कर रहा। हमेशा -Wall -Wextra से कंपाइल करें: gcc -Wall -Wextra southeast.c -o southeast।
✅ त्वरित दोहराव (Quick Revision)
विषय
एक लाइन में
पॉइंटर
डेटा का पता (मेमोरी में उसकी जगह)
&x
x का पता
*p
पते p पर रखा मान (dereference)
*p = 99;
p के पते की सामग्री बदलना
int *p
ऐसा पॉइंटर वेरिएबल जो int की ओर इशारा करे
C की कॉल
आर्ग्युमेंट का मान कॉपी होकर जाता है
बदलना हो तो
वेरिएबल का पता भेजो (पॉइंटर)
stack
फ़ंक्शन के भीतर के वेरिएबल
globals
फ़ंक्शन के बाहर के वेरिएबल
%p
पता छापने के लिए (हेक्स में)
ऐरे वेरिएबल
पहले तत्व के पते जैसा, पर पूरा पॉइंटर नहीं
sizeof(ऐरे)
ऐरे का पूरा आकार (जैसे 15)
sizeof(पॉइंटर)
32-बिट पर 4, 64-बिट पर 8
ऐरे को फ़ंक्शन में देना
decay होकर पॉइंटर बन जाता है
s = t; (s ऐरे)
कंपाइल एरर: ऐरे वेरिएबल मोड़ा नहीं जा सकता
a[i]
*(a + i) के बराबर
इंडेक्स 0 से क्यों
इंडेक्स वह संख्या है जो पहले तत्व के पते में जोड़ी जाती है
int* में 1 जोड़ना
पते में 4 बाइट (int के आकार) जुड़ते हैं
पॉइंटर के टाइप क्यों
अंकगणित में सही आकार से गुणा करने के लिए
पॉइंटरों का गुणा
नहीं हो सकता
scanf को पता क्यों
वह वेरिएबल अपडेट करता है, इसलिए &age भेजते हैं
📌 ये नोट्स Head First C (David Griffiths और Dawn Griffiths, O'Reilly) के PDF पेज 81–105 पर आधारित हैं और सिर्फ़ निजी अध्ययन के लिए हैं।
मेमोरी और पॉइंटर (Memory and Pointers) · स्ट्रिंग्स (Strings)
📖 किताब:Head First C — David Griffiths & Dawn Griffiths (O'Reilly)
📄 हिस्सा: PDF पेज 105 से 129 (किताब के छपे पेज 65 से 89)
📚 अध्याय: Chapter 2 का आख़िरी हिस्सा (पेज 105–122) और Chapter 2.5 (पेज 123–129)
🛠️ सुधार: किताब की छपाई की गलतियाँ ठीक करके लिखी गई हैं। हर सुधार 🛠️ चिह्न से दिखाया गया है और आख़िर में पूरी सूची है।
scanf / printf को दिया जाने वाला पैटर्न, जैसे "%i"
हेडर फ़ाइल
header file
फ़ंक्शनों की सूची वाली फ़ाइल, जैसे string.h
स्टैंडर्ड लाइब्रेरी
Standard Library
कंपाइलर के साथ मुफ़्त मिलने वाला तैयार कोड
डिक्लेयरेशन / डेफ़िनिशन
declaration / definition
घोषणा / परिभाषा
टूल
tool
काम का साधन (किताब का "toolbox" भी इसी से)
🅰️ CHAPTER 2 — मेमोरी और पॉइंटर (जारी)
1. पॉइंटर से डेटा एंट्री (Using pointers for data entry)
📄 PDF पेज 105 · किताब पेज 65
कीबोर्ड से यूज़र की स्ट्रिंग लेना आप पहले से जानते हैं। यह scanf() फ़ंक्शन से होता है:
char name[40];
printf("Enter your name: ");
scanf("%39s", name);
📝 नाम इसी ऐरे (array) में स्टोर होगा।
📝 scanf ज़्यादा से ज़्यादा 39 अक्षर पढ़ेगा, और स्ट्रिंग को ख़त्म करने वाला \0 उसके ऊपर से।
scanf() काम कैसे करता है?
scanf() एक char पॉइंटर (pointer) लेता है। यहाँ आप उसे एक ऐरे वेरिएबल दे रहे हैं। अब शायद आपको अंदाज़ा हो गया होगा कि वह पॉइंटर क्यों लेता है। वजह यह है कि scanf() को ऐरे के कंटेंट (contents) अपडेट करने हैं।
💡 जिन फ़ंक्शनों को किसी वेरिएबल को अपडेट करना होता है, उन्हें वेरिएबल का मान नहीं चाहिए, उन्हें उसका एड्रेस (address) चाहिए।
scanf() से संख्या कैसे लें?
संख्या वाले वेरिएबल का पॉइंटर पास करके।
int age;
printf("Enter your age: ");
scanf("%i", &age);
📝 %i का मतलब है कि यूज़र एक int वैल्यू डालेगा।
📝 int का एड्रेस पाने के लिए & ऑपरेटर (operator) इस्तेमाल करो।
चूँकि आप नंबर वाले वेरिएबल का एड्रेस फ़ंक्शन को दे रहे हैं, इसलिए scanf() उस वेरिएबल का कंटेंट अपडेट कर सकता है।
आपकी मदद के लिए, scanf() में वही फ़ॉर्मेट कोड (format code) चलते हैं जो आप printf() को देते हैं:
फ़ॉर्मेट कोड
मतलब
%i
एक पूर्णांक (integer) डालो
%29s
ज़्यादा से ज़्यादा 29 अक्षर डालो (+ '\0')
%f
एक दशमलव वाली संख्या (floating-point number) डालो
एक साथ एक से ज़्यादा जानकारी भी पढ़ी जा सकती है:
char first_name[20];
char last_name[20];
printf("Enter first and last name: ");
scanf("%19s %19s", first_name, last_name);
printf("First: %s Last:%s\n", first_name, last_name);
📝 यह पहले नाम को पढ़ता है, फिर एक स्पेस (space), फिर दूसरे नाम को।
आउटपुट (output):
File Edit Window Help Meerkats
> ./name_test
Enter first and last name: Sanders Kleinfeld
First: Sanders Last: Kleinfeld
>
📝 पहला और आख़िरी नाम अलग-अलग ऐरे में स्टोर हुए हैं।
scanf() फ़ंक्शन में एक छोटी-सी…समस्या है। अब तक आपने जितना भी कोड लिखा है, उसमें scanf() जितने अक्षर पढ़ेगा उसकी सीमा बहुत सावधानी से लगाई गई है:
scanf("%39s", name);
scanf("%2s", card_name);
ऐसा क्यों? आख़िर scanf() भी printf() जैसी ही फ़ॉर्मेट स्ट्रिंग (format string) इस्तेमाल करता है, और printf से स्ट्रिंग छापने के लिए तो बस %s लिखते हैं। दरअसल, अगर आप scanf() में सिर्फ़ %s लिखें, तो समस्या तब आती है जब कोई यूज़र ज़रा ज़्यादा टाइप कर दे:
File Edit Window Help TakeAByte
> ./food
Enter favorite food: liver-tangerine-raccoon-toffee
Favorite food: liver-tangerine-raccoon-toffee
Segmentation fault: 11
>
प्रोग्राम क्रैश हो जाता है। वजह यह है कि scanf() ने food ऐरे के लिए तय जगह से बहुत आगे तक डेटा लिख दिया।
🖼️ चित्र की व्याख्या (food ऐरे)
food ऐरे सिर्फ़ पाँच अक्षरों पर ख़त्म हो जाता है: l i v e r
अक्षर r के आगे जो कुछ भी है (- t a n ...), वह ऐरे के बाहर है।
"-" से आगे का कोड अवैध (illegal) जगह में लिखा जा रहा है।
scanf() बफ़र ओवरफ़्लो (buffer overflow) करा सकता है
अगर आप scanf() से पढ़ी जाने वाली स्ट्रिंग की लंबाई सीमित करना भूल जाएँ, तो कोई भी यूज़र प्रोग्राम में उसकी स्टोर करने की जगह से कहीं ज़्यादा डेटा डाल सकता है। फिर यह फ़ालतू डेटा मेमोरी के ऐसे हिस्से में लिख जाता है जो कंप्यूटर ने ठीक से दिया ही नहीं था।
हो सकता है आपकी किस्मत अच्छी हो और डेटा बस स्टोर हो जाए, बिना कोई दिक़्क़त किए। पर बहुत ज़्यादा संभावना है कि बफ़र ओवरफ़्लो से बग (bug) आएँगे। इसे सेगमेंटेशन फ़ॉल्ट (segmentation fault) कहें या एबॉर्ट ट्रैप (abort trap), एरर मैसेज चाहे जो आए, नतीजा एक ही है: क्रैश।
3. fgets(): scanf() का विकल्प
📄 PDF पेज 107 · किताब पेज 67
टेक्स्ट डेटा डालने के लिए एक और फ़ंक्शन है: fgets()। यह भी scanf() की तरह char पॉइंटर लेता है, लेकिन scanf() से अलग, fgets() को अधिकतम लंबाई (maximum length) देनी ही पड़ती है:
📝 दूसरा आर्गुमेंट: स्ट्रिंग का अधिकतम आकार ('\0' मिलाकर)।
📝 तीसरा आर्गुमेंट:stdin का मतलब है कि डेटा कीबोर्ड से आएगा। stdin के बारे में आगे और पता चलेगा।
🛠️ सुधार: किताब में '/0' छपा है, सही '\0' (बैकस्लैश) है।
इसका मतलब है कि fgets() को बुलाते समय आप ग़लती से लंबाई देना भूल नहीं सकते। यह फ़ंक्शन के सिग्नेचर (signature) में ही अनिवार्य आर्गुमेंट के रूप में मौजूद है। साथ ही, fgets() के बफ़र साइज़ में आख़िरी \0 भी गिना जाता है। इसलिए scanf() की तरह लंबाई में से 1 घटाने की ज़रूरत नहीं।
fgets() के साथ sizeof का इस्तेमाल
ऊपर के कोड में अधिकतम लंबाई sizeof ऑपरेटर (operator) से तय हुई है। इसमें सावधानी रखो। याद रखो: sizeof किसी वेरिएबल द्वारा घेरी गई जगह लौटाता है। ऊपर के कोड में food एक ऐरे वेरिएबल है, इसलिए sizeof पूरे ऐरे का साइज़ देता है। अगर food सिर्फ़ एक सादा पॉइंटर वेरिएबल होता, तो sizeof ऑपरेटर बस पॉइंटर का साइज़ लौटाता।
अगर आपको पता है कि आप fgets() को ऐरे वेरिएबल दे रहे हैं, तो sizeof ठीक है।
अगर आप सिर्फ़ सादा पॉइंटर दे रहे हैं, तो मनचाही लंबाई सीधे लिख दो:
📝 अगर food सादा पॉइंटर होता, तो sizeof की जगह यहाँ साफ़ लंबाई दी जाती।
⚰️ क़ब्रिस्तान के किस्से (Tales from the Crypt)
fgets() फ़ंक्शन असल में एक पुराने फ़ंक्शन gets() से निकला है।
भले ही fgets() को scanf() से ज़्यादा सुरक्षित माना जाता है, सच यह है कि पुराना gets() फ़ंक्शन इन दोनों से कहीं ज़्यादा ख़तरनाक है। वजह? gets() पर कोई सीमा है ही नहीं:
char dangerous[10];
gets(dangerous);
😱 नहीं ईईईई!!!! गंभीरता से, इसे इस्तेमाल मत करो।
📝 gets() बहुत पुराना फ़ंक्शन है। पर आपको बस इतना जानना है कि इसे कभी इस्तेमाल नहीं करना चाहिए।
4. टाइटल फ़ाइट: scanf() बनाम fgets()
📄 PDF पेज 108 · किताब पेज 68
🥊 आइए, आइए! वह मुक़ाबला आ गया है जिसका हम सबको इंतज़ार था। लाल कोने में: फुर्तीला, हल्का, लचीला, पर ज़रा-सा ख़तरनाक। डेटा इनपुट का बिगड़ैल लड़का: scanf()। और नीले कोने में: सीधा-सादा, सुरक्षित, वह फ़ंक्शन जिससे आप अपनी माँ को मिलवाना चाहेंगे: fgets()!
राउंड
सवाल
scanf()
fgets()
राउंड 1: सीमा (Limits)
क्या यूज़र जितने अक्षर डाल सकता है, उन्हें सीमित करते हो?
scanf() डेटा सीमित कर सकता है, बशर्ते फ़ॉर्मेट स्ट्रिंग में साइज़ जोड़ना याद रखो।
fgets() में सीमा अनिवार्य है। उसके आगे से कुछ नहीं निकल सकता।
राउंड 2: कई फ़ील्ड (Multiple fields)
क्या एक से ज़्यादा फ़ील्ड डालने के लिए इस्तेमाल हो सकते हो?
हाँ!scanf() एक से ज़्यादा फ़ील्ड ही नहीं, बल्कि संरचित (structured) डेटा भी लेने देता है, यहाँ तक कि फ़ील्डों के बीच कौन-से अक्षर आएँ यह भी तय कर सकते हो।
आउच!fgets() यह राउंड ठुड्डी पर मुक्का खाकर हारा। fgets() सिर्फ़ एक स्ट्रिंग एक बफ़र में डालने देता है। कोई और डेटा टाइप नहीं। बस स्ट्रिंग। बस एक बफ़र।
राउंड 3: स्ट्रिंग में स्पेस (Spaces in strings)
अगर कोई स्ट्रिंग डाले, तो क्या उसमें स्पेस हो सकता है?
ऊफ़!scanf() को यहाँ बुरी चोट लगी। %s से स्ट्रिंग पढ़ते समय वह पहला स्पेस आते ही रुक जाता है। एक से ज़्यादा शब्द चाहिए तो या तो उसे कई बार बुलाओ, या कोई जटिल रेगुलर एक्सप्रेशन (regular expression) जुगाड़ लगाओ।
कोई दिक़्क़त नहीं। fgets() हर बार पूरी स्ट्रिंग पढ़ लेता है।
नतीजे:
🏆 राउंड 1: fgets() अंकों पर जीता।
🏆 राउंड 2: scanf() साफ़ तौर पर जीता।
🏆 राउंड 3: पलटवार! राउंड fgets() के नाम।
🧠 निचोड़: दोनों फ़ंक्शनों में अच्छा, साफ़ मुक़ाबला हुआ। अगर आपको कई फ़ील्ड वाला संरचित डेटा लेना है, तो scanf() इस्तेमाल करो। अगर आप एक असंरचित (unstructured) स्ट्रिंग ले रहे हैं, तो fgets() शायद बेहतर रास्ता है।
5. तीन-पत्ती का खेल (Three-card monte)
📄 PDF पेज 109–112 · किताब पेज 69–72
🃏 पेज 69: खेल शुरू
हेड फ़र्स्ट लाउंज (Head First Lounge) के पिछले कमरे में तीन-पत्ती (three-card monte) का खेल चल रहा है। कोई तीन पत्तों को इधर-उधर घुमाता है, और आपको ध्यान से देखकर बताना है कि आपके हिसाब से बेगम (Queen) कहाँ गई। बेशक, हेड फ़र्स्ट लाउंज में असली पत्ते नहीं, कोड इस्तेमाल हो रहा है। यह रहा उनका प्रोग्राम:
यह कोड तीन अक्षरों वाली स्ट्रिंग "JQK" के अक्षरों को फेंटने (shuffle) के लिए बना है। याद रखो: C में स्ट्रिंग बस अक्षरों का ऐरे होती है। प्रोग्राम अक्षरों की अदला-बदली करता है और फिर स्ट्रिंग को छापता है।
खिलाड़ी दाँव लगाते हैं कि उनके हिसाब से "Q" अक्षर कहाँ होगा, और फिर कोड कंपाइल (compile) करके चलाया जाता है।
💥 पेज 70: अरे…मेमोरी की समस्या है…
कार्ड-शार्क (card shark) के कोड में कोई गड़बड़ है। जब लाउंज के नोटबुक कंप्यूटर पर कोड कंपाइल करके चलाया जाता है, तो ये होता है:
File Edit Window Help PlaceBet
> gcc monte.c -o monte && ./monte
bus error
और तो और, अगर वही कोड दूसरी मशीनों और ऑपरेटिंग सिस्टमों पर चलाया जाए, तो तरह-तरह के एरर आते हैं:
File Edit Window Help HolyCrap
> gcc monte.c -o monte && ./monte
monte.exe has stopped working
💬 कॉमिक के बोल: "धत्त तेरे की! मुझे पता था कि उस कार्ड शार्क पर भरोसा नहीं किया जा सकता…" · Whack! · SegPhault! · Kapow! · Bus Error! · Segmentation Error!
❓ कोड में गड़बड़ क्या है?
🤔 पेज 71: आपका अंदाज़ा क्या है? (What's Your Hunch?)
अब अपनी सहज बुद्धि (intuition) का इस्तेमाल करो। ज़्यादा मत सोचो, बस एक अंदाज़ा लगाओ। नीचे दिए जवाबों को पढ़ो और सिर्फ़ एक चुनो जो आपके हिसाब से सही है।
आपको क्या लगता है समस्या क्या है?
⬜ स्ट्रिंग को अपडेट नहीं किया जा सकता।
⬜ हम स्ट्रिंग के बाहर के अक्षर अदल-बदल रहे हैं।
⬜ स्ट्रिंग मेमोरी में है ही नहीं।
⬜ कुछ और।
✅ पेज 72: अंदाज़े का हल (Solution)
सही जवाब: स्ट्रिंग को अपडेट नहीं किया जा सकता।
स्ट्रिंग लिटरल (string literal) कभी अपडेट नहीं हो सकते
जो वेरिएबल किसी स्ट्रिंग लिटरल की ओर इशारा करता है, उससे स्ट्रिंग का कंटेंट बदला नहीं जा सकता:
char *cards = "JQK";
📝 यह वेरिएबल इस स्ट्रिंग को बदल नहीं सकता।
लेकिन अगर आप स्ट्रिंग लिटरल से ऐरे बनाओ, तो उसे बदला जा सकता है:
char cards[] = "JQK";
यह सब इस पर निर्भर करता है कि C मेमोरी का इस्तेमाल कैसे करता है…
6. मेमोरी में: char *cards = "JQK";
📄 PDF पेज 113 · किताब पेज 73
🛠️ सुधार: इस पेज के शीर्षक में तारा (*) छपने से रह गया था। सही कोड char *cards = "JQK"; है।
यह समझने के लिए कि इस लाइन से मेमोरी एरर क्यों आता है, हमें कंप्यूटर की मेमोरी में झाँककर देखना होगा कि कंप्यूटर ठीक-ठीक क्या करता है।
🧩 चार चरण
1️⃣ कंप्यूटर स्ट्रिंग लिटरल को लोड करता है।
जब कंप्यूटर प्रोग्राम को मेमोरी में लोड करता है, तो वह सारे कॉन्स्टेंट (constant) मान, जैसे स्ट्रिंग लिटरल "JQK", कॉन्स्टेंट मेमोरी ब्लॉक में रख देता है। मेमोरी का यह हिस्सा रीड-ओनली (read-only) होता है।
2️⃣ प्रोग्राम cards वेरिएबल को स्टैक (stack) पर बनाता है।
स्टैक मेमोरी का वह हिस्सा है जो कंप्यूटर लोकल वेरिएबल (फ़ंक्शन के अंदर वाले वेरिएबल) के लिए इस्तेमाल करता है। cards वेरिएबल यहीं रहेगा।
3️⃣ cards वेरिएबल में "JQK" का एड्रेस रखा जाता है।cards वेरिएबल में स्ट्रिंग लिटरल "JQK" का एड्रेस होगा। स्ट्रिंग लिटरल आम तौर पर रीड-ओनली मेमोरी में रखे जाते हैं ताकि कोई उन्हें बदल न सके।
4️⃣ कंप्यूटर स्ट्रिंग बदलने की कोशिश करता है।
जब प्रोग्राम cards वेरिएबल जिस स्ट्रिंग की ओर इशारा कर रहा है उसका कंटेंट बदलने की कोशिश करता है, तो वह बदल नहीं सकता, क्योंकि स्ट्रिंग रीड-ओनली है।
💬 कॉमिक का बोल: "मैं इसे अपडेट नहीं कर सकता, दोस्त। यह कॉन्स्टेंट मेमोरी ब्लॉक में है, इसलिए रीड-ओनली है।"
चरण 3 में cards का तीर Constants वाले J Q K \0 की ओर जाता है।
तो समस्या यह है कि "JQK" जैसे स्ट्रिंग लिटरल रीड-ओनली मेमोरी में रखे जाते हैं। वे कॉन्स्टेंट हैं।
पर अगर समस्या यही है, तो इसे ठीक कैसे करें?
7. स्ट्रिंग बदलनी हो तो कॉपी बनाओ
📄 PDF पेज 114 · किताब पेज 74
सच यह है कि अगर आपको किसी स्ट्रिंग का कंटेंट बदलना है, तो आपको उसकी कॉपी पर काम करना होगा। अगर आप स्ट्रिंग की कॉपी मेमोरी के ऐसे हिस्से में बनाओ जो रीड-ओनली नहीं है, तो उसके अक्षर बदलने पर कोई दिक़्क़त नहीं होगी।
J Q K \0 ← यह स्ट्रिंग रीड-ओनली मेमोरी में है…
J Q K \0 …तो स्ट्रिंग की कॉपी मेमोरी के ऐसे हिस्से में बनाओ जिसे बदला जा सके।
पर कॉपी बनाएँ कैसे? बस स्ट्रिंग को नए ऐरे के रूप में बनाओ:
char cards[] = "JQK";
📝 cards अब सिर्फ़ पॉइंटर नहीं है। cards अब ऐरे है।
शायद यह साफ़ नहीं है कि इससे कुछ बदलता क्यों है। सारी स्ट्रिंग्स ऐरे हैं। पर पुराने कोड में cardsसिर्फ़ एक पॉइंटर था। नए कोड में वह ऐरे है। अगर आप cards नाम का ऐरे बनाकर उसे स्ट्रिंग लिटरल से सेट करो, तो cards ऐरे एक बिल्कुल नई कॉपी होगा। वेरिएबल सिर्फ़ स्ट्रिंग लिटरल की ओर इशारा नहीं कर रहा। वह एक नया ऐरे है जिसमें स्ट्रिंग लिटरल की ताज़ा कॉपी है।
यह प्रैक्टिस में कैसे काम करता है, यह देखने के लिए आपको मेमोरी में देखना होगा कि होता क्या है।
🤓 गीक बिट्स (Geek Bits): cards[] या *cards?
🛠️ सुधार: किताब के शीर्षक में cards* छपा है। C में पॉइंटर का तारा नाम से पहले आता है, यानी *cards।
अगर आपको ऐसी घोषणा (declaration) दिखे, तो इसका असली मतलब क्या है?
char cards[]
यह इस पर निर्भर करता है कि आप इसे कहाँ देख रहे हो।
केस 1: सामान्य वेरिएबल घोषणा। तब इसका मतलब है कि cards एक ऐरे है, और आपको उसे तुरंत कोई मान देना पड़ेगा:
int my_function()
{
char cards[] = "JQK";
...
}
📝 cards एक ऐरे है।
📝 ऐरे का साइज़ नहीं दिया गया है, इसलिए इसे तुरंत किसी चीज़ पर सेट करना ज़रूरी है।
केस 2: फ़ंक्शन के आर्गुमेंट (argument) के रूप में। तब इसका मतलब है कि cards एक पॉइंटर है:
हम देख चुके हैं कि ग़लत कोड से मेमोरी में क्या होता है। अब देखते हैं कि हमारे नए कोड में क्या होता है।
🧩 तीन चरण
1️⃣ कंप्यूटर स्ट्रिंग लिटरल को लोड करता है।
पहले की तरह, जब कंप्यूटर प्रोग्राम को मेमोरी में लोड करता है, तो वह कॉन्स्टेंट मान, जैसे स्ट्रिंग "JQK", रीड-ओनली मेमोरी में स्टोर करता है।
2️⃣ प्रोग्राम स्टैक पर एक नया ऐरे बनाता है।
हम ऐरे घोषित कर रहे हैं, इसलिए प्रोग्राम "JQK" स्ट्रिंग रखने लायक बड़ा ऐरे बनाएगा, यानी चार अक्षरों की जगह (J, Q, K, \0)।
3️⃣ प्रोग्राम ऐरे को इनिशियलाइज़ (initialize) करता है।
जगह बनाने के साथ-साथ, प्रोग्राम स्ट्रिंग लिटरल "JQK" का कंटेंट स्टैक मेमोरी में कॉपी भी करता है।
फ़र्क़ यह है कि मूल कोड में एक पॉइंटर रीड-ओनली स्ट्रिंग लिटरल की ओर इशारा कर रहा था। पर अगर आप ऐरे को स्ट्रिंग लिटरल से इनिशियलाइज़ करो, तो आपके पास अक्षरों की एक कॉपी आ जाती है, और आप उसे जितना चाहो बदल सकते हो।
File Edit Window Help Where'sTheLady?
> gcc monte.c -o monte && ./monte
QKJ
💬 "हाँ! बेगम पहला पत्ता थी। मुझे पता था…"
कोड चल गया! आपका cards वेरिएबल अब मेमोरी के असुरक्षित (unprotected) हिस्से की स्ट्रिंग की ओर इशारा करता है, इसलिए हम उसका कंटेंट बदलने के लिए आज़ाद हैं।
🧮 जाँच: QKJ कैसे आया?
शुरुआत में cards = "JQK" और a_card = 'K':
चरण
कोड
cards की स्थिति
1
cards[2] = cards[1];
JQQ
2
cards[1] = cards[0];
JJQ
3
cards[0] = cards[2];
QJQ
4
cards[2] = cards[1];
QJJ
5
cards[1] = a_card;
QKJ ✅
🤓 गीक बिट्स (Geek Bits)
भविष्य में इस समस्या से बचने का एक तरीका यह है कि कभी भी ऐसा कोड मत लिखो जो एक सादे char पॉइंटर को स्ट्रिंग लिटरल मान पर सेट करे, जैसे:
char *s = "Some string";
किसी पॉइंटर को स्ट्रिंग लिटरल पर सेट करने में कोई बुराई नहीं है। समस्या तभी आती है जब आप स्ट्रिंग लिटरल को बदलने की कोशिश करते हो। इसकी जगह, अगर आप पॉइंटर को किसी लिटरल पर सेट करना चाहते हो, तो हमेशा const कीवर्ड इस्तेमाल करो:
const char *s = "some string";
इस तरह, अगर कंपाइलर (compiler) को ऐसा कोड दिखेगा जो स्ट्रिंग बदलने की कोशिश करता है, तो वह आपको कंपाइल एरर देगा:
s[0] = 'S';
monte.c:7: error: assignment of read-only location
10. जादुई गोली का केस (The Case of the Magic Bullet)
वह अपनी पुरानी Guns 'n' Ammo पत्रिकाओं का संग्रह Delicious Library में स्कैन कर रहा था कि दरवाज़े पर दस्तक हुई और वह अंदर आई: 5 फ़ुट 6 इंच, सुनहरे बाल, बढ़िया लैपटॉप बैग और सस्ते जूते। वह भाँप गया कि वह एक कोड जॉकी (code jockey) है। "आपको मेरी मदद करनी ही होगी…आपको उसका नाम साफ़ करना होगा! जिमी बेक़ुसूर था, मैं कहती हूँ! बेक़ुसूर!" उसने उसे एक टिशू पकड़ाया ताकि वह अपनी नीली-नीली आँखों से आँसू पोंछ ले, और उसे कुर्सी तक ले गया।
वही पुरानी कहानी थी। वह एक लड़के से मिली थी, जो एक और लड़के को जानता था। जिमी ब्लॉमस्टीन (Jimmy Blomstein) स्थानीय Starbuzz में टेबल पर सर्विस करता था, और अपने सप्ताहांत साइकिल चलाने और अपने टैक्सीडर्मी (taxidermy) संग्रह पर काम करने में बिताता था। उसे उम्मीद थी कि एक दिन वह इतना बचा लेगा कि एक हाथी ख़रीद सके। पर वह ग़लत संगत में पड़ गया था। नक़ाबपोश डाकू (Masked Raider) सुबह कॉफ़ी पर जिमी से मिला था, और दोनों ज़िंदा थे:
char masked_raider[] = "Alive";
char *jimmy = masked_raider;
printf("Masked raider is %s, Jimmy is %s\n", masked_raider, jimmy);
File Edit Window Help
Masked raider is Alive, Jimmy is Alive
फिर, उसी दोपहर, नक़ाबपोश डाकू एक डकैती डालने निकला, जैसी वह सैकड़ों पहले भी डाल चुका था। पर इस बार उसने जी-मैन (G-Men) की उस भीड़ का हिसाब नहीं लगाया था जो हेड फ़र्स्ट लाउंज के पिछले कमरे में अपनी साप्ताहिक तीन-पत्ती का मज़ा ले रही थी। आप तस्वीर समझ गए होंगे। गोलियों की बौछार, एक चीख़, और कुछ पल बाद खलनायक फ़ुटपाथ पर पड़ा था, और सार्वजनिक स्वास्थ्य के लिए ख़तरा बन गया:
दिक़्क़त यह है कि जब टूट्स (Toots) अपने बॉयफ़्रेंड का हाल पूछने कॉफ़ी शॉप गई, तो उसे बताया गया कि वह अपना आख़िरी ऑरेंज मोचा फ़्रैपुचीनो परोस चुका है:
printf("Masked raider is %s, Jimmy is %s\n", masked_raider, jimmy);
File Edit Window Help
Masked raider is DEAD!, Jimmy is DEAD!
तो माजरा क्या है? एक ही जादुई गोली ने जिमी और नक़ाबपोश डाकू, दोनों को कैसे मार दिया? आपको क्या लगता है, हुआ क्या?
✅ पेज 78: केस हल (Five-Minute Mystery Solved)
एक ही जादुई गोली ने जिमी और नक़ाबपोश डाकू, दोनों को कैसे मार दिया?
मृदुभाषी बरिस्ता (barista) जिमी को रहस्यमय ढंग से ठीक उसी समय गोली लगी जब खलनायक नक़ाबपोश डाकू को लगी:
#include <stdio.h>
int main()
{
char masked_raider[] = "Alive";
char *jimmy = masked_raider;
printf("Masked raider is %s, Jimmy is %s\n", masked_raider, jimmy);
masked_raider[0] = 'D';
masked_raider[1] = 'E';
masked_raider[2] = 'A';
masked_raider[3] = 'D';
masked_raider[4] = '!';
printf("Masked raider is %s, Jimmy is %s\n", masked_raider, jimmy);
return 0;
}
📢 मार्केटिंग विभाग का नोट: Brain Booster ड्रिंक का प्रोडक्ट प्लेसमेंट (product placement) हटा दो; वह सौदा नहीं हो पाया।
जासूस को इस रहस्य की तह तक पहुँचने में कुछ समय लगा। इंतज़ार के दौरान उसने हेड फ़र्स्ट ब्रेन बूस्टर फ़्रूट बेवरेज की एक लंबी, ताज़गी भरी चुस्की ली। वह कुर्सी पर पीछे टिका और मेज़ के उस पार उसकी नीली, गहरी नीली आँखों में देखा। वह सामने से आते ट्रक की हेडलाइट में फँसी ख़रगोश जैसी लग रही थी, और वह जानता था कि गाड़ी वही चला रहा है।
"मेरे पास आपके लिए बुरी ख़बर है। जिमी और नक़ाबपोश डाकू…एक ही आदमी थे!"
"नहीं!"
उसने तेज़ साँस ली और हाथ मुँह पर रख लिया। "माफ़ करना, बहन। मुझे जो दिखता है वही बोलना पड़ता है। बस मेमोरी का इस्तेमाल देखो।" उसने एक चित्र बनाया:
masked_raider ─┐
├──▶ A l i v e \0
jimmy ─────────┘
"jimmy और masked_raider एक ही मेमोरी एड्रेस के सिर्फ़ उपनाम (alias) हैं। वे एक ही जगह की ओर इशारा कर रहे हैं। जब masked_raider ने गोली खाई, तो जिमी ने भी खाई। इसके ऊपर, सैन फ़्रांसिस्को के हाथी अभयारण्य (elephant sanctuary) का यह इनवॉइस है और 15 टन पैकिंग सामान का यह ऑर्डर है, तो यह मामला खुला और बंद है।"
🧠 सीख:char *jimmy = masked_raider; से कॉपी नहीं बनती। दोनों वेरिएबल एक ही मेमोरी की ओर इशारा करते हैं। इसलिए एक के ज़रिए बदलाव करने पर दूसरे में भी दिखता है।
11. बुलेट पॉइंट और सवाल-जवाब
📄 PDF पेज 119 · किताब पेज 79
📌 बुलेट पॉइंट (Bullet Points)
अगर आपको किसी वेरिएबल घोषणा में * दिखे, तो इसका मतलब है कि वह वेरिएबल पॉइंटर होगा।
स्ट्रिंग लिटरल रीड-ओनली मेमोरी में रखे जाते हैं।
अगर आपको स्ट्रिंग बदलनी है, तो नए ऐरे में उसकी कॉपी बनानी होगी।
आप char पॉइंटर को const char * घोषित कर सकते हो, ताकि कोड उससे स्ट्रिंग न बदल सके।
❓ कोई सवाल बेवकूफ़ाना नहीं होता (There are no Dumb Questions)
सवाल: कंपाइलर ने मुझे सीधे यह क्यों नहीं बताया कि मैं स्ट्रिंग नहीं बदल सकता?
जवाब: क्योंकि हमने cards को सादे char * के रूप में घोषित किया था, इसलिए कंपाइलर को पता नहीं था कि वेरिएबल हमेशा किसी स्ट्रिंग लिटरल की ओर ही इशारा करेगा।
सवाल: स्ट्रिंग लिटरल रीड-ओनली मेमोरी में क्यों रखे जाते हैं?
जवाब: क्योंकि उन्हें कॉन्स्टेंट बनाया गया है। अगर आप "Hello World" छापने वाला फ़ंक्शन लिखते हो, तो आप नहीं चाहोगे कि प्रोग्राम का कोई और हिस्सा "Hello World" स्ट्रिंग लिटरल को बदल दे।
सवाल: क्या सभी ऑपरेटिंग सिस्टम रीड-ओनली नियम लागू करते हैं?
जवाब: ज़्यादातर करते हैं। Cygwin पर gcc के कुछ वर्ज़न असल में आपको स्ट्रिंग लिटरल बदलने देते हैं और कोई शिकायत नहीं करते। पर ऐसा करना हमेशा ग़लत है।
सवाल:const का असल मतलब क्या है? क्या इससे स्ट्रिंग रीड-ओनली हो जाती है?
जवाब: स्ट्रिंग लिटरल वैसे भी रीड-ओनली हैं। const मॉडिफ़ायर (modifier) का मतलब है कि अगर आप उस वेरिएबल के ज़रिए बदलाव की कोशिश करोगे, तो कंपाइलर शिकायत करेगा।
सवाल: क्या अलग-अलग मेमोरी सेगमेंट (segment) हमेशा मेमोरी में एक ही क्रम में दिखते हैं?
जवाब: किसी एक ऑपरेटिंग सिस्टम के लिए वे हमेशा एक ही क्रम में होंगे। पर अलग-अलग ऑपरेटिंग सिस्टमों में क्रम थोड़ा अलग हो सकता है। जैसे, Windows कोड को सबसे निचले मेमोरी एड्रेस पर नहीं रखता।
सवाल: मुझे अब भी समझ नहीं आता कि ऐरे वेरिएबल मेमोरी में स्टोर क्यों नहीं होता। अगर वह मौजूद है, तो कहीं तो रहता होगा?
जवाब: जब प्रोग्राम कंपाइल होता है, तो ऐरे वेरिएबलों के सारे संदर्भ (references) ऐरे के एड्रेस से बदल दिए जाते हैं। इसलिए सच यह है कि अंतिम एक्ज़ीक्यूटेबल (executable) में ऐरे वेरिएबल मौजूद ही नहीं रहता। यह ठीक है, क्योंकि ऐरे वेरिएबल को कभी किसी और जगह इशारा नहीं करना पड़ेगा।
सवाल: अगर मैं नए ऐरे को स्ट्रिंग लिटरल पर सेट करूँ, तो क्या प्रोग्राम सचमुच हर बार कंटेंट कॉपी करेगा?
जवाब: यह कंपाइलर पर निर्भर है। अंतिम मशीन कोड (machine code) या तो स्ट्रिंग लिटरल के बाइट ऐरे में कॉपी कर देगा, या फिर जब भी प्रोग्राम उस घोषणा तक पहुँचेगा, हर अक्षर का मान अलग से सेट कर देगा।
सवाल: आप बार-बार "घोषणा (declaration)" कह रहे हैं। इसका मतलब क्या है?
जवाब: डिक्लेयरेशन (declaration) कोड का वह टुकड़ा है जो बताता है कि कोई चीज़ (वेरिएबल, फ़ंक्शन) मौजूद है। डेफ़िनिशन (definition) कोड का वह टुकड़ा है जो बताता है कि वह चीज़ क्या है। अगर आप कोई वेरिएबल घोषित करके उसे कोई मान दो (जैसे int x = 4;), तो वह कोड एक साथ घोषणा भी है और परिभाषा भी।
सवाल:scanf() को scanf() क्यों कहते हैं?
जवाब:scanf() का मतलब है "scan formatted" (फ़ॉर्मेट किए हुए को स्कैन करो), क्योंकि इसका इस्तेमाल फ़ॉर्मेट किया हुआ इनपुट स्कैन करने में होता है।
12. मेमोरी याद रखो (Memory memorizer)
📄 PDF पेज 120 · किताब पेज 80
मेमोरी, ऊपर (सबसे ऊँचा एड्रेस) से नीचे (सबसे नीचा एड्रेस):
हिस्सा
क्या है
Highest address
⬆️ सबसे ऊँचा एड्रेस
📚 स्टैक (Stack)
मेमोरी का वह हिस्सा जो लोकल वेरिएबल के लिए इस्तेमाल होता है। जब भी आप कोई फ़ंक्शन बुलाते हो, उस फ़ंक्शन के सारे लोकल वेरिएबल स्टैक पर बनते हैं। इसे स्टैक इसलिए कहते हैं क्योंकि यह प्लेटों के ढेर जैसा है: फ़ंक्शन में घुसते समय वेरिएबल ढेर में जुड़ते हैं, और फ़ंक्शन से निकलते समय हट जाते हैं। अजीब बात यह है कि स्टैक असल में उल्टा काम करता है। यह मेमोरी के ऊपरी सिरे से शुरू होता है और नीचे की ओर बढ़ता है।
🏔️ हीप (Heap)
मेमोरी का वह हिस्सा जो हमने अब तक असल में इस्तेमाल नहीं किया है। हीप डायनेमिक मेमोरी के लिए है: ऐसा डेटा जो प्रोग्राम चलते समय बनता है और फिर काफ़ी देर तक बना रहता है। आगे किताब में आप देखोगे कि हीप का इस्तेमाल कैसे करना है।
🌍 ग्लोबल्स (Globals)
ग्लोबल वेरिएबल वह वेरिएबल है जो सारे फ़ंक्शनों के बाहर रहता है और सबको दिखता है। ग्लोबल प्रोग्राम के पहली बार चलते समय बनते हैं, और आप उन्हें आज़ादी से अपडेट कर सकते हो। पर यह उनसे अलग है…(नीचे)
🔒 कॉन्स्टेंट्स (Constants)(Read-only memory)
कॉन्स्टेंट भी प्रोग्राम के पहली बार चलते समय बनते हैं, पर वे रीड-ओनली मेमोरी में रखे जाते हैं। कॉन्स्टेंट वे चीज़ें हैं, जैसे स्ट्रिंग लिटरल, जो प्रोग्राम चलते समय आपको चाहिए होंगी, पर आप उन्हें कभी बदलना नहीं चाहोगे।
💻 कोड (Code)
आख़िर में, कोड सेगमेंट (code segment)। कई ऑपरेटिंग सिस्टम कोड को सबसे निचले मेमोरी एड्रेसों पर रखते हैं। कोड सेगमेंट भी रीड-ओनली होता है। मेमोरी का यह वह हिस्सा है जहाँ असल असेंबल (assemble) किया हुआ कोड लोड होता है।
Lowest address
⬇️ सबसे नीचा एड्रेस
13. Chapter 2 का C टूलबॉक्स (Your C Toolbox)
📄 PDF पेज 121 · किताब पेज 81
🎉 Chapter 2 पूरा! आपने Chapter 2 पूरा कर लिया है, और अब अपने टूलबॉक्स (toolbox) में पॉइंटर और मेमोरी जोड़ लिए हैं। किताब के सभी टूल-टिप्स (tooltips) की पूरी सूची के लिए परिशिष्ट ii (Appendix ii) देखें।
टूल (Tool)
मतलब
scanf("%i", &x)
यूज़र को सीधे नंबर x डालने देगा।
&x
x का एड्रेस लौटाता है। &x को x का पॉइंटर कहते हैं।
ints अलग-अलग साइज़ के होते हैं
अलग-अलग मशीनों पर int का साइज़ अलग हो सकता है।
char पॉइंटर वेरिएबल x
char *x के रूप में घोषित होता है।
लोकल वेरिएबल
स्टैक पर स्टोर होते हैं।
स्ट्रिंग लिटरल
रीड-ओनली मेमोरी में स्टोर होते हैं।
ऐरे वेरिएबल
पॉइंटर के रूप में इस्तेमाल हो सकते हैं।
ऐरे को स्ट्रिंग से इनिशियलाइज़ करना
नया ऐरे बनाकर स्ट्रिंग उसमें कॉपी हो जाएगी।
*a
पते a का कंटेंट पढ़ता है।
fgets(buf, size, stdin)
टेक्स्ट डालने का आसान तरीक़ा।
(PDF पेज 122 किताब में ख़ाली है।)
🅱️ CHAPTER 2.5 — स्ट्रिंग्स (Strings)
14. Chapter 2.5: स्ट्रिंग्स (String theory)
📄 PDF पेज 123 · किताब पेज 83
🎭 स्ट्रिंग थ्योरी (String theory)
💬 कॉमिक के बोल:
पहला: "strcmp() कहता है कि हम एकदम एक जैसे हैं।"
दूसरा: "मुझे तो लगा उसने तुम्हें छोटा कहा और बोला कि तुम्हारा पिछवाड़ा बड़ा है।"
स्ट्रिंग्स में सिर्फ़ पढ़ने से ज़्यादा कुछ है
आपने देखा है कि C में स्ट्रिंग्स असल में char ऐरे होती हैं, पर C आपको उनके साथ क्या-क्या करने देता है? यहीं string.h काम आता है। string.h, C स्टैंडर्ड लाइब्रेरी (C Standard Library) का वह हिस्सा है जो स्ट्रिंग पर काम (string manipulation) के लिए समर्पित है। अगर आप स्ट्रिंग्स को जोड़ना (concatenate), एक स्ट्रिंग को दूसरी में कॉपी करना, या दो स्ट्रिंग्स की तुलना करना चाहते हो, तो string.h के फ़ंक्शन इसी के लिए बने हैं।
इस अध्याय में आप देखोगे कि स्ट्रिंग्स का ऐरे कैसे बनाते हैं, और फिर strstr() फ़ंक्शन से स्ट्रिंग्स के अंदर खोज कैसे करते हैं, इस पर बारीकी से नज़र डालोगे।
15. सुज़ैन की तलाश में (Desperately seeking Susan)
📄 PDF पेज 124 · किताब पेज 84
रेट्रो जूकबॉक्स (jukebox) पर इतने ज़्यादा ट्रैक (tracks) हैं कि लोग अपनी मनपसंद संगीत ढूँढ ही नहीं पाते। ग्राहकों की मदद करने के लिए, हेड फ़र्स्ट लाउंज के लोग चाहते हैं कि आप एक और प्रोग्राम लिखो।
💬 "उफ़्फ़! Wayne Newton…फिर से! हमें एक सर्च प्रोग्राम चाहिए जो लोगों को जूकबॉक्स पर ट्रैक ढूँढने में मदद करे।"
🎵 ट्रैक सूची
एल्बम "Little Known Sinatra" के नए ट्रैक:
#
ट्रैक का नाम
1
I left my heart in Harvard Med School
2
Newark, Newark - a wonderful town
3
Dancing with a Dork
4
From here to maternity
5
The girl from Iwo Jima
लोगों का कहना है कि भविष्य में और बहुत सारे ट्रैक आएँगे, पर वे 79 अक्षरों से लंबे कभी नहीं होंगे।
सूची शायद लंबी होती जाएगी, इसलिए अभी सिर्फ़ शुरू के कुछ ट्रैक हैं। आपको एक C प्रोग्राम लिखना है जो यूज़र से पूछे कि वह कौन-सा ट्रैक ढूँढ रही है, और फिर सारे ट्रैक में खोज करके जो मेल खाएँ उन्हें दिखाए।
❓ इस प्रोग्राम में बहुत सारी स्ट्रिंग्स होंगी। आपके हिसाब से C में यह जानकारी कैसे रिकॉर्ड की जा सकती है?
16. ऐरे का ऐरे (Array of arrays)
📄 PDF पेज 125 · किताब पेज 85
आपको कई ट्रैक नाम रिकॉर्ड करने हैं। आप ऐरे में एक साथ कई चीज़ें रिकॉर्ड कर सकते हो। पर याद रखो: हर स्ट्रिंग ख़ुद एक ऐरे है। इसका मतलब है कि आपको ऐरे का ऐरे (array of arrays) बनाना होगा, इस तरह:
char tracks[][80] = {
"I left my heart in Harvard Med School",
"Newark, Newark - a wonderful town",
"Dancing with a Dork",
"From here to maternity",
"The girl from Iwo Jima",
};
📝 कोड की व्याख्या
पहला ब्रैकेट []: सभी स्ट्रिंग्स के ऐरे के लिए है। कंपाइलर ख़ुद गिन लेता है कि पाँच स्ट्रिंग्स हैं, इसलिए इन ब्रैकेटों के बीच संख्या लिखने की ज़रूरत नहीं।
दूसरा ब्रैकेट [80]: हर अलग स्ट्रिंग के लिए है। आप जानते हो कि ट्रैक नाम कभी 79 अक्षरों से लंबे नहीं होंगे, इसलिए मान 80 रखो।
तो अब जब आप जानते हो कि डेटा C में रिकॉर्ड कैसे करना है, तो इसके साथ करना क्या है?
17. string.h लाइब्रेरी
📄 PDF पेज 126 · किताब पेज 86
📋 खोजने वाली स्ट्रिंग्स का स्पेक (Spec)
लोगों ने आपको एक स्पेक (spec) दे दिया है:
🔤 यूज़र से वह टेक्स्ट पूछो जिसे वह ढूँढ रही है।
🔁 सारे ट्रैक नामों पर लूप (loop) चलाओ।
✅ अगर ट्रैक नाम में खोजा गया टेक्स्ट है, तो वह ट्रैक नाम दिखाओ।
अच्छा, आप ट्रैकों को रिकॉर्ड करना जानते हो। आप किसी एक ट्रैक नाम का मान पढ़ना भी जानते हो, इसलिए उनमें से हर एक पर लूप चलाना मुश्किल नहीं होना चाहिए। आप यूज़र से खोजने के लिए टेक्स्ट पूछना भी जानते हो। पर यह कैसे देखें कि किसी ट्रैक नाम में कोई ख़ास टेक्स्ट है या नहीं?
📚 string.h का इस्तेमाल
C स्टैंडर्ड लाइब्रेरी (C Standard Library) तैयार कोड का एक ऐसा समूह है जो C कंपाइलर इंस्टॉल करने पर आपको मुफ़्त में मिलता है। लाइब्रेरी का कोड उपयोगी काम करता है, जैसे फ़ाइलें खोलना, गणित करना, या मेमोरी सँभालना। अब, संभावना है कि आप पूरी स्टैंडर्ड लाइब्रेरी को एक साथ इस्तेमाल नहीं करना चाहोगे, इसलिए लाइब्रेरी को कई हिस्सों में बाँटा गया है, और हर हिस्से की एक हेडर फ़ाइल (header file) है। हेडर फ़ाइल उन सभी फ़ंक्शनों की सूची देती है जो लाइब्रेरी के उस ख़ास हिस्से में रहते हैं।
अब तक आपने असल में सिर्फ़ stdio.h हेडर फ़ाइल इस्तेमाल की है। stdio.h आपको स्टैंडर्ड इनपुट/आउटपुट फ़ंक्शन इस्तेमाल करने देती है, जैसे printf और scanf।
पर स्टैंडर्ड लाइब्रेरी में स्ट्रिंग प्रोसेस करने वाला कोड भी है। स्ट्रिंग प्रोसेसिंग बहुत-से प्रोग्रामों में ज़रूरी होती है, और स्टैंडर्ड लाइब्रेरी का स्ट्रिंग कोड जाँचा-परखा, स्थिर और तेज़ है।
🧰 string.h क्या-क्या कर सकता है?
काम
दो स्ट्रिंग्स की आपस में तुलना करना
किसी स्ट्रिंग में खोज करना
स्ट्रिंग को छोटे-छोटे टुकड़ों में काटना
स्ट्रिंग की कॉपी बनाना
💬 string.h में खेलने के लिए और भी बहुत-सी रोमांचक चीज़ें हैं। यह तो बस शुरुआत है।
स्ट्रिंग कोड को अपने प्रोग्राम में string.h हेडर फ़ाइल से शामिल करो। इसे प्रोग्राम के सबसे ऊपर जोड़ो, ठीक वैसे ही जैसे आप stdio.h शामिल करते हो।
#include <stdio.h>
#include <string.h>
📝 आप अपने जूकबॉक्स प्रोग्राम में stdio.h और string.hदोनों इस्तेमाल करोगे।
18. पहेली: string.h के फ़ंक्शन और उनका काम
📄 PDF पेज 127–128 · किताब पेज 87–88
🧩 पेज 87: पहेली
देखो, क्या आप हर string.h फ़ंक्शन को उसके काम के विवरण से मिला सकते हो।
फ़ंक्शन
विवरण (किसी एक से मिलाओ)
strchr()
दो स्ट्रिंग्स को जोड़ो (concatenate)।
strcmp()
किसी स्ट्रिंग के अंदर दूसरी स्ट्रिंग की जगह ढूँढो।
strstr()
किसी स्ट्रिंग के अंदर किसी अक्षर की जगह ढूँढो।
strcpy()
स्ट्रिंग की लंबाई ढूँढो।
strlen()
दो स्ट्रिंग्स की तुलना करो।
strcat()
एक स्ट्रिंग को दूसरी में कॉपी करो।
❓ ऊपर में से कौन-सा फ़ंक्शन आपको जूकबॉक्स प्रोग्राम में इस्तेमाल करना चाहिए? अपना जवाब नीचे लिखो।
✅ पेज 88: हल (Solution)
आपको हर string.h फ़ंक्शन को उसके काम से मिलाना था:
फ़ंक्शन
सही काम
strchr()
किसी स्ट्रिंग के अंदर किसी अक्षर की जगह ढूँढता है।
strcmp()
दो स्ट्रिंग्स की तुलना करता है।
strstr()
किसी स्ट्रिंग के अंदर दूसरी स्ट्रिंग की जगह ढूँढता है।
strcpy()
एक स्ट्रिंग को दूसरी में कॉपी करता है।
strlen()
स्ट्रिंग की लंबाई ढूँढता है।
strcat()
दो स्ट्रिंग्स को जोड़ता (concatenate) है।
🎯 जूकबॉक्स प्रोग्राम के लिए सही फ़ंक्शन:strstr()
19. strstr() फ़ंक्शन का इस्तेमाल
📄 PDF पेज 129 · किताब पेज 89
तो strstr() फ़ंक्शन असल में काम कैसे करता है? एक उदाहरण देखते हैं। मान लो आप बड़ी स्ट्रिंग "dysfunctional" के अंदर स्ट्रिंग "fun" ढूँढ रहे हो। आप इसे ऐसे बुलाओगे:
strstr("dysfunctional", "fun")
🖼️ मेमोरी की तस्वीर
मान लो "dysfunctional" मेमोरी में एड्रेस 4,000,000 से शुरू होती है:
अक्षर
d
y
s
f
u
n
c
t
i
o
n
a
l
एड्रेस
4,000,000
4,000,001
4,000,002
4,000,003
4,000,004
4,000,005
4,000,006
4,000,007
4,000,008
4,000,009
4,000,010
4,000,011
4,000,012
💬 strstr() स्ट्रिंग "fun" को जगह 4,000,003 से शुरू होता हुआ पाएगा।
strstr() फ़ंक्शन पहली स्ट्रिंग में दूसरी स्ट्रिंग को खोजता है। अगर उसे स्ट्रिंग मिल जाती है, तो वह मेमोरी में मिली हुई स्ट्रिंग का एड्रेस लौटाता है। ऊपर के उदाहरण में फ़ंक्शन पाएगा कि fun सबस्ट्रिंग (substring) मेमोरी एड्रेस 4,000,003 से शुरू होती है।
❓ और अगर strstr() को सबस्ट्रिंग न मिले तो?
तब strstr() मान 0 लौटाता है। क्या आप सोच सकते हो ऐसा क्यों है? अगर आपको याद हो, तो C शून्य को false मानता है। इसका मतलब है कि आप strstr() को यह जाँचने के लिए इस्तेमाल कर सकते हो कि एक स्ट्रिंग दूसरी के अंदर मौजूद है या नहीं, इस तरह:
char s0[] = "dysfunctional";
char s1[] = "fun";
if (strstr(s0, s1))
puts("I found the fun in dysfunctional!");
🔍 स्पष्टीकरण: तकनीकी रूप से strstr() न मिलने पर NULL (नल पॉइंटर) लौटाता है, और NULL का मान 0 होता है। इसीलिए किताब "0" कहती है। if में 0 false माना जाता है, इसलिए ऊपर का कोड काम करता है।
चलो देखते हैं कि जूकबॉक्स प्रोग्राम में strstr() का इस्तेमाल कैसे कर सकते हैं।
20. 🛠️ किताब की छपाई की गलतियाँ और सुधार
इस हिस्से (पेज 105–129) में जो गलतियाँ मिलीं और जिन्हें ऊपर ठीक करके लिखा गया है:
#
PDF पेज (किताब पेज)
किताब में छपा
सही रूप
1
107 (67)
fgets के दूसरे आर्गुमेंट में स्ट्रिंग-समाप्ति '/0'
'\0' (बैकस्लैश, स्लैश नहीं)
2
113 (73)
शीर्षक char cards="JQK"; (तारा छूट गया)
char *cards = "JQK";
3
114 (74)
गीक बिट्स का शीर्षक cards[] या cards*?
cards[] या *cards? (पॉइंटर में तारा नाम से पहले आता है)
📌 ध्यान दें: पेज 105 की सूची और दूसरे कोड उदाहरणों में कोई गलती नहीं मिली। QKJ वाला आउटपुट भी ऊपर चरण-दर-चरण जाँचकर सही पाया गया।
स्ट्रिंग्स (Strings) का समापन · Chapter 3: छोटे टूल बनाना (Creating Small Tools)
📖 किताब:Head First C — David Griffiths & Dawn Griffiths (O'Reilly)
📄 हिस्सा: PDF पेज 130 से 154 (किताब के छपे पेज 90 से 114)
📚 अध्याय: Chapter 2.5 का बाक़ी हिस्सा (पेज 130–141) और Chapter 3 की शुरुआत (पेज 143–154)
🛠️ सुधार: किताब की गलतियाँ ठीक करके लिखी गई हैं। हर सुधार 🛠️ चिह्न से दिखाया गया है और आख़िर में पूरी सूची है।
प्रोग्राम में डेटा आने का रास्ता (डिफ़ॉल्ट: कीबोर्ड)
स्टैंडर्ड आउटपुट
Standard Output (stdout)
प्रोग्राम से डेटा बाहर जाने का रास्ता (डिफ़ॉल्ट: स्क्रीन)
रीडायरेक्शन
redirection
इनपुट/आउटपुट को कीबोर्ड-स्क्रीन की जगह फ़ाइल की ओर मोड़ना
फ़िल्टर
filter
जो टूल डेटा को लाइन-दर-लाइन पढ़े, प्रोसेस करे और वापस लिख दे
ग्लोबल स्कोप
global scope
किसी भी फ़ंक्शन के बाहर की जगह
ग्लोबल वेरिएबल
global variable
फ़ंक्शनों के बाहर बना वेरिएबल, जो सबको दिखता है
लूप
loop
कोड को बार-बार चलाने वाली संरचना
पॉइंटर अरिथमेटिक
pointer arithmetic
पॉइंटर में जोड़-घटाव करके एड्रेस निकालना
जेसन
JSON
JavaScript Object Notation, डेटा लिखने का एक फ़ॉर्मेट
वैलिडेट
validate
डेटा सही है या नहीं, यह जाँचना
🅰️ CHAPTER 2.5 — स्ट्रिंग्स (समापन)
1. पूल पज़ल (Pool Puzzle)
📄 PDF पेज 130 और 132 · किताब पेज 90 और 92
🏊 पेज 90: पहेली
लाउंज के लोगों ने ट्रैक सूची में खोज करने वाला कोड लिखना शुरू कर दिया था, पर, हाय राम! जिस काग़ज़ पर वे कोड लिख रहे थे, उसका कुछ हिस्सा पूल में गिर गया। क्या आप कोड के सही टुकड़े चुनकर खोज वाला फ़ंक्शन (search function) पूरा कर सकते हो? पूल की सफ़ाई हुए काफ़ी समय हो गया है, इसलिए सावधान: पूल के कुछ टुकड़े इस प्रोग्राम में ज़रूरी ही नहीं हो सकते।
📝 नोट: लोगों ने कुछ नए कोड के टुकड़े भी डाल दिए हैं जो उन्हें किसी किताब में मिले थे।
📝 नोट: पूल की हर चीज़ सिर्फ़ एक बार इस्तेमाल हो सकती है!
void find_track(char search_for[])
{
int i;
for (i = 0; i < 5; i++) {
if ( ( , ))
printf("Track %i: '%s'\n", , );
}
}
कोड की टिप्पणियाँ:
void का मतलब है कि यह फ़ंक्शन कोई मान नहीं लौटाएगा।
देखो, आप एक अलग फ़ंक्शन बना रहे हो। शायद जब आप main() फ़ंक्शन लिखोगे, तो वह इसे बुलाएगा।
यह for लूप (for loop) है। इसे हम थोड़ी देर में विस्तार से देखेंगे, अभी बस इतना जानो कि यह कोड के इस टुकड़े को पाँच बार चलाएगा।
if में आप जाँच रहे हो कि क्या ट्रैक नाम में खोजा गया शब्द मौजूद है।
अगर ट्रैक नाम खोज से मेल खाता है, तो आप उसे यहाँ दिखाओगे (display)।
printf में दो मान छपेंगे: एक पूर्णांक (integer) होगा और दूसरा स्ट्रिंग।
🏊 पूल में पड़े टुकड़े:
strstr
"Sinatra"
tracks[i]
search_for
way
i
tracks[i]
my
✅ पेज 92: हल (Pool Puzzle Solution)
void find_track(char search_for[])
{
int i;
for (i = 0; i < 5; i++) {
if (strstr(tracks[i], search_for))
printf("Track %i: '%s'\n", i, tracks[i]);
}
}
इस्तेमाल हुए टुकड़े:strstr, tracks[i] (दो बार, दो अलग जगह), search_for, i
बेकार (decoy) टुकड़े:"Sinatra", way, my
कैसे काम करता है:strstr(tracks[i], search_for) देखता है कि i नंबर वाले ट्रैक में खोजा गया टेक्स्ट मौजूद है या नहीं। अगर मौजूद है, तो strstr एड्रेस लौटाता है (जो true माना जाता है), और printf ट्रैक का नंबर i और उसका नाम tracks[i] छापता है।
2. कंपाइलर बनो (BE the Compiler)
📄 PDF पेज 131 और 133 · किताब पेज 91 और 93
🧠 पेज 91: पहेली
जूकबॉक्स प्रोग्राम को एक main() फ़ंक्शन चाहिए जो यूज़र से इनपुट पढ़े और सामने वाले पेज पर बने find_track() फ़ंक्शन को बुलाए। आपका काम है कि आप ख़ुद कंपाइलर (compiler) बनकर बताओ कि नीचे दिए main() फ़ंक्शनों में से कौन-सा जूकबॉक्स प्रोग्राम के लिए सही है।
find_track() को खोज वाला शब्द दिए बिना बुलाया जा रहा है।
B
यह वर्ज़न ऐरे की पूरी लंबाई इस्तेमाल नहीं कर रहा। कोडर ने लंबाई में से एक घटा दिया है, जैसा आप scanf() के साथ करते। (fgets() में ऐसा करने की ज़रूरत नहीं, क्योंकि उसका साइज़ \0 मिलाकर होता है।)
C
✅ यही सही main() फ़ंक्शन है।
D
यह वर्ज़न scanf() इस्तेमाल कर रहा है, और किताब के अनुसार यह यूज़र को ऐरे में 81 अक्षर तक डालने देगा।
🛠️ टिप्पणी (विकल्प D पर):scanf() का पहला आर्गुमेंट फ़ॉर्मेट स्ट्रिंग होता है, इसलिए scanf(search_for, 80, stdin) जैसा कोड वैसे भी सही नहीं है। fgets() की जगह scanf() इस्तेमाल करना हो, तो सही रूप scanf("%79s", search_for); होता, पर तब स्पेस वाले शब्द नहीं पढ़े जाते।
3. कोड रिव्यू (Code Review)
📄 PDF पेज 134 · किताब पेज 94
चलो कोड को एक साथ जोड़ते हैं और देखते हैं कि अब तक हमारे पास क्या-क्या है:
#include <stdio.h>
#include <string.h>
char tracks[][80] = {
"I left my heart in Harvard Med School",
"Newark, Newark - a wonderful town",
"Dancing with a Dork",
"From here to maternity",
"The girl from Iwo Jima",
};
void find_track(char search_for[])
{
int i;
for (i = 0; i < 5; i++) {
if (strstr(tracks[i], search_for))
printf("Track %i: '%s'\n", i, tracks[i]);
}
}
int main()
{
char search_for[80];
printf("Search for: ");
fgets(search_for, 80, stdin);
find_track(search_for);
return 0;
}
📝 हर हिस्से की व्याख्या
हिस्सा
मतलब
#include <stdio.h>
printf() और fgets() के लिए stdio.h अब भी चाहिए।
#include <string.h>
आपको string.h हेडर भी चाहिए, ताकि strstr() फ़ंक्शन से खोज कर सको।
char tracks[][80]
tracks ऐरे को main() और find_track() फ़ंक्शनों के बाहर रखोगे, ताकि ट्रैक प्रोग्राम में हर जगह इस्तेमाल हो सकें।
void find_track(...)
यह आपका नया find_track() फ़ंक्शन है। इसे main() से बुलाने से पहले यहाँ घोषित (declare) करना होगा।
i++
इसका मतलब है i का मान 1 बढ़ाओ।
if (strstr(...)) वाला कोड
यह सारे मेल खाते ट्रैक दिखाएगा।
int main()
यह आपका main() फ़ंक्शन है, जो प्रोग्राम का शुरुआती बिंदु (starting point) है।
fgets(search_for, 80, stdin)
आप यहाँ खोजने का टेक्स्ट माँग रहे हो।
find_track(search_for)
अब आप अपना नया find_track() फ़ंक्शन बुलाते हो और मेल खाते ट्रैक दिखाते हो।
🛠️ सुधार: किताब की टिप्पणी में लिखा है "printf() और scanf() के लिए stdio.h चाहिए।" इस प्रोग्राम में scanf() है ही नहीं। यहाँ printf() और fgets() इस्तेमाल हो रहे हैं, इसलिए ऊपर वैसा ही लिखा गया है।
🧱 कोड इसी क्रम में क्यों जोड़ना चाहिए?
कोड को इसी क्रम में जोड़ना ज़रूरी है:
हेडर सबसे ऊपर शामिल किए जाते हैं, ताकि आपका कोड कंपाइल करने से पहले कंपाइलर के पास सारे सही फ़ंक्शन हों।
फिर आप tracks को परिभाषित करते हो, फ़ंक्शन लिखने से पहले। इसे tracks ऐरे को ग्लोबल स्कोप (global scope) में रखना कहते हैं।
ग्लोबल वेरिएबल वह है जो किसी ख़ास फ़ंक्शन के बाहर रहता है। tracks जैसे ग्लोबल वेरिएबल प्रोग्राम के सभी फ़ंक्शनों को उपलब्ध होते हैं।
आख़िर में फ़ंक्शन आते हैं: पहले find_track(), फिर main()। find_track() फ़ंक्शन को main() से बुलाने से पहले आना चाहिए।
4. टेस्ट ड्राइव (Test Drive)
📄 PDF पेज 135 · किताब पेज 95
अब टर्मिनल (terminal) चालू करने और देखने का समय है कि कोड चलता है या नहीं।
File Edit Window Help string.h
> gcc text_search.c -o text_search && ./text_search
Search for: town
Track 1: 'Newark, Newark - a wonderful town'
>
और बढ़िया ख़बर यह है कि प्रोग्राम चल गया!
भले ही यह प्रोग्राम अब तक के लिखे किसी भी कोड से थोड़ा लंबा है, यह असल में बहुत ज़्यादा काम कर रहा है। यह स्ट्रिंग्स का ऐरे बनाता है और फिर स्ट्रिंग लाइब्रेरी की मदद से उन सबमें खोजकर वह म्यूज़िक ट्रैक ढूँढ लेता है जो यूज़र चाहती थी।
💬 कॉमिक के बोल: "अरे वाह! उस कोड ने तो धूम मचा दी। बार में बैठे लोग Sinatra की पूरी अच्छाई पर झूम रहे हैं!"
🤓 गीक बिट्स (Geek Bits)
string.h में उपलब्ध फ़ंक्शनों के बारे में और जानकारी के लिए देखें: http://tinyurl.com/82acwue
अगर आप Mac या Linux मशीन इस्तेमाल कर रहे हो, तो हर string.h फ़ंक्शन (जैसे strstr()) के बारे में और जानने के लिए टाइप करो:
man strstr
5. सवाल-जवाब और बुलेट पॉइंट
📄 PDF पेज 136 · किताब पेज 96
❓ कोई सवाल बेवकूफ़ाना नहीं होता (There are no Dumb Questions)
सवाल: ट्रैकों की सूची tracks[][80] के रूप में क्यों परिभाषित की गई? tracks[5][80] क्यों नहीं?
जवाब: आप ऐसे भी परिभाषित कर सकते थे, पर कंपाइलर ख़ुद देख लेता है कि सूची में पाँच चीज़ें हैं, इसलिए आप [5] छोड़कर बस [] लिख सकते हो।
सवाल: तो फिर हम tracks[][] क्यों नहीं लिख सकते?
जवाब: ट्रैक नाम सब अलग-अलग लंबाई के हैं, इसलिए आपको कंपाइलर को बताना होगा कि सबसे बड़े नाम के लिए भी काफ़ी जगह दे।
सवाल: क्या इसका मतलब है कि tracks ऐरे की हर स्ट्रिंग 80 अक्षर की है?
जवाब: प्रोग्राम हर स्ट्रिंग के लिए 80 अक्षर की जगह देगा, भले ही उनमें से हर एक उससे बहुत छोटी हो।
सवाल: तो tracks ऐरे मेमोरी में 5 × 80 = 400 अक्षरों की जगह लेता है?
जवाब: हाँ।
सवाल: अगर मैं string.h जैसी हेडर फ़ाइल शामिल करना भूल जाऊँ तो क्या होगा?
जवाब: कुछ हेडर फ़ाइलों के लिए कंपाइलर चेतावनी (warning) देगा और फिर भी उन्हें शामिल कर लेगा। दूसरी हेडर फ़ाइलों के लिए कंपाइलर सीधे कंपाइलर एरर दे देगा।
सवाल: हमने tracks ऐरे की परिभाषा फ़ंक्शनों के बाहर क्यों रखी?
जवाब: हमने उसे ग्लोबल स्कोप में रखा। ग्लोबल वेरिएबल प्रोग्राम के सारे फ़ंक्शन इस्तेमाल कर सकते हैं।
सवाल: अब जब हमने दो फ़ंक्शन बना लिए, तो कंप्यूटर को कैसे पता चलता है कि कौन-सा पहले चलाना है?
जवाब: प्रोग्राम हमेशा main() फ़ंक्शन को सबसे पहले चलाएगा।
सवाल: मुझे find_track() फ़ंक्शन main() से पहले क्यों रखना पड़ता है?
जवाब: C को किसी फ़ंक्शन को बुलाए जाने से पहले यह पता होना चाहिए कि वह फ़ंक्शन कौन-से पैरामीटर (parameter) लेता है और उसका रिटर्न टाइप (return type) क्या है।
सवाल: अगर मैं फ़ंक्शनों को किसी दूसरे क्रम में रखूँ तो क्या होगा?
जवाब: तब आपको कुछ चेतावनियाँ (warnings) मिलेंगी।
🔍 स्पष्टीकरण: यह किताब 2012 की है। कुछ नए कंपाइलर (जैसे GCC 14) फ़ंक्शन को घोषित किए बिना बुलाने पर चेतावनी की जगह सीधे एरर देते हैं। इसलिए सुरक्षित तरीक़ा वही है: पहले find_track(), फिर main()।
📌 बुलेट पॉइंट (Bullet Points)
आप char strings[...][...] से ऐरे का ऐरे बना सकते हो।
पहले ब्रैकेट बाहरी ऐरे तक पहुँचने के लिए इस्तेमाल होते हैं।
दूसरे ब्रैकेट हर भीतरी ऐरे के ब्योरे तक पहुँचने के लिए इस्तेमाल होते हैं।
string.h हेडर फ़ाइल आपको C स्टैंडर्ड लाइब्रेरी के स्ट्रिंग पर काम करने वाले फ़ंक्शनों तक पहुँच देती है।
आप C प्रोग्राम में कई फ़ंक्शन बना सकते हो, पर कंप्यूटर हमेशा main() पहले चलाएगा।
6. कोड मैग्नेट (Code Magnets)
📄 PDF पेज 137–138 · किताब पेज 97–98
🧲 पेज 97: पहेली
लोग एक गेम के लिए नया कोड बना रहे हैं। उन्होंने एक फ़ंक्शन बनाया है जो स्क्रीन पर स्ट्रिंग को उल्टा (पीछे से आगे) दिखाएगा। दुर्भाग्य से फ़्रिज के कुछ चुंबक (magnets) अपनी जगह से हट गए हैं। क्या आप कोड को दोबारा जोड़ने में उनकी मदद कर सकते हो?
void print_reverse(char *s)
{
size_t len = strlen(s);
char *t = + - 1;
while ( >= ) {
printf("%c", *t);
t = - ;
}
puts("");
}
टिप्पणियाँ:
size_t बस एक पूर्णांक है जो चीज़ों के साइज़ स्टोर करने के काम आता है।
strlen(s) स्ट्रिंग की लंबाई निकालता है, जैसे strlen("ABC") == 3।
🧲 बिखरे हुए चुंबक:len · s · t · - · 1 · s · t
✅ पेज 98: हल (Code Magnets Solution)
void print_reverse(char *s)
{
size_t len = strlen(s);
char *t = s + len - 1;
while (t >= s) {
printf("%c", *t);
t = t - 1;
}
puts("");
}
🧠 पॉइंटर अरिथमेटिक (pointer arithmetic): इस तरह एड्रेसों की गणना करना "पॉइंटर अरिथमेटिक" कहलाता है।
🔍 यह कोड कैसे काम करता है? ("ABC" के उदाहरण से)
चरण
क्या होता है
1
len = strlen(s) → len = 3
2
t = s + len - 1 → tआख़िरी अक्षर 'C' की ओर इशारा करता है (s से 2 जगह आगे)
3
while (t >= s) → जब तक t स्ट्रिंग की शुरुआत से पीछे न चला जाए, लूप चलता है
4
printf("%c", *t) → t जिस अक्षर की ओर इशारा करता है उसे छापो: C, फिर B, फिर A
5
t = t - 1 → पॉइंटर को एक अक्षर पीछे खिसकाओ
नतीजा: CBA
7. ऐरे का ऐरे बनाम पॉइंटर का ऐरे
📄 PDF पेज 138 · किताब पेज 98
🆚 Array of arrays vs. array of pointers
आपने देखा कि स्ट्रिंग्स का क्रम (sequence) स्टोर करने के लिए ऐरे का ऐरे कैसे इस्तेमाल होता है। पर एक और विकल्प है: पॉइंटर का ऐरे (array of pointers)। पॉइंटर का ऐरे असल में वही है जैसा नाम से लगता है: मेमोरी एड्रेसों की सूची जो एक ऐरे में स्टोर हो। अगर आपको स्ट्रिंग लिटरल की सूची जल्दी बनानी हो, तो यह बहुत काम का है:
📝 किताब में कोड दो हिस्सों (Across / Down) में छपा है और उसमें कोई // टिप्पणी नहीं है। ऊपर एक साथ जोड़कर लिखा गया है, और सुविधा के लिए // आड़ा / खड़ा नंबर टिप्पणी के रूप में जोड़े गए हैं।
✅ पेज 100: हल (C-Cross Solution)
juices[] के इंडेक्स:
इंडेक्स
0
1
2
3
4
5
6
7
8
9
10
फल
dragonfruit
waterberry
sharonfruit
uglifruit
rumberry
kiwifruit
mulberry
strawberry
blueberry
blackberry
starfruit
बीच की अदला-बदली (swap):
a = juices[2]; → a = sharonfruit
juices[2] = juices[8]; → juices[2] = blueberry
juices[8] = a; → juices[8] = sharonfruit
बाद में juices[1] = juices[3]; → juices[1] = uglifruit
🎉 Chapter 2.5 पूरा! आपने Chapter 2.5 पूरा कर लिया है, और अब अपने टूलबॉक्स (toolbox) में स्ट्रिंग्स जोड़ लिए हैं। किताब के सभी टूल-टिप्स की पूरी सूची के लिए परिशिष्ट ii (Appendix ii) देखें।
टूल (Tool)
मतलब
स्ट्रिंग्स का ऐरे
असल में ऐरे का ऐरे है।
char strings[...][...]
इससे आप ऐरे का ऐरे बनाते हो।
string.h हेडर
इसमें उपयोगी स्ट्रिंग फ़ंक्शन हैं।
strcmp()
दो स्ट्रिंग्स की तुलना करता है।
strstr(a, b)
स्ट्रिंग a में स्ट्रिंग b का एड्रेस लौटाता है।
strchr()
स्ट्रिंग के अंदर किसी अक्षर की जगह ढूँढता है।
strcat()
दो स्ट्रिंग्स को जोड़ता (concatenate) है।
strlen()
स्ट्रिंग की लंबाई ढूँढता है।
strcpy()
एक स्ट्रिंग को दूसरी में कॉपी करता है।
(PDF पेज 142 किताब में ख़ाली है।)
🅱️ CHAPTER 3 — छोटे टूल बनाना (Creating Small Tools)
10. Chapter 3: एक काम करो, और उसे अच्छे से करो
📄 PDF पेज 143 · किताब पेज 103
🛠️ Do one thing and do it well
सब कुछ सही काम के लिए सही टूल (tool) चुनने का खेल है…
हर ऑपरेटिंग सिस्टम में छोटे टूल (small tools) होते हैं। C में लिखे छोटे टूल ख़ास, छोटे काम करते हैं, जैसे फ़ाइलें पढ़ना और लिखना, या डेटा को छानना (filter करना)। अगर आपको और जटिल काम करने हों, तो आप कई टूल को आपस में जोड़ भी सकते हो।
पर ये छोटे टूल बनते कैसे हैं? इस अध्याय में आप छोटे टूल बनाने के बुनियादी हिस्से देखोगे। आप सीखोगे कि:
कमांड-लाइन ऑप्शन (command-line options) कैसे सँभालते हैं,
सूचना की धाराओं (streams) को कैसे सँभालते हैं,
और रीडायरेक्शन (redirection) क्या है।
यानी आप बहुत जल्दी टूल बनाने में माहिर हो जाओगे।
11. छोटे टूल बड़ी समस्याएँ सुलझाते हैं (Small tools can solve big problems)
📄 PDF पेज 144 · किताब पेज 104
💡 छोटा टूल (small tool): एक C प्रोग्राम जो एक काम करता है और उसे अच्छे से करता है।
यह स्क्रीन पर किसी फ़ाइल का कंटेंट दिखा सकता है या कंप्यूटर पर चल रही प्रोसेसें (processes) सूचीबद्ध कर सकता है। या वह किसी फ़ाइल की पहली 10 लाइनें दिखा सकता है या उसे प्रिंटर पर भेज सकता है। ज़्यादातर ऑपरेटिंग सिस्टम में छोटे टूलों का पूरा सेट आता है जिन्हें आप कमांड प्रॉम्प्ट (command prompt) या टर्मिनल (terminal) से चला सकते हो। कभी-कभी, जब आपके सामने कोई बड़ी समस्या हो, तो आप उसे छोटी-छोटी समस्याओं की शृंखला में तोड़ सकते हो, और फिर हर एक के लिए छोटे टूल लिख सकते हो।
💬 Linux जैसे ऑपरेटिंग सिस्टम सैकड़ों-सैकड़ों छोटे टूलों से मिलकर बने हैं।
🚴 समस्या: साइकिल सवार का GPS डेटा
💬 "किसी ने मेरे लिए एक मैप वेब एप्लिकेशन (map web application) लिखा है, और मैं अपना रूट डेटा उसके साथ प्रकाशित करना चाहता हूँ। दिक़्क़त यह है कि मेरे GPS से आने वाले डेटा का फ़ॉर्मेट ग़लत है।"
साइकिल सवार के GPS का डेटा (यह कॉमा से अलग किया गया फ़ॉर्मेट (comma-separated format) है):
🎯 अगर आपके प्रोग्राम के एक छोटे हिस्से को डेटा को एक फ़ॉर्मेट से दूसरे में बदलना हो, तो यही छोटे टूल के लिए बिल्कुल सही काम है।
12. पॉकेट कोड (Pocket Code)
📄 PDF पेज 145–146 · किताब पेज 105–106
🎒 पेज 105: पहेली
अरे, लंबी सवारी पर कोड का प्रिंटआउट लेकर कौन नहीं गया, और बाद में पाया कि वह जल्दी ही… पढ़ने लायक़ नहीं रहा? हम सबके साथ ऐसा होता है, है ना? पर थोड़ा सोचो तो तुम कोड का मूल वर्ज़न दोबारा जोड़ने में कामयाब हो जाओगे।
यह प्रोग्राम कमांड लाइन से कॉमा-अलग डेटा पढ़ सकता है और फिर उसे JSON फ़ॉर्मेट में दिखाता है। देखो, क्या तुम पता लगा सकते हो कि ग़ायब कोड क्या है।
#include <stdio.h>
int main()
{
float latitude;
float longitude;
char info[80];
int started = ;
puts("data=[");
while (scanf("%f,%f,%79[^\n]", , , ) == 3) {
if (started)
printf(",\n");
else
started = ;
printf("{latitude: %f, longitude: %f, info: '%s'}", , , );
}
puts("\n]");
return 0;
}
किताब की टिप्पणियाँ:
हम एक से ज़्यादा जानकारी डालने के लिए scanf() इस्तेमाल कर रहे हैं।
scanf() फ़ंक्शन उतने मानों की संख्या लौटाता है जितने वह पढ़ पाया।
ये मान क्या होंगे? याद रखो: scanf()हमेशा पॉइंटर इस्तेमाल करता है।
%79[^\n] का मतलब है: "मुझे लाइन के अंत तक का हर अक्षर दे दो।"
started को कैसे सेट करना है, इसमें सावधानी रखो।
छापने के लिए कौन-से मान चाहिए?
✅ पेज 106: हल (Pocket Code Solution)
#include <stdio.h>
int main()
{
float latitude;
float longitude;
char info[80];
int started = 0;
puts("data=[");
while (scanf("%f,%f,%79[^\n]", &latitude, &longitude, info) == 3) {
if (started)
printf(",\n");
else
started = 1;
printf("{latitude: %f, longitude: %f, info: '%s'}", latitude, longitude, info);
}
puts("\n]");
return 0;
}
किताब की टिप्पणियाँ:
जगह
मतलब
started = 0
हमें started को 0 से शुरू करना है, जिसका मतलब false है।
&latitude, &longitude
क्या तुम्हें संख्या वाले वेरिएबलों पर & याद रहा? scanf() को पॉइंटर चाहिए।
info पर & क्यों नहीं
info पहले से ऐरे है, और ऐरे वेरिएबल पॉइंटर की तरह काम करता है।
if (started) printf(",\n")
आप कॉमा तभी दिखाओगे जब आप पिछली लाइन पहले ही दिखा चुके हो।
started = 1
लूप शुरू होने के बाद आप started को 1 (true) पर सेट कर सकते हो।
printf में & नहीं
यहाँ & की ज़रूरत नहीं है, क्योंकि printf() संख्याओं के मान इस्तेमाल कर रहा है, एड्रेस नहीं।
🔍 %f,%f,%79[^\n] का मतलब
हिस्सा
मतलब
%f
एक दशमलव संख्या पढ़ो (अक्षांश)
,
फिर एक कॉमा
%f
एक और दशमलव संख्या पढ़ो (देशांतर)
,
फिर एक कॉमा
%79[^\n]
लाइन के अंत तक के अधिकतम 79 अक्षर पढ़ो (जानकारी)
== 3 इसलिए, क्योंकि scanf() उतने मान लौटाता है जितने वह पढ़ सका। तीनों मान पढ़े जाएँ तो लूप चलता रहता है।
13. टेस्ट ड्राइव: इनपुट और आउटपुट गड्डमड्ड
📄 PDF पेज 147 · किताब पेज 107
तो जब आप यह कोड कंपाइल करके चलाओगे तो क्या होगा? यह करेगा क्या?
आख़िर में प्रोग्राम रोकने के लिए आपको Ctrl-D दबाना पड़ता है।
प्रोग्राम आपको कीबोर्ड से GPS डेटा डालने देता है और फिर JSON-फ़ॉर्मेट वाला डेटा स्क्रीन पर दिखाता है। समस्या यह है कि इनपुट और आउटपुट सब आपस में मिले हुए हैं। साथ ही, बहुत ज़्यादा डेटा है। अगर आप छोटा टूल लिख रहे हो, तो आप डेटा हाथ से टाइप नहीं करना चाहते, आप बड़ी मात्रा का डेटा फ़ाइल पढ़कर लेना चाहते हो।
और, JSON डेटा इस्तेमाल कैसे होगा? स्क्रीन पर तो वह शायद ही किसी काम का है।
तो क्या प्रोग्राम ठीक चल रहा है? क्या वह सही चीज़ कर रहा है? क्या आपको कोड बदलना पड़ेगा?
💬 "हमें आउटपुट स्क्रीन पर नहीं चाहिए। हमें उसे फ़ाइल में चाहिए ताकि हम उसे मैपिंग एप्लिकेशन के साथ इस्तेमाल कर सकें। रुको, मैं दिखाता हूँ…"
1️⃣ बाइक के GPS से डेटा डाउनलोड करो।
यह gpsdata.csv नाम की फ़ाइल बनाता है, जिसमें हर जगह के लिए डेटा की एक लाइन होती है।
📝 यह वह GPS यूनिट है जिससे बाइक की जगह ट्रैक होती है।
📝 डेटा इसी फ़ाइल में डाउनलोड होता है।
2️⃣ geo2json टूल को gpsdata.csv का कंटेंट लाइन-दर-लाइन पढ़ना है…
📝 यह हमारा geo2json टूल है। यह फ़ाइल पढ़ रहा है।
3️⃣ …और फिर उस डेटा को JSON फ़ॉर्मेट में output.json नाम की फ़ाइल में लिखना है।
📝 आपका टूल इस फ़ाइल में डेटा लिखेगा।
4️⃣ जिस वेब पेज में मैप एप्लिकेशन है, वह output.json फ़ाइल को पढ़ता है।
यह सारी जगहों को मैप पर दिखाता है।
📝 मैपिंग एप्लिकेशन output.json से डेटा पढ़कर उसे वेब पेज के अंदर नक़्शे पर दिखाता है।
15. पर आप फ़ाइलें इस्तेमाल नहीं कर रहे…
📄 PDF पेज 149 · किताब पेज 109
समस्या यह है कि फ़ाइलें पढ़ने-लिखने की जगह, आपका प्रोग्राम अभी कीबोर्ड से डेटा पढ़ रहा है और उसे डिस्प्ले (स्क्रीन) पर लिख रहा है।
कीबोर्ड ──▶ geo2json ──▶ स्क्रीन (डिस्प्ले)
📝 डेटा कीबोर्ड से पढ़ा जा रहा है।
📝 हमारा टूल डेटा को नए फ़ॉर्मेट में बदलता है।
📝 फिर डेटा डिस्प्ले पर भेजा जाता है, फ़ाइल में नहीं।
पर यह काफ़ी नहीं है। अगर डेटा पहले से कहीं किसी फ़ाइल में रखा है, तो यूज़र उसे पूरा हाथ से टाइप नहीं करना चाहेगा। और अगर JSON फ़ॉर्मेट वाला डेटा बस स्क्रीन पर दिखाया जा रहा है, तो वेब पेज के अंदर का मैप उसे पढ़ ही नहीं पाएगा।
आपको प्रोग्राम को फ़ाइलों के साथ चलाना होगा। पर कैसे? अगर आप कीबोर्ड और डिस्प्ले की जगह फ़ाइलें इस्तेमाल करना चाहते हो, तो आपको कौन-सा कोड बदलना पड़ेगा? क्या कोई कोड बदलना भी पड़ेगा?
💬 "क्या हमारे प्रोग्राम को कोड बदले बिना फ़ाइलें इस्तेमाल करवाने का कोई तरीक़ा है? दोबारा कंपाइल किए बिना भी?"
🤓 गीक बिट्स (Geek Bits): फ़िल्टर (Filters)
जो टूल डेटा को लाइन-दर-लाइन पढ़ते हैं, प्रोसेस करते हैं और फिर वापस लिख देते हैं, उन्हें फ़िल्टर (filters) कहते हैं। अगर आपके पास Unix मशीन है, या आपने Windows पर Cygwin इंस्टॉल किया है, तो आपके पास पहले से कुछ फ़िल्टर टूल इंस्टॉल हैं:
टूल
काम
head
फ़ाइल की पहली कुछ लाइनें दिखाता है।
tail
फ़ाइल के अंत की लाइनें दिखाता है।
sed
स्ट्रीम एडिटर (stream editor)। इससे आप टेक्स्ट को खोजकर बदलने जैसे काम कर सकते हो।
आगे आप देखोगे कि फ़िल्टरों को आपस में जोड़कर फ़िल्टर चेन (filter chains) कैसे बनाते हैं।
16. रीडायरेक्शन (Redirection)
📄 PDF पेज 150 · किताब पेज 110
🔀 आप रीडायरेक्शन इस्तेमाल कर सकते हो
आप कीबोर्ड से पढ़ने और डिस्प्ले पर लिखने के लिए scanf() और printf() इस्तेमाल कर रहे हो। पर सच यह है कि वे सीधे कीबोर्ड और डिस्प्ले से बात नहीं करते। इसके बजाय वे स्टैंडर्ड इनपुट (Standard Input) और स्टैंडर्ड आउटपुट (Standard Output) इस्तेमाल करते हैं। स्टैंडर्ड इनपुट और स्टैंडर्ड आउटपुट प्रोग्राम चलते समय ऑपरेटिंग सिस्टम बनाता है।
डेटा ──▶ [ Standard Input ] ──▶ प्रोग्राम ──▶ [ Standard Output ] ──▶ डेटा
📥 प्रोग्राम को डेटा स्टैंडर्ड इनपुट से मिलता है।
📤 प्रोग्राम डेटा स्टैंडर्ड आउटपुट से बाहर भेजता है।
डेटा कैसे अंदर आए और कैसे बाहर जाए, यह ऑपरेटिंग सिस्टम तय करता है। अगर आप प्रोग्राम को कमांड प्रॉम्प्ट या टर्मिनल से चलाते हो, तो ऑपरेटिंग सिस्टम कीबोर्ड की सारी कीस्ट्रोक (keystrokes) स्टैंडर्ड इनपुट में भेज देगा। और अगर ऑपरेटिंग सिस्टम स्टैंडर्ड आउटपुट से कोई डेटा पढ़ता है, तो डिफ़ॉल्ट रूप से वह डेटा डिस्प्ले पर भेज देगा।
scanf() और printf() फ़ंक्शनों को पता ही नहीं और उन्हें परवाह भी नहीं कि डेटा कहाँ से आ रहा है या कहाँ जा रहा है। वे बस स्टैंडर्ड इनपुट और स्टैंडर्ड आउटपुट को पढ़ते-लिखते हैं।
अब यह थोड़ा जटिल लग सकता है। आख़िर प्रोग्राम को सीधे कीबोर्ड और स्क्रीन से बात क्यों न करने दें? क्या वह ज़्यादा आसान नहीं होता?
ऑपरेटिंग सिस्टम प्रोग्रामों से स्टैंडर्ड इनपुट और स्टैंडर्ड आउटपुट के ज़रिए बात करते हैं, इसकी एक बहुत अच्छी वजह है:
🔑 आप स्टैंडर्ड इनपुट और स्टैंडर्ड आउटपुट को रीडायरेक्ट (redirect) कर सकते हो, ताकि वे डेटा कहीं और पढ़ें-लिखें, जैसे फ़ाइलों से और फ़ाइलों में।
17. स्टैंडर्ड इनपुट को < से रीडायरेक्ट करो
📄 PDF पेज 151 · किताब पेज 111
कीबोर्ड पर डेटा डालने की जगह, आप फ़ाइल से डेटा पढ़ने के लिए < ऑपरेटर इस्तेमाल कर सकते हो।
यह वह फ़ाइल (gpsdata.csv) है जिसमें GPS डिवाइस का डेटा है:
< ऑपरेटिंग सिस्टम से कह रहा है कि फ़ाइल का डेटा प्रोग्राम के स्टैंडर्ड इनपुट में भेज दो।
आपको GPS डेटा टाइप नहीं करना पड़ता, इसलिए वह आउटपुट के साथ गड्डमड्ड नहीं होता।
अब आपको स्क्रीन पर बस प्रोग्राम से आता JSON डेटा दिखता है।
gpsdata.csv ──(<)──▶ geo2json
🧠 निचोड़:< ऑपरेटर ऑपरेटिंग सिस्टम को बताता है कि प्रोग्राम का स्टैंडर्ड इनपुट कीबोर्ड की जगह gpsdata.csv फ़ाइल से जुड़ना चाहिए। इस तरह आप प्रोग्राम को फ़ाइल से डेटा भेज सकते हो। अब बस उसके आउटपुट को रीडायरेक्ट करना बाक़ी है।
18. स्टैंडर्ड आउटपुट को > से रीडायरेक्ट करो
📄 PDF पेज 152 · किताब पेज 112
स्टैंडर्ड आउटपुट को फ़ाइल की ओर रीडायरेक्ट करने के लिए आपको > ऑपरेटर इस्तेमाल करना होगा:
अब देखने का समय है कि आपकी बनाई नई डेटा फ़ाइल को नक़्शे पर जगहें दिखाने के लिए इस्तेमाल किया जा सकता है या नहीं। आप मैपिंग प्रोग्राम वाले वेब पेज की एक कॉपी लेकर उसे output.json फ़ाइल वाले उसी फ़ोल्डर में रखोगे। फिर आपको उस वेब पेज को ब्राउज़र में खोलना है।
⚠️ ऐसा करो! (Do this!)
वेब पेज यहाँ से डाउनलोड करो: http://oreillyhfc.appspot.com/map.html
gpsapp/
├── map.html ← यह वह वेब पेज है जिसमें नक़्शा है।
└── output.json ← यह वह फ़ाइल है जो हमारे प्रोग्राम ने बनाई।
नक़्शा चल गया! वेब पेज के अंदर का नक़्शा आउटपुट फ़ाइल से डेटा पढ़ पाता है।
💬 "बढ़िया! अब मैं अपनी यात्राएँ वेब पर प्रकाशित कर सकता हूँ!"
20. ख़राब डेटा की समस्या (Bad data)
📄 PDF पेज 154 · किताब पेज 114
आपका प्रोग्राम GPS डेटा पढ़कर उसे मैपिंग एप्लिकेशन के लिए सही ढंग से फ़ॉर्मेट कर पा रहा है। पर कुछ दिनों बाद एक समस्या आ जाती है।
💬 "मैंने सवारी के दौरान GPS यूनिट दो बार गिरा दी, और अब मैप दिखता ही नहीं।"
तो हुआ क्या? समस्या यह है कि GPS डेटा फ़ाइल में कुछ ख़राब डेटा (bad data) था:
📍 दूसरी लाइन में दशमलव बिंदु (decimal point) ग़लत जगह पर है: 423.63182 होना चाहिए था 42.363182।
पर geo2json प्रोग्राम जो डेटा पढ़ता है, उसकी कोई जाँच नहीं करता। वह बस संख्याओं को दोबारा फ़ॉर्मेट करके आउटपुट में भेज देता है।
यह तो आसानी से ठीक हो जाना चाहिए। आपको डेटा को वैलिडेट (validate) करना होगा, यानी जाँचना होगा कि वह सही है।
🌍 एक अतिरिक्त जानकारी: अक्षांश (latitude) का मान −90 से +90 के बीच ही हो सकता है। इसीलिए 423.63182 साफ़ तौर पर ग़लत है।
21. 🛠️ किताब की गलतियाँ और सुधार
इस हिस्से (पेज 130–154) में जो गलतियाँ और कमियाँ मिलीं, उन्हें ऊपर ठीक करके लिखा गया है:
#
PDF पेज (किताब पेज)
किताब में
सही रूप / टिप्पणी
1
134 (94)
टिप्पणी: "printf() और scanf() के लिए stdio.h चाहिए"
इस प्रोग्राम में scanf() है ही नहीं। यहाँ printf() और fgets() इस्तेमाल होते हैं, इसलिए यही लिखा गया।
2
133 (93)
विकल्प D: scanf(search_for, 80, stdin) को "81 अक्षर डालने देगा" बताया गया
scanf() का पहला आर्गुमेंट फ़ॉर्मेट स्ट्रिंग होता है, इसलिए यह कोड वैसे ही ग़लत है। टिप्पणी जोड़ी गई।
3
136 (96)
"फ़ंक्शन दूसरे क्रम में रखने पर बस चेतावनियाँ मिलेंगी"
नए कंपाइलरों (जैसे GCC 14) में यह एरर भी हो सकता है। स्पष्टीकरण जोड़ा गया।
4
139–140 (99–100)
क्रॉसवर्ड का कोड दो टुकड़ों में, बिना क्रम समझाए
कोड एक साथ जोड़कर और हर लाइन के जवाब के साथ समझाया गया। जवाब चित्र से भी मिलाए गए।
📌 ध्यान दें:find_track(), print_reverse(), geo2json का कोड, और रीडायरेक्शन के उदाहरण सही पाए गए। "ABC" पर print_reverse का CBA आउटपुट और क्रॉसवर्ड के सारे आठ जवाब ऊपर चरण-दर-चरण जाँचे गए हैं।
Chapter 3: छोटे टूल बनाना (Creating Small Tools) — जारी
📖 किताब:Head First C — David Griffiths & Dawn Griffiths (O'Reilly)
📄 हिस्सा: PDF पेज 155 से 179 (किताब के छपे पेज 115 से 139)
🎯 इस हिस्से में: डेटा की जाँच (validation) · स्टैंडर्ड एरर (Standard Error) · fprintf() · पाइप (pipe) · bermuda टूल · fopen() से अपनी डेटा स्ट्रीम बनाना
🛠️ सुधार: किताब की गलतियाँ ठीक करके लिखी गई हैं। हर सुधार 🛠️ चिह्न से दिखाया गया है और आख़िर में पूरी सूची है।
प्रोग्राम का दूसरा आउटपुट, सिर्फ़ एरर संदेशों के लिए
डेटा स्ट्रीम
data stream
डेटा के आने या जाने का रास्ता, फ़ाइल के पॉइंटर के रूप में
एग्ज़िट स्टेटस
exit status
प्रोग्राम ख़त्म होने पर लौटाई जाने वाली संख्या
पाइप
pipe (|)
एक प्रोग्राम के आउटपुट को दूसरे के इनपुट से जोड़ने वाला चिह्न
पाइपलाइन
pipeline
पाइप से जुड़े प्रोग्रामों की शृंखला
सूडोकोड
pseudocode
कोड का सरल भाषा में ख़ाका
मोड
mode
फ़ाइल खोलने का तरीक़ा: r पढ़ना, w लिखना, a जोड़ना
अपेंड
append
फ़ाइल के अंत में डेटा जोड़ना
प्रोसेस
process
मेमोरी में चल रहा प्रोग्राम
टूल
tool
एक छोटा प्रोग्राम जो एक ख़ास काम करता है
ग्लोबल / मैक्रो
global / macro
(देखें पेज 139 का सवाल-जवाब)
1. डेटा की जाँच का कोड जोड़ो
📄 PDF पेज 155–156 · किताब पेज 115–116
📝 पेज 115: काम
आपको geo2json प्रोग्राम में कुछ कोड जोड़ना है जो ख़राब अक्षांश (latitude) और देशांतर (longitude) मानों की जाँच करे। कुछ ख़ास जटिल नहीं चाहिए। अगर कोई अक्षांश या देशांतर अपेक्षित सीमा (range) से बाहर हो, तो बस एक एरर संदेश दिखाओ और प्रोग्राम को एरर स्टेटस 2 के साथ बंद कर दो।
📌 नियम:
अगर अक्षांश −90 से कम या 90 से ज़्यादा है, तो स्टेटस 2 के साथ एरर।
अगर देशांतर −180 से कम या 180 से ज़्यादा है, तो स्टेटस 2 के साथ एरर।
#include <stdio.h>
int main()
{
float latitude;
float longitude;
char info[80];
int started = 0;
puts("data=[");
while (scanf("%f,%f,%79[^\n]", &latitude, &longitude, info) == 3) {
if (started)
printf(",\n");
else
started = 1;
printf("{latitude: %f, longitude: %f, info: '%s'}", latitude, longitude, info);
}
puts("\n]");
return 0;
}
✅ पेज 116: हल
#include <stdio.h>
int main()
{
float latitude;
float longitude;
char info[80];
int started = 0;
puts("data=[");
while (scanf("%f,%f,%79[^\n]", &latitude, &longitude, info) == 3) {
if (started)
printf(",\n");
else
started = 1;
if ((latitude < -90.0) || (latitude > 90.0)) {
printf("Invalid latitude: %f\n", latitude);
return 2;
}
if ((longitude < -180.0) || (longitude > 180.0)) {
printf("Invalid longitude: %f\n", longitude);
return 2;
}
printf("{latitude: %f, longitude: %f, info: '%s'}", latitude, longitude, info);
}
puts("\n]");
return 0;
}
🛠️ सुधार: किताब में printf के भीतर की उद्धरण-चिह्न टेढ़ी (curly) छपी हैं (“Invalid latitude: %f\n”)। C के कोड में सीधे (straight) चिह्न " ही चलते हैं, टेढ़े चिह्न कंपाइल एरर देंगे। ऊपर सही रूप लिखा गया है।
किताब की टिप्पणियाँ:
ये लाइनें जाँचती हैं कि अक्षांश और देशांतर सही सीमा में हैं।
ये लाइनें सरल एरर संदेश दिखाती हैं।
return 2; की ये लाइनें main() फ़ंक्शन से एरर स्टेटस 2 के साथ बाहर निकल जाती हैं।
🔍 शर्त कैसे पढ़ें?
(latitude < -90.0) || (latitude > 90.0)
|| का मतलब है "या" (OR)। यानी: अक्षांश −90 से कम हो या 90 से ज़्यादा हो, तो वह सीमा से बाहर है।
2. टेस्ट ड्राइव: कोई एरर मैसेज नहीं?
📄 PDF पेज 157 · किताब पेज 117
तो अब आपके पास कोड तैयार है जो जाँचता है कि अक्षांश और देशांतर सीमा में हैं या नहीं। पर क्या यह हमारे प्रोग्राम को ख़राब डेटा सँभालने लायक़ बना देगा? देखते हैं।
कोड कंपाइल करो और फिर ख़राब डेटा को प्रोग्राम में चलाओ:
💬 "यह क्या है??? कोई एरर संदेश नहीं?" (किताब का मज़ाक: "WTF" मतलब "Welcome To Finland") · "और सारे पॉइंट कहाँ गए?"
हम्म… यह अजीब है। आपने एरर जाँचने वाला कोड जोड़ा, पर जब आप प्रोग्राम चलाते हो, तो ऐसा लगता है कुछ भी अलग नहीं हुआ। पर अब नक़्शे पर एक भी पॉइंट नहीं दिख रहा। यह क्या चक्कर है?
🤔 सोचो: कोड को ध्यान से पढ़ो। आपको क्या लगता है क्या हुआ? क्या कोड वही कर रहा है जो आपने कहा था? कोई एरर संदेश क्यों नहीं आया? मैपिंग प्रोग्राम को यह क्यों लगा कि पूरी output.json फ़ाइल ख़राब है?
3. कोड डीकंस्ट्रक्शन (Code DeConstruction)
📄 PDF पेज 158 · किताब पेज 118
मैपिंग प्रोग्राम output.json फ़ाइल की शिकायत कर रहा है, तो चलो उसे खोलकर देखते हैं कि अंदर क्या है:
फ़ाइल खोलते ही आप ठीक-ठीक देख सकते हो कि हुआ क्या। प्रोग्राम ने देखा कि कुछ डेटा में समस्या है, और वह तुरंत बंद हो गया। उसने और डेटा प्रोसेस नहीं किया और एक एरर संदेश आउटपुट किया। समस्या यह है कि आप स्टैंडर्ड आउटपुट को output.json में रीडायरेक्ट कर रहे थे, यानी आपने एरर संदेश भी रीडायरेक्ट कर दिया। इसलिए प्रोग्राम चुपचाप ख़त्म हो गया, और आपको कभी पता नहीं चला कि समस्या क्या थी।
अब, आप प्रोग्राम का एग्ज़िट स्टेटस (exit status) जाँच सकते थे, पर आप तो असल में एरर संदेश देखना चाहते हो।
❓ पर अगर आप आउटपुट रीडायरेक्ट कर रहे हो, तब भी एरर संदेश कैसे दिखाओगे?
अगर आपका प्रोग्राम डेटा में कोई समस्या पाता है, तो वह स्टेटस 2 के साथ बाहर निकलता है। पर प्रोग्राम ख़त्म होने के बाद आप वह एरर स्टेटस कैसे जाँचोगे? यह इस पर निर्भर है कि आप कौन-सा ऑपरेटिंग सिस्टम इस्तेमाल कर रहे हो।
Mac, Linux, कोई और Unix मशीन, या Windows पर Cygwin:
File Edit Window Help
$ echo $?
2
Windows का कमांड प्रॉम्प्ट:
File Edit Window Help
C:\> echo %ERRORLEVEL%
2
दोनों कमांड एक ही काम करते हैं: वे प्रोग्राम के ख़त्म होने पर लौटाई गई संख्या दिखाते हैं।
4. काश एरर के लिए कोई ख़ास आउटपुट होता
📄 PDF पेज 159 · किताब पेज 119
💬 "क्या ही अच्छा होता अगर एरर के लिए कोई अलग ख़ास आउटपुट होता, ताकि मुझे अपने एरर स्टैंडर्ड आउटपुट में मिलाने न पड़ते? पर मुझे पता है यह बस एक कल्पना है…"
(इस पेज पर बस यही संवाद है। अगला पेज बताता है कि यह कल्पना नहीं है।)
5. स्टैंडर्ड एरर (Standard Error) से मिलो
📄 PDF पेज 160 · किताब पेज 120
स्टैंडर्ड आउटपुट किसी प्रोग्राम से डेटा बाहर भेजने का डिफ़ॉल्ट तरीक़ा है। पर अगर कोई असाधारण बात हो जाए, जैसे कोई एरर? तब आप एरर संदेशों जैसी चीज़ों को आम आउटपुट से थोड़ा अलग तरीक़े से सँभालना चाहोगे।
इसीलिए स्टैंडर्ड एरर (Standard Error) बनाया गया था। स्टैंडर्ड एरर एक दूसरा आउटपुट है जो एरर संदेश भेजने के लिए बनाया गया।
👂👄 इंसान के दो कान और एक मुँह होता है, पर प्रोसेस (process) की बनावट थोड़ी अलग है। हर प्रोसेस का एक कान (स्टैंडर्ड इनपुट) और दो मुँह (स्टैंडर्ड आउटपुट और स्टैंडर्ड एरर) होते हैं।
इंसान
प्रोसेस
👂 कान
दो
एक: Standard Input (सिर्फ़ एक कान, दूसरा कान नहीं है)
👄 मुँह
एक (एक मुँह, कई इस्तेमाल)
दो: Standard Output और Standard Error
देखते हैं कि ऑपरेटिंग सिस्टम इन्हें कैसे सेट करता है।
6. डिफ़ॉल्ट रूप से स्टैंडर्ड एरर डिस्प्ले पर जाता है
📄 PDF पेज 161 · किताब पेज 121
याद है कि जब नई प्रोसेस बनती है, तो ऑपरेटिंग सिस्टम स्टैंडर्ड इनपुट को कीबोर्ड की ओर और स्टैंडर्ड आउटपुट को स्क्रीन की ओर मोड़ देता है? ठीक उसी समय ऑपरेटिंग सिस्टम स्टैंडर्ड एरर भी बनाता है, और स्टैंडर्ड आउटपुट की तरह स्टैंडर्ड एरर भी डिफ़ॉल्ट रूप से डिस्प्ले पर भेजा जाता है।
डिफ़ॉल्ट स्थिति:
कीबोर्ड ──▶ Standard Input ──▶ प्रोग्राम ──▶ Standard Output ──▶ डिस्प्ले
└──▶ Standard Error ──▶ डिस्प्ले
इसका मतलब यह है कि अगर कोई स्टैंडर्ड इनपुट और स्टैंडर्ड आउटपुट को फ़ाइलों की ओर रीडायरेक्ट कर दे, तब भी स्टैंडर्ड एरर डिस्प्ले पर डेटा भेजता रहेगा।
रीडायरेक्ट करने के बाद:
फ़ाइल ──▶ Standard Input ──▶ प्रोग्राम ──▶ Standard Output ──▶ फ़ाइल
└──▶ Standard Error ──▶ डिस्प्ले (अब भी)
और यह बहुत बढ़िया बात है, क्योंकि इसका मतलब है कि भले ही स्टैंडर्ड आउटपुट कहीं और रीडायरेक्ट हो गया हो, स्टैंडर्ड एरर पर भेजे गए संदेश डिफ़ॉल्ट रूप से स्क्रीन पर फिर भी दिखेंगे।
तो आप अपने छिपे हुए एरर संदेशों की समस्या को बस उन्हें स्टैंडर्ड एरर पर दिखाकर ठीक कर सकते हो।
❓ पर यह करें कैसे?
7. fprintf() डेटा स्ट्रीम में छापता है
📄 PDF पेज 162 · किताब पेज 122
आप देख चुके हो कि printf() फ़ंक्शन डेटा स्टैंडर्ड आउटपुट पर भेजता है। जो आपको पता नहीं था, वह यह है कि printf() फ़ंक्शन असल में fprintf() नाम के एक और सामान्य फ़ंक्शन का ही एक रूप है:
printf("I like Turtles!");
fprintf(stdout, "I like Turtles!");
📝 जब आप printf() बुलाते हो, तो वह असल में fprintf() को बुलाता है।
📝 ये दोनों कॉल बराबर (equivalent) हैं।
📝 पहला आर्गुमेंट stdout है: यह Standard Output डेटा स्ट्रीम है। यह बताता है कि डेटा कहाँ भेजना है।
📝 दूसरा आर्गुमेंट: यह वह डेटा है जो भेजा जाएगा।
fprintf() फ़ंक्शन आपको चुनने देता है कि टेक्स्ट कहाँ भेजना है। आप fprintf() से टेक्स्ट stdout (Standard Output) या stderr (Standard Error) पर भेज सकते हो।
❓ कोई सवाल बेवकूफ़ाना नहीं होता
सवाल:stdout और stderr हैं। क्या stdin भी है?
जवाब: हाँ, और जैसा आपने अंदाज़ा लगाया होगा, यह Standard Input को दर्शाता है।
सवाल: क्या मैं उसमें छाप सकता हूँ?
जवाब: नहीं, Standard Input में छापा नहीं जा सकता।
सवाल: क्या मैं उससे पढ़ सकता हूँ?
जवाब: हाँ, fscanf() से, जो scanf() जैसा ही है, पर इसमें आप डेटा स्ट्रीम बता सकते हो।
सवाल: तो क्या fscanf(stdin, ...) बिल्कुल scanf(...) जैसा ही है?
जवाब: हाँ, दोनों एक जैसे हैं। असल में, पर्दे के पीछे scanf(...) बस fscanf(stdin, ...) को ही बुलाता है।
सवाल: क्या मैं Standard Error को रीडायरेक्ट कर सकता हूँ?
जवाब: हाँ; >Standard Output को रीडायरेक्ट करता है। पर 2>Standard Error को रीडायरेक्ट करता है।
सवाल: तो मैं geo2json 2> errors.txt लिख सकता हूँ?
जवाब: हाँ।
8. कोड को fprintf() से अपडेट करो
📄 PDF पेज 163 · किताब पेज 123
बस कुछ छोटे बदलावों से आप अपने एरर संदेश स्टैंडर्ड एरर पर छपवा सकते हो।
#include <stdio.h>
int main()
{
float latitude;
float longitude;
char info[80];
int started = 0;
puts("data=[");
while (scanf("%f,%f,%79[^\n]", &latitude, &longitude, info) == 3) {
if (started)
printf(",\n");
else
started = 1;
if ((latitude < -90.0) || (latitude > 90.0)) {
fprintf(stderr, "Invalid latitude: %f\n", latitude);
return 2;
}
if ((longitude < -180.0) || (longitude > 180.0)) {
fprintf(stderr, "Invalid longitude: %f\n", longitude);
return 2;
}
printf("{latitude: %f, longitude: %f, info: '%s'}", latitude, longitude, info);
}
puts("\n]");
return 0;
}
🛠️ सुधार: किताब के पेज पर पुरानी (ग़लत) लाइनें कटी हुई छपी हैं, पर टेक्स्ट निकालने पर वे और नई लाइनें साथ-साथ दिखती हैं। ऊपर के कोड में सिर्फ़ अंतिम (सही) लाइनें रखी गई हैं। ध्यान दो: printf(stderr, ...) ग़लत है, क्योंकि printf() पहला आर्गुमेंट फ़ॉर्मेट स्ट्रिंग मानता है। stderr देना हो तो fprintf() ही चाहिए।
इसका मतलब है कि कोड अब ठीक पहले की तरह ही काम करेगा, सिवाय इसके कि एरर संदेश अब स्टैंडर्ड आउटपुट की जगह स्टैंडर्ड एरर पर दिखेंगे।
चलो कोड चलाकर देखते हैं।
9. टेस्ट ड्राइव और स्ट्रीम का सार
📄 PDF पेज 164 · किताब पेज 124
अगर आप प्रोग्राम को दोबारा कंपाइल करके ख़राब GPS डेटा फिर से उसमें चलाओ, तो यह होता है:
🛠️ सुधार: किताब में दूसरी लाइन में ./geo2json-page21 छपा है। कंपाइल किए गए प्रोग्राम का नाम geo2json है, इसलिए सही कमांड ./geo2json है।
यह बढ़िया है। इस बार, भले ही आप स्टैंडर्ड आउटपुट को output.json फ़ाइल में रीडायरेक्ट कर रहे हो, एरर संदेश अब भी स्क्रीन पर दिख रहा है।
स्टैंडर्ड एरर ठीक इसी मक़सद से बनाया गया था: एरर संदेशों को आम आउटपुट से अलग रखना। पर याद रखो: stderr और stdout दोनों बस आउटपुट स्ट्रीम हैं। और आपको इन्हें किसी भी चीज़ के लिए इस्तेमाल करने से कोई नहीं रोकता।
चलो अपनी नई Standard Input और Standard Error वाली महारत आज़माते हैं।
📊 स्ट्रीमों का सार (किताब की ओर से)
चीज़
क्या होता है
printf()
डेटा Standard Output पर भेजता है।
Standard Output
डिफ़ॉल्ट रूप से डिस्प्ले पर जाता है।
>
कमांड लाइन पर > से आप Standard Output को फ़ाइल में रीडायरेक्ट कर सकते हो।
scanf()
डेटा Standard Input से पढ़ता है।
Standard Input
डिफ़ॉल्ट रूप से कीबोर्ड से पढ़ता है।
<
कमांड लाइन पर < से आप Standard Input को फ़ाइल पढ़ने के लिए रीडायरेक्ट कर सकते हो।
Standard Error
एरर संदेश आउटपुट करने के लिए आरक्षित है।
2>
आप Standard Error को 2> से रीडायरेक्ट कर सकते हो।
10. टॉप सीक्रेट (Top Secret)
📄 PDF पेज 165–166 · किताब पेज 125–126
🕵️ पेज 125: पहेली
हमारे पास यह मानने की वजह है कि नीचे का प्रोग्राम गुप्त संदेश भेजने में इस्तेमाल हुआ है:
#include <stdio.h>
int main()
{
char word[10];
int i = 0;
while (scanf("%9s", word) == 1) {
i = i + 1;
if (i % 2)
fprintf(stdout, "%s\n", word);
else
fprintf(stderr, "%s\n", word);
}
return 0;
}
📝 i % 2 का मतलब है: "i को 2 से भाग देने पर जो शेषफल बचे।"
हमने secret.txt नाम की एक फ़ाइल और निर्देशों वाला काग़ज़ का टुकड़ा पकड़ा है:
secret.txt का कंटेंट:
THE BUY SUBMARINE
SIX WILL EGGS
SURFACE AND AT
SOME NINE MILK PM
आपका मिशन: दोनों गुप्त संदेशों को डिकोड करो। अपने जवाब नीचे लिखो।
Message 1
Message 2
✅ पेज 126: हल
Message 1 (message1.txt, Standard Output)
Message 2 (message2.txt, Standard Error)
THE
BUY
SUBMARINE
SIX
WILL
EGGS
SURFACE
AND
AT
SOME
NINE
MILK
PM
🧠 यह कैसे काम करता है?
प्रोग्राम फ़ाइल के शब्दों को एक-एक करके पढ़ता है, और एक गिनती i रखता है:
शब्द नंबर i
शब्द
i % 2
कहाँ गया
1
THE
1 (सच)
stdout → message1.txt
2
BUY
0 (झूठ)
stderr → message2.txt
3
SUBMARINE
1
stdout
4
SIX
0
stderr
5
WILL
1
stdout
6
EGGS
0
stderr
7
SURFACE
1
stdout
8
AND
0
stderr
9
AT
1
stdout
10
SOME
0
stderr
11
NINE
1
stdout
12
MILK
0
stderr
13
PM
1
stdout
पढ़ने पर:
संदेश 1:"THE SUBMARINE WILL SURFACE AT NINE PM" (पनडुब्बी रात नौ बजे सतह पर आएगी)
संदेश 2:"BUY SIX EGGS AND SOME MILK" (छह अंडे और थोड़ा दूध ख़रीद लो)
11. ऑपरेटिंग सिस्टम का इंटरव्यू (The Operating System Exposed)
📄 PDF पेज 167 · किताब पेज 127
🎤 इस हफ़्ते का इंटरव्यू: क्या ऑपरेटिंग सिस्टम मायने रखता है?
Head First: ऑपरेटिंग सिस्टम जी, हमें बहुत ख़ुशी है कि आपने आज हमारे लिए समय निकाला।
O/S: टाइम शेयरिंग (time sharing): यही तो मेरी ख़ासियत है।
Head First: आप गुमनामी की शर्त पर आने को तैयार हुए हैं, है ना?
O/S: पूछो मत, बताओ मत (Don't Ask/Don't Tell)। बस मुझे O/S बुलाओ।
Head First: क्या इससे फ़र्क़ पड़ता है कि आप किस तरह के O/S हैं?
O/S: बहुत-से लोग इस बात पर भिड़ जाते हैं कि कौन-सा ऑपरेटिंग सिस्टम इस्तेमाल करना चाहिए। पर सादे C प्रोग्रामों के लिए, हम सब ज़्यादातर एक जैसा बर्ताव करते हैं।
Head First: C स्टैंडर्ड लाइब्रेरी की वजह से?
O/S: हाँ, अगर आप C लिख रहे हो, तो बुनियादी चीज़ें हर जगह एक जैसी हैं। मैं हमेशा कहता हूँ, बत्ती बुझा दो तो हम सब एक जैसे ही हैं। समझ रहे हो न मैं क्या कह रहा हूँ?
Head First: ओह, बिल्कुल। तो आप प्रोग्रामों को मेमोरी में लोड करने के ज़िम्मेदार हो?
O/S: मैं उन्हें प्रोसेस (processes) में बदल देता हूँ, सही कहा।
Head First: यह तो ज़रूरी काम है?
O/S: मुझे तो ऐसा ही लगता है। आप किसी प्रोग्राम को यूँ ही मेमोरी में फेंककर उसे संघर्ष करने के लिए छोड़ नहीं सकते, है ना? बहुत सारी तैयारी होती है। मुझे प्रोग्रामों के लिए मेमोरी आवंटित (allocate) करनी होती है और उन्हें उनकी स्टैंडर्ड डेटा स्ट्रीम से जोड़ना होता है, ताकि वे डिस्प्ले और कीबोर्ड जैसी चीज़ें इस्तेमाल कर सकें।
Head First: जैसे आपने अभी geo2json प्रोग्राम के लिए किया?
O/S: वह तो सचमुच एक टूल है।
Head First: ओह, माफ़ कीजिए।
O/S: नहीं, मेरा मतलब है कि वह असल में एक टूल है: एक सीधा-सादा, टेक्स्ट-आधारित प्रोग्राम।
📝 अंग्रेज़ी में "tool" का एक मतलब "बेवकूफ़" भी होता है। इसीलिए Head First ने "माफ़ कीजिए" कहा, और O/S को सफ़ाई देनी पड़ी।
Head First: आह, समझा। और क्या आपका वास्ता बहुत-से टूलों से पड़ता है?
O/S: यही तो ज़िंदगी है, है ना? यह ऑपरेटिंग सिस्टम पर निर्भर है। Unix-जैसे सिस्टम काम निपटाने के लिए बहुत-से टूल इस्तेमाल करते हैं। Windows उन्हें कम इस्तेमाल करता है, पर वे वहाँ भी अहम हैं।
Head First: आपस में काम करने वाले छोटे टूल बनाना तो लगभग एक दर्शन (philosophy) है, है ना?
O/S: यह जीने का एक तरीक़ा है। कभी-कभी जब आपके पास कोई बड़ी समस्या हो, तो उसे सरल कामों के एक समूह में तोड़ना आसान हो सकता है।
Head First: फिर हर काम के लिए एक टूल लिखें?
O/S: बिल्कुल। फिर ऑपरेटिंग सिस्टम का इस्तेमाल करो, यानी मेरा, टूलों को आपस में जोड़ने के लिए।
Head First: क्या इस तरीक़े के कोई फ़ायदे हैं?
O/S: सबसे बड़ा फ़ायदा है सादगी (simplicity)। अगर आपके पास छोटे प्रोग्रामों का सेट है, तो उन्हें टेस्ट करना आसान होता है। दूसरी बात, एक बार टूल बना लेने के बाद, आप उसे दूसरे प्रोजेक्टों में भी इस्तेमाल कर सकते हो।
Head First: कोई नुक़सान?
O/S: खैर, टूल देखने में उतने अच्छे नहीं लगते। वे आम तौर पर कमांड लाइन पर काम करते हैं, इसलिए उनमें वह नहीं होता जिसे आप आँखों को भाने वाला रूप (Eye Appeal) कह सकते हो।
Head First: क्या इससे फ़र्क़ पड़ता है?
O/S: उतना नहीं जितना आप सोचते हो। अगर आपके पास मज़बूत टूलों का सेट है जो ज़रूरी काम करता है, तो आप उन्हें हमेशा किसी अच्छे इंटरफ़ेस से जोड़ सकते हो, चाहे वह डेस्कटॉप एप्लिकेशन हो या वेबसाइट। पर, अरे, समय देखो। माफ़ करना, मुझे आपको बीच में रोकना पड़ेगा।
Head First: ओह, ठीक है, शुक्रिया O/S, बहुत अच्छा लगा…ज़्ज़्ज़्ज़ज़…
12. छोटे टूल लचीले होते हैं (Small tools are flexible)
📄 PDF पेज 168 · किताब पेज 128
छोटे टूलों की एक बड़ी ख़ूबी उनका लचीलापन (flexibility) है। अगर आप ऐसा प्रोग्राम लिखो जो एक काम बहुत अच्छे से करता है, तो बहुत संभावना है कि आप उसे कई संदर्भों में इस्तेमाल कर पाओगे। जैसे, अगर आपने ऐसा प्रोग्राम बनाया जो फ़ाइल के भीतर टेक्स्ट खोज सकता है, तो आप उसे एक से ज़्यादा जगहों पर काम का पाओगे।
उदाहरण के लिए, अपने geo2json टूल के बारे में सोचो। आपने उसे साइकिलिंग डेटा दिखाने में मदद के लिए बनाया था, है ना? पर कोई वजह नहीं कि आप उसे किसी और मक़सद के लिए इस्तेमाल न करो…जैसे जाँच करने में…
🔺 बरमूडा रेक्टैंगल (Bermuda Rectangle)
नक़्शे पर चारों कोने:
अक्षांश (latitude) 34° और 26°
देशांतर (longitude) −64° और −76°
यह देखने के लिए कि हमारा टूल कितना लचीला है, चलो इसे एक बिल्कुल अलग समस्या के लिए इस्तेमाल करते हैं। सिर्फ़ डेटा को नक़्शे पर दिखाने की जगह, इसे कुछ ज़्यादा जटिल काम के लिए इस्तेमाल करने की कोशिश करते हैं। मान लो आप पहले की तरह GPS डेटा का पूरा सेट पढ़ना चाहते हो, पर सब कुछ दिखाने की जगह सिर्फ़ वही जानकारी दिखाना चाहते हो जो बरमूडा रेक्टैंगल के अंदर पड़ती है।
इसका मतलब है कि आप सिर्फ़ वही डेटा दिखाओगे जो इन शर्तों से मेल खाता है:
हमारा geo2json टूल उसे दिया गया सारा डेटा दिखाता है। तो हमें क्या करना चाहिए? क्या हमें geo2json को ऐसे बदलना चाहिए कि वह डेटा एक्सपोर्ट भी करे और जाँचे भी?
हम कर सकते हैं, पर याद रखो, छोटा टूल:
🎯 एक काम करता है और उसे अच्छे से करता है।
आप geo2json टूल को बदलना नहीं चाहोगे, क्योंकि आप चाहते हो कि वह सिर्फ़ एक काम करे। अगर आप प्रोग्राम से कुछ और जटिल करवाओगे, तो आप अपने यूज़रों के लिए समस्याएँ खड़ी कर दोगे, जो उम्मीद करते हैं कि टूल ठीक उसी तरह काम करता रहेगा।
💬 "मैं सच में डेटा फ़िल्टर नहीं करवाना चाहता। मुझे तो सब कुछ दिखाते रहना है।"
तो अगर आप geo2json टूल को बदलना नहीं चाहते, तो क्या करें?
🧰 छोटे टूल डिज़ाइन करने के सुझाव (Tips for Designing Small Tools)
geo2json जैसे छोटे टूल ये सारे डिज़ाइन सिद्धांत मानते हैं:
✅ वे Standard Input से डेटा पढ़ सकते हैं।
✅ वे Standard Output पर डेटा दिखा सकते हैं।
✅ वे अस्पष्ट बाइनरी फ़ॉर्मेट की जगह टेक्स्ट डेटा से काम करते हैं।
✅ हर टूल एक सरल काम करता है।
14. अलग काम के लिए अलग टूल
📄 PDF पेज 170 · किताब पेज 130
अगर आप बरमूडा रेक्टैंगल के बाहर पड़ने वाले डेटा को छोड़ना चाहते हो, तो आपको एक अलग टूल बनाना चाहिए जो बस यही करे। तो आपके पास दो टूल होंगे:
एक नया bermuda टूल जो बरमूडा रेक्टैंगल के बाहर का डेटा छान देगा।
आपका मूल geo2json टूल जो बचे हुए डेटा को नक़्शे के लिए बदलेगा।
आप इन प्रोग्रामों को इस तरह जोड़ोगे:
सारा डेटा ──▶ bermuda ──▶ geo2json ──▶ नक़्शा
📝 आप अपना सारा डेटाbermuda टूल में डालोगे। इस डेटा में बरमूडा रेक्टैंगल के अंदर और बाहर, दोनों की घटनाएँ शामिल हैं।
📝 टूल सिर्फ़ वही डेटा आगे भेजेगा जो बरमूडा रेक्टैंगल के अंदर पड़ता है।
📝 इसलिए आप geo2json को सिर्फ़ बरमूडा रेक्टैंगल का डेटा भेजोगे।
📝 geo2json ठीक पहले की तरह काम करेगा।
📝 आप ऐसा नक़्शा बनाओगे जिसमें सिर्फ़ बरमूडा रेक्टैंगल का डेटा होगा।
समस्या को दो कामों में बाँटकर आप geo2json को बिना छुए छोड़ पाओगे। इसका मतलब है कि उसके मौजूदा यूज़र अब भी उसे इस्तेमाल कर पाएँगे। सवाल यह है:
❓ आप अपने दोनों टूलों को आपस में कैसे जोड़ोगे?
15. पाइप (pipe) से इनपुट और आउटपुट जोड़ो
📄 PDF पेज 171 · किताब पेज 131
आप देख चुके हो कि रीडायरेक्शन से किसी प्रोग्राम फ़ाइल के स्टैंडर्ड इनपुट और स्टैंडर्ड आउटपुट को कैसे जोड़ते हैं। पर अब आप bermuda टूल के स्टैंडर्ड आउटपुट को geo2json के स्टैंडर्ड इनपुट से जोड़ोगे, इस तरह:
bermuda ──(|)──▶ geo2json
📝 | चिह्न एक पाइप (pipe) है जो एक प्रोसेस के Standard Output को दूसरी प्रोसेस के Standard Input से जोड़ता है।
📝 bermuda का आउटपुट…
📝 …geo2json के इनपुट में जाता है।
🔌 पाइप एक प्रोसेस के Standard Output को दूसरी प्रोसेस के Standard Input से जोड़ने के काम आ सकता है।
इस तरह, जब भी bermuda टूल को बरमूडा रेक्टैंगल के अंदर का कोई डेटा दिखेगा, वह उसे अपने Standard Output पर भेज देगा। पाइप वह डेटा bermuda टूल के Standard Output से geo2json टूल के Standard Input तक पहुँचा देगा।
ऑपरेटिंग सिस्टम इसका पूरा ब्योरा सँभाल लेगा कि पाइप यह काम ठीक-ठीक कैसे करेगा। चीज़ें चलाने के लिए आपको बस ऐसी कमांड देनी है:
bermuda | geo2json
📝 ऑपरेटिंग सिस्टम दोनों प्रोग्राम एक ही समय पर चलाएगा।
📝 यह वह पाइप है।
📝 bermuda का आउटपुट geo2json का इनपुट बन जाएगा।
तो अब समय है bermuda टूल बनाने का।
16. bermuda टूल
📄 PDF पेज 172 · किताब पेज 132
bermuda टूल बहुत हद तक geo2json टूल की तरह काम करेगा: वह GPS डेटा का सेट लाइन-दर-लाइन पढ़ेगा, और फिर डेटा Standard Output पर भेजेगा।
पर दो बड़े फ़र्क़ होंगे:
पहला: वह हर डेटा को Standard Output पर नहीं भेजेगा, बस वे लाइनें जो बरमूडा रेक्टैंगल के अंदर हैं।
दूसरा:bermuda टूल हमेशा डेटा उसी CSV फ़ॉर्मेट में आउटपुट करेगा जिसमें GPS डेटा स्टोर होता है।
📝 टूल का सूडोकोड (pseudocode)
हर लाइन के लिए अक्षांश (latitude), देशांतर (longitude) और बाक़ी डेटा पढ़ो:
अगर अक्षांश 26 और 34 के बीच है, तो:
अगर देशांतर -76 और -64 के बीच है, तो:
अक्षांश, देशांतर और बाक़ी डेटा दिखाओ
🛠️ सुधार: किताब के सूडोकोड में देशांतर "−64 और −76 के बीच" लिखा है। पिछले पेज की शर्त (longitude > -76 और longitude < -64) के हिसाब से सही क्रम −76 और −64 के बीच है। ऊपर वैसा ही लिखा गया है।
चलो सूडोकोड को C में बदलते हैं।
17. पूल पज़ल: bermuda प्रोग्राम पूरा करो
📄 PDF पेज 173–174 · किताब पेज 133–134
🏊 पेज 133: पहेली
आपका लक्ष्य bermuda प्रोग्राम का कोड पूरा करना है। पूल से कोड के टुकड़े लेकर नीचे की ख़ाली जगहों में रखो। आपको पूल के सारे टुकड़े इस्तेमाल नहीं करने होंगे।
📝 नोट: पूल की हर चीज़ सिर्फ़ एक बार इस्तेमाल हो सकती है!
#include <stdio.h>
int main()
{
float latitude;
float longitude;
char info[80];
while (scanf("%f,%f,%79[^\n]", , , ) == 3)
if (( > ) ( < ))
if (( > ) ( < ))
printf("%f,%f,%s\n", , , );
return 0;
}
एक लाइन पढ़ो। तीनों मान पढ़े जाएँ तो लूप चलता रहे। (info ऐरे है, इसलिए & नहीं।)
if ((latitude > 26) && (latitude < 34))
अक्षांश 26 और 34 के बीच है? (&& = और, दोनों शर्तें सच हों।)
if ((longitude > -76) && (longitude < -64))
देशांतर −76 और −64 के बीच है?
printf("%f,%f,%s\n", latitude, longitude, info)
दोनों शर्तें सच हों, तब वह लाइन CSV फ़ॉर्मेट में दिखाओ।
💡 && का मतलब "और" (AND) है। यहाँ || ("या") ग़लत होता, क्योंकि हमें अक्षांश का 26 से बड़ा और 34 से छोटा, दोनों होना चाहिए।
18. टेस्ट ड्राइव: दोनों टूल एक साथ
📄 PDF पेज 175 · किताब पेज 135
⚠️ ऐसा करो! (Do this!)spooky.csv फ़ाइल यहाँ से डाउनलोड करो: http://oreillyhfc.appspot.com/spooky.csv
अब जब आपने bermuda टूल पूरा कर लिया है, तो समय है उसे geo2json टूल के साथ इस्तेमाल करने का, और देखने का कि क्या आप बरमूडा रेक्टैंगल के अंदर की कोई अजीब घटनाएँ नक़्शे पर दिखा पाते हो।
दोनों टूल कंपाइल कर लेने के बाद, आप कंसोल (console) चालू करके दोनों प्रोग्राम इस तरह साथ चला सकते हो:
याद रखो: अगर आप Windows पर चल रहे हो, तो ./ की ज़रूरत नहीं है।
| वह पाइप है जो प्रोसेसों को जोड़ता है।
spooky.csv वह फ़ाइल है जिसमें सारी घटनाएँ हैं।
bermuda टूल उन घटनाओं को छान देता है जिन्हें हम नज़रअंदाज़ करना चाहते हैं।
geo2json टूल घटनाओं को JSON फ़ॉर्मेट में बदलेगा।
हम आउटपुट output.json में सहेजेंगे।
जब आप दोनों प्रोग्रामों को आपस में जोड़ते हो, तो आप उन्हें एक ही प्रोग्राम की तरह मान सकते हो। पाइप से दोनों अलग प्रोग्रामों को जोड़कर आप उन्हें एक प्रोग्राम जैसा बना सकते हो, इसलिए आप Standard Input और Standard Output को पहले की तरह ही रीडायरेक्ट कर सकते हो।
सवाल: छोटे टूलों का Standard Input और Standard Output इस्तेमाल करना इतना ज़रूरी क्यों है?
जवाब: क्योंकि इससे टूलों को पाइप से आपस में जोड़ना आसान हो जाता है।
सवाल: यह मायने क्यों रखता है?
जवाब: छोटे टूल आम तौर पर अपने दम पर पूरी समस्या हल नहीं करते, बस कोई छोटी तकनीकी समस्या, जैसे डेटा को एक फ़ॉर्मेट से दूसरे में बदलना। पर अगर आप उन्हें जोड़ सको, तो आप बड़ी समस्याएँ हल कर सकते हो।
सवाल: असल में पाइप क्या होता है?
जवाब: ब्योरा ऑपरेटिंग सिस्टम पर निर्भर है। पाइप मेमोरी के हिस्सों या अस्थायी फ़ाइलों से बन सकते हैं। ज़रूरी बात यह है कि वे एक सिरे से डेटा लेते हैं और दूसरे सिरे से क्रम में बाहर भेजते हैं।
सवाल: अगर दो प्रोग्राम पाइप से जुड़े हैं, तो क्या पहले प्रोग्राम को पूरा चलकर ख़त्म होना पड़ेगा, तभी दूसरा शुरू होगा?
जवाब: नहीं। दोनों प्रोग्राम एक ही समय चलेंगे; जैसे-जैसे पहला प्रोग्राम आउटपुट बनाता जाएगा, दूसरा प्रोग्राम उसे इस्तेमाल करता जाएगा।
सवाल: छोटे टूल टेक्स्ट क्यों इस्तेमाल करते हैं?
जवाब: यह सबसे खुला फ़ॉर्मेट है। अगर कोई छोटा टूल टेक्स्ट इस्तेमाल करता है, तो इसका मतलब है कि कोई भी दूसरा प्रोग्रामर बस टेक्स्ट एडिटर से आउटपुट आसानी से पढ़ और समझ सकता है। बाइनरी फ़ॉर्मेट आम तौर पर अस्पष्ट और समझने में कठिन होते हैं।
सवाल: क्या मैं कई प्रोग्राम पाइप से जोड़ सकता हूँ?
जवाब: हाँ, बस हर प्रोग्राम के नाम के बीच और | जोड़ दो। जुड़ी हुई प्रोसेसों की शृंखला को पाइपलाइन (pipeline) कहते हैं।
सवाल: अगर कई प्रोसेस पाइप से जुड़ी हैं और मैं > और < से Standard Input और Output रीडायरेक्ट करूँ, तो किन प्रोसेसों का इनपुट-आउटपुट रीडायरेक्ट होगा?
जवाब:< फ़ाइल का कंटेंट पाइपलाइन की पहली प्रोसेस को भेजेगा। > पाइपलाइन की आख़िरी प्रोसेस का Standard Output पकड़ेगा।
सवाल:bermuda और geo2json को चलाते समय क्या कोष्ठक (parentheses) सचमुच ज़रूरी हैं?
जवाब: हाँ। कोष्ठक यह पक्का करते हैं कि डेटा फ़ाइल bermuda प्रोग्राम के Standard Input से पढ़ी जाए।
📌 बुलेट पॉइंट (Bullet Points)
अगर आप कोई अलग काम करना चाहते हो, तो एक अलग छोटा टूल लिखने पर विचार करो।
टूलों को Standard Input और Standard Output के साथ काम करने के लिए डिज़ाइन करो।
छोटे टूल आम तौर पर टेक्स्ट डेटा पढ़ते-लिखते हैं।
आप पाइप से एक प्रोसेस के Standard Output को दूसरी प्रोसेस के Standard Input से जोड़ सकते हो।
20. एक से ज़्यादा फ़ाइलों में आउटपुट चाहिए तो?
📄 PDF पेज 177 · किताब पेज 137
हम देख चुके हैं कि रीडायरेक्शन से एक फ़ाइल से डेटा पढ़कर दूसरी फ़ाइल में कैसे लिखते हैं। पर अगर प्रोग्राम को कुछ ज़्यादा जटिल करना हो, जैसे डेटा एक से ज़्यादा फ़ाइलों में भेजना?
सोचो कि आपको एक और टूल बनाना है जो फ़ाइल से डेटा का एक सेट पढ़े और फिर उसे दूसरी फ़ाइलों में बाँट दे।
तो समस्या क्या है? आप कई फ़ाइलों में लिख नहीं सकते, है ना? दिक़्क़त यह है कि रीडायरेक्शन से आप ज़्यादा से ज़्यादा दो फ़ाइलों में ही लिख सकते हो: एक Standard Output से और एक Standard Error से। तो आप क्या करोगे?
21. अपनी डेटा स्ट्रीम ख़ुद बनाओ (Roll your own data streams)
📄 PDF पेज 178 · किताब पेज 138
जब कोई प्रोग्राम चलता है, तो ऑपरेटिंग सिस्टम उसे तीन फ़ाइल डेटा स्ट्रीम देता है: Standard Input, Standard Output और Standard Error। पर कभी-कभी आपको चलते-चलते दूसरी डेटा स्ट्रीम बनानी पड़ती हैं।
अच्छी ख़बर यह है कि ऑपरेटिंग सिस्टम आपको सिर्फ़ उन्हीं स्ट्रीमों तक सीमित नहीं रखता जो प्रोग्राम शुरू होते समय दी जाती हैं। आप प्रोग्राम चलते समय अपनी स्ट्रीम ख़ुद बना सकते हो।
हर डेटा स्ट्रीम एक फ़ाइल के पॉइंटर के रूप में होती है, और आप fopen() फ़ंक्शन से नई डेटा स्ट्रीम बना सकते हो:
आख़िर में, जब आप डेटा स्ट्रीम का काम पूरा कर लो, तो उसे बंद (close) करना होगा। सच यह है कि प्रोग्राम ख़त्म होने पर सारी डेटा स्ट्रीम अपने आप बंद हो जाती हैं, फिर भी हमेशा स्ट्रीम को ख़ुद बंद करना अच्छी आदत है:
fclose(in_file);
fclose(out_file);
चलो अब इसे आज़माते हैं।
22. पहेली: GPS डेटा को तीन फ़ाइलों में बाँटो
📄 PDF पेज 179 · किताब पेज 139
यह एक ऐसे प्रोग्राम का कोड है जो GPS फ़ाइल से सारा डेटा पढ़ता है और फिर उसे तीन दूसरी फ़ाइलों में से किसी एक में लिख देता है। देखो, क्या आप ख़ाली जगहें भर सकते हो।
🛠️ सुधार: पिछले पेज (137) के चित्र में तीसरी फ़ाइल का नाम other.csv है, जबकि इस पेज के कोड में "others.csv" है। एक ही प्रोग्राम में नाम एक जैसा होना चाहिए। यहाँ कोड वाला नाम others.csv रखा गया है।
✅ भरने के संकेत (इसी हिस्से से निकले)
इस पहेली का आधिकारिक हल किताब में अगले पेज (180) पर है, जो इस हिस्से से बाहर है। पर इसी हिस्से में बताई बातों से जवाब निकलता है:
ख़ाली जगह
क्या भरेंगे
क्यों
fopen("spooky.csv", ___)
"r"
इस फ़ाइल से पढ़ना है
fopen("ufos.csv", ___)
"w"
इसमें लिखना है
fopen("disappearances.csv", ___)
"w"
इसमें लिखना है
fopen("others.csv", ___)
"w"
इसमें लिखना है
___(in, "%79[^\n]\n", line) == 1
fscanf
स्ट्रीम से पढ़ना है
___(file1, "%s\n", line); (तीनों जगह)
fprintf
स्ट्रीम में लिखना है
___(file1); (तीनों जगह)
fclose
स्ट्रीम बंद करनी है
❓ सवाल-जवाब
सवाल: मेरे पास कितनी डेटा स्ट्रीम हो सकती हैं?
जवाब: यह ऑपरेटिंग सिस्टम पर निर्भर है, पर आम तौर पर एक प्रोसेस के पास 256 तक हो सकती हैं। असल बात यह है कि इनकी संख्या सीमित होती है, इसलिए इस्तेमाल के बाद इन्हें बंद ज़रूर करो।
सवाल:FILE अंग्रेज़ी में बड़े अक्षरों में क्यों है?
जवाब: यह ऐतिहासिक कारण से है। FILE पहले मैक्रो (macro) से परिभाषित होता था। मैक्रो को आम तौर पर बड़े अक्षरों के नाम दिए जाते हैं। मैक्रो के बारे में आगे आपको बताया जाएगा।
23. 🛠️ किताब की गलतियाँ और सुधार
इस हिस्से (पेज 155–179) में जो गलतियाँ और कमियाँ मिलीं, उन्हें ऊपर ठीक करके लिखा गया है:
#
PDF पेज (किताब पेज)
किताब में
सही रूप / टिप्पणी
1
156 (116)
printf(“Invalid latitude: %f\n”, latitude); में टेढ़े (curly) उद्धरण-चिह्न
C में सीधे " ही चलते हैं। टेढ़े चिह्न कंपाइल एरर देंगे।
2
163 (123)
कोड में पुरानी (कटी हुई) और नई लाइनें साथ छपी हैं, जिनमें ग़लत printf(stderr, ...) भी है
सिर्फ़ अंतिम सही fprintf(stderr, ...) रखा गया, और बदलाव की तुलना-तालिका जोड़ी गई।
3
164 (124)
./geo2json-page21 < gpsdata.csv > output.json
./geo2json, क्योंकि कंपाइल किए प्रोग्राम का नाम यही है।
4
172 (132)
सूडोकोड में देशांतर "−64 और −76 के बीच"
शर्त के अनुसार −76 और −64 के बीच।
5
177 और 179 (137, 139)
चित्र में other.csv, कोड में others.csv
कोड वाला नाम others.csv रखा गया (दोनों जगह एक जैसा होना चाहिए)।
6
155 (115)
"expected numeric" (अपेक्षित संख्यात्मक)
मतलब सीमा (range) से है, इसलिए अनुवाद में "सीमा" लिखा गया।
📌 ध्यान दें:bermuda प्रोग्राम (&& वाली शर्तें), Top Secret का हल (दोनों संदेश), और fopen/fprintf/fscanf/fclose के उदाहरण सही पाए गए। Top Secret के दोनों संदेश ऊपर शब्द-दर-शब्द जाँचे गए हैं।