C Language Tutorial Subtitles for Beginners with Practice

[संगीत]

हाय एवरीवन मैं हूं आपकी श्रद्धा दीदी एंड

वेलकम टू अपना कॉलेज आज की सी ट्यूटोरियल

में हमने बेसिक से लेकर एडवांस तक पूरी की

पूरी सी को खत्म कर रखा है तो इस वीडियो

को देखने के बाद आप कोडिंग प्रोग्रामिंग

सीख जाएंगे और अगर आपका कॉलेज में एग्जाम

है जिसके अंदर सी पूछी जाती है तो उसकी

आपकी पूरी तैयारी हो जाएगी इस ट्यूटोरियल

को हमने 11 चैप्टर्स के अंदर डिवाइड किया

है जिनके नीचे आपको टाइम स्टंप्स मिल रहे

होंगे तो आप इंडिविजुअली भी अगर आपको कोई

टॉपिक पढ़ना है तो वो भी जाकर आप पढ़ सकते

हैं और चैप्टर्स के साथ हमने 100

क्वेश्चंस इस वीडियो के अंदर इंक्लूड किए

हैं जिसमें से 70 क्वेश्चन मैंने पर्सनली

आपको अपने सामने सॉल्व करवाए हैं और 30

क्वेश्चंस को मैंने आपकी प्रैक्टिस के लिए

होमवर्क में दिया है साथ के साथ वीडियो के

साथ कोड्स जितने भी हैं या नोट्स जितने भी

हैं उनका लिंक भी आपको नीचे मिल रहा होगा

ताकि एक बार ट्यूटोरियल खत्म करने के बाद

आप कभी भी आकर फ्री में रिवीजन कर सके

इसके साथ अगर कोई भी ऐसी चीज है जो आपको

इंपॉर्टेंट लगती है या आप मुझे बताना

चाहते हैं तो उसको आप नीचे मुझे कमेंट

करके बता सकते हैं और बीच में अगर आपको

कोई भी लेक्चर बुकमार्क करना है कोई भी

टॉपिक बुकमार्क करना है उसका आप नीचे

सिंपली टाइम लिख दीजिए और उसको कमेंट कर

दीजिए तो अगली बार हम आएंगे तो वो कमेंट

हमें ऊपर दिख रहा होगा तो शुरुआत करते हैं

अपने सबसे नए और सबसे बड़े सी ट्यूटोरियल

की तो सी में कोड करने से पहले हमें दो

चीजें अपने सिस्ट सिस्टम के अंदर इंस्टॉल

करनी पड़ेंगी जिनमें से सबसे पहला है

हमारा वीएस कोड यानी कोड एडिटर अब कोड

एडिटर एक नोटबुक की तरह होता है जैसे

नोटबुक के अंदर हम इंग्लिश में हिंदी में

चीजें लिख रहे होते हैं वैसे ही अपने कोड

एडिटर के ऊपर हम कोई कोड लिखते हैं और हम

जिस कोड एडिटर का इस्तेमाल करेंगे उसका

नाम है वीएस कोड अब इसके अलावा आपने देखा

होगा कि कॉलेजेस के अंदर स्कूल्स के अंदर

कुछ लोग कोड ब्लॉक्स पर काम कर रहे होते

हैं कुछ लोग किसी और सॉफ्टवेयर पर काम कर

रहे होते हैं पर यहां हम वीएस कोड इसलिए

यूज़ कर रहे हैं क्योंकि ये बहुत अच्छा

सॉफ्टवेयर है और इसमें आप सिर्फ सी की

प्रोग्रामिंग नहीं उसके बाद अगर आपको c+ प

जावा या फिर किसी और लैंग्वेज में

प्रोग्रामिंग करनी है तो उसके लिए भी हम

आपको एटमॉस्फेयर ये पूरा ऐसे तैयार करके

दे देंगे कि आपको कुछ और इंस्टॉल ना करना

पड़े तो शुरुआत से ही जब हम एक अच्छे कोड

एडिटर पर काम करते हैं ना तो उसके बहुत

सारे फायदे होते हैं दूसरी चीज जो हमें

इंस्टॉल करनी पड़ेगी वो है हमारा कंपाइलर

जिसके लिए हम सर्च करेंगे फॉर जीसीसी अब

कंपाइलर एक ऐसा सिस्टम एक ऐसा सॉफ्टवेयर

होता है जिसके अंदर रूल्स लिखे होते हैं

हमारी प्रोग्रामिंग लैंग के तो सी का

कंपाइलर होगा जिसके अंदर सी की लैंग्वेज

के जो भी रूल्स है ना वो लिखे होंगे तो आप

जो भी कोड लिखेंगे वह आपके कोड के लिखने

के बाद चेक करेगा कि क्या आपने कोड सही

लिखा है और उस कोड को रन करने का काम भी

कंपाइलर करता है तो कंपाइलर्स के बारे में

हम बाद में डिटेल में पढ़ रहे होंगे अभी

सबसे पहले इंस्टॉल करते हैं अपने कोड

एडिटर को यानी वीएस कोड को तो वीएस कोड को

इंस्टॉल करने के लिए हमें अपनी स्क्रीन पर

सबसे पहले

लोड वीएस कोड फॉर विंड अब यहां पर सबसे

पहला हमारे पास ऑप्शन आएगा कि हम विज के

लिए डाउनलोड करना चाहते हैं

नेक्स्ट पर अब एक चेक बॉक्स की जो लिस्ट

है वह हमारे पास आ रही होगी और हमें क्या

करना है सारे के सारे चेक बॉक्सेस को टिक

कर देना है ऊपर वाला कहता है कि डेस्कटॉप

पर एक आइकन हमारे लिए क्रिएट हो जाए तो और

नीचे वाले पथ्स वगैरह की काफी सारी

इंफॉर्मेशन हमें दे रहे हैं तो सारे चेक

बॉक्सेस को टिक कर देंगे एंड उसके बाद कर

देंगे हम इंस्टॉल तो फाइनली वीएस कोड

हमारे लिए इंस्टॉल हो जाएगा और क्लिक कर

देंगे फिनिश पर अब इसके बाद हम सिस्टम में

जाकर सर्च कर सकते हैं फॉर वीएस कोड वीएस

कोड सर्च करने के बाद वो खुल जाएगा और ऐसा

कुछ हमारे पास स्क्रीन पर डिस्प्ले होकर आ

जाएगा जिसके अंदर सबसे पहले तो हम एक थीम

चूज कर सकते हैं हमारी मर्जी है कि हम एक

लाइट थीम चूज करें या डार्क थीम चूज करें

तो वी विल गो विद डार्क उसके बाद आपको

नेक्स्ट सेक्शन नेक्स्ट सेक्शन करते जाना

है अगर हम चाहे तो गट भी इंस्टॉल कर सकते

हैं पर गट के लिए अभी हम काम नहीं करेंगे

अभी इंस्टॉल नहीं करेंगे और मार्क कर

देंगे एज डन अब वीएस कोड के अंदर कोई हमें

नई फाइल खोलनी है जिसके अंदर हम चीजें लिख

सक तो न्यू फाइल पर क्लिक कर सकते हैं और

ऐसे फाइल्स के अंदर हम डिफरेंट डिफरेंट

कोड्स को प्रोग्राम्स को लिख रहे होंगे अब

यहां हमने वीएस कोड डाउनलोड किया है लेकिन

अगर आप किसी और कोड एडिटर पर भी काम करना

चाहते हैं आपके पास ऑलरेडी डाउनलोडेड है

तो आप उसका भी इस्तेमाल कर सकते हैं सेम

कोड हम कर रहे होंगे दूसरी चीज जो हम

डाउनलोड करेंगे वो है सी का कंपाइलर अब सी

के कंपाइलर को डाउनलोड करने के लिए सबसे

पहले हमें लिखना पड़ेगा

chromecast.com दिख रहा होगा उसपे हमें

क्लिक करना है तो डाउनलोड हमारे लिए

स्टार्ट हो जाएगा सबसे पहले जो विंडो

अपीयर करेगी पॉपअप आएगा उसके ऊपर

इंस्टॉलेशन डायरेक्ट्रीएंट्री

जें हैं वो डाउनलोड होती रहेंगी फिर एक

विंडो खुलेगी जिसमें वो हमसे पूछ रहा है

कि हमें और कौन से पैकेजेस डाउनलोड करने

हैं तो उसमें जो चेक बॉक्स हमारे पास आएगा

वो डिफरेंट डिफरेंट लैंग्वेजेस के लिए है

अभी के लिए क्या करेंगे बेसिक सब के लिए

डाउनलोड कर लेते हैं तो इंस्टॉल में सब पे

हमें क्लिक कर देना है मतलब चेक बॉक्स सब

के लिए टिक करना है फिर लेफ्ट में जाके एक

इंस्टॉलेशन का ऑप्शन आएगा इंस्टॉलेशन के

ऑप्शन में हमें क्लिक करना है और फिर

अप्लाई चेंजेज पर क्लिक करके सबके लिए

हमें डाउनलोड कर लेने हैं अपने पैकेजेस तो

ये पैकेजेस हो सकता है आपकी इंटरनेट स्पीड

के हिसाब से कुछ टाइम बाद डाउनलोड हो तो

उसके लिए आपको थोड़ा वेट करना पड़ सकता है

अब जैसे ही ये पैकेजेस डाउनलोड हो जाएंगे

ना उसके बाद हमारे पास आएगा कि ऑल चेंजेज

आर अप्लाइड सक्सेसफुली तो फिर हम उस चीज

को को कर देंगे क्लोज तो अभी हमने कोड

एडिटर को डाउनलोड कर लिया यानी वीएस कोड

को हमने सीके कंपाइलर को डाउनलोड कर लिया

इंस्टॉल कर लिया है पर एक छोटी सी चीज बची

है वो है हमारे एनवायरमेंट वेरिएबल अब

एनवायरमेंट वेरिएबल क्या होता है या इस

स्टेप में हम एगजैक्टली कर क्या रहे हैं

उसके हम डिटेल में नहीं जाएंगे बेसिक चीज

यह समझनी है कि आपको अगर सी का कोड अपने

सिस्टम के अंदर चलाना है तो उससे पहले

आपको यह सारे स्टेप्स जो हैं वोह फॉलो

करने पड़ेंगे इसके लिए सबसे पहले हम क्या

करेंगे हम अपने कंप्यूटर के सिस्टम में

फाइल्स में जाएंगे और उसमें दिस पीसी पर

जा रहे होंगे दिस पीसी के अंदर हम सर्च

करेंगे फॉर मजी डब् एम आई एन जीड तो सर्च

करने के बाद मजीड के फोल्डर में जाना है

उसके अंदर हमें जाना है बिन के फोल्डर में

तो बिन के फोल्डर में जब ऊपर पूरा का पूरा

पाथ एक डिस्प्ले हो रहा होगा उस पर जब हम

क्लिक करेंगे ना तो हमारा एक पाथ हाईलाइट

होगा व्हिच इज सी ड्राइव स् मजीड बिन इस

पूरे के पूरे पाथ को हमें कॉपी करना है

क्योंकि इसको हम अपने सिस्टम के

एनवायरमेंट वेरिएबल में ऐड करने वाले

तो राइट क्लिक करके इसको कॉपी कर लेंगे हम

अब हमें क्या करना है अब हमें अपने

कंप्यूटर के अंदर सर्च करना है कंट्रोल

पैनल के लिए कंट्रोल पैनल के अंदर जाकर

जाएंगे हम सिस्टम्स में सिस्टम्स के अंदर

हम जा रहे होंगे एडवांस सिस्टम सेटिंग्स

में अब जैसे ही एडवांस सिस्टम सेटिंग्स पर

जाएंगे तो एक पॉपअप दिखेगा हमें स्क्रीन

पर जिसके अंदर हमें इस एनवायरमेंट वेरिएबल

वाले ऑप्शन पर जाना है तो एक और

एनवायरमेंट वेरिएबल का ऑप्शन हमारे पास आ

रहा होगा इस ऑप्शन के अंदर इन एनवायरमेंट

वेरिएबल में नीचे सिस्टम वेरिएबल के अंदर

हमें पाथ को ढूंढना है जैसे ही हम पाथ को

ढूंढ लेंगे ना पाथ पे हमें जाना है तो

हमारा ब्लू कर्सर जैसे ही पाथ पे आ जाएगा

फिर हम कर देंगे उसको एडिट तो हम पाथ को

एडिट करने वाले हैं इसमें हम एक नया पाथ

एडिट करेंगे और नए पाथ के अंदर हम कॉपी कर

देंगे अपनी वो लोकेशन जिसके अंदर हमारे

मजी डब् का बिन फोल्डर है उस लोकेशन को

हमने कॉपी कर दिया उस लोकेशन को हमने

पेस्ट कर दिया है फिर एंटर प्रेस करेंगे

फिर प्रेस करेंगे ओके दोबारा से केके एंड

फाइनली लास्ट का ओके तो इस तरीके से हमारे

वेरिएबल के अंदर पाथ वेरिएबल के अंदर हमने

अपने मंजी डब् के बिन के पाथ को ऐड करा

दिया है अब वीएस कोड को खोलेंगे और अब हम

क्या करने वाले हैं एक सैंपल कोड करके मैं

बस आपको रन करके दिखाने वाली हूं जिसके

अंदर अभी हमें ये नहीं समझना कि सी के

अंदर प्रोग्रामिंग किस तरीके से होती है

या चीजें रन कैसे करते हैं या जो भी हम

लिख रहे हैं उसका मतलब क्या है बस सिंपली

देखना है कि जैसे ही हमने अपना एनवायरमेंट

सेट किया है हमारा सी का कोई भी कोड इस पर

रन करता है तो फाइल के अंदर खोलकर मैं एक

सैंपल कोड लिखने वाली हूं तो वीएस कोड के

अंदर हम एक नई फाइल खोलने वाले हैं उस नई

फाइल को सबसे पहले सेव कर लेते हैं h

world.con करने से पहले वीएस कोड में कुछ

एक्सटेंशंस होती हैं जिनको हमें इंस्टॉल

करना पड़ता है ताकि वीएस कोड समझ पाए कि

आप कौन सा कोड कोड रन करने वाले हैं व

उसके लिए कुछ और एडिशनल आपको फंक्शनैलिटीज

लाकर दे दे तो नीचे आपको एक्सटेंशंस का

ऑप्शन मिल रहा होगा अब सी को रन करने के

लिए हमें c c+ प का जो एक्सटेंशन पैक है

उसको अपने वीएस कोड के अंदर इंस्टॉल करना

पड़ेगा इसको इंस्टॉल एक बार हमने कर लिया

तो ऊपर टर्मिनल में जाकर हम ओपन करेंगे

न्यू टर्मिनल अब मैं कुछ कमांड्स लिखने

वाली हूं जो बहुत ही ज्यादा

कॉम्प्लेक्टेड लिख लिखकर बहुत अच्छे

एडवांस लेवल के सी के प्रोग्राम्स लिखने

वाले हैं तो बिल्कुल अभी चिंता नहीं करनी

कि ये

कॉम्प्लेक्शन करने वाली हैं तो मैंने कुछ

कोड लिखी कमांड्स लिखी नीचे और जैसे ही

मैंने कमांड लिखी मेरे लिए हेलो वर्ल्ड

मेरी स्क्रीन पर प्रिंट होकर आ जाएगा एंड

आप नोटिस करेंगे ऊपर कोड के अंदर भी मैंने

प्रिंट एफ एक चीज लिखी है जिसके अंदर

मैंने हेलो वर्ल्ड लिखा है तो मैंने ऊपर

कोड में भी लिखा है नीचे मेरी स्क्रीन में

भी आ गया है तो कुछ इस तरीके से हमारे सी

का कोड काम कर रहा होता है

के लिए अलग से भी बहुत सारे वीडियोस बनाए

हुए हैं तो आपको अगर कोई भी डाउट आता है

इंस्टॉलेशन में आप उस पर्टिकुलर वीडियो को

जाकर देख सकते हैं एंड उसमें काफी सारे जो

डाउट्स है वो आपके क्लियर हो रहे होंगे अब

अपने सी कोड को लिखने के लिए हम सबसे पहले

एक फाइल क्रिएट करेंगे फाइल को क्रिएट

करने के लिए ऊपर जाना है फाइल में और वहां

पर क्लिक करना है ओपन पर अब ओपन के अंदर

हमारे पास ऑप्शन आएंगे कि कोई हमारे पास

पुराना फोल्डर हो उसको हम पहले से खोल दें

लेकिन हम एक नया फोल्डर बनाने वाले हैं

जिसका हम नाम देंगे सी ट्यूटोरियल्स

इस सी फोल्डर को हम ओपन करने वाले हैं अब

हमारे पास एक ओपन हो गया है फोल्डर इसके

अंदर पर कोई फाइल नहीं है तो सबसे पहले हम

एक सी की फाइल लगाएंगे जैसे हम क्या करते

थे प्रैक्टिकल फाइल बनाया करते थे ना

स्कूल के अंदर जिसमें सारे की सारी हम

चीजें लिखा करते थे वैसे ही यहां पर हम एक

फाइल बनाएंगे जिसके अंदर सारा का सारा

अपना कोड हम लिखने वाले हैं फाइल बनाने के

लिए हम क्लिक करेंगे इस आइकन पर और अपनी

फाइल का हम नाम देंगे हेलोड सी तो ये

हमारी फाइल आ गई है यहां से हम इसे कर

देते हैं बंद अब यहां पर फाइल का नाम हमने

h . स दिया हम अपनी फाइल को कोई भी नाम दे

सकते हैं हो सकता है हम उसे लिखना चाहे

फर्स्ट प्रोग्राम तो हम लिख सकते हैं

फर्स्ट प्रोग्राम स ये डॉ स जो है इसको

एक्सटेंशन कहते हैं जैसे अगर हम t एकटी

फाइल नोटपैड पे कभी फाइल बना देते विज के

सिस्टम में तो उसको हम लिखते थे

abc.xyz

लिखा होता है

पे डॉट पवा लिखा होता है तो जो एक्सटेंशन

होता है वो बता देता है कि फाइल के अंदर

क्या है यहां पे डॉट सी जो है वो सी का

एक्सटेंशन है और ये बता रहा है हमें कि

हमने एक सी की फाइल क्रिएट करी है अब इस

फाइल के अंदर हम क्या करेंगे एक सैंपल कोड

लिखेंगे सी का इस कोड से हम समझेंगे कि सी

को लिखना कितना आसान है और बिल्कुल जितना

लोग बता देते हैं ना प्रोग्रामिंग कोडिंग

बहुत तोप चीज है उतनी कोई बड़ी चीज नहीं

है बहुत ही आसान है इसके अंदर हम कुछ-कुछ

चीजें लिखेंगे जो अभी हमें समझ नहीं आएंगी

लेकिन चैप्टर वन हमारा जैसे ही कंप्लीट ट

होगा सारी चीजें क्लियर हो जाएंगी तो यहां

पर हम कुछ-कुछ चीजें लिखने वाले हैं जो

शायद एलियन लैंग्वेज लग सकती है एसटीडी आड

ए इंट मेन प्रिंट एफ हेलो वर्ल्ड रिटर्न

रो अब यहां हमने हेलो वर्ल्ड लिखा है अब

ये सॉर्ट ऑफ कन्वेंशन होता है कि जो भी नई

प्रोग्रामिंग लैंग्वेज आप सीखते हैं ना

उसमें सबसे पहला कोड जो ये मतलब रूल है

कोडिंग वर्ल्ड का कि सबसे पहला कोड आपको

हेलो वर्ल्ड ही लिखना पड़ता है तो उसका

हमने कोड लिखा है इस कोड का काम है कि यह

हेलो वर्ल्ड को स्क्रीन पे प्रिंट करवा

देगा तो देखते हैं कैसे इसको कर लेते हैं

सेव और किसी भी सी कोड को रन करने के लिए

हमें ऊपर जाना पड़ता है टर्मिनल पे और हम

खोलेंगे न्यू टर्मिनल न्यू टर्मिनल में

सबसे पहले एक लाइन लिखते हैं जीसीसी h स

यहां पर ये जीसीसी जो है वो हमारा कंपाइलर

है c का तो हम उस कंपाइलर को इवोक कर रहे

हैं और उसके बाद लिखेंगे अपनी फाइल का नाम

तो बेसिकली हम क्या कह रहे हैं कि हमारे

जो फाइल में हमने कोड लिखा है उसको कंपाइल

कर दो ये कंपाइल इतना डिफिकल्ट जो शब्द है

ना ये भी चैप्टर वन के एंड तक क्लियर हो

जाएगा तो फाइल को हमने कर दिया कंपाइल अब

इसको रन करेंगे कोड को कैसे रन करेंगे हम

लिखेंगे / एड आउट ये a एक अ बाय डिफॉल्ट

फाइल क्रिएट हो जाती है जिसका एक्सटेंशन

है डॉट आउट यानी डॉट आउटपुट इसको हम कर

देंगे रन तो प्रिंट होगा हमारे लिए हेलो

वर्ल्ड अब जो कोडर्स विंडोज पर हैं उन्हें

यहां पर लिखना पड़ेगा ड a.exe क्योंकि

विंडोज में बाय डिफॉल्ट a.exe फाइल क्रिएट

होती है जिसकी एक्सटेंशन होती है डटी यानी

एग्जीक्यूटेबल फाइल लेकिन जो स्टूडेंट्स

हमारे

बहुत सिंपल और बहुत लॉजिकल है अगर थोड़ा

सा अब हम कोडिंग सीख पाते हैं तो हम

डिस्कवर करेंगे कि उससे हम कितनी सारी

इंटरेस्टिंग चीजें बना सकते हैं तो ये लिख

दिया है हमने अपना हेलो वर्ल्ड प्रोग्राम

इसके अंदर ये मेन क्या होता है ये इंक्लूड

क्या होता है ये यहां पे हैश क्यों लिखा

हुआ है ये ज़ीरो क्यों लिखा हुआ है इन सब

का मतलब हमें धीरे-धीरे समझ में आने वाला

है अब अपने चैप्टर वन के अंदर हम कुछ

बेसिक कांसेप्ट पढ़ेंगे जिनको पढ़ने के

बाद हमें प्रोग्रामिंग समझ में आने लग

जाएगी इसके अंदर हम सबसे पहले पढ़ने वाले

हैं वेरिएबल के बारे में कीवर्ड्स क्या

होते हैं हमारे कांस्टेंट्स क्या होते हैं

साथ में कॉमेंट्स किस तरीके से लिखे जाते

हैं हमने जो अभी सी का बेसिक प्रोग्राम

लिखा है इसका स्ट्रक्चर क्या होता है और

ये जो हमने कंपाइलेशन की बात करी थी हमारा

कोड एक्चुअली रन कैसे हो रहा है इस मशीन

पे इस कंप्यूटर पे इस सब के बारे में हम

सिर्फ अपने चैप्टर वन में पढ़ेंगे और सारी

चीजें सीख लेंगे सबसे पहला टॉपिक जिसके

साथ हम शुरुआत करने वाले हैं ये है

वेरिएबल वेरिएबल की डेफिनेशन की अगर बात

करें तो ये होता है नेम ऑफ अ मेमोरी

लोकेशन व्हिच स्टोर्स सम डेटा अब वेरिएबल

मेमोरी लोकेशन का नाम होता है जब भी हमें

कोई चीज स्टोर करनी पड़ती है उसके लिए

पहले जगह चाहिए होती है जैसे मान लीजिए

हमें कोई जूते रखने हैं तो जूतों के लिए

पहले डब्बे होते हैं ना किसी भी दुकान में

बहुत सारे हर डब्बे के अंदर कुछ जूते आते

हैं एक डब्बे के अंदर हील्स रखी होंगी एक

डब्बे के अंदर चप्पल रखी होंगी तो वो जो

चप्पल है वो हील्स है वो शूज हैं

स्पोर्ट्स शूज हैं वो सारा हमारा डाटा है

और उस डब्बे को हम एक कंटेनर कह सकते हैं

जिसके अंदर हमारा डेटा रहता है और उसी

कंटेनर को अगर हम कोई नाम दे दें तो वो

नाम होगा हमारा वेरिएबल उसी तरीके से

मम्मी जब किचन में बहुत सारे मसाले रखा

करती हैं मान लीजिए एक डब्बा है जिसमें

मसूर की दाल रखी है एक डब्बा है जिसमें

हल्दी रखी है एक डब्बा है जिसमें नमक रखा

है तो ये जो कंटेनर्स होते हैं इनके अंदर

हमारा डाटा होता है यानी कोई हमारा खाने

का सामान होता है बाहर वाला जो कंटेनर

होता है उसको हम कह देते हैं वेरिएबल अब

इसी तरीके से कंप्यूटर भी कुछ डाटा स्टोर

करता है ये डाटा जहां पर जाकर स्टोर होता

है मान लीजिए यह है हमारे कंप्यूटर की

मेमोरी और इसमें खुद के कुछ-कुछ डब्बे बने

हुए हैं और इस मेमोरी के अंदर अगर हमें

नंबर 25 स्टोर कराना है तो उसको हम किसी

एक डब्बे में स्टोर करा देंगे और उस डब्बे

को हम एक नाम दे देंगे जो नाम है यहां पर

a और इसी a को हम कह देते हैं वेरिएबल अब

मान लो इसके बाद नंबर नहीं कोई कैरेक्टर

स्टोर कराना है तो ये कैरेक्टर s को हम एक

नई मेमोरी लोकेशन यानी नए डब्बे पर स्टोर

करा देंगे उस मेमोरी लोकेशन का हम नाम दे

देंगे b और ये b क्या कहलाएगा ये कहलाएगा

हमारा वेरिएबल तो मेमोरी के अंदर अगर हमें

कुछ भी स्टोर कराते हैं तो उस मेमोरी

लोकेशन को जब कोई नाम दे देते हैं उस

डब्बे को कोई नाम दे देते हैं उसको हम

वेरिएबल कहते हैं अब वेरिएबल को एक्चुअली

इंप्लीमेंट कैसे करते हैं उसका कोड लिखकर

देख लेते हैं हल्का सा यह वाली लाइन हम

हटा रहे होंगे यह जो सारा का सारा कोड है

यह हमारा बाय डिफॉल्ट कोड है यानी इसको हम

हर बार लिखने वाले हैं अभी हमें इस पर

ध्यान नहीं देना अभी हमें बीच के कुछ

पार्ट पर ध्यान देना है मान लीजिए हमें

नंबर 25 को स्टोर कराना है तो हम यहां पर

लिखेंगे इंट नंबर इज इक्वल टू 25 तो इस

सिंगल लाइन की वजह से हमारा नंबर 25 में

मेरी में स्टोर हो गया उस डब्बे के अंदर

जाके और उस डब्बे का नाम हमने यहां पर

लिया है नंबर वैसे ही अगर कोई कैरेक्टर

स्टोर कराना हो कैर स्टार इ इक्वल टू

स्टार तो अपनी मेमोरी के अंदर हमारे

कीबोर्ड पे जो स्टार बना हुआ है इसको हमने

स्टोर करा दिया मेमोरी में और उस वेरिएबल

का उस कंटेनर का नाम हमने दे दिया स्टार

उसी तरीके से अगर हमें एज स्टोर करानी है

तो हम लिखेंगे इंट ए इ इक्वल टू 22 तो

यहां पे हमने अपनी एज 22 मेमोरी के अंदर

स्टोर करा दी और उस लोकेशन का नाम हमने दे

दिया एज यहां पर यह जो इंट क्या है यह

कैरेक्टर क्या है इसको हम अभी के लिए

इग्नोर करेंगे और ध्यान देंगे सिर्फ इस

लाइन पर वैसे ही मान लीजिए हमें कोई

डेसीमल वैल्यू स्टोर करानी हुई तो हम

लिखेंगे फ्लोट पा =

3.14 तो ये जो पाई की हमारी वैल्यू होती

है 3.14 ये भी अब मेमोरी के अंदर जाके

स्टोर हो गई है और उस मेमोरी लोकेशन का उस

कंटेनर का हमने नाम दे दिया पाई तो कुछ इस

तरीके से कोई भी नंबर कोई भी वैल्यू अपनी

मेमोरी के अंदर हम स्टोर करा सकते हैं और

वह जहां पर स्टोर हुई है उस कंटेनर का हम

नाम याद रख सकते हैं तो इनको हम वेरिएबल

कहते हैं अब c के अंदर वेरिएबल को लिखने

के कुछ-कुछ रूल्स होते हैं इनमें से सबसे

पहला रूल हमारा होता है कि वेरिएबल आर केस

सेंसिटिव केस सेंसिटिव कहने का क्या मतलब

है कि छोटा a और बड़ा a अलग-अलग होंगे जो

हमारा कैपिटल a और हमारा स्मल a होता है

ये अलग-अलग होंगे इनको हम सेम नहीं मान

सकते जैसे अगर हमें कोई नंबर स्टोर कराना

है 30 तो हम लिख सकते हैं इंट a = 30 तो

मेमोरी के अंदर 30 स्टोर हो गया और उस

लोकेशन का नाम जहां पे स्टोर हुआ उसको

हमने a दे दिया अब हमें दूसरा नंबर स्टोर

कराना है 40 तो अगर हम लिखें इंट a = 40

तो दूसरी लोकेशन पर 40 हमारे पास स्टोर हो

गया और उस लोकेशन का नाम हमने कैपिटल a दे

दिया यहां पर ये स्ल a और यह कैपिटल a

दोनों अलग-अलग वेरिएबल हैं सेम नहीं है

दूसरा रूल जो c का कहता है वेरिएबल के

बारे में वो यह कहता है कि फर्स्ट

कैरेक्टर इज अल्फाबेट और अंडरस्कोर इसका

क्या मतलब है कि वेरिएबल के नाम में जो भी

हमारा पहला कैरेक्टर होता है वह या तो एक

नॉर्मल इंग्लिश का कैरेक्टर हो सकता है या

फिर अंडरस्कोर हो सकता है इसके अलावा और

कोई वैल्यू नहीं हो सकती जैसे अगर हमें एज

स्टोर करानी थी तो हमने क्या लिखा था यहां

पर हमने लिखा था इंट एज इसे हम इस तरीके

से भी लिख सकते थे इंट ए = 22 लेकिन इसको

हम ऐसे नहीं लिख सकते हाइन ए = 22 क्योंकि

यहां पे हमारी रेड लाइन आ जाएगी और यह गलत

हो जाएगा यहां पे अगर हम वन एज भी लिखना

चाहे तो यह रेड हो गया यानी गलत आगे सिर्फ

कोई इंग्लिश का कैरेक्टर या फिर अंडरस्कोर

ही आ सकता है वेरिएबल के नाम में तीसरा

रूल हमारा कहता है नो कॉमा और ब्लैंक

स्पेस यानी वेरिएबल के नाम में ना कोई

कॉमा हो सकता है ना कोई ब्लैंक स्पेस हो

सकती है जैसे अगर हमें कोई फाइनल प्राइस

स्टोर कराना है तो हम लिखेंगे इंट फाइनल

अंडरस्कोर प्राइस इ इ ₹1 अब ये जो

अंडरस्कोर है ना सिर्फ यही एक ऐसा स्पेशल

कैरेक्टर है जो हमारे वेरिएबल के नाम के

अंदर आ सकता है मान लीजिए इस अंडरस्कोर की

जगह हम यहां पर स्पेस दे देते हैं तो यहां

पे हमारे पास आ जाता एरर क्योंकि हम स्पेस

नहीं दे सकते वेरिएबल के नाम में या फिर

स्पेस की जगह अगर हम कॉमा दे देते तो भी

एरर आता क्योंकि कॉमा भी नहीं दे सकते हम

एक ही स्पेशल कैरेक्टर को यूज़ कर सकते

हैं वेरिएबल में जो होता है अंडरस्कोर जो

लेकर आता है हमें फोर्थ रूल की तरफ व्हिच

इज नो अदर सिंबल अदर दन अंडरस्कोर कैन बी

यूज्ड अब वेरिएबल के बारे में एक स्पेशल

चीज वेरिएबल की वैल्यू जो है ना वो फिक्स

नहीं होती वो चेंज हो सकती है जैसे हमने

डिफाइन कर दिया हमारा एज वेरिएबल क्योंकि

आज की डेट में हमारी एज जो है वो 22 है

लेकिन कल को यानी 2 साल बाद हमारी एज 24

हो जाएगी अपडेट होके तो उसको हम किस तरीके

से लिखेंगे एज इ इक्व

24 तो पहले हमारा जो एज वेरिएबल था यानी

वो जो मेमोरी लोकेशन थी उसमें 22 स्टोर्ड

था पर अब 2 साल बाद हमारी एज में हमने

स्टोर करा दिया 24 तो इस तरीके से किसी भी

वेरिएबल की वैल्यू को हम अपडेट कर सकते

हैं तो वेरिएबल जो हैं हमारे कोड के अंदर

वो चेंज होते रहते हैं एंड इनफैक्ट

वेरिएबल का जो इंग्लिश मतलब होता है वो भी

होता है कोई ऐसी चीज जो चेंज होती रहती है

तो इट ऑल मेक्स सेंस नाउ अब वेरिएबल को जब

भी हम लिखते हैं एक स्पेशल टिप हर

प्रोग्रामर को दी जाती है जो एक सीनियर

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

नाम हमेशा मीनिंगफुल होने चाहिए यानी

वेरिएबल को पढ़ते ही देखते ही हमें समझ

में आ जाए इसके अंदर स्टोर क्या हुआ है

जैसे हमने यहां पर एज स्टोर की तो वेरिएबल

का नाम एज दे दिया एक स्टार स्टोर कर दिया

तो उसका नाम स्टार दे दिया कोई रैंडम नंबर

स्टोर किया है तो नाम हमने नंबर दे दिया

कभी-कभी रैंडम हां हम ए बी सी इस तरीके के

नाम रख सकते हैं क्योंकि वो इजी पड़ता है

लेकिन जब भी हम कोई बड़ा प्रोग्राम लिख

रहे हैं ना उसमें ए बी सी करके बहुत सारे

वेरिएबल हो जाएंगे इसीलिए वहां पर

मीनिंगफुल नाम देने बहुत जरूरी हैं तो अगर

आगे जाकर आप अपने इंटरव्यूज में बैठते हैं

कंपनीज में प्लेसमेंट्स के लिए या फिर कोई

अपना प्रोजेक्ट बना रहे हैं अच्छे लेवल का

फ्रीलांसिंग करें तो उसके अंदर अपने

वेरिएबल के नाम हमें बहुत अच्छे से लिखने

हैं जैसे अगर हमें 100 ही स्टोर कराना था

तो यहां पे सीधा सिर्फ एफ लिख सकते थे

लेकिन हमने पूरा नाम लिखा फाइनल प्राइस

जिससे समझ आए कि 100 जो है एक प्राइस है

अब जो नेक्स्ट चीज जिसके बारे में हम

पढ़ने वाले वेरिएबल के बाद वो है हमारी

डाटा टाइप्स सी के अंदर बहुत सारे डेटा

टाइप्स होते हैं ये डिफरेंट जो डेटा

टाइप्स हैं उनकी हमने आपको लिस्ट दी हुई

है और ये सारी की सारी स्लाइड्स आपको नीचे

डिस्क्रिप्शन बॉक्स में अवेलेबल होंगी तो

यहां पर अभी कुछ भी याद करने की जरूरत

नहीं है इनफैक्ट ये सारे के सारे हमें याद

करने भी नहीं पड़ते इसमें कुछ-कुछ ऐसे हैं

जो कोडिंग करते करते हमें डेफिनेटली याद

हो जाएंगे तो उसी से सारी चीजें जो है

दिमाग में रहती है डेटा टाइप होता है कि

मेमोरी के अंदर आप किस तरीके का डाटा

स्टोर कर रहे हैं और जिस भी तरीके का डाटा

होता है ना उसके लिए स्पेसिफाइड होता है

कि ये इतनी ही मेमोरी खाएगा जैसे जब भी

पेन ड्राइव खरीदते हैं तो उसपे लिखा होता

है कि ये 8gb की पेन ड्राइव है या 16gb की

पेन ड्राइव है उसी तरीके से हमारा जो

कैरेक्टर टाइप का डाटा होता है वो खाता है

हमारी वन बाइट की मेमोरी को अगर इंटी जर

टाइप के डाटा की बात करें तो वो खाता है

हमारी 2 बाइट की मेमोरी को अगर फ्लोट डाटा

की बात करें तो वो खाता है हमारी फोर वाली

मेमोरी को अब वो स्टूडेंट्स जो दूसरी

लैंग्वेजेस सीखने के बाद सी को सीख रहे

हैं वो मेरी तरह थोड़े से सरप्राइज्ड हो

जाएंगे क्यों क्योंकि उन्हें पता चलेगा कि

सी के अंदर ना तो बोलियन टाइप का डेटा

टाइप होता है ना स्ट्रिंग टाइप का डटा

टाइप होता है ये दोनों सी के अंदर एजिस्ट

नहीं करते हैं क्योंकि सी सबसे पहले आई थी

यानी सी 1970 में आई थी उसके बाद c+ प आई

थी उसके बाद जावा आई थी उसके बाद

जावास्क्रिप्ट आई थी तो सी हमारी बहुत ही

पुरानी लैंग्वेज है इसीलिए इसमें काफी

सारी ऐसी चीजें हैं जैसे ऑब्जेक्ट्स और

क्लासेस हो गए जो मिसिंग होते हैं तो ये

कॉन्सेप्ट्स जो हैं इनके लिए हमें दूसरी

लैंग्वेजेस बाद में सीखनी पड़ती है तो इन

सारे डाटा टाइप्स में से हम कुछ-कुछ

इंपॉर्टेंट डे डाटा टाइप्स जो हैं उनको

लिखकर देखेंगे और सिर्फ उन्हें ही अभी

हमें याद रखना है बाकियों को याद अभी रखने

की जरूरत नहीं है तो अपने कोड के अंदर

हमने जो ऑलरेडी काफी सारी चीजें लिखी थी

उनको एक बार हटा देते हैं और तीन डेटा

टाइप्स की यहां पे बात करेंगे सबसे पहला

डेटा टाइप है हमारा इंट इंट क्या स्टोर

करता है इंट स्टोर करता है इंटी जर

वैल्यूज को यानी जो वैल्यूज हमारी होल

होती हैं या तो पॉजिटिव हो सकती है या

नेगेटिव हो सकती हैं जैसे + 1 हो गया + 2

हो गया + 5 हो गया -1 हो गया 0 हो गया इस

तरीके की वैल्यूज तो अगर हमें एज स्टोर

करवानी है तो एज हमारी एक होल वैल्यू होती

है यूजुअली तो उसको हम स्टोर करवाएंगे इंट

डाटा टाइप में तो यहां लिखेंगे इंट एज इ

इक्वल टू 22 तो इस लाइन से हमें तीन चीजें

पता चली सबसे पहला जो डाटा हम स्टोर करा

रहे हैं वो है 22 जिस मेमोरी लोकेशन पे

स्टोर कराया है उसका नाम हमने दिया है एज

और जिस टाइप का डाटा है वो है इंटी जर

वैल्यू अब वैसे ही अगर हमें पाई की वैल्यू

स्टोर करानी हो पाई तो हमारा इंटी जर होता

नहीं है उसके अंदर तो डेसीमल वैल्यूज आती

हैं इसीलिए उसको हम स्टोर कराएंगे फ्लोट

डेटा टाइप में तो यहां लिखेंगे फ्लोट फिर

लिखेंगे पाई और इसकी वैल्यू हम दे देंगे

3.14 तो ये डेसिमल वैल्यूज वाला एक नंबर

है इसको हमने फ्लोट डेटा टाइप में स्टोर

कराया है अब इसके अलावा एक और डटा टाइप

होता है जिसका नाम होता है कैरेक्टर तो जो

भी हमारी स्पेशल कैरेक्टर्स होते हैं ना

जैसे हैश हो गया हमारा एम पर हो गया रेट

हो गया स्टार हो गया यानी एस्ट रिस्क उन

सबको हम कैरेक्टर डाटा टाइप में स्टोर

कराते हैं कैरेक्टर के लिए लिखना पड़ेगा

कैर और यहां पर मान लीजिए हम लिखते हैं

अपना शैग

तो यहां पर सबसे पहले कैरेक्टर्स को स्टोर

कराने के लिए हमें सिंगल कोट लिखने पड़ते

हैं और अंदर हम लिख सकते हैं अपना

कैरेक्टर तो इस तरीके से हमने कैर डटा

टाइप का एक वेरिएबल स्टोर करा लिया फ्लोट

का करा लिया इंट का करा लिया अभी के लिए

क्योंकि हम बेसिक लेवल से चल रहे हैं यही

तीन जो हैं ये तीनों मेन हैं जिनको हमें

याद रखने की जरूरत है बाकी हम टाइम के साथ

और ज्यादा सीखते चले जाएंगे अब नेक्स्ट

टॉपिक जिसकी हम बात करेंगे वो है हमारे

कांस्टेंट्स हमने बात की थी इससे पहले

वेरिएबल की वेरिएबल में क्या इशू था

वेरिएबल की वैल्यू चेंज हो सकती थी अब अगर

जब भी हम बड़ी-बड़ी कंपनीज में बड़े-बड़े

सॉफ्टवेयर्स बनाते हैं जैसे कोई एडमिन

पैनल हमने बनाया कोई वेबसाइट बनाई उसके

टेस्टिंग पर्पसस के लिए हम क्या करते हैं

एक अपना खुद का ईमेल पासवर्ड रख लेते हैं

जो फिक्स्ड होता है जिसकी वैल्यू हमें

चेंज नहीं करनी हर बार उसी ईमेल पासवर्ड

से हमें लॉग इन करना है तो हम क्या कर

सकते हैं किसी फाइल के अंदर एक ईमेल

वेरिएबल बना सकते हैं एक पासवर्ड वेरिएबल

बना सकते हैं और दोनों के अंदर कोई वैल्यू

रख सकते हैं सी के अंदर वो वैल्यूज जो

हमेशा कांस्टेंट रहती हैं जिनकी वैल्यू

चेंज नहीं होती उनको हम कहते हैं

कांस्टेंट्स कांस्टेंट्स हमारे तीन टाइप

के होते हैं इनमें से सबसे पहले हैं इंटी

जर कांस्टेंट्स जैसे हमारा नंबर वन हो गया

वन की वैल्यू हमेशा वन ही रहेगी वन की

वैल्यू नेगेटिव 1 या 0 या नेगेटिव फ वो

नहीं हो सकती वन की वैल्यू हमेशा

कांस्टेंट रहेगी फिक्स्ड रहेगी तो हमारे 1

2 3 0 -1 -2 इस तरीके के जो कांस्टेंट्स

होते हैं इनको इंटी जर कांस्टेंट्स कहते

हैं उसके बाद आते हैं हमारे रियल

कांस्टेंट्स रियल कांस्टेंट्स यानी जिनके

अंदर रियल नंबर्स होते हैं जैसे वन 0 अब

1.01 भी होता है लेकिन यह रियल कांस्टेंट

है इसको दिखाने के लिए इसका पट 0

एक्स्ट्रा लिखा गया है उसी तरीके से 2 का

प0 एक्स्ट्रा लिखा गया है अगर ये सिर्फ टू

होता तो फिर ये इंटी जर कांस्टेंट बन जाता

अभी ये रियल कांस्टेंट है 3.14 यहां पर

हमारे पास आना चाहिए था - 2.4 तो फिर ये

एक रियल कांस्टेंट होता अब तीसरा टाइप ऑफ

कांस्टेंट हमारे पास होते हैं कैरेक्टर

कांस्टेंट्स कैरेक्टर्स में क्या-क्या आ

जाते हैं हमारे सारे अल्फाबेट्स आ जाते

हैं अपर केस लोअर केस में हमारे पास

कैपिटल ए आ गया स्पेशल कैरेक्टर्स भी आ

जाते हैं जैसे हमारे पास हैश आ गया हमारा

एम परसेंट आ गया हमारा एस्ट रिस्क आ गया

या इसके अलावा हमारा ट द रेट आ गया तो इस

तरीके के सारे कैरेक्टर्स मिलकर हमारे

कैरेक्टर कांस्टेंट्स बनाते हैं और एक चीज

नोट करनी पड़ेगी यहां पर कि कैरेक्टर

कांस्टेंट जो होते हैं ना इस कैपिटल a की

वैल्यू हमेशा कैपिटल a ही रहेगी स्ल ए

नहीं हो जाएगी और जब भी कैरेक्टर

कांस्टेंट्स को कोड के अंदर लिखना होता है

तो उनको हम लिखते हैं सिंगल कोड्स के अंदर

यानी जब भी हम कोई कैरेक्टर कांस्टेंट

लिखेंगे कोड में तो वहां पर हमें सिंगल

कोड्स लगाने पड़ेंगे अब नेक्स्ट टॉपिक

जिसकी हम बात करेंगे उसका नाम है कीवर्ड्स

जैसे डिक्शनरी के अंदर कुछ-कुछ वर्ड होते

हैं हर वर्ड का अपना एक फिक्स्ड मतलब होता

है उसको चेंज नहीं कर सकते वैसे ही हर

प्रोग्रामिंग लैंग्वेज की अपनी एक

डिक्शनरी होती है सी की भी अपनी एक

डिक्शनरी है जिसके अंदर कुछ-कुछ वर्ड्स जो

हैं वो रिजर्व्ड हैं यानी वो फिक्स्ड है

उसका मतलब सिर्फ वही रहेगा उसको हम

वेरिएबल नाम की तरह यूज़ नहीं कर सकते ना

ही करना चाहिए

तो इसी तरीके से सी के अंदर कुछ रिजर्व्ड

वर्ड्स हैं जिनका कुछ स्पेशल मीनिंग है और

यह मीनिंग कंपाइलर को पता है तो सी

प्रोग्रामिंग लैंग्वेज के अंदर 32

कीवर्ड्स होते हैं और इन कीवर्ड्स का हमें

खास ध्यान देना है अगर इन 32 की लिस्ट की

बात करें तो हमारे 32 कीवर्ड्स कुछ ऐसे

होते हैं सी के अंदर इस लिस्ट में हमें

दिख रहा होगा कि इंट हमारा एक रिजर्व्ड

वर्ड है हमारा कीवर्ड है सी का तो इसको

यानी किसी भी वेरिएबल का नाम हम इंट नहीं

रख सकते वैसे ही हम इसमें ढूंढने निकले तो

फ्लोट भी हम हमारा एक कीवर्ड है इसके

अलावा कैरेक्टर भी हमारा एक कीवर्ड है और

ये जो सारे के सारे कीवर्ड्स हैं ना इनको

अब अपने पूरे कोर्स के अंदर हम कहीं ना

कहीं एक्सप्लोर कर लेंगे तो हमें पता चल

जाएगा कौन-कौन से कीवर्ड्स हैं इसीलिए जब

भी अपने प्रोग्राम में देखते हैं ना हम

जैसे हमारे पास ये इंट लिखा हुआ है इस इंट

का एक स्पेशल मतलब है जो सिर्फ कंपाइलर को

पता है तो किसी भी वेरिएबल का नाम हमें

इंट नहीं रखना ये रिटर्न है रिटर्न भी एक

कीवर्ड है किसी भी वेरिएबल का नाम हमें

रिटर्न नहीं रखना क्योंकि ये स्पेशल

वर्ड्स है जिनके मतलब फिक्स्ड हैं जो

कंपाइलर को पता है अब एक बार अपने

प्रोग्राम के स्ट्रक्चर को समझते हैं कि

जिस भी प्रोग्राम को जिस भी कोड को हम लिख

रहे हैं उसको एक्चुअली समझ कैसे सकते हैं

हम कि वो बना कैसे होता है तो जैसे ह्यूमन

बॉडी का एक स्केलेटन होता है वैसे ही हर

एक कोड का हर एक प्रोग्राम का एक

स्ट्रक्चर होता है अगर हम अपने सी के

प्रोग्राम के स्ट्रक्चर की बात करें तो

हमारा प्रोग्राम कुछ ऐसा दिखता है ये

हमारा इनिशियल कोड है जिसको हमने लिखा था

इसमें सबसे पहले लिखा हुआ है हैश इंक्लूड

फिर हमारे एंगुलर ब्रैकेट्स आ जाते हैं और

बीच में आया है एसटीडी आड ए इसको कहते हैं

हम अपना प्री

प्रोसेसर डायरेक्टिव अब एक प्री प्रोसेसर

डायरेक्टिव होता क्या है इसको बाद में

पढ़ेंगे अभी के लिए ये समझना है कि इस

लाइन को हमें हमेशा अपने कोड के अंदर

लिखना है नहीं तो हमारा सी को कोड नहीं चल

रहा होगा उसके बाद हम हमेशा ये लाइन लिखते

हैं इंट मेन उसके बाद हमारे पेंसिस और फिर

कर्ली ब्रेसस और इन कर्ली ब्रेसस के अंदर

जो भी पार्ट लिखा होता है यह होता है

हमारा मेन का कोड हमारा जो प्रोग्राम का

एग्जीक्यूशन होता है वो मेन फंक्शन से

शुरू होता है यानी इस फंक्शन से फंक्शन

हमारे कोड का एक ऐसा पार्ट होता है जो

हमें कुछ काम करके देता है हम फंक्शंस के

बारे में भी डिटेल में पढ़ने वाले हैं मेन

फंक्शन से हमेशा किसी भी सी प्रोग्राम का

एग्जीक्यूशन शुरू होगा और वो एग्जीक्यूशन

होगा लाइन बाय लाइन यानी सबसे पहले ये

लाइन आई है तो पहले ये एग्जीक्यूट होगी

फिर ये लाइन आई है तो फिर ये एग्जीक्यूट

होगी इसके बाद हमारा मेन फंक्शन जो है वो

खत्म हो जाता है अब आप नोटिस करेंगे कि हर

लाइन के पीछे हम कोड के अंदर एक सेमीकलन

लिखते हैं यानी इस लाइन के पीछे भी एक

सेमीकलन लिखा है इस लाइन के पीछे भी एक

सेमीकलन लिखा है यह सेमीकलन हमारी लाइन

में एक फुल स्टॉप की तरह होता है जैसे हम

हिंदी में पूर्ण विराम लगाते हैं हम

इंग्लिश के सेंटेंसेस में एंड में डॉट

लगाते हैं यानी पीरियड लगाते हैं वैसे ही

हम अपने सी प्रोग्राम के अंदर एक सेमीकलन

लगाकर ये दिखाते हैं कि यहां पर हमारी

लाइन खत्म हो गई है अब आगे जो भी लिखा हुआ

है वो नेक्स्ट लाइन का है इस पूरी की पूरी

चीज को हम यहां भी लिख सकते थे इसके बाद

और हमें पता होता कि वो नेक्स्ट लाइन में

है क्योंकि सेमी कोलन के बाद आ रहा है और

इसके साथ-साथ हमारा जो कोड है ना उसकी

सारी इंस्ट्रक्शंस केस सेंसिटिव है यानी

यहां पर अगर हम लिख लिखना चाहे इंट मेन तो

यह गलत होगा क्योंकि ये सारे अपर केस में

आ गए क्योंकि सी एक के सेंसिटिव लैंग्वेज

है तो जो स्मॉल है वो स्मॉल केस में रहेगा

जो अपर है वो अपर केस में रहेगा उसको हम

इंटरचेंज या रिप्लेस नहीं कर सकते तो इस

तरीके का स्ट्रक्चर रहता है जब भी हम अपना

एक सी प्रोग्राम क्रिएट करते हैं ऊपर

हमेशा एक हेडर फाइल या अपना प्रीप्रोसेसर

डायरेक्टिव इंक्लूड करना है उसके बाद इंट

मेन लिखना है और ये कर्ली ब्रेसेज लगाने

हैं और इसके बीच में हम कुछ भी लिख सकते

हैं पर एंड में हम हमेशा हमेशा एक रिटर्न

जरो वाली लाइन लिखते हैं यह रिटर्न रो में

रो दिखाता है जरो एरर्स यानी हमारा कोड

सक्सेसफुली एग्जीक्यूट हो गया इसमें कोई

एरर नहीं आया तो ये रिटर्न जरो भी हमेशा

एंड में लिखेंगे यहां पर ये वाला पार्ट है

जिसको हम अपने कोड के अंदर कभी भी कहीं भी

चेंज कर सकते हैं अब नेक्स्ट टॉपिक जिसके

बारे में हम पढ़ेंगे इस चैप्टर में वो है

हमारे कमेंट्स जैसे हम लाइफ के अंदर

कुछ-कुछ कमेंट्स देते रहते हैं ना लोगों

को या हम किसी

चीज लिखना जो हमारे कोड का पार्ट नहीं है

कुछ एक्स्ट्रा पार्ट है कॉमेंट्स इंग्लिश

में भी हो सकते हैं कुछ-कुछ लैंग्वेजेस

अलाउ करती हैं कि हमारे कॉमेंट्स हम

डिफरेंट लैंग्वेजेस में भी लिखते हैं हम

चाइनीज में कॉमेंट्स लिख सकते हैं रशियन

में लिख सकते हैं तो ये वो पार्ट है जो

कोड में इंक्लूडेड नहीं है ये हमारे

एक्स्ट्रा इंस्ट्रक्शंस होते हैं अब

कॉमेंट दो टाइप्स के होते हैं सी के अंदर

सबसे पहले होते हैं हमारे सिंगल लाइन

कॉमेंट्स जिनको हम डबल स्लैश लगाकर लिखते

हैं और उसके बाद होते हैं हमारे मल्टीपल

लाइन कॉमेंट्स जिनको हम इस फॉर्मेट में

लिखते हैं अब अपने कोड में एक्चुअली

कमेंट्स लिख कर देखते हैं कि लिखे कैसे

जाते हैं जैसे इस कोड के अंदर हमने अंदर

बताया है कि डेटा टाइप्स क्या होते हैं तो

यहां पर हम एक कॉमेंट लिख सकते हैं डबल

स्लैश लगाकर दिस कोड डिस्प्लेज हाउ डेटा

टाइप्स वर्क इन सी तो ये एक ऐसी चीज है जो

इंग्लिश में लिखी गई है और कोड का पार्ट

नहीं है ऐसे ही मान लो कि हमें मल्टीपल

लाइन में कॉमेंट्स लिखने होते हैं तो हम

लिखते हैं स्लश एस्ट रिस्क और एस्ट रिस्क

स्लैश और इसके बीच में हम कुछ भी लिख सकते

थे दिस इज अ मल्टी लाइन कमेंट तो यह हमारी

मल्टीपल लाइंस पर हम कुछ-कुछ चीजें लिखे

जा रहे हैं और ये सारी कॉमेंट का पार्ट है

अब अगर इसको हम हटा दें तो ये जो इंग्लिश

वाली चीज है ना ये हमें एरर देगी क्योंकि

ये एक्चुअली सी को समझ ही नहीं आ रही

कंपाइलर समझ ही नहीं पा रहा कि इसका मतलब

क्या है ये एक्चुअली लिखा क्या हुआ है

इसीलिए वो पार्ट जो सेंस नहीं बना था

कंपाइलर के लिए उसको हम हमेशा कमेंट्स में

लिखते हैं जैसे बड़ी-बड़ी कंपनीज में जब

भी आप कोड लिखने चलेंगे तो कोड इतना

ज्यादा हजारों लाइनों के कोड हो जाते हैं

कि उसको समझना मुश्किल हो जाता है इसीलिए

दूसरे प्रोग्रामर्स को हेल्प करने के लिए

हम अपने कोड के अंदर कमेंट्स लिखते हैं

उनको ये बताने के लिए कि कोड का कौन सा

पार्ट क्या फंक्शन परफॉर्म करता है अब

नेक्स्ट टॉपिक जिसको हम पढ़ेंगे वो है

आउटपुट जब भी हम किसी भी लैंग्वेज में

प्रोग्रामिंग करते हैं इनपुट आउटपुट बहुत

एसेंशियल बहुत जरूरी पार्ट है

प्रोग्रामिंग का सबसे पहले सीखेंगे सी के

अंदर हम आउटपुट कैसे दिखाते हैं उसके बाद

सीखेंगे सी के अंदर हम इनपुट कैसे लेते

हैं तो आउटपुट दिखाने के लिए सी के अंदर

अभी हमने लिखा था एक स्टेटमेंट वो होती है

प्रिंट एफ और उसके बाद लगाते हैं हम

पैरेंस पैरेंस के अंदर हम लिखते हैं डबल

कोट्स और डबल कोट्स के अंदर हम कुछ भी लिख

सकते हैं हमने लिखा था हेलो वर्ल्ड पर

यहां पर हम लिख सकते हैं हेलो श्रद्धा

यहां पर हम लिख सकते हैं हेलो अपना कॉलेज

यहां पर हम लिख सकते हैं हेलो सी तो कुछ

भी लिखा जा सकता है इन डबल कोड्स के अंदर

और जो भी चीज हम लिखेंगे वो वैसी की वैसी

स्क्रीन पे हमारे पास प्रिंट हो जाएगी और

इस प्रिंट प्रिंट करवाने का

रिस्पांसिबिलिटी जो है इस प्रिंट एफ नाम

के एक फंक्शन ने लिखी है प्रिंट एफ हमारे

लिए कुछ भी प्रिंट करवा देता है स्क्रीन

पे और इस लाइन के एंड में हम लगा देंगे

सेमीकलन यह दिखाने के लिए की लाइन यहां पर

खत्म हो गई इसका एग्जांपल अगर

देखें तो अपने कोड के अंदर हम यहां पर लिख

सकते हैं प्रिंट एफ और उसमें लिख सकते हैं

हेलो सी इसको कर लेते हैं सेव ऊपर वाली

एक्स्ट्रा स्पेस को उडा देते हैं और रन

करते हैं अपने कोड को टर्मिनल खोलकर ऊपर

आएगा जीसीसी हेलोड स और हमारे लिए प्रिंट

हो गया हेलो सी अब मान लीजिए हमें बार-बार

बार-बार हेलो सी प्रिंट करना है उसको कैसे

प्रिंट करेंगे इसी लाइन को कॉपी कर लेते

हैं पेस्ट पेस्ट पेस्ट तो चार बार हमने

हेलो सी को प्रिंट कर लिया इसको सेव कर

लेते हैं और यहां पर दोबारा से रन करेंगे

अब हमारे पास हेलो सी प्रिंट हुआ उसके

इमीडिएट बाद दोबारा से हेलो सी प्रिंट हुआ

इसी तरीके से चार बार प्रिंट हुआ पर हम तो

चाहते थे कि अगली अगली अगली अगली लाइन में

प्रिंट हो तो वो नेक्स्ट लाइन हमेशा करने

के लिए ना यहां पर हमें एक चीज लिखनी

पड़ती है स्पेशल चीज जो है हमारा बै स् n

ये बै स् n दिखाता है कि जो भी हमें

प्रिंट करना था ना प्रिंट f में वो तो

प्रिंट हो जाएगा उसके बाद एक नेक्स्ट लाइन

आ जाएगी इसी सेम को यहां पर बै स् n लिख

देते हैं इसके बाद भी नेक्स्ट लाइन चाहिए

इसके बाद भी नेक्स्ट लाइन चाहिए और इसके

बाद भी नेक्स्ट लाइन चाहिए तो इसको कर

देते हैं सेव अब यहां पर दोबारा रन करेंगे

इसको तो अब हमारा जो आउटपुट है वो नेक्स्ट

लाइन में चला गया है एक्चुअली हुआ क्या

इसने हेलो सी प्रिंट किया तो हेलो सी

प्रिंट हो गया उसके बाद बै स्ल ए प्रिंट

किया तो बैक स्ल ए यानी नेक्स्ट लाइन तो

हम यहां पर आ गए फिर दोबारा से हेलो सी

प्रिंट हुआ फिर दोबारा से बै स् n तो

नेक्स्ट लाइन में आ गए इसी तरीके से जब भी

हमें आउटपुट नेक्स्ट लाइन में लेके आना हो

ना तो हम बै स् n लिख देते हैं अब मान

लेते हैं हमने कोई वेरिएबल बनाया है अपने

कोड के अंदर जैसे अगर हमने लिखा इंट ए इ

इक्वल टू 22 और इस एज को हम प्रिंट करवाना

चाहते हैं अपनी स्क्रीन पर कैसे प्रिंट

करवाए इस एज को तो हमें इसके लिए लिखना

पड़ेगा प्रिंट एफ एज इज क्या हम लिखें एज

एक बार इस चीज का हम आउटपुट देखते हैं एज

इज एज तो ये जो डबल कोट्स के अंदर हमने जो

भी लिखा ना इसको हम स्ट्रिंग कहते हैं

यानी ये चीज वैसी की वैसी प्रिंट हो जाएगी

पर हमें तो इसके एज के अंदर का नंबर

प्रिंट करवाना था तो आउटपुट को प्रिंट

करवाने के स के अंदर कुछ-कुछ केसेस आ जाते

हैं इनमें से सबसे पहला केस होता है कि जब

भी हमें कोई इंटी जर प्रिंट करवाना हो तो

उसके लिए हमें अपनी प्रिंट स्टेटमेंट में

लिखना पड़ता है सबसे पहले परसेंटेज का

साइन और डी यह डी दिखाता है डबल वैल्यू को

डबल भी एक डाटा टाइप होता है इसके बारे

में हम बाद में पढ़ रहे होंगे तो परसेंटेज

का साइन और डी और उसके बाद जैसे ही लाइन

खत्म हो जाए फिर लिखेंगे कॉमा और फिर लिख

देंगे अपने वेरिएबल की वैल्यू तो जब भी

चीज प्रिंट होगी ना यह पूरा का पूरा तो

प्रिंट हो जाएगा और इस परसेंटेज डी की जगह

हमारी एज की वैल्यू आ जाएगी जो उसको

रिप्लेस कर देगी उसी तरीके से अगर रियल

नंबर्स के लिए करवाना है तो हम लिख

लिखेंगे परसेंटेज f और फिर लिख देंगे

वेरिएबल तो ये वेरिएबल की वैल्यू रिप्लेस

कर लेगी इस परसेंटेज f को जब भी आउटपुट

प्रिंट होगा अगर कैरेक्टर्स के लिए कराना

है तो लिखेंगे परसेंटेज c और फिर लिख

देंगे अपना वेरिएबल तो वेरिएबल यहां पर इस

परसेंटेज c को रिप्लेस कर लेगा तो इस

तरीके से हमें जब भी कोई वेरिएबल प्रिंट

करवाना होता है जिसका डटा टाइप है कुछ

जिसका कुछ टाइप है तो उसके लिए हम

परसेंटेज डी लिखते हैं इंटी जर टाइप में

परसेंटेज f लिखते हैं रियल नंबर्स में और

परसेंटेज स लिखते हैं कैरेक्टर्स में और

इनको एक्चुअली सी के अंदर इन तीनों को हम

कहते हैं फॉर्मेट

स्पेसिफाई करते हैं कि आउटपुट किस फॉर्मेट

में हमारे पास आएगा और ये जो प्रिंट एफ

फंक्शन है ये एक्चुअली हमारा लाइब्रेरी

फंक्शन है जो बाय डिफॉल्ट सी के अंदर हमें

पहले से परोस के दे दिया जाता है तो एक

बार इन आउटपुट के केसेस को हम भी देख लेते

हैं एग्जीक्यूट करके अब अगर हमें एज लिखनी

है तो हमें पता है कि यहां हमें लिखना

पड़ेगा परसेंटेज डी यहां लगाना पड़ेगा

कॉमा और यहां हम लिखेंगे एज इसको कर लेते

हैं सेव और खोलते हैं अपना टर्मिनल अब

हमारे पास प्रिंट हो कर आ गया है एज इज 22

यहां पे यह परसेंटेज का साइन इसलिए आ रहा

है क्योंकि हमने नेक्स्ट लाइन नहीं दिया

तो इसको सेव करके अगर हम नेक्स्ट लाइन दे

अब हमारे पास आया एज इज 22 अब सिमिलर

तरीके से अगर एज की जगह हमें प्रिंट

करवानी है पाई की वैल्यू तो हम लिखेंगे

फ्लोट पा =

3.14 और यहां पर हम लिखेंगे परसेंटेज f और

यहां लिखेंगे पाई इसको कर लेते हैं सेव तो

अब हमारे पास प्रिंट हुआ एज इज

3.14 तो बाय डिफॉल्ट फ्लोट के अंदर कुछ

नंबर ऑफ डेसिमल्स हैं जो हमेशा प्रिंट ही

होने होते हैं तो उनको हमने यहां पर

प्रिंट कर दिया है अब आप सोच रहे होंगे कि

बार-बार ये जो स्टेटमेंट है एग्जीक्यूशन

की ये कैसे आ रही है तो आपकी जो एरो कीज

होती हैं कीबोर्ड पर आप उनको अपर वाली की

जो है प्रेस कर सकते हैं तो पुरानी

कमांड्स में जा सकते हैं तो तो आपको

बार-बार पूरी स्टेटमेंट एग्जीक्यूट करने

के लिए लिखनी नहीं पड़ेगी आप डायरेक्टली

उस की को प्रेस करके एग्जीक्यूट कर सकते

हैं अब सिमिलर वे में अगर हमें कोई

कैरेक्टर प्रिंट करवाना हो मान लो हमने

कैरेक्टर बनाया है एक स्टार जो स्टार

वेरिएबल का नाम है और इसके अंदर एस्टरिस

को स्टोर कराया है तो हम यहां लिखेंगे

स्टार इज यहां आ जाएगा परसेंटेज सी और

यहां आ जाएगा स्टार इसको कर लेते हैं सेव

और इसको रन किया तो आउटपुट हमारे पास आया

स्टारस एस्ट डिस्क तो कुछ इस तरीके से

हमारे डिफरेंट तरीके के डाटा को हम अपनी

स्क्रीन के ऊपर प्रिंट करवा सकते हैं अब

नेक्स्ट कांसेप्ट जो काफी इंपॉर्टेंट

कांसेप्ट है इस लैंग्वेज का वो है हमारा

इनपुट स के अंदर इनपुट लेने के लिए हम एक

फंक्शन का इस्तेमाल करते हैं जो एक दूसरा

लाइब्रेरी फंक्शन है जिसका नाम है स्कैन

एफ जैसे प्रिंट करने के लिए यूज किया था

प्रिंट एफ वैसे ही कुछ भी इनपुट लेने के

लिए स्कैन करने के लिए यूज करेंगे स्कैन f

अब इसका फॉर्मेट यह रहता है कि जो भी

वैल्यू हमें इनपुट लेनी है उसका सबसे पहले

टाइप लिख देंगे तो फॉर्मेट

स्पेसिफाई परसेंटेज डी हमें दिखाता है कि

हम एक इंट टाइप की वैल्यू को इनपुट लेने

वाले हैं तो सबसे पहले अपने कोट्स लगा

देंगे डबल कोट्स उसके अंदर अपना फॉर्मेट

स्पेसिफाई कॉमा कॉमा के बाद हमें लिखना है

कि ये जो वैल्यू हम इनपुट ले रहे हैं उसका

टाइप तो हमने समझ लिया अब उसको कौन से

वेरिएबल में स्टोर कराना है तो लिखेंगे

अपने वेरिएबल का नाम और उस वेरिएबल के नाम

से पहले एम परसेंट लगा देंगे ये एम परसेंट

यानी एंड एक्चुअली एक एड्रेस है ये इस

वेरिएबल का एड्रेस है यानी ये क्या करेगा

मेमोरी के अंदर जहां पर एज को कोई मेमोरी

का ब्लॉक दिया गया है उस एड्रेस पर जाएगा

और जो भी इनपुट हमारे पास आएगा उसको उस

एड्रेस प जाके स्टोर करा देगा तो कुछ इस

तरीके का काम रहता है स्कैनफ का अब क्या

करते हैं एक नंबर को इनपुट लेके देखते हैं

कि एक्चुअली स्कैन एफ जो है स्कैन कैसे

करता है नंबर को हम बना लेते हैं एक

वेरिएबल एज अब यहां पर लिखेंगे प्रिंट एफ

एंटर एज अब इस वेरिएबल को स्कैन कर लेते

हैं स्कैन एफ से परसेंटेज डी एड्रेस एज और

जो भी वैल्यू हमारे पास वहां पर जाकर

स्टोर हो जाएगी उसी को हम प्रिंट करवा

देंगे यानी दोबारा से परसेंटेज डी इससे

पहले लिख देते हैं एज इज एज इसको कर लेते

हैं सेव अब ऊपर जाकर अपना टर्मिनल खोलते

हैं सबसे पहले एंटर करनी है हमें अपनी एज

एंटर कर देंगे 22 हमारे पास प्रिंट हुआ है

एज इज 22 तो जो भी हमने एज एंटर की थी वो

हमारे पास वापस प्रिंट होकर आ गई है यहां

पे स्कैनफ ने क्या किया एज को एंटर किया

और मेमोरी के अंदर एज वेरिएबल जिस भी

लोकेशन पर पॉइंट कर रहा था वहां पे जाके

उस एज को हमने स्टोर करा दिया उस नंबर 22

को स्टोर करा दिया और जब प्रिंट एफ ने वो

नंबर वापस मांगा तो उसके बाद हमारे पास

प्रिंट हो गया एज इज और यहां पर इसने

दिखाया कि इंट टाइप की वैल्यू प्रिंट करनी

है और फिर हमने एज के अंदर से डाटा निकाल

के अपनी स्क्रीन पे दिखा दिया तो कुछ इस

तरीके से हमारा इनपुट आउटपुट वर्क करता है

सी के अंदर अब हम यहां पर एक छोटा सा

प्रोग्राम बनाने वाले हैं इस छोटे से

प्रोग्राम में क्या करेंगे एक नंबर ए को

इनपुट लेंगे एक नंबर बी को इनपुट लेंगे और

इन दोनों के सम को हम आउटपुट करा देंगे

तोय छोटा सा कोड हम लिखने वाले हैं इस कोड

के लिए सबसे पहले उन नंबर्स को हम क्रिएट

कर लेते हैं तो इंट ए एंड बी अब सबसे पहले

प्रिंट एफ करते हैं एंटर ए उसके बाद स्कैन

कर लेंगे ए को डी एंड ए उसके बाद प्रिंट

एफ कर देंगे एंटर बी फिर स्कैनफ से इसको

ले लेंगे इनपुट एंड b अब इन दोनों के सम

को एक तीसरे वेरिएबल में स्टोर करा देंगे

यानी इंट सम इ इ a + b तो यहां पे भी प्लस

माइनस मल्टीप्लाई डिवाइड रिमाइंडर ये सब

मैथ की तरह काम करते हैं तो प्लस के लिए

प्लस साइन होता है माइनस के लिए माइनस

साइन होता है और ये इक्वल टू क्या करता है

इन दोनों की वैल्यू को कैलकुलेट करेगा और

उसको सम के अंदर डाल देगा ये इक्वल टू जो

है इसको असाइनमेंट ऑपरेटर कहते हैं प्लस

को हम एडिशन ऑपरेटर की तरह यूज़ करते हैं

इन ऑपरेटर्स के बारे में डिफरेंट डिफरेंट

जो भी सी के अंदर होते हैं बाद में हम

डिस्कस कर रहे होंगे डिटेल में तो यह जो

सम हमारे पास आया है इसको अब प्रिंट करवा

देंगे प्रिंट एफ से सम

इज परसेंटेज

d सम इस कोड को कर लेते हैं सेव इसके अंदर

क्या किया हमने दो वेरिएबल बनाए a और b

सबसे पहले लिखा एंटर कर दो a तो a को हमने

एंटर करवा दिया और उसको उस वेरिएबल की

मेमोरी लोकेशन में जाके स्टोर कर दिया

उसके बाद b को एंटर करवाया उसको b की

मेमोरी लोकेशन में जाके स्टोर कर दिया

उसके बाद एक नया वेरिएबल बनाया सम जिसके

अंदर a और b को ऐड करके जो फाइनल वैल्यू

आई उसको स्टोर करा दिया उसके बाद हमने

प्रिंट करवा दिया है सम की वैल्यू को अब

अपने टर्मिनल को खोलकर इसका आउटपुट

एनालाइज करते हैं सबसे पहले हम a की

वैल्यू को एंटर करेंगे तो एंटर करते हैं

टू फिर एंटर करेंगे b की वैल्यू को इसमें

एंटर कर देते हैं फाइव तो हमारे पास

आउटपुट में आया सम इज सेवन इस तरीके से टू

और फाइव का दोनों का सम हुआ और फिर सेवन

प्रिंट हो गया अब यहां पे हम छोटी सी

ट्रिक सीखने वाले हैं यहां पर एक तीसरा

वेरिएबल सम हमने बनाया इसको तो हम हटा

देते हैं और डायरेक्टली क्या करेंगे इस सम

को हटाकर यहां लिख देंगे a + b और इसको कर

लेते हैं सेव और एक बार दोबारा से अपनी

कोड को रन करते हैं 2 5 तो डायरेक्टली

हमारे पास सेवन जो है जो हमारा सम है वो

प्रिंट हो गया तो हमें एक तीसरा वेरिएबल

बनाने की जरूरत नहीं पड़ी जब भी हमें सम

प्रिंट करवाना है अगर हमें यहां पर

डिफरेंस भी प्रिंट करवाना होता तो हम प्लस

की जगह माइनस लिख सकते थे दोनों का

प्रोडक्ट प्रिंट करवाना होता तो एस्टरिस

करके इनको मल्टीप्लाई भी कर सकते थे तो इस

तरीके से जो भी वैल्यू प्रिंट करवानी है

डायरेक्टली उस पर ऑपरेशंस कर सकते हैं और

उसको यहां पर हम लिख सकते हैं अब हमने

काफी सारी चीजें सीख ली है सी के अंदर और

ये सारी की सारी चीजें कैसे रन की इनको

हमने एक फाइल में लिखा और उस फाइल से

हमारे पास आउटपुट आते चले गए अब इस पूरे

के पूरे प्रोसेस को हम कंपाइलेशन कहते हैं

इस प्रोसेस को समझते हैं कि एक्चुअली होता

क्या है कंपाइलेशन की जो डेफिनेशन है वो

है अ कंप्यूटर प्रोग्राम दैट ट्रांसलेट्स

सी कोड इनटू मशीन कोड तो कंपाइलर एक ऐसा

प्रोग्राम होता है जो सी का कोड लिखता है

और उसको मशीन कोड में ट्रांसलेट कर देता

है जैसे जो हमारे पार्लियामेंट होते हैं

उसमें अगर कोई फॉरेन गेस्ट आए होते हैं तो

बीच में ट्रांसलेटर्स आते हैं अगर फ्रेंच

के प्राइम मिनिस्टर आएंगे तो बीच में

ट्रांसलेटर होगा जो उनकी फ्रेंच को समझेगा

और प्राइम मिनिस्टर यानी इंडियन प्राइम

मिनिस्टर तक पहुंचाएगा उसी तरीके से हमारे

कंप्यूटर के अंदर भी लैंग्वेजेस के लिए

ट्रांसलेटर्स होते हैं कंप्यूटर जो है वो

सी को नहीं समझता हमारी जो विंडोज मशीन है

मैक मशीन है

linux.com सी वाली एक फाइल थी उसको हमने

कंपाइलर के पास भेजा और सी के कंपाइलर ने

क्या किया सबसे पहले चेक करेगा कि फाइल जो

है सी जो रूल्स डिफाइन करता है जो

सिंटेक्स डिफाइन करता है उन सब को फॉलो कर

रही है ना कोई गलती तो नहीं है इसके अंदर

कोई एरर तो नहीं है हमारा जो वेरिएबल का

नाम है उसको हमने एक नंबर से तो शुरू नहीं

कर दिया अंडरस्कोर ही लगाया ना शुरुआत में

तो इस तरीके के बेसिक एरर्स को वो चेक

करता है और अगर एरर्स होते हैं तो फिर वो

कंपाइलेशन फेल कर देता है लेकिन अगर

कंपाइल हो जाती है हमारी फ मतलब उसमें कोई

सिंटेक्स वाले एरर्स नहीं है और उसके बाद

यह कंपाइलर उसको कन्वर्ट कर देता है

windows.exe फाइल में कन्वर्ट कर देता है

और

linux.com में भी डसी बना सकते हैं और विज

में भी डॉट आउट बना सकते हैं पर बाय

डिफॉल्ट जो आपको एक्सटेंशन दिख रही होगी

आपकी मशीन के अंदर वो यह एक्सटेंशन होगी

तो घबराने की बात नहीं है अगर आपको अभी

मेरी स्क्रीन पर डॉट आउट दिख रहा है और

अपनी स्क्रीन पर आपको डॉटसी दिख रहा है तो

अब हमने सी के जो है बेसिक बेसिक कांसेप्ट

समझ लिए हैं और अभी तक हमें थोड़ा बहुत

आईडिया लग चुका है कि एक्चुअली

प्रोग्रामिंग है क्या तो इसके अंदर हम दो

ऐसे सवाल सॉल्व करेंगे जो अगर आप कॉलेज की

पढ़ाई कर रहे हैं तो उसमें यूजुअली बेसिक

से अगर आपसे कोई इजी लेवल सवाल पूछे जाते

हैं तो वो कुछ ऐसे से देखेंगे इनमें सबसे

पहला प्रैक्टिस क्वेश्चन जिसको हम सॉल्व

करेंगे वो है राइट अ प्रोग्राम टू

कैलकुलेट एरिया ऑफ अ स्क्वायर तो स्क्वायर

का एरिया हमें कैलकुलेट करना है साइड

हमारे पास गिवन है हमें पता है मैथ हमने

छोटी क्लास में पढ़ ी रखी है कि स्क्वायर

का एरिया क्या होता है साइड मल्टीप्ला बाय

साइड तो हम क्या करेंगे एक ऐसा प्रोग्राम

बनाएंगे जिसमें साइड को इनपुट ले लेंगे और

फिर एरिया को आउटपुट दे देंगे अपने कोड के

अंदर यह चीज करके देखते हैं ऊपर एक कॉमेंट

लिख लेते हैं एरिया

ऑफ स्क्वायर सबसे पहले एक वेरिएबल डिफाइन

करेंगे साइड उसके बाद प्रिंट एफ कर लेते

हैं

एंटर साइड अब स्कैन एफ से उसको ले लेते

हैं इनपुट तो लिखेंगे परसेंटेज डी एंड

साइड अब हम प्रिंट करवा सकते हैं एरिया

इज परसेंटेज डी साइड इनटू साइड इसको कर

लेते हैं सेव और अपने टर्मिनल को खोलकर

इसको करते हैं रन हमारी साइड हम एंटर करते

हैं फोर तो हमारा एरिया आ गया स्क्वायर का

16 क्योंकि 4 * 4 इ 16 अब यहां पर जरूरी

नहीं है कि जो हमारी साइड हो वो एक इंटी

जर हो ये हमारी फ्लोट वैल्यू भी हो सकती

है अगर साइड हमारी फ्लोट वैल्यू हुई तो इस

केस में यहां पर परसेंटेज d की जगह

परसेंटेज f आ जाएगा यहां पर भी परसेंटेज f

आ जाएगा क्योंकि दो फ्लोट्स अगर

मल्टीप्लाई होते हैं तो फ्लोट वैल्यू

प्रोड्यूस होती है इसको कर लेंगे सेव और

दोबारा से करेंगे रन तो अब अगर साइड हम

एंटर करें फोर तो आएगा हमारे पास एरिया इज

स

16.00 तो ऑटोमेटिक फोर को उसने अंदर ही

इंटरनली फ्लोट में कन्वर्ट कर लिया अब

नेक्स्ट प्रैक्टिस क्वेश्चन जिसको हम करने

वाले हैं ये कहता है राइट अ प्रोग्राम टू

कैलकुलेट एरिया ऑफ अ सर्कल हमें यहां पर

लिखा है साइड पर यहां पर होना चाहिए कि

हमें सर्कल की रेडियस गिवन है और एरिया ऑफ

अ सर्कल हमें पता है होता है हमारे पास पा

r स् तो पा की वैल्यू तो पता ही है कि

कांस्टेंट होती है 3.14 इसमें r स् और

मल्टीप्लाई कर देंगे तो इस तरीके से एरिया

ऑफ़ अ सर्कल हमारे पास आ जाएगा इसके लिए

प्रोग्राम को थोड़ा सा चेंज कर लेते हैं य

फ्लोट रेडियस लिख देते हैं और यहां लिख

देते हैं

एंटर

रेडियस अब हमें जो भी वैल्यू एंटर होगी अब

जो भी वैल्यू एंटर होगी उसको हम रेडियस

वेरिएबल में स्टोर करा देंगे अब लिखेंगे

एरिया

इज पाई यानी 3.14 मल्टीप्ला बाय

रेडियस मलाड बाय रेडियस क्योंकि हमें लेना

है रेडियस का स्क्वायर इसको कर लेते हैं

सेव यहां पर रेडियस को हमने डिफाइन किया

वेरिएबल को उसके बाद प्रिंट एफ से लिखा

हमने स्क्रीन पर एंटर रेडियस फिर रेडियस

को हमने स्टोर करा लिया फिर हमने एरिया को

स्टोर करा लिया एरिया को कैसे स्टोर कराया

3.14 को मल्टीप्लाई कर दिया रेडियस से और

दोबारा मल्टीप्लाई कर दिया रेडियस से इसको

हम रन कर लेते हैं टर्मिनल में रेडियस अगर

हम एंटर करें थ्र तो आउटपुट हमारे पास आ

है कि सर्कल का एरिया है 28.2 600 तो इस

तरीके से हम इन सवालों को सॉल्व कर सकते

हैं अभी तक जितना भी हमने इस चैप्टर के

अंदर पढ़ा है अभी हमारा चैप्टर वन खत्म हो

चुका है हमने यहां पर अपना चैप्टर वन यानी

सी के सारे बेसिक कॉन्सेप्ट्स को बहुत

सक्सेसफुली कंप्लीट कर लिया है इन सारे

कांसेप्ट को यूज़ करके ऐसे-ऐसे क्वेश्चंस

होते हैं जो कभी-कभी आपके मिड सेमेस्टर या

एंड सेमेस्टर एग्जाम में पूछ लिए जाते हैं

जैसे हो सकता है फारेनहाइट से सेल्सियस का

कन्वर्जन दे दिया जाए सेल्सियस से

फारेनहाइट का कन्वर्जन दे दिया जाए या फिर

हमारे पास सिंपल इंटरेस्ट कैलकुलेट करने

के फॉर्मूले आपको बोल दिया जाए कि इस

फॉर्मूले को लगाओ या फिर यहां पे जैसे

हमने रेडियस निकाल रेडियस से हमने एरिया

निकाला है स्क्वायर का एरिया निकाला वैसे

रेक्टेंगल का एरिया बोल सकते हैं ट्रायंगल

का एरिया बोल सकते हैं या बोल सकते हैं

कंपाउंड इंटरेस्ट आप कैलकुलेट करें तो

बेसिकली मैथ के छोटे-मोटे फॉर्मूले लगाकर

जो भी चीजें पॉसिबल हो सकती हैं या इनपुट

आउटपुट से जो भी चीजें पॉसिबल हो सकती हैं

उस तरीके का हमें यह कांसेप्ट करने के बाद

कोड मिल सकता है अब नेक्स्ट चैप्टर है

हमारा चैप्टर टू यानी इंस्ट्रक्शंस एंड

ऑरेटर्स इसके अंदर हम पढ़ेंगे कि सी के

अंदर इंस्ट्रक्शंस और ऑपरेटर्स का क्या

मतलब होता है अब इस चैप्टर के अंदर हम

काफी सारी न्यूमेरिकल चीजें करेंगे जो

मैथ्स से रिलेटेड होंगी साथ के साथ हम

काफी सारे नए कांसेप्ट सीखेंगे तो अगर हम

नोट्स के अंदर ऐसे पेजेस देख रहे हैं

जिसके अंदर काफी सारी इंफॉर्मेशन लिखी हुई

है तो घबराना नहीं है क्योंकि उन चीजों को

एक साथ रटने की जरूरत नहीं है हमें सारे

के सारे नोट्स आपके पास नीचे अवेलेबल

होंगे जब आपका मन करे रिवीजन करने का जब

आपका मन करे कि अब मुझे इन चीजों को याद

करने की जरूरत है जैसे एग्जाम से एक दिन

पहले या इंटरव्यू के लिए अगर रिवीजन करना

है तब आप इनको जाकर एक्सेस कर सकते हैं उन

नामों को पढ़ सकते हैं अभी क्लास के चलते

टाइम पर जो चीजें हमारे दिमाग में रह रही

है उनको नेचुरली दिमाग में रखना है

एक्स्ट्रा अभी हमें चीजें मेमोराइज करने

का जो कष्ट है वो बिल्कुल नहीं लेना है तो

चैप्टर की शुरुआत करते हैं सबसे पहले हम

पढ़ेंगे कि इंस्ट्रक्शंस क्या होती है सी

के अंदर इंस्ट्रक्शंस की बेसिक डेफिनेशन

होती है कि दीज आर स्टेटमेंट्स इन अ

प्रोग्राम यानी अभी तक हम सी के जितने भी

प्रोग्राम लिख रहे थे कोड लिख रहे थे सब

में क्या था एक सीक्वेंस ऑफ इंस्ट्रक्शंस

थी एक के बाद एक के बाद एक के बाद एक के

बाद स्टेटमेंट्स लिखी हुई थी जब भी हम

प्रोग्राम की ऑफिशियल डेफिनेशन देखते हैं

ना तो इट इज अ सीक्वेंस ऑफ इंस्ट्रक्शंस

जैसे हमें मान लो मैगी बनानी होती है तो

सीक्वेंस ऑफ इंस्ट्रक्शंस क्या होते हैं

कि सबसे पहले पानी उबाल लो उसके अंदर मैगी

मसाला डालो और उसके अंदर अपनी एक्चुअल

मैगी डालो और फिर उसको गर्म होने दो चाय

बनानी होती है तो पहले पानी डालो उसके

अंदर हमारा दूध डाल देते हैं चीनी डाल

देते हैं चाय पत्ती डाल देते हैं अदरक डाल

देते हैं फिर उसको बॉयल करने देते हैं फिर

उसको छान लेते हैं तो ये कुछ सीक्वेंस ऑफ

इंस्ट्रक्शंस है वैसे ही किसी भी

प्रोग्राम के अंदर एक सीक्वेंस ऑफ

इंस्ट्रक्शंस होती हैं जो प्रोग्राम को

बताती हैं कि उसको क्या-क्या करना है अब

हम जब टाइप्स ऑफ इंस्ट्रक्शंस पढ़ते हैं

तो उसमें तीन टाइप्स हमारे आते हैं सबसे

पहला टाइप डिक्लेरेशन इंस्ट्रक्शन दूसरी

है हमारी एरिथ मेे िक इंस्ट्रक्शन और

तीसरी है हमारी कंट्रोल इंस्ट्रक्शन इन

तीनों इंस्ट्रक्शंस के अलग-अलग काम होते

हैं और काम के अकॉर्डिंग इनका नाम रखा हुआ

है तो ऐसा नहीं है कि इनको याद करना बहुत

मुश्किल होगा सबसे पहले अगर बात करें टाइप

डिक्लेरेशन इंस्ट्रक्शंस की तो टाइप

डिक्लेरेशन से क्या समझते हैं टाइ टाइप

डिक्लेरेशन यानी किसी भी वेरिएबल को

डिक्लेयर करना उसके टाइप के साथ तो जब भी

हम ऐसी स्टेटमेंट्स लिखते हैं ऐसी

इंस्ट्रक्शंस लिखते हैं जहां पर हमें एक

वेरिएबल बताना होता है और उसका टाइप हमें

डिक्लेयर करना होता है उसको हम टाइप

डिक्लेरेशन स्टेटमेंट दे देते हैं हम बहुत

टाइम से अपने सी कोड के अंदर टाइप

डिक्लेरेशन स्टेटमेंट्स लिखते आ रहे हैं

इसको हम लिख सकते हैं जैसे अगर हमने लिखा

इंट a = 4 यह भी हमारी एक टाइप डिक्लेरेशन

स्टेटमेंट है अगर हमने लिखा कैरेक्टर c इ

इक्व टू एस्ट रिस्क ये भी हमारी एक टाइप

डिक्लेरेशन स्टेटमेंट है पर जब भी हम ये

स्टेटमेंट्स लिखते हैं ना एक छोटी सी गलती

हम कर देते हैं कि एक रूल को भूल जाते हैं

रूल हमारा कहता है डिक्लेयर वेरिएबल बिफोर

यूजिंग इट जब भी हम किसी वेरिएबल को यूज

कर रहे हैं उसको यूज़ करने से पहले हमें

डिक्लेयर जरूर कर देना है यानी देखना है

उसके अंदर कोई वैलिड वैल्यू हो हमने

कंपाइलर को पहले ही बता दिया हो कि यह

वेरिएबल एजिस्ट करता है कोड में और फिर हम

यूज करें अगर ऐसा नहीं होगा और सी कंपाइलर

अचानक से किसी वेरिएबल को देख लेगा कि ये

कहां से आ गया तो फिर वो एरर थ्रो करेगा

जैसे इसके वैलिड एग्जांपल्स अगर देखें तो

हमने यहां पर इंट a को डिक्लेयर किया एज

22 फिर इंट b में लिखा है कि a की वैल्यू

b में डाल दो यह बिल्कुल सही है क्योंकि a

ऑलरेडी डिक्लेयर हो चुका है और फिर b में

उसकी वैल्यू गई है और इसी को अगर हम कोड

की फॉर्म में लिखकर देखें तो अपने फंक्शन

के अंदर हम लिख सकते हैं इंट a = 22 और

फिर लिखें अगर इंट b = a तो यहां पर कोई

भी ए एरर हमारे पास नहीं आया यह कोड जो है

हमारा बहुत अच्छे से काम करेगा उसके बाद

हम क्या कर सकते हैं अगर हम इस तरीके से

भी लिख रहे हैं इंट c = ू b + 1 यानी

ऑलरेडी डिक्लेयर्ड एक वेरिएबल है उसमें आप

कुछ ऐड कर रहे हैं या फिर इसमें अगर -1

होता या फिर ये मल्टीप्ला बाय 2 होता

डिवाइडेड बाय 3 होता तो इस तरीके की भी

अगर हम एरिथ मेे ऑपरेशंस करते राइट हैंड

साइड पे और फिर उसको c में असाइन करते हैं

तो वो भी वैलिड है वो भी बिल्कुल सही है

इसको एक्चुअली लिख के देखते हैं प्रोग्राम

में c इ इक्वल टू हमारा हो जाए अगर b

मल्टीप्ला बाय 6 तो कोई एरर नहीं आया

हमारे पास क्योंकि एक वैलिड स्टेटमेंट है

एक और टाइप ऑफ वैलिड इंस्ट्रक्शन क्या हो

सकता है इंट d = 1 e इसमें हमारे पास क्या

हुआ कि हमने एक वेरिएबल डिक्लेयर किया d

जिसको वैल्यू दे दी वन इसके साथ-साथ हमने

एक और इंटी जर वेरिएबल डिक्लेयर किया e

लेकिन e को अभी कोई वैल्यू हमने दी नहीं

है तो ये बिल्कुल वैलिड स्टेटमेंट है जहां

d की वैल्यू असाइन हो रही है पर e की नहीं

हो रही इसको भी हम कोड में लिख के देख

लेते हैं इंट d

= हमने वन दे दिया पर e जो है उसको कोई

वैल्यू नहीं दी तो यह भी बिल्कुल वैलिड

स्टेटमेंट होगा अब कुछ एग्जांपल्स देखते

हैं इनवैलिड स्टेटमेंट्स के c के अंदर

जैसे अगर हम कोई वेरिएबल बनाए ओल्ड एज अब

ओल्ड एज वेरिएबल के अंदर अगर हम कोई

वैल्यू स्टोर करा दें व्हिच इज़ 22 और फिर

हम एक नया वेरिएबल बनाएं न्यू एज न्यू एज

को हम बना दें ओल्ड एज

प्लस इयर्स यानी कितने इयर्स पास हो गए

हैं तो यहां पर ओल्ड एज वेरिएबल तो ऑलरेडी

है पर इयर्स नहीं है अब मान लो इयर्स को

भी हम डिक्लेयर करने निकले इंट इयर्स इ

इक्व 2 कि 2 साल के बाद हमारी नई एज क्या

होने वाली है अब इयर्स हमने बता तो दिया

कोड के अंदर कि उसकी वैल्यू टू है फिर भी

यहां पे रेड लाइन क्यों आ रही है क्योंकि

हमने ईयर्स को बताने से पहले उसको यूज कर

लिया है तो वेरिएबल को डिक्लेयर करने से

पहले जब हम उसको यूज कर लेते हैं तो वो

एरर देता है स के अंदर यानी कंपाइलर क्या

करता है लाइन बाय लाइन जाता है इस लाइन

में उसने पढ़ लिया कि ओल्ड एज एक वेरिएबल

है उसकी वैल्यू 22 है इस लाइन में पढ़

लिया कि इन न्यू एज भी हमारा एक इंट

वेरिएबल है उसकी वैल्यू है ओल्ड एज की

वैल्यू जो उसको पता है क्या था प्लस इयर्स

अब वो यहां पे कंफ्यूज हो जाएगा कि इयर्स

तो अभी तक पढ़ा ही नहीं मैंने इयर्स तो वो

अगली लाइन में पढ़ने वाला था इसीलिए अगर

इस तरीके की कोई स्टेटमेंट है तो उसमें

इयर्स को ऊपर होना चाहिए तभी ये एक वैलिड

स्टेटमेंट होगी तभी जो हमारी टाइप

डिक्लेरेशन स्टेटमेंट्स होती हैं उनके

अंदर एरर्स नहीं आएंगे अब एक और टाइप की

हम वैलिड स्टेटमेंट समझे अगर तो मल्टीपल

वेरिएबल को हम एक साथ डिक्लेयर कर सकते

हैं यानी यहां पर हमने उनको डिक्लेयर कर

दिया इंट a b c एंड उसके बाद a को b को c

को तीनों को सेम वैल्यू असाइन कर दी व्हिच

इज़ वन यह वैल्यू कैसे असाइन हुई वन की

वैल्यू c में असाइन हुई फिर c की वैल्यू

यानी व b में असाइन हुई फिर b की वैल्यू

यानी व a में असाइन हुई तो इस तरीके का

प्रोसेस रहा इसको एक बार अपने कोड में हम

करके भी देख लेते हैं जैसे अगर हम कुछ

वेरिएबल डिक्लेयर करते हैं x y और z

तो हम वैल्यूज दे सकते हैं x = y = z = 4

तो इस तरीके की जो स्टेटमेंट है वो c के

अंदर वैलिड है पर वही अगर इसका दूसरा हम

वर्जन देखें जिसमें हम डिक्लेरेशन के टाइम

पर ही यहां पे फोर दे

दे यानी इन सबको इक्वल टू करें और हम सोचे

कि एक लाइन स्किप कर देते हैं एक्स्ट्रा

हमें क्यों लिखना तो यहां पर रेड लाइन

ऑटोमेटिक आ जाती है ये रेड लाइन क्यों आई

क्योंकि जब हम फोर को z में असाइन कर रहे

हैं तो फिर उसकी वैल्यू y के पास जा रही

है और वह सोच रहा है अभी तक तो जो z है वह

कंपाइलर को पता ही नहीं क्या है क्योंकि

ये लाइन अभी खत्म नहीं हुई है सेम लाइन के

अंदर हम जो z है उसमें वैल्यू असाइन भी कर

रहे हैं और उसकी वैल्यू किसी और को भी दे

रहे हैं सेम स्टेटमेंट में हम y को एक

वैल्यू असाइन भी कर रहे हैं और फिर उसकी

वैल्यू किसी और को भी दे रहे हैं यानी

यूज़ और डिक्लेयर साथ में नहीं कर सकते

पहले हमेशा डिक्लेयर करना पड़ेगा उसके बाद

वेरिएबल को यूज करना पड़ेगा नहीं तो c

हमें एरर दे देगा तो इस तरीके के जो एरर्स

हैं उन्हें हमें नहीं करना जब भी मल्टीपल

वेरिएबल साथ में डिफाइन कर रहे हैं c के

अंदर डिक्लेयर कर रहे हैं तो उनको एक साथ

डिक्लेयर कर दीजिए पर उनकी वैल्यूज जो है

उनका यूसेज जो है वो बाद में होगा नेक्स्ट

टाइप ऑफ इंस्ट्रक्शंस जो सी के अंदर

एजिस्ट करती हैं वो है हमारी एरिथ मेे िक

इंस्ट्रक्शंस एरिथ मेे शब्द ऐसा है जो

हमने 11 12थ में नाथ 10थ में या सिक्सथ टू

एथ की मैथ्स में जरूर पढ़ा होगा एरिथ मेे

िक का मतलब हम समझते हैं कि जहां प्लस

माइनस मल्टीप्लाई डिवाइड ये सब चल रहा

होता है यानी बेसिकली मैथ्स से रिलेटेड

सारी चीजें तो मैथ की अगर हम कोई भी

स्टेटमेंट देखें जैसे मान लीजिए हम a + b

का एग्जांपल लें तो उसके अंदर जिन चीजों

पर ऑपरेशन परफॉर्म होता है यानी प्लस हो

रहा है जो चीज मल्टीप्लाई हो रही है

डिवाइड हो रही है जिसका रिमाइंडर हम निकाल

रहे हैं क्वेश निकाल रहे हैं इनको हम कहते

हैं ऑपरेंट तो यहां पर a बन जाएगा हमारा

ऑपरेंट वन बी बन जाएगा हमारा ऑपरेंट टू

इसी तरीके से अगर कोई और स्टेटमेंट होती

जैसे a + b - c ल्ड बा d तो यहां पर a b c

d हमारे चार ऑपरेंट होते हैं और दूसरी

टर्म जिसको हमें सीखने की जरूरत है वो है

ऑपरेटर ऑपरेटर क्या होता है वो सिंबल जो

बताता है कि क्या ऑपरेशन परफॉर्म होने

वाला है जैसे यहां पर हमारा ऑपरेटर है

अपना प्लस ऑपरेटर हो सकता है यहां पे

माइनस परफॉर्म हो रहा होता सबट क्शन

परफॉर्म हो रहा होता तो हमारा माइनस जो

होता वो बन जाता हमारा ऑपरेटर अगर

मल्टीप्लाई हो रहा होता तो एस्ट रिस्क

हमारा ऑपरेटर बन जाता डिवाइड हो रहा होता

तो इस स्लैश को हम अपना ऑपरेटर कह देते तो

स के अंदर वो इंस्ट्रक्शंस जि उसके अंदर

कुछ-कुछ ऑपरेंड्स होते हैं कुछ-कुछ

ऑपरेटर्स होते हैं उनको हम एरिथ मेे िक

इंस्ट्रक्शंस कहते हैं अब एरिथ मेे िक

इंस्ट्रक्शंस के एग्जांपल्स क्या-क्या हो

सकते हैं इनको हम लिख के देखते हैं जैसे

अगर हम एक नया वेरिएबल डिफाइन करें इंट a

= 1 है और b = 2 है और यहां पर हम नया

वेरिएबल डिफाइन करते हैं सम = a + b तो

यहां पर ये एक एरिदमेटोसस

लिया जा रहा है a और b ऑपरेंड्स हैं प्लस

हमारा एक ऑपरेटर है और सम हमारा एक नया

वेरिएबल है जिसके अंदर वैल्यू हमारी असाइन

हो जाती है यानी स्टोर हो जाती है जाकर

ऐसे ही हम बना सकते हैं

इंट मल्टीप्लाई = a * बा b अब यहां पर

मल्टीप्लाई एक वेरिएबल है जिसके अंदर a *

b की वैल्यू जाकर स्टोर हो रही है अब जब

भी हम एरिथ मेे िक इंस्ट्रक्शंस की बात

करते हैं एक स्पेशल चीज़ हमें ज़रूर नोट

करनी है वह यह है कि सिंगल वेरिएबल ऑन द

लेफ्ट हैंड साइड जब भी हम कोई एरिथ मेे

ऑपरेशंस परफॉर्म करते हैं वो सारे के सारे

हमारे राइट हैंड साइड पे जाते हैं यानी a

+ b - c * बा d ऐसा कुछ हमारे पास

एक्सप्रेशन होगा उसकी सारे की वैल्यू हम

किसी वेरिएबल लेफ्ट में असाइन करेंगे जो

लेफ्ट हैंड साइड पर लिखा होगा और ये सारी

की सारी वैल्यू राइट से लेफ्ट में जाकर

स्टोर हो जाएगी और लेफ्ट साइड में हमें

हमेशा ध्यान रखना है कि एक सिंगल वेरिएबल

हमारे पास हो सिंगल वेरिएबल के अंदर ही

सारा का सारा आउटपुट निकल के जाके स्टोर

होगा हम लेफ्ट साइड में अगर रखें कि हम तो

दो वेरिएबल स्टोर कराना चाहते हैं इंट x y

= a * b तो इस केस में क्या होगा कि a * b

की वैल्यू y को असाइन हो जाएगी पर x को

असाइन नहीं होगी क्योंकि x यहां पर हमने

सिर्फ एक नया वेरिएबल डिक्लेयर कर दिया है

y एक नया वेरिएबल डिक्लेयर किया जिसमें a

* b की वैल्यू गई है तो लेफ्ट में मतलब इस

एक्सप्रेशन के लिए हमारे पास सिर्फ y है

जिसमें इसकी वैल्यू स्टोर हुई है इसके बाद

हम बात करने वाले एरिथ मेे िक

इंस्ट्रक्शंस में क्या-क्या हमारे

एक्सप्रेशंस वैलिड होते हैं क्या-क्या

नहीं होते कुछ बेसिक ऑपरेशंस हम समझ लेते

हैं एरिथ मेे िक इंस्ट्रक्शंस में हमारे

पास आ जाता है प्लस ऑपरेटर माइनस ऑपरेटर

मल्टीप्लाई ऑपरेटर और डिवाइड ऑपरेटर इसके

साथ-साथ एक और ऑपरेटर हमारे पास होता है

मॉड्यूल जिसके बारे में हम अभी पढ़ने वाले

हैं इसी चैप्टर के अंदर तो ये पांच हमारे

मेन ऑपरेटर्स होते हैं अब इसमें वैलिड

स्टेटमेंट्स क्या-क्या होंगी जैसे a = b +

c हमने लिखा है ये एक वैलिड स्टेटमेंट है

यानी यहां पर ये दोनों हमारे ऑपरेंट हैं

ये ऑपरेटर है और लेफ्ट हैंड साइड में हमने

सिंगल जो है एक वेरिएबल लिखा हुआ है

नेक्स्ट की बात करें तो b * c भी एक वैलिड

ऑपरेशन है क्योंकि हमारे पास

मल्टीप्लिकेशन आया और उसको हमने a में

स्टोर करा दिया अब राइट हैंड साइड में

इनवैलिड की अगर बात करें तो राइट हैंड

साइड में है a और लेफ्ट में है हमारा b +

c अब अगर मैथ हम पढ़ रहे होते तो ये

बिल्कुल सही स्टेटमेंट होती मैथ के हिसाब

से पर यहां पर हमारे लिए बिल्कुल गलत

स्टेटमेंट है ये स्टेटमेंट कंपाइलर को कह

रही है कि a की वैल्यू को लो और उसको b +

c में स्टोर करा दो जबकि b + c एक सिंगल

वेरिएबल नहीं है क्योंकि लेफ्ट हैंड साइड

पे सिंगल वेरिएबल नहीं लिखा हुआ तो

स्टेटमेंट हमारी बिल्कुल गलत हो जाती है

इसको एक बार कोड में लिख लेते हैं जैसे

अगर हम लिखते हैं इंट b + c = a अब यहां

पर एक रेड लाइन आ गई क्योंकि ये स्टेटमेंट

गलत है क्योंकि लेफ्ट साइड पे हमारे पास

एक ही वेरिएबल होना चाहिए जिसके अंदर

वैल्यू स्टोर हो पर यहां पर अगर हम इसको

रिवर्स कर देंगे यानी यहां लिख देंगे a और

यहां पर लिख देंगे b + c तो ये सही हो

जाएगी पर ऊपर हमें b और c को डिफाइन करना

पड़ेगा b को हम लिख लेते हैं = c = 1 तो

अब यह स्टेटमेंट बिलकुल सही हो जाएगी

क्योंकि सारे वेरिएबल डिफाइन हैं और लेफ्ट

साइड में हमने लिखा है सिर्फ a को अब और

क्या एक्सप्रेशंस हो सकते हैं जैसे मैथ के

अंदर हम क्या लिखते हैं दो नंबर्स को

मल्टीप्लाई करना होता है तो लिख देते हैं

इ x = 2 * 3 हम वहां पर डॉट लगा देते हैं

या फिर 2 * 3 इसको भी मल्टीप्लिकेशन की

तरह देखा जाता है पर यह सेम चीज़ c के

अंदर वैलिड नहीं है c के अंदर अगर आप लिख

देंगे a =

c की तरह नहीं देखा जाएगा इसको एक एरर की

तरह देखा जाएगा इसका एग्जांपल क्या हो

सकता है जैसे हम लिखें इंट d =

bc-c तो a के अंदर क्या स्टोर होगा b c से

डिवाइड होगा और जो भी हमारे पास क्श आएगा

वो a के अंदर जाकर स्टोर हो जाएगा वहीं पर

इनवैलिड एक्सप्रेशन यह हो सकता है कि

कहीं-कहीं हमने देखा है कि b की पावर c

अगर हमें लिखना हो तो हम कैसे लिख दे ते

हैं b c यह वाला जो एक्सप्रेशन है यह गलत

होता है c के अंदर c के अंदर पावर हमारे

पास एक सिंगल ऑपरेटर नहीं होता पावर के

लिए हमें पड एक फंक्शन यूज करना पड़ता है

जिसके अंदर पहले हम डालेंगे b फिर हम

डालेंगे c ये हमें देगा वैल्यू b टू द

पावर c तो अगर a के अंदर हमें स्टोर कराना

है पावर ऑफ b टू द पावर c तो हम कुछ ऐसा

लिख रहे होंगे अगर हमने ये लिखा तो ये

वैल्यू हमारी गलत हो जाएगी यह वैल्यू सही

हो जाएगी इसका एग्जांपल देखते हैं अपने

कोड के अंदर इंट

पावर इ इक्वल टू b की पावर c ऊपर हमें बस

एक और हेडर फाइल को इंक्लूड करना पड़ेगा

इंक्लूड

मैथड h ये मैथड ए एक हेडर फाइल है यानी

इसके अंदर ऑलरेडी कुछ-कुछ चीजें हैं जो हम

यूज कर सकते हैं तो पावर जो हम फंक्शन

यूज़ कर रहे हैं वह मैथड h से ही आया है

हमारे पास अब पावर को अगर हम प्रिंट

करवाएं तो 1 की पावर व हमें ऑलरेडी पता है

कि हमारे पास वन ही प्रिंट होकर आएगा पावर

को हम प्रिंट करवाना चाहते हैं

इसको कर लेते हैं सेव और करते हैं रन तो

हमारे पास वन प्रिंट होकर आया है वहीं पर

यहां अगर हम लिख देते b इसको अगर हम सेव

करके रन कराएं तो क्या आउटपुट आएगा हमारे

पास हमारे पास आउटपुट आया है रो अब ये रो

क्यों आया है हमारे पास तो एरर आना चाहिए

था क्योंकि पावर तो एजिस्ट ही नहीं करता

एक्चुअली ये जो ऑपरेटर होता है ना स के

अंदर इसको जॉर ऑपरेटर कहते हैं जॉर के

बारे में हम बाद में सीखने वाले हैं ये

बिट वाइज ऑपरेशन करने के लिए परफॉर्म होता

है हमें पता है कि c के अंदर हर जो नंबर

होता है वो मशीन को तो समझ में आता है

नहीं मशीन को कौन सा कोड समझ में आता है

मशीन को समझ में आता है मशीन कोड जो लिखा

होता है जीरोज और वनस में तो जब भी हम

जीरोज और वंस के बीच में ऑपरेशन परफॉर्म

करते हैं वो हमारे बिट वाइज ऑपरेशंस होते

हैं तो ये हमारा एक जॉर ऑपरेटर है जो

बिट्स के बीच में परफॉर्म होता है बिट्स

का यानी सेम बिट्स के बीच में जब आप जौर

करते हैं तो उसका आउटपुट जरो हमारे पास

आता है बिट वाइज ऑपरेटर्स के बारे में हम

बाद में पढ़ रहे होंगे पर अभी के लिए b टू

द पावर c अगर हम इस तरीके से लिखने की

कोशिश करें हैं वो वैलिड स्टेटमेंट है ऐसा

नहीं है कंपाइल र हमें एरर देगा पर आउटपुट

हमारे पास गलत आएगा b की पावर c हमारा

आउटपुट नहीं आएगा आउटपुट कुछ और आएगा

इसीलिए इसको हम नहीं लिखेंगे अगर हम पावर

दिखाना चाहते हैं पावर दिखानी है तो फिर

हमें मैथड ए का यूज करना पड़ेगा और यूज

करना पड़ेगा अपने पावर फंक्शन का नेक्स्ट

टॉपिक जिसकी हम बात करने वाले हैं वो है

हमारा मॉड्यूलर ऑपरेटर तो इसको मॉड्यूलर

या मॉडलो भी कहा जाता है इसको परसेंटेज का

जो साइन होता है ये होता है हमारा मॉड्यूल

ऑपरेटर ये ऑपरेटर क्या करता है अगर हमने

लिखा है a मॉडलो b तो यह हमें रिटर्न कर

देगा रिमाइंडर ऑफ a डिड बा b का जैसे इसके

कुछ एग्जांपल्स अगर देखें तो 4 मॉडलो 2

हमें रिटर्न करेगा रो 5 मॉडलो 3 हमें

रिटर्न करेगा ू क्योंकि फोर को टू से

डिवाइड करेंगे तो रिमाइंडर हमारे पास आएगा

़ फव को थ्री से हम डिवाइड करेंगे तो

रिमाइंडर हमारे पास आएगा टू क्श एट आएगा

वन तो अगर हम 5 / 3 करते तो क्ट हमारे पास

आता वन यहां पर मॉड्यूल और ंडर देता है तो

हमारे पास रिमाइंडर आया टू उसी तरीके से

12 मॉड्यूल 10 करेंगे तो रिमाइंडर टू ही

आएगा और 20 मॉड्यूल 10 करेंगे तो रिमाइंडर

आएगा हमारे पास जीरो तो कुछ इस तरीके से

जब भी रिमाइंडर फाइंड आउट करना होता है तब

यूज करते हैं अपने मॉड्यूल ऑपरेटर का इसका

एग्जांपल लिख के देखते हैं अगर हमें

प्रिंट एफ करना हो एक इंटी जर वैल्यू

जिसमें हम प्रिंट करवाना चाहते हैं 16 मड

10 तो हमें ऑलरेडी पता है कि आंसर हमारे

पास क्या आना चाहिए आंसर आना चाहिए सिक्स

और आंसर में प्रिंट हुआ है हमारे हमारे

पास 6 क्योंकि 16 को जब 10 से डिवाइड

करेंगे तो छह रिमाइंडर में बचेगा अब

मॉड्यूल ऑपरेटर जो है ना हमारे फ्लोट

वैल्यूज पर काम नहीं करता जैसे अगर हम

यहां पर लिखें 1.6 / 1.0 और इसको सेव करके

अगर हम रन करना चाहे तो रन नहीं करेगा

क्योंकि इनवैलिड ऑपरेंड्स है ऑपरेंट है

हमारा 1.6 और दूसरा ऑपरेंट है 1.0 तो

मॉड्यूल ऑपरेटर जो है सिर्फ इंटी जर्स पे

काम करता है जब भी इंटी जर को इंटी जर से

डिवाइड करते हैं तो हमें रिटर्न करके देता

है एक इ इंटी जर रिमाइंडर वैल्यू अब इंटी

जर में भी दो केसेस होते हैं या तो हमारा

जो न्यूमरेशन है वो पॉजिटिव हो सकता है या

हमारा न्यूमरेशन नेगेटिव हो सकता है जब भी

हमारा न्यूमरेशन पॉजिटिव होता है तो हमारे

पास जो रिमाइंडर आता है वो भी एक पॉजिटिव

रिमाइंडर आता है पर जब हमारा न्यूमरेशन

नेगेटिव होता है तो हमारा रिमाइंडर भी

नेगेटिव आता है हमारे पास इसके एग्जांपल्स

कैसे देख सकते हैं यहां पर अगर हम लिखें

-8 मॉडलो 3 इसको कर लेते हैं सेव और इसको

करते हैं रन तो हमारे पास आंसर में आया -2

क्योंकि 8 को जब थ्री से डिवाइड करेंगे तो

रिमाइंडर में आएगा टू क्योंकि सिक्स हमारा

ऑलरेडी डिवाइड हो जाएगा क्योंकि हमारे

न्यूमरेशन नेगेटिव है तो हमारा आंसर भी

रिमाइंडर में आया है नेगेटिव पर इसी को

अगर हम पॉजिटिव एट बना दें और इसको हम सेव

करके रन करें तो अब आउटपुट में आएगा + 2

तो इस तरीके से जब भी हमें नेगेटिव

रिमाइंडर चाहिए तो हमने न्यूमरेशन को

नेगेटिव रखना है जब भी पॉजिटिव रिमाइंडर

चाहिए तो अपने न्यूमरेशन को पॉजिटिव रखना

है नेक्स्ट टॉपिक जिसकी हम बात करेंगे

एरिथ मेे िक इंस्ट्रक्शंस में उसका नाम है

टाइप कन्वर्जन जब भी हमारे जो डिफरेंट

डिफरेंट ऑपरेंट होते हैं उनके अगर सेम

टाइप है तो आउटपुट भी सेम टाइप का आएगा

लेकिन उनके डटा टाइप अगर अलग-अलग हैं तो

आउटपुट भी अलग डाटा टाइप का आएगा जब भी हम

इंट का कोई ऑपरेशन परफॉर्म कराते हैं इंट

के साथ तो आउटपुट में इंट ही आएगा जब भी

फ्लोट का ऑपरेशन कराते हैं फ्लोट के साथ

तो आउटपुट में फ्लोट ही आएगा लेकिन अगर

इंट का ऑपरेशन हुआ फ्लोट के साथ तो आउटपुट

में फ्लोट आएगा जब हम अपने डटा टाइप्स

वाली टेबल की बात करते हैं ना तो इंट

हमारा जो लेता है वो लेता है दो बाइट और

फ्लोट हमारा लेता है चार बाइट्स तो इस

तरीके से फ्लोट का जो कंटेनर है इस डाटा

टाइप का जो कंटेनर है वो बड़ा है यानी

ज्यादा वैल्यू स्टोर कर सकता है तो सी

कंपाइलर क्या करता है थोड़ा सा लॉजिक

लगाता है लॉजिक कैसे लगाया कि अगर इंट

वैल्यू है वो तो छोटी है पर फ्लोट की

वैल्यू तो बड़ी है ना और इनके बीच में कोई

ऑपरेशन हुआ मान लीजिए प्लस हुआ या

मल्टीप्लाई हुआ या डिवाइड हुआ उसमें एक

बड़ा नंबर आउटपुट में आएगा अब उस बड़े

नंबर को स्टोर कराने के लिए एक बड़ा

कंटेनर चाहिए यानी फ्लोट जैसा कंटेनर

चाहिए तो इसीलिए आउट ट में हम इंट को नहीं

रखते फ्लोट को रखते हैं तो जब भी इंट का

ऑपरेशन परफॉर्म होगा फ्लोट के साथ हमारे

पास आउटपुट में आएगा फ्लोट इसके

एग्जांपल्स क्या हो सकते हैं एग्जांपल

जैसे इंट का इंट के साथ अगर हम मल्टीप्लाई

करें टू तो आंसर में आएगा फोर पर यहां पर

2.0 को मल्टीप्लाई करें अगर टू के साथ तो

आउटपुट में हमारे पास आएगा 4.0 और यहां पर

2.0 को मल्टीप्लाई करें 2.0 के साथ तो

आउटपुट में आएगा 4.0 इसको अपने कोड में

लिखकर देखते हैं तो सबसे पहले प्रिंट एफ

करवाएंगे हम

2 * 2 इसको कर लेते हैं सेव तो आउटपुट में

आया 4 लेकिन 2.0 को अगर मल्टीप्लाई कराए

टू के साथ तो यहां पर ये एरर आ गया सबसे

पहले ही एरर क्यों आया क्योंकि आउटपुट जो

है एक फ्लोट वैल्यू होना चाहिए था पर हमने

बोला कि आउटपुट इंटी जर वैल्यू होगा तो

इसको अब हमें चेंज करना पड़ेगा टू f इसको

कर लेते हैं सेव और दोबारा से इसको करते

हैं रन रन करने के बाद आउटपुट हमारे पास

आया

4.00 जो भी फ्लोट का हमारे पास बाय

डिफॉल्ट जितने भी डे मिल जाते हैं इसके

बाद अगर यह 2.0 * 2.0 होता तो उस केस में

क्या होता उस केस में भी हमारे पास सेम

आउटपुट आता व्हिच इज अ फ्लोट वैल्यू अब इस

ऑपरेशन की जगह हम डिवाइड भी यूज़ कर सकते

हैं अगर मान लीजिए हम चार को डिवाइड कर

रहे होते 2.2 से तो इस केस में भी फ्लोट

जो है आउटपुट आना चाहिए क्योंकि एक ऑपरेंट

हमारे पास फ्लोट का है तो आउटपुट में आया

है एक फ्लोट वैल्यू तो इस तरीके से टाइप

कन्वर्जन हो जाता है टाइप कन्वर्जन कैसे

हुआ अगर कंपाइलर देखता है कि आउट पुट जो

है वो बड़े कंटेनर में स्टोर होना चाहिए

क्योंकि बड़ा आउटपुट है तो वो जबरदस्ती

उसको छोटे कंटेनर में स्टोर नहीं कराता

खुद से यानी इंट में स्टोर नहीं कराएगा वो

कोशिश करेगा इस पूरे के पूरे आउटपुट को

सेव कर लिया जाए तो वो फ्लोट के अंदर उसको

बाय डिफॉल्ट स्टोर कराता है अब हम इसके

थोड़े से और स्पेशल केसेस देख लेते हैं

जैसे अगर हमने टू को डिवाइड किया थ्री के

साथ तो क्योंकि ये दोनों के दोनों हमारे

इंटी जर वैल्यूज है आउटपुट हमारा इंटी जर

आना चाहिए आउटपुट एक बार देखते हैं यहां

पे इंटी जर आएगा तो इसको कर देते हैं हम d

आउटपुट हमारे पास आया है रो क्योंकि हमेशा

एक इंटी जर आउटपुट आएगा अब टू को जब हम थ

से डिवाइड करेंगे तो 0 पॉइंट समथिंग

समथिंग आता है पर क्योंकि एक इंटी जर

वैल्यू है इसके अंदर सिंगल डिजिट हम हमारे

होल डिजिट स्टोर होते हैं डेसीमल स्टोर

नहीं होते तो इसको वो जीरो बना देगा वहीं

पर अगर हम 2.0 इसको ले लेते तो अब हमारे

पास आउटपुट में आती है एक फ्लोट वैल्यू

फ्लोट वैल्यू में क्या आउटपुट आता है

हमारे पास ये हमें दे देता 0.666

667 तो अगर हमें एग्जैक्ट आउटपुट चाहिए तो

उसके लिए हम फ्लोट बना देंगे दोनों में से

किसी एक को पर अगर हम चाहते हैं कि डेसीमल

का जितना भी पार्ट आए वो कंप्लीट हट जाए

तो उसको हम बना देंगे इंटी जर्स तो थ्री

को हम डिवाइड कर सकते हैं टू के साथ थ्री

को जब भी टू के साथ डिवाइड करेंगे तो यहां

पर आउटपुट हमारे पास आना चाहिए एक इंटी जर

वैल्यू आउटपुट में आएगा वन लेकिन 3.0 को

अगर टू से डिवाइड करेंगे तो आउटपुट में वन

नहीं आएगा इसको भी कर देते हैं f आउटपुट

में अब हमारे पास आएगा 1.5 तो जब एग्जैक्ट

आंसर चाहिए तब फ्लोट बनाना है जब हम

बिल्कुल डेसीमल को हटाना ही चाहते हैं तब

हम बना देंगे उसको इंटी जर तो टाइप

कन्वर्जन कुछ इस तरीके से होता है टाइप

कन्वर्जन पे बेस्ड एक काफी इंटरेस्टिंग

सवाल अभी सॉल्व करेंगे सवाल में हमें यह

करना है कि इंट a को देखना है उसकी वैल्यू

जो है 1.99 999 है कैसे काम करेगा ये अगर

इस वैल्यू को हम एक इंटी जर में असाइन

करेंगे तो वो क्या करेगा इसके डेसिमल्स

हटा देगा डेसिमल्स हटा देगा यानी इस पार्ट

को कंपलीटली हटा देगा तो यहां पर a की

वैल्यू वन होनी चाहिए या ए की वैल्यू टू

होनी चाहिए वो हम अपने कोड से एनालाइज

करने वाले कोड में हम लिखेंगे इंट ए =

1.99

999 इसको कर लेते हैं सेव और अब प्रिंट

करवा देंगे अपने ए को और इसकी वैल्यू

देखेंगे कि एक्चुअली प्रिंट क्या होता है

यहां पर उसने सबसे पहले तो एरर दे दिया कि

डबल से इंट में कन्वर्जन जो है वो पॉसिबल

नहीं है इंप्लीड कन्वर्जन पॉसिबल नहीं है

जब भी टाइप कन्वर्जन होता है ना सी के

अंदर दो टाइप ऑफ कन्वर्जन होते हैं सबसे

पहला हमारा जो कन्वर्जन होता है वो होता

है इंप्ली इंप्ली कन्वर्जन कंपाइलर खुद कर

देता है और दूसरा टाइप हमारा होता है

एक्सप्लिसिट एक्सप्लिसिट कन्वर्जन हम एज अ

प्रोग्रामर हम एज अ यूजर खुद करते हैं

हमारा कंपाइलर हमें करके नहीं देता ये वो

कन्वर्ज है जो हम खुद से करना चाहते हैं

ये एक्सटर्नल कन्वर्जंस है तो इंप्लीड

कन्वर्जंस कहते हैं कि जो छोटे टाइप्स हैं

जैसे इंट जैसा टाइप वही फ्लोट में जाकर

स्टोर हो सकता है इंट जैसा टाइप डबल में

जाकर स्टोर हो सकता है पर फ्लोट या डबल

इंट के अंदर आकर स्टोर नहीं हो सकता

इसीलिए ऑटोमेटिक इसको कन्वर्ट नहीं करेगा

लेकिन अगर हम खुद से एज अ प्रोग्रामर एज अ

कोडर कन्वर्ट कराना चाहते हैं तो हम यहां

इस तरीके से वैल्यू लिख देते हैं हम दो

पैरेंस लगाते हैं दोनों के बीच में उस

टाइप में लिख देते हैं जिसमें हम कन्वर्ट

कराना ना चाहते हैं तो क्या करेगा कंपाइलर

फोर्सफुली कन्वर्ट करेगा कंपाइलर करना

नहीं चाहता बड़े टाइप को छोटे में कन्वर्ट

पर उसको करना पड़ेगा क्योंकि हमने इंट लिख

दिया है आगे अब इसको सेव करते हैं और अब

एक बार इसको दोबारा कंपाइल करके देखते हैं

तो अब उसने सक्सेसफुली कंपाइल कर दिया है

और अब हम अगर अपने कोड को रन करें तो उसका

जो आउटपुट आएगा दैट विल बी वन तो जब भी

इसने कन्वर्ट किया ना इस डबल वैल्यू को

बाय डिफॉल्ट सी में जो सारी फ्लोट वैल्यूज

होती है उनको डबल की तरह देखा जाता है

क्योंकि डबल बड़ा डटा टाइप है अब जब इसने

इस डबल वैल्यू को यानी इस वैल्यू को इंट

में कन्वर्ट किया तो इसने ये

999999 को कंप्लीट हटा दिया वो राउंड ऑफ

नहीं करता सी का कंपाइलर एरिथ मेे ऑपरेशंस

में जब भी फ्लोट से इंट में कन्वर्ट करता

है राउंड ऑफ नहीं करता कि 1.99 है तो उसको

टू बना दो और फिर टू डाल दो इंटी जर में

वो मैथ की तरह इतना ज्यादा लॉजिक नहीं

लगाता अगर डेसीमल हटाने हैं तो वो पूरे के

पूरे हटा देगा और सिर्फ वन स्टोर कराएगा

तो इस चीज का हमें खास ध्यान रखना है जब

भी हम इंटरव्यूज में बैठते हैं और ऐसे कुछ

सवाल हमसे पूछ लिए जाते हैं कि सी में आप

बताओ या क्लास टेस्ट में मिट सेम में एंड

सेम में क्वेश्चन आता है कि इसके आउटपुट

में हम क्या लिखेंगे तो हमें अपने

डेसिमल्स को कंप्लीट उड़ा देना है नेक्स्ट

टॉपिक जिसकी हम बात करेंगे वो है ऑपरेटर

प्रेसीडेंट जैसे मैथ के अंदर हमने एक रूल

पढ़ा था छोटा सा जिसको हम कहते थे बॉर्ड

मास रूल बॉर्ड मास रूल हमारा क्या कहता था

पहले ब्रैकेट ओपन कर लो उसके बाद पहले

डिवाइड करो फिर मल्टीप्लाई करो फिर ऐड करो

फिर सबट क्ट करो तो इस तरीके से मैथ में

अगर बहुत सारे ऑपरेशंस दिए हुए हैं तो कौन

से ऑपरेशन को पहले करना है कौन से ऑपरेशन

को बाद में करना है उसका हमारे पास एक

प्रॉपर सीरीज होता था सीक्वेंस होता था

वैसे ही सी के अंदर है कौन सा ऑपरेशन पहले

परफॉर्म होगा कौन सा ऑपरेशन बाद में

परफॉर्म होगा ये सी के कंपाइलर के अंदर

पहले से ही हमारे पास डिफाइंड है अब इसमें

प्रायोरिटी ऑर्डर को हम प्रेसीडेंट कह

देते हैं यानी प्रायोरिटी में जो ऊपर आएगा

उसकी प्रेसीडेंट हाई है जो प्रायोरिटी में

नीचे आएगा उसकी प्रेसीडेंट लो है तो सबसे

पहले प्रायोरिटी में आते हैं हमारे पास

मल्टीप्लाई डिवाइड एंड मॉड्यूल ऑपरेटर इन

तीनों ऑपरेटर्स की प्रायोरिटी सबसे ऊपर

होती है उसके बाद प्रायोरिटी में आते हैं

प्लस माइनस उसके बाद प्रायोरिटी में आता

है ये इक्वल टू इक्वल टू को c के अंदर हम

असाइनमेंट ऑपरेटर भी कहते हैं असाइन करना

किसी चीज को यानी किसी चीज को उसको दे

देना जैसे अगर हम कहते थे कि स्कूल में जो

मॉनिटर बनता था उसको कहते थे कि इसको

मॉनिटर वाली जो पोस्ट है वो असाइन हो गई

है यानी इसको दे दी गई है तो जब भी कोई

वैल्यू हम देते हैं उसको हम कहते हैं

असाइनमेंट तो अगर a + b = c हमने लिखा है

तो इस a + b की वैल हमने c के अंदर असाइन

कर दिया है तो इस तरीके से हम मतलब समझते

हैं चीजों का c के अंदर अब एक एग्जांपल

अगर देखें x = 4+ 9 * 10 लिखा हुआ है तो

इसको हम सॉल्व कैसे करेंगे प्रेसीडेंट देख

लेंगे सबसे पहले कि 4+ 9 पहले करना है या

9 * 10 ओबवियसली हमारे मल्टीप्लाई की

प्रेसीडें हाई है तो 9 * 10 पहले करेंगे 9

* 10 करेंगे तो 90 आ गया इसमें अब हम फोर

को ऐड करेंगे तो फोर को ऐड करेंगे तो

हमारा जो ना 94 आंसर है वो x के अंदर जाकर

स्टोर हो जाएगा पर अगर हम गलत तरीके से

करते तो गलत तरीका करने का क्या होता कि

ना को फोर में ऐड कर देते तो 13 हो जाता

मल्टीप्ला बाय 10 जिसका आउटपुट आता 130 पर

ये एक गलत आउटपुट होता सही आउटपुट है इसका

94 इसको एक बार कोड भी करके देख लेते हैं

कि कितना हमने सही किया है इंट ए के अंदर

हम स्टोर करेंगे 4 प् 9 इन 10 इसको करते

हैं रन और आउटपुट में हमारे पास आया है 94

अब एक और दूसरे तरीके के हमारे पास जो है

एक्सप्रेशंस लिखे हो सकते हैं तो यह हमारे

पास केस आ गया ऑपरेशंस ऑफ सेम प्रेसीडेंट

यानी मल्टीप्लाई की भी उतनी प्रेसीडेंट है

और डिवाइड की भी उतनी प्रेसीडेंट है तो

पहले कौन सा सॉल्व होगा तो इसके लिए हमारे

पास एसोसिएटिविटी रूल आता है ये जो रूल्स

है ना ये दिखने में खतरनाक लग रहे होंगे

पर बहुत लॉजिकल है इनको अभी रटना नहीं है

ये जैसे-जैसे हम डिफरेंट डिफरेंट प्रॉब्लम

सॉल्व करेंगे अपने प्रैक्टिस प्रॉब्लम्स

भी सॉल्व करेंगे अपने आप आ जाएंगी और बहुत

लॉजिकल है समझने में तो बिल्कुल इनके नाम

याद करने कि इसको एसोसिएटिविटी कहते थे

इसको प्रेसीडेंट कहते थे इतने भारी शब्द

बिल्कुल रट्टेड की बिल्कुल अभी जरूरत नहीं

है नोट्स आपको पूरे अवेलेबल होंगे उनको आप

जाकर कभी भी रिवाइज कर सकते हैं कभी भी

एक्सेस कर सकते हैं एसोसिएटिविटी हम यूज

करते हैं जब भी हमारे पास आते हैं

ऑपरेटर्स ऑफ सेम प्रेसिडेंस सेम

प्रेसिडेंस में जैसे अगर हम अपने एग्जांपल

की बात करें एसोसिएटिविटी कहता है कि

लेफ्ट से राइट कर लो यानी लेफ्ट लेफ्ट से

लेकर राइट तक ऑपरेशंस को परफॉर्म करते जाओ

अगर सेम प्रेसीडें के है तो जैसे यहां पर

मल्टीप्लाई डिवाइड और यह वाला मल्टीप्लाई

सेम प्रेसीडें के है तो हम क्या करेंगे

लेफ्ट से राइट कैलकुलेट कर लेंगे लेफ्ट से

राइट कैलकुलेट करते हैं तो सबसे पहले

कैलकुलेट होगा 4 * 3 4 * 3 हो जाएगा हमारा

12 फिर कैलकुलेट होगा 12 / 6 ये बन जाएगा

हमारा ू फिर कैलकुलेट होगा 2 * 2 ये बन

जाएगा हमारा फर तो सबसे पहले हमने फोर को

थ्र से मल्टीप्लाई किया फिर इसके आउटपुट

को हमने सिक्स के साथ डिवाइड किया फिर

इसके आउटपुट को हमने टू के साथ मल्टीप्लाई

किया तो इस तरीके से लेफ्ट से राइट हम

चलते चले गए अगर इसको ब्रैकेट फॉर्म में

मुझे दिखाना हो तो मैं क्या लिख सकती हूं

मैं लिख सकती हूं पहले मल्टीप्लाई कर दो

फोर को थ्री से फिर डिवाइड कर दो इसको और

फिर इसके बाद मल्टीप्लाई कर दो इसको टू से

और फाइनल वैल्यू को x में असाइन कर दो और

हमारी फाइनल वैल्यू आई थी हमारे पास फोर

इसी का हम कोड लिख लेते हैं कोड में

लिखेंगे 4 * 3 / बा 6 * 2 इसको कर लेते

हैं सेव तो इस वैल्यू के लिए जो हमारे पास

आउटपुट

आएगा वो आया है फोर क्योंकि यहां पे

एसोसिएटिविटी रूल लगा है लेफ्ट से राइट तक

हमारी कैलकुलेशंस होती चली गई अब हमने

काफी सारी चीजें पढ़ ली एरिथ मेे िक

इंस्ट्रक्शन में तो उनके थोड़े से हम सवाल

कर लेते हैं ताकि दिमाग में चीजें सारी की

सारी बैठ जाए तो प्रैक्टिस क्वेश्चन फोर

करते हैं इन चारों के लिए हमें सवाल सॉल्व

करना है सबसे पहले अपने बोर्ड के अंदर

सॉल्व करके देखेंगे अपनी स्लाइड्स पे

सॉल्व करके देखेंगे उसके बाद क्या क्या

करेंगे उसका कोड लिखकर उसको वेरीफाई कर

लेंगे अब पहला सवाल है हमारे पास 5 * 2 -

2 * 3 यहां पे मल्टीप्लाई और इस

मल्टीप्लाई दोनों की प्रेसीडेंट ऊपर है और

माइनस जो है हमें बाद में करना है तो

प्रेसीडेंट दोनों की सेम है मल्टीप्लाई की

तो क्या करेंगे लेफ्ट वाला रूल लगा देंगे

सबसे पहले मल्टीप्लाई करेंगे 5 * 2 को तो

इसकी जगह लिख देंगे 10 बीच में है माइनस

फिर प्रेसीडें के हिसाब से सॉल्व होना

चाहिए 2 * 3 तो 2 * 3 को हमने सॉल्व करके

लिख दिया 6 और इन दोनों का आउटपुट हमारे

पास आया फोर तो सबसे पहले यह सॉल्व होगा

क्योंकि हायर प्रेसीडें में और लेफ्ट में

भी आता है फिर यह सॉल्व होगा क्योंकि हायर

प्रेसीडें में और लेफ्ट के बाद राइट में आ

गया फिर हमारा माइनस सॉल्व होगा तो ये हो

जाएगा 10 - 6 = 4 इसी को कोड फॉर्म में

लिख लेते हैं कोड में हम लिखेंगे 5 न 2 -

3 *

2 यहां पर लगा देते हैं अपना स्टेटमेंट

टर्मिनेटर सेमी जो होता है उसको टर्मिनेटर

कहा जाता है टर्मिनेटर हमारा वो एआई मूवी

वाला रोबॉट वाला टर्मिनेटर नहीं टर्मिनेटर

यानी किसी चीज को रोक देना तो जैसे वो

अपोकलिप्टो कने आया था मूवी के अंदर यहां

पर यह क्या करता है स्टेटमेंट को वहीं पे

रोक देता है तो अब इसको कर देते हैं

कंपाइल एंड रन रन करके आउटपुट हमारे पास

आया फोर सेकंड प्रॉब्लम है हमारे पास 5 *

2 डिवाइड बा 2 * 3 यहां पर क्योंकि तीन

ऑपरेटर्स हैं तीनों की प्रेसीडेंट हाईएस्ट

है तो इसमें हम लगाएंगे अपना एसोसिएटिविटी

रूल एसोसिएटिविटी रूल क्या कहता है लेफ्ट

से राइट भैया कैलकुलेट कर लो तो 5 * 2 को

सबसे पहले कैलकुलेट करेंगे आ गया हमारे

पासस 10 फिर 10 डिवाइड बा 2 को कैलकुलेट

करेंगे आ गया हमारे पास 5 अब इसका आउटपुट

आया 5 इसको मल्टीप्लाई कर लेंगे ्र के साथ

तो आउटपुट हमारे पास आएगा 15 इसको वेरीफाई

भी कर लेते हैं हम आउटपुट लिखेंगे इसको कर

लेते हैं डिवाइड कंपाइल रन सिक्स इसलिए

आया है क्योंकि यहां पर 3 मल्ला बा 2 हमने

लिख दिया ये एक्चुअली होना चाहिए था 2

मल्ला बा 3 इसको कर लेते हैं कंपाइल एंड

रन आउटपुट में हमारे पास आया 15 थर्ड जो

प्रॉब्लम है उसमें है 5 मड बा 2 / 2 म 3

अब इसको कैसे सॉल्व करना है क्योंकि

ब्रैकेट तो दीदी हम पहली बार देख रहे हैं

तो जब भी ब्रैकेट आता है ना सबसे पहले

ब्रैकेट के अंदर की चीज को सॉल्व करने है

ये सिंगल चीज है जो वर्ड मैस के साथ मैच

करती है कि ब्रैकेट आए तो पहले ब्रैकेट

ओपन कर लो तो ब्रैकेट के अंदर की चीज सबसे

पहले सॉल्व होगी यानी ये एक्सप्रेशन हमारे

पास बन जाएगा 5 मल बा 1 मल्ला बा 3 अब

क्या करेंगे अब दो ऑपरेशंस बच गए ये

मल्टीप्लाई और ये मल्टीप्लाई दोनों की

प्रेसीडेंट सेम है तो एसोसिएटिविटी रूल

लगा दो तो ये बन जाएगा हमारे पास 5 * 3

यानी 15 इसका भी आउटपुट 15 आना चाहिए तो

यहां पर हल्का सा चेंज कर लेते हैं एक

ब्रैकेट लगा लेते हैं इसको कर लेते हैं

सेव आउटपुट में आएगा 15 और जो लास्ट सवाल

है इसके अंदर वह यह है 5 + 2 / 2 * 3

इसमें क्या चीज़ होगी इसमें हमारे पास तीन

ऑपरेशंस हैं सबसे पहले है एडिशन फिर है

डिवाइड फिर है मल्टीप्लाई अब हायर

प्रेसीडेंट किसकी हायर प्रेसीडेंट है

डिवाइड और मल्टीप्लाई की दोनों की सेम

प्रेसीडेंट है तो लगा देंगे लेफ्ट

एसोसिएटिविटी लेफ्ट एसोसिएटिविटी से यह

किसमें कन्वर्ट हो जाएगा 5 प् सबसे पहले

कर देंगे 2 / 2 फिर कर देंगे मल्टीप्ला बा

3 फिर उसको ऐड कर देंगे फाइव से तो ये हो

जाएगा 5 प् अंदर वाला एक्सप्रेशन बन गया 1

* 3 उसके बाद करेंगे 5 + 3 और ये बन जाएगा

हमारे पास 8 अब इसी को सेम आउटपुट में कर

लेते हैं एक्सप्रेशन हमारे पास था 5 + 2

डिवाइड बा 2 ल्ड बा 3 इसको कर लेते हैं

सेव और रन करेंगे आउटपुट में हमारे पास

आया एट तो इस तरीके के जो सवाल हैं ये

आपके एमसीक्यू में भी पूछ लिए जाएंगे

प्लेसमेंट टाइम पे या फिर आपसे अपने स्कूल

के कॉलेज के टेस्ट के अंदर पूछ लिए जाएंगे

तो सवाल का जवाब किस तरीके से करना है अगर

थ्योर पेपर है तो उसमें एक्चुअली सॉल्व

करके दिखाना है कि लेफ्ट एसोसिएटिविटी

लगेगी कैसे कौन सी चीज पहले सॉल्व होगी

बेस्ट इसको करने का तरीका है अपनी सुविधा

के लिए आप ये पैरेंस लगा लें ब्रैकेट्स

लगा लें तो पता चल जाएगा कौन सी चीज पहले

सॉल्व करनी है कौन सी चीज बाद में सॉल्व

करनी है और अगर कोड में लिखना है तो कोड

में तो ऑटोमेटिक सी का कंपाइलर कर ही लेगा

तो काफी आसान है इन चीजों को करना जैसे

बॉर्ड मास का रूल होता है होता है वैसे यह

भी रूल होता है थोड़े से चार पांच सवाल

होमवर्क प्रॉब्लम्स और हम कर लेंगे तो

उसके बाद चीजें काफी क्लियर हो जाएंगी

नेक्स्ट जिस टॉपिक की हम बात करेंगे वो है

हमारी कंट्रोल इंस्ट्रक्शंस अब शुरुआत में

हमने पढ़ा था कि इंस्ट्रक्शंस तीन टाइप की

होती है टाइप डिक्लेरेशन हमने पढ़ लिया कि

वेरिएबल को पहले डिक्लेयर करना है फिर

यूज़ करना है सेकंड हमने पढ़ लिया एरिथ

मेे िक इंस्ट्रक्शन जिसके अंदर मॉड्यूल

हमने नया सीखा हमने टाइप कन्वर्जन सीखा

हमने प्रेसीडेंट सीखी अब हम पढ़ने वाले

हैं कंट्रोल इंस्ट्रक्शंस कंट्रोल

इंस्ट्रक्शंस वो इंस्ट्रक्शंस होती हैं जो

डिटरमिन करती हैं हेल्प करती हैं बताने

में हमारा फ्लो ऑफ प्रोग्राम अभी तक हमने

क्या पढ़ा था सीक्वेंस में इंस्ट्रक्शंस

चल रही थी एक कोड लिखा हु है उसमें पहली

स्टेटमेंट पहले एग्जीक्यूट होगी यानी ये

वाली स्टेटमेंट पहले एग्जीक्यूट होगी उसके

बाद ये स्टेटमेंट एग्जीक्यूट होगी उसके

बाद ये स्टेटमेंट एग्जीक्यूट होगी लेकिन

कुछ ऐसी स्टेटमेंट होती है सीके कोड के

अंदर जो फ्लो चेंज कर सकती हैं हो सकता है

हमारी नीचे वाली स्टेटमेंट पहले

एग्जीक्यूट हो और ऊपर वाली बाद में हो ये

जो स्टेटमेंट्स होती है ना जो फ्लो को

अल्टर करने की चेंज करने की पावर रखते हैं

इनको हम कहते हैं कंट्रोल इंस्ट्रक्शंस जो

कंट्रोल कर सकती है फ्लो ऑफ इंस्ट्रक्शंस

इन अ प्रोग्राम अब ये चार टाइप्स की होती

है इनमें से सबसे पहली होती है सीक्वेंस

कंट्रोल सीक्वेंस कंट्रोल इंस्ट्रक्शंस वो

होती हैं जो सीक्वेंस वाइज चलती रहती है

यानी एक के बाद एक के बाद एक अगर हमारा

फ्लो बनता है तो उनको हम सीक्वेंस कंट्रोल

इंस्ट्रक्शंस कहते हैं जैसे हमने अभी तक

सीखते आए हैं जिनको हम ये सारी की सारी

हमारी सीक्वेंस कंट्रोल इंस्ट्रक्शंस है

सेकंड टाइप ऑफ कंट्रोल इंस्ट्रक्शन हमारे

पास होती है डिसीजन कंट्रोल सजन कंट्रोल

में हम पढ़ेंगे इफ एल्स के बारे में यह वो

इंस्ट्रक्शंस है जिनके बारे में हम आने

वाले चैप्टर्स के अंदर पढ़ने वाले हैं

क्योंकि बहुत डिटेल में इनको डिस्कवर करना

होता है और यह सारी की सारी मिलाकर हमारी

सी प्रोग्रामिंग के बेसिक्स फॉर्म करती

हैं तो डिसीजन कंट्रोल के अंदर हम आगे

इफल्स वाला टॉपिक पढ़ेंगे लूप कंट्रोल के

अंदर हम जो डिफरेंट डिफरेंट लूप्स होते

हैं सी के अंदर जैसे हमारा फॉर लूप हो गया

हमारा वाइल लूप हो गया डिफरेंट लूप

पढ़ेंगे यानी किसी काम को अगर हमें

बार-बार बार बार बारबार करना होता है सेम

कुछ लाइंस को यूज करके उसमें हम लूप

कंट्रोल इंस्ट्रक्शन यूज करते हैं जब हमें

कोई डिसीजन लेना होता है कि आज बारिश हो

रही है तो छाता लेकर जाना है या नहीं जाना

सूरज है और संडे है तो आज हम खुश होंगे या

नहीं होंगे ऐसे कुछ-कुछ डिसीजंस होते हैं

इनको जब भी हम कोड में लिखते हैं वो लिखते

हैं डिसीजन कंट्रोल इंस्ट्रक्शंस की हेल्प

से उसके बाद लास्ट आती है हमारे पास केस

कंट्रोल इंस्ट्रक्शन जिसके अंदर कुछ-कुछ

केसेस के हिसाब से हम अलग-अलग चीजें करते

हैं जैसे अगर मंडे टू फ्राइडे है तो काम

पे जाना है और संडे आ गया तो फिर काम पर

नहीं जाना फिर हमें घर पे बैठ के रेस्ट

लेना है इस पूरे एक फ्लो को हमें कोड में

कैसे दिखा सकते हैं वेरिएबल की हेल्प से

और केसेस की हेल्प से कि कौन से दिन में

काम पे जाना है कौन से दिन में घर पे रहना

है तो उन स्टेटमेंट्स का जब भी हम लिख रहे

होते हैं उन इंस्ट्रक्शंस को उनको हम केस

कंट्रोल के अंदर डालते हैं इन तीनों को हम

आने वाले चैप्टर्स के अंदर पढ़ेंगे

सीक्वेंस कंट्रोल हम ऑलरेडी पढ़ चुके हैं

इसके साथ नेक्स्ट टॉपिक इसी चैप्टर के

अंदर जिसकी हम बात करेंगे वो है हमारे

ऑपरेटर्स अब ऑपरेटर्स हमने ऑलरेडी बेसिक

देख लिया है एरिथ मेे िक ऑपरेटर्स क्या

होते थे एरिथ मेे ऑपरेटर्स की कैटेगरी में

हमारे पास आ गया था प्लस माइनस मल्टीप्लाई

डिवाइड ये मल्टीप्लाई ये डिवाइड और

मॉड्यूल तो ये पांच मेजर एरिथ मेे िक

ऑपरेटर्स हम ऑलरेडी पढ़ चुके हैं अब c के

अंदर और भी डिफरेंट टाइप्स ऑफ ऑपरेटर्स

होते हैं हमारे पास रिलेशनल ऑपरेटर्स होते

हैं जो दो ऑपरेंट के बीच का रिलेशन बताते

हैं हमारे पास लॉजिकल ऑपरेटर्स होते हैं

जो दोनों के बीच में लॉजिकल चीज निकाल के

लेकर आते हैं फिर बिट वाइज ऑपरेटर्स भी

होते हैं अभी हमने बात की थी कि मशीन

लैंग्वेज के अंदर मशीन कोड के अंदर सब कुछ

जीरोज और वनस की फॉर्म में होता है और उन

जीरोज और वंस के बीच में अगर हम ऑपरेशन

करते हैं उसको बिट वाइज ऑपरेशन कह देते

हैं फिर असाइनमेंट ऑपरेटर्स भी होते हैं

फिर एक होता है टरनरी ऑपरेटर ये हमारा

कंडीशनल ऑपरेटर होता है यानी अगर किसी

कंडीशन के हिसाब से हमें कोई चीज करनी है

और दूसरी चीज नहीं करनी वो हम टरनरी

ऑपरेटर की हेल्प से भी लिख सकते हैं उसको

इफल्स की हेल्प से भी लिखा जाता है इसकी

हेल्प से भी लिखा जाता है मेजर इसमें

समझने वाली चीज है रिलेशनल और लॉजिकल और

असाइनमेंट यह तीनों इनमें से सबसे इजी है

एरिथ मेे िक के बाद इनको हम अभी पढ़ लेंगे

टरनरी ऑपरेटर को नेक्स्ट चैप्टर में हम

पढ़ेंगे जब भी हम कंडीशनल स्टेटमेंट्स पढ़

रहे होंगे और बिट वाइज ऑपरेटर्स को हम आने

वाले चैप्टर्स में पढ़ेंगे तो सबसे पहले

बात करते हैं अपने रिलेशनल ऑपरेटर्स की अब

रिलेशनल ऑपरेटर्स दो ऑपरेंट के बीच का

रिलेशन बताते हैं मैथ के अंदर जब भी हम

लिखते हैं ना कि a = b हमें चेक करना हो

कि a b के इक्वल है क्या वो हम c के अंदर

ऐसे का ऐसा नहीं नहीं लिख सकते c के अंदर

अगर कहीं लिख देंगे a = b तो इसका मतलब हो

जाएगा b की वैल्यू को उठाकर a में डाल दो

वो तो इक्वलिटी चेक करना नहीं हुआ तो जब

भी चेक करना होता है कि a की वैल्यू मतलब

एक वैल्यू किसी दूसरी वैल्यू के इक्वल है

क्या तो हम लगाते हैं डबल इक्वल टू a इ इ

= b का मतलब है कि हम यहां पर पूछ रहे हैं

क्वेश्चन कर रहे हैं कि a की वैल्यू b की

वैल्यू के इक्वल है क्या और a = b का मतलब

है कि b की वैल्यू को a में डाल रहे हैं

तो जब भी हम रिलेशनल ऑपरेटर्स की बात करते

हैं रिलेशन चेक करने की बात करते तो हम

इसको यूज कर रहे होंगे यानी डबल इक्वल टू

को अगर अपने कोड में हम लिखना चाहे आउटपुट

करवाते

हैं यहां पर लिखेंगे a इक्वल टू इक्वल टू

या a डिफाइंड नहीं है तो 4 इक्व टू इक्वल

टू 4 अगर हम लिखे इसको कर लेते हैं सेव और

उसको रन करते हैं तो हमारे पास आउटपुट में

आएगा वन ये वन क्या दिखाता है वन कहता है

ट्रू है स्टेटमेंट यानी 4 = इ 4 रिटर्न कर

रहा है ट्रू यानी सही बता रहा है सी

कंपाइलर पर अगर यहां ते 4 = = 3 तो इस केस

में हमारे पास वन नहीं प्रिंट होता इस केस

में प्रिंट होता रो यानी 4 = = ू 3 फॉल्स

रिटर्न कर रहा है गलत है तो सी एक स्पेशल

लैंग्वेज है जिसके अंदर ट्रू फॉल्स नहीं

होते ट्रू फॉल्स की जगह ट्रू की जगह हमारे

पास होता है वन और फाल्स की जगह हमारे पास

होता है रो इनफैक्ट कोई भी नॉन जीरो इंटी

जर अगर c के अंदर हम लिख दें जैसे 2 3 4 5

6 7 -1 -5 ये सारे के सारे रिप्रेजेंट

करते हैं ट्रू को पर अगर जहां जीरो आ गया

उसका मतलब फाल्स होता है स के अंदर तो जो

स्टूडेंट्स जो जावा सीखने के बाद सी सीख

रहे हैं c+ प्स के बाद जावास्क्रिप्ट के

बाद उन्हें ये थोड़ा सा अजीब लगेगा कि सी

के अंदर ट्रू फॉल्स जैसा कुछ नहीं होता वन

होता है ट्रू की जगह और जीरो होता है

फाल्स की जगह तो अगर इक्वल टू इक्वल टू

में वन प्रिंट हुआ तो मतलब ट्रू है

स्टेटमेंट और फाल्स प्रिंट हुआ तो हमारे

पास आएगा स्क्रीन पर जीरो वहीं पर दूस

दूसरा रिलेशन जो हम चेक करते हैं वो होता

है ग्रेटर देन का या ग्रेटर दन इक्वल टू

का जैसे अगर हम 3 ग्र दन 4 लिखें ये

रिटर्न करेगा रो क्योंकि फाल्स है 3 तो

ग्रेटर दन 4 होता नहीं पर अगर हम 4 ग्र दन

3 करें ये रिटर्न करेगा हमारे पास ट्रू पर

अगर हम 4 ग्रेटर दन 4 कर दें ये रिटर्न

करेगा रो क्योंकि फोरर इज नॉट ग्रेटर दन 4

लेकिन 4 ग्रेटर दन इक्वल टू 4 करें तो ये

रिटर्न करेगा वन तो ये कुछ-कुछ केसेस होते

हैं जिनके हिसाब से हम आउटपुट अपना

प्रोड्यूस कराते हैं इनको कोड में करके

देख लेते 4 ग्रेटर 3 अगर

लिखा तो आउटपुट में आया

न पर यहीं पर अगर 3 ग्रेटर दन 4 हमने लिख

दिया तो आउटपुट में अब आना चाहिए जीरो

यानी फॉल्स अगर हमने 3 ग्रेटर दन 3 लिखा

तो आउटपुट में आएगा जीरो क्योंकि थ इज

नेवर ग्रेटर दन 3 पर अगर हमने 3 ग्रेटर दन

इक्वल टू कर दिया तो ग्रेटर देन तो चेक

करेगा इक्वल टू भी चेक करेगा इस केस में

आउटपुट आएगा हमारे पास 1 तो यह ग्रेटर दन

और ग्रेटर दन इक्वल टू हो गया थर्ड

रिलेशनल ऑपरेटर जिसकी हम बात करेंगे यह है

हमारा लेस दन इक्वल टू लेस दन और लेस दन

इक्वल टू सेम केसेस रहेंगे 3 इज लेन 4

इसमें रिटर्न करेगा ट्रू 4 इज लेन 3 इसमें

रिटर्न करेगा फाल्स 3 इज लेसन 3 इसमें

रिटर्न करेगा 0 और 3 इज लेन इक्व 3 इसमें

रिटर्न करेगा वन यानी ट्रू इनके भी केसेस

बना लेते हैं इज ग्रेटर दन इक्वल टू कर

देते हैं लेसन इक्वल टू तो लेस दन इक्वल

टू में हमारे पास प्रिंट होगा ट्रू अगर

सिर्फ लेस दन किया तो उस केस में हमारे

पास प्रिंट

होगा रो अगर 4 < 3 किया इस केस में प्रिंट

होगा फॉल्स क्योंकि ये गलत स्टेटमेंट है

यानी रो और अगर किया हमने 4 लेसन 5 इस केस

में प्रिंट होगा ट्रू तो कुछ इस तरीके से

हमारी रिलेशनल स्टेटमेंट्स काम करती हैं

अब एक लास्ट स्पेशल रिलेशनल ऑपरेटर हमारे

पास है जिसको हम कहते हैं नॉट इक्वल टू

इसका नाम हम रखते हैं नॉट इक्वल टू इसको

हम कहते थे इक्वल टू जब भी इक्वल होंगी दो

वैल्यूज यह वन रिटर्न करेगा जब भी नहीं

होंगी जीरो रिटर्न करेगा जब भी इक्वल नहीं

होंगी दो वैल्यूज तब यह वन रिटर्न करेगा

और जब भी इक्वल होंगी तब यह जीरो रिटर्न

करेगा यानी यह दोनों एक दूसरे के ऑपोजिट्स

है जैसे अगर हम अपनी स्टेटमेंट में लिखना

चाहे फर इज नॉट = 4 और वहीं पर हम प्रिंट

करवाना चाहे 4 = ू = 4 जब भी हम

एक्सक्लेमेशन मार्क लगा देते हैं सी के

अंदर प्रोग्रामिंग के अंदर तो उसको हमेशा

नॉट की तरह हमें पढ़ना होता है जहां भी

एक्सक्लेमेशन आया मतलब नॉट नॉट नॉट तो नॉट

ऑपरेटर जो होता है अलग से एक ऑपरेटर होता

है अभी यह जो है व कंप्लीट है नॉट इक्वल

टू इन दोनों के बीच में हम स्पेस नहीं दे

सकते इन दोनों को हमें साथ में लिखना होता

है अब आउटपुट एक बार एनालाइज कर हैं

फर्स्ट स्टेटमेंट का आउटपुट आया जीरो यानी

फाल्स फोर इज नॉट इक्वल टू 4 इस स्टेटमेंट

में हम कह रहे हैं कि चार चार के इक्वल

नहीं होता ओबवियसली एक फॉल्स स्टेटमेंट है

इसलिए प्रिंट हुआ जीरो सेकंड स्टेटमेंट

में कह रहे हैं चार चार के इक्वल ही होता

है तो इसीलिए प्रिंट हुआ वन अब यहीं पर

अगर हम कह देते कि चार तीन के इक्वल नहीं

होता या हम कह देते कि चार तीन के इक्वल

होता है इसमें फर्स्ट स्टेटमेंट में तो

प्रिंट होगा हमारे पास वन क्यों क्योंकि

हम सही कह रहे हैं कि चार तीन के इक्वल

होता ही नहीं है और सेकंड स्टेटमेंट में

प्रिंट होगा फाल्स क्योंकि हम कह रहे हैं

चार तीन के इक्वल होता है जो कि ऑब् वियस

फॉल्स है तो प्रिंट होगा ज़ीरो तो इस

तरीके से जब भी इक्वल टू चेक करना है तो

दो इक्वल टू लगाएंगे जब भी नॉट इक्वल टू

चेक करना है तो एक्सक्लेमेशन मार्क के साथ

इक्वल टू को हम नॉट इक्वल टू कहते हैं

नेक्स्ट टाइप ऑफ ऑपरेटर जिसकी हम बात

करेंगे वो है हमारे लॉजिकल ऑपरेटर्स

कभी-कभी ऐसा होता है c के अंदर कि हमें

लॉजिक चेक करना होता है चीजों का जैसे

लॉजिकल स्टेटमेंट को हम किन केसेस में

यूज़ कर सकते हैं मान लेते हैं हमने c को

यूज़ करके एक सिस्टम बनाया है कोडिंग वाला

सिस्टम जिसके अंदर हम उसके मार्क्स फीड कर

रहे हैं और अगर हम कहते हैं कि उसके

मार्क्स अगर 30 से ज्यादा है और 90 से कम

है तो तो उसको ग्रेड दे दो a और 90 से अगर

ऊपर है या 100 और 90 के बीच में तो फिर

उसको ग्रेड दे दो a प् अगर ऐसे हमें केसेस

चेक करने हैं तो हमें चेक करना पड़ेगा कि

मार्क्स 90 से ऊपर भी हो और 100 से नीचे

भी हो यहां पे चेक करना पड़ेगा मार्क्स 30

से ऊपर भी हो और 90 से नीचे भी हो तभी a

देना पड़ेगा तो जब दो कंडीशंस एक साथ चेक

करनी हो या दो कंडीशंस में से मान लो कोई

एक ट्रू है जैसे आज अगर कोई नेशनल हॉलीडे

है या फिर आज संडे है तभी हम बाहर घूमने

जाएंगे दोनों में से कोई भी एक चीज ट्रू

हो गई तो फिर हमें काम करना पड़ेगा अगर

दोनों ही ट्रू है तो तो करना ही है दोनों

में से एक भी ट्रू है तब भी करना है तो

ऐसे कुछ-कुछ केसेस होते हैं ना रियल लाइफ

केसेस जिनको हम कोड में डालना चाहते हैं

तब हमारे लॉजिकल ऑपरेटर्स हमारे काम आते

हैं सबसे पहला लॉजिकल ऑपरेटर है एंड

ऑपरेटर इसको हम एंड भी कहते हैं इसके अंदर

हम दो एंड लगाते हैं अगर आप ध्यान से

देखें तो m पर m पर सिंगल एंड अगर हम

लिखेंगे तो ये बिट वाइज ऑपरेटर होता है

जिसको हमें यहां पर नहीं लिखना दो एंड

हमेशा लिखेंगे तो वो लॉजिकल ऑपरेटर होगा

इसको हम कैसे यूज़ कर सकते हैं जैसे मान

लो हम फर्स्ट स्टेटमेंट लिखते हैं 4 इ > 3

ये क्या देगी हमें ये देगी वन यानी ट्रू

और हम दूसरी स्टेटमेंट लिखते हैं 5 इज

ग्रे द 2 ये स्टेटमेंट भी हमें वन देगी

यानी ट्रू देगी अगर इन दोनों स्टेटमेंट्स

को हम चाहते हैं दोनों स्टेटमेंट जब ट्रू

हो तभी हमारे पास फाइ फाइनल आउटपुट ट्रू

आए तो इन दोनों के बीच में हम लगा देंगे

एंड तो ये ट्रू होगा और ये ट्रू होगा तभी

आउटपुट ट्रू आएगा पर इनमें से अगर एक भी

ट्रू नहीं है यानी यहां पर हमारे पास आ

जाता है 2 इज ग्रेटर दन 5 तो ये दे देगा

जीरो यानी फॉल्स तो आउटपुट हमारे पास

फॉल्स आएगा एंड के लिए जरूरी है कि फर्स्ट

स्टेटमेंट और सेकंड स्टेटमेंट या जितनी भी

हम स्टेटमेंट्स के बीच में एंड लगा रहे

हैं वो सारी की सारी ट्रू हो नहीं तो

फाल्स आउटपुट आ जाएगा जैसे इसका आउटपुट

अगर हम देखें तो यहां पर हम लिख सकते हैं

4 इ ग्र द 3 एंड एंड 5 इ ग्रे द 2 तो ये

दोनों स्टेटमेंट्स हमारी सच है यानी 4 भी

ग्रेटर दन 3 है और 5 भी ग्रेटर दन टू है

तो ट्रू और ट्रू का जो एंड होगा वो हमारे

पास ट्रू आएगा लेकिन यहां पर एक भी हम

फाल्स बना दें यानी यहां पर लिख दें 3 इज

ग्रेटर दन फॉल्स फर तो यहां पर जो आउटपुट

हमारे पास आएगा वो आएगा रो ये स्टेटमेंट

तो सच है हमारी 5 ग्र 2 पर ये एक फॉल्स हो

गई जहां भी फॉल्स हो गई मतलब पूरा फॉल्स

हो गया अगर एंड लगाया है तो दोनों फॉल्स

होंगे तब भी फॉल्स है दोनों में से एक

फॉल्स होगा तब भी फॉल्स है दोनों ट्रू

होंगे तभी ट्रू प्रिंट होगा तो इसकी हम

टेबल भी बनाते हैं कभी-कभी एक दो आपके

सब्जेक्ट होते हैं इलेक्ट्रॉनिक्स के अंदर

भी कंप्यूटर साइंस के अंदर भी आईटी के

अंदर भी जहां पर ये तीनों लॉजिकल ऑपरेटर्स

की एक टेबल बनती है और अगर आपने लॉजिक

गेट्स पढ़े होंगे कॉलेज के अंदर तो आपको

समझ आएगा कि हम किसके बारे में बात कर रहे

हैं अगर नहीं पढ़े तो अगले वाले

सेमेस्टर्स में शायद आप पढ़ रहे होंगे तो

टेबल ये बनती है कि फर्स्ट एक्सप्रेशन और

सेकंड एक्सप्रेशन हमारे पास अगर कुछ इस

तरीके के क्यों तो फाइनल आउटपुट क्या आएगा

फर्स्ट एक्सप्रेशन ट्रू है सेकंड भी ट्रू

है तो आउटपुट में आएगा ट्रू अगर हम एंड की

बात कर रहे हैं फर्स्ट ट्रू है सेकंड

फॉल्स है तो आउटपुट में आएगा फॉल्स फर्स्ट

फॉल्स है सेकंड ट्रू है तो आउटपुट में

आएगा फॉल्स फर्स्ट फॉल्स है सेकंड भी

फॉल्स है तो भी आउटपुट में आएगा फॉल्स तो

ये छोटी सी टेबल है जिससे हम हल्का सा

विजुलाइज कर सकते हैं कि किस तरीके से

हमारे आउटपुट्स आते हैं जब भी हम लॉजिकल

एंड की बात करते हैं नेक्स्ट हम बात करने

वाले हैं लॉजिकल र की और में हमारे

कीबोर्ड के अंदर पाइप वाला एक सिंबल होता

है यानी एक स्ट्रेट लाइन का सिंबल होता है

इसको जब हम दो बार लिख देते हैं तो वो

हमारा लॉजिकल और ऑपरेटर बन जाता है अब

सिंगल पाइप भी एक ऑपरेटर होता है वो बिट

वाइज र होता है यहां पर हम बात कर रहे हैं

लॉजिकल र की लॉजिकल र क्या करता है दो

स्टेटमेंट या तीन स्टेटमेंट या जितनी भी

स्टेटमेंट अगर हम दे दें और सबके बीच में

लॉजिकल और लगा दें तो उनमें से अगर एक भी

ट्रू हो जाए तो फिर आउटपुट हमारे पास ट्रू

आएगा बाकी सारी चाहे फॉल्स हो पर एक भी

ट्रू होगी तो आउटपुट ट्रू आएगा नहीं तो

सारी फॉल्स तो आउटपुट फॉल्स आएगा तो इसका

अगर कोड लिखकर देखें तो सबसे पहले हमारे

पास है 3 ग्र द 4 जो कि एक फॉल्स

स्टेटमेंट है यहीं पर अगर हम और लगा दें

और लिख दें और 5 ग्र द 2 तो यहां पर ये

स्टेटमेंट फॉल्स है ये स्टेटमेंट ट्रू है

तो इसका आउटपुट एंड में तो हमारे पास

फाल्स आया था पर और में हमारे पास ट्रू आ

जाएगा तो इसकी भी अपनी एक टेबल बन सकती है

टेबल में अगर हम ले फर्स्ट और सेकंड

एक्सप्रेशन और उसके बाद फाइनल आउटपुट को

एनालाइज करें तो यहां पर अगर ट्रू ट्रू

दिए होंगे तो आउटपुट में ट्रू आएगा ट्रू

फॉल्स दिए होंगे तो आउटपुट में ट्रू आएगा

फॉल्स ट्रू दिया होगा तो भी आउटपुट में

ट्रू आएगा लेकिन दोनों फॉल्स होंगे तभी

हमारे आउटपुट में फॉल्स आ रहा होगा तो ये

हमारा है लॉजिकल ऑर इसके अलावा एक और

स्पेशल ऑपरेटर होता है जो होता है हमारा

लॉजिकल नॉट ऑपरेटर लॉजिकल नॉट ऑपरेटर कहता

है कि अगर ट्रू दिया है तो उसको फॉल्स कर

दो फॉल्स दिया है तो उसको ट्रू बना दो

यानी जो भी हमें दिया हुआ है एक्सप्रेशन

के अंदर उसको उल्टा कर देना है चाहे वो

कुछ भी हो जैसे अगर एक एक्सप्रेशन है 3 >

4 हमें पता है यह फॉल्स देगा पर इसके आगे

नॉट लगा दिया तो यह ट्रू दे देगा वहीं पर

अगर दूसरा एक्सप्रेशन है 5 > 1 हमें पता

है यह ट्रू देगा पर वहीं पर नॉट लगा दिया

तो यह फॉल्स दे देगा तो इस तरीके से जब भी

एक्सप्रेशन के आउटपुट को उल्टा करना होता

है फ्लिप करना होता है तो हम नॉट लगा देते

हैं यहां पर देखते हैं हमें पता है कि 5 >

1 हमें देगा ट्रू पर आगे इसके नॉट लगा

दिया तो आउटपुट में हमारे पास आएगा फाल्स

यानी ज़ीरो अगर दो एक्सप्रेशंस की भी बात

करें यानी 5 ग्र 1 जो है यह हमें देगा

ट्रू और और या यहां पर लगा देते हैं एंड

एंड 3 ग्र 4 इसका आउटपुट अगर हम गेस करने

निकले 5 ग्र द 1 देगा ट्रू 3 ग्र 4 देगा

फॉल्स दोनों के बीच में लगा है एंड एक

ट्रू है एक फॉल्स है तो आउटपुट में आएगा

फॉल्स लेकिन इस सब के बाहर हमने नॉट लगा

दिया तो फाल्स की जगह हमारे पास प्रिंट

होने वाला है ट्रू यहां पर एक और ब्रैकेट

लगा देते हैं आउटपुट में में हमें पता है

हमारे पास ट्रू प्रिंट होकर आना चाहिए तो

प्रिंट हुआ है ट्रू यानी वन तो कुछ इस

तरीके से हमारे लॉजिकल ऑपरेटर्स काम करते

हैं इन लॉजिकल ऑपरेटर्स की जो एक्चुअल

इंपॉर्टेंस है ना वो हम नेक्स्ट चैप्टर

में सीखेंगे जब हम कंडीशनल स्टेटमेंट्स की

बात करेंगे जब भी इफ एल्स वाले कंडीशनल

स्टेटमेंट्स हम लिखते हैं तो उसके अंदर

कंडीशन डालनी होती है कि वो कंडीशन ट्रू

है या फॉल्स है तो वहां पर इन एक्सप्रेशंस

को हम सबसे ज्यादा यूज़ कर रहे होंगे अब

यहां पर हमारे पास एक सवाल आता है कि

सिंगल एक्सप्रेशन के अंदर हम कुछ एरिथ मेे

िक ऑपरेटर्स भी लिख सकते हैं एरिथ मेे

ऑपरेटर्स जैसे सिंगल एक्सप्रेशन में हम

लिख सकते हैं a + b - c + d * e इस तरीके

से और सिंगल एक्सप्रेशन के अंदर हम उनको

कंपेयर भी कर सकते हैं यानी इस वैल्यू को

ग्रेटर द 4 * 3 * 5 इस तरीके की वैल्यू को

हम फिर एंड एंड कर सकते हैं 4 > 2 तो इतना

लंबा हम एक एक्सप्रेशन लिख सकते हैं जिसके

अंदर एरिदमेटोसस

हमारे रिलेशनल ऑपरेटर्स आ रहे होंगे तो

फिर इनमें प्रेसीडेंट कैसे डिसाइड होती है

तो इनका भी अपना एक ऑपरेटर प्रेसीडेंट

ऑर्डर होता है जिसमें प्रायोरिटी वाइज

प्रेसीडेंट होती है सबसे हायर प्रेसीडेंट

जो दी जाती है वो दी जाती है हमारे नॉट

ऑपरेटर को जहां भी नॉट ऑपरेटर आ गया सबसे

पहले नॉट करना है उसके बाद बाकी सारी

चीजें करनी है उसके बाद मल्टीप्लाई डिवाइड

मॉड्यूल को फिर प्लस माइनस आ जाते हैं फिर

आ जाते हैं हमारे रिलेशनल ऑपरेटर्स फिर आ

जाते हैं रिलेशनल ऑपरेटर्स में इक्वल टू

और नॉट इक्वल टू फिर आते हैं हमारे लॉजिकल

ऑपरेटर्स जिसमें सबसे पहले देखा जाता है

एंड कैसे होगा फिर देखा जाता है और कैसे

होगा फिर आ जाता है इक्वल टू यानी

असाइनमेंट ऑपरेटर पहले ऊपर वाली सारी

चीजें हो जाएंगी फिर लेफ्ट हैंड साइड में

जाके जो भी लिखा होगा उसमें हम असाइन कर

देंगे वैल्यू को तो कुछ इस तरीके से

प्रेसीडेंट रहता है इसको भी याद करने की

जरूरत नहीं है मेजर चीजें जो इसमें याद

रखनी है वो ये है कि सबसे पहले नॉट को

किया जाएगा रिलेशनल ऊपर आते हैं लॉजिकल

नीचे आते हैं तो इस तरीके से हम रखेंगे

बाकी जब भी आपको कैलकुलेशन में रेफर करना

पड़े आप इन सेम नोट्स को जाकर रेफर कर

सकते हैं

अब इसके बाद एक और ऑपरेटर का टाइप हम पढ़

लेते हैं यह काफी आसान ऑपरेटर है सबसे

आसान ऑपरेटर जो होने वाले हैं हमारे

असाइनमेंट ऑपरेटर असाइन करना हम ऑलरेडी

पढ़ चुके हैं इक्वल टू क्या करता है a इ b

है तो b की वैल्यू को a में डाल देगा c =

d है तो d की वैल्यू को c में डाल देगा e

= f + g - h है तो इस पूरे एक्सप्रेशन की

वैल्यू को e में डाल देगा ये होता है

असाइनमेंट ऑपरेटर का काम उसके बाद हमारा

प्लस इक्वल टू वाला ऑपरेटर होता है ये

बेसिकली हमारे शॉर्ट हैंड ऑपरेटर है क्या

है शॉर्ट हैंड ऑपरेटर्स यह क्या करते हैं

मुश्किल लंबी लंबी जो स्टेटमेंट होती है

ना उसको छोटा करने के तरीके बताते हैं

जैसे अगर हमने लिखा है a = a प् बी अगर हम

अपने कोड में इस चीज को

लिखें इंट a =

1 इंट बी = 4 और हम लिखना चाहते हैं इंट

या a = ए प् बी तो यहां पर क्या आना चाहिए

b है 4 a है व तो 1 प् 4 होगा 5 तो a की

वैल्यू अब फ बन जाएगी इसको प्रिंट भी

कराकर हम टैली कर सकते

हैं आउटपुट में आएगा फाइव तो a की वैल्यू

फाइव बन गई क्योंकि फोर और वन को मिलाकर

फाइव हो गया अब हम नोटिस करेंगे लेफ्ट में

भी a लिखा हुआ है राइट में भी a लिखा हुआ

है जब लेफ्ट और राइट में सेम एक्सप्रेशन

होता है ना यानी सेम वेरिएबल लिखा होता है

तो उसको हम छोटा कर सकते हैं छोटा कैसे कर

सकते हैं इस a = a + b को हम लिख सकते हैं

a प् इक्वल टू b तो यहां पर प्लस इक्वल टू

ने रिप्लेस कर लिया है इक्वल टू a को तो

इस तरीके से हम बार-बार बार-बार जब भी सेम

वेरिएबल को लेफ्ट में और राइट में यूज

करते हैं तो हम इक्वल टू को रिप्लेस कर

सकते हैं प्लस इक्वल टू से तो वो ऑपरेशन

परफॉर्म हो जाएगा जैसे यहां पर अगर हम

स्टेटमेंट लिखें a +

= b और फिर इसकी वैल्यू को चेक करें तो

सेम आउटपुट हमारे पास आएगा व्हिच इज अब जो

सेम चीज हमने प्लस के साथ की वो

मल्टीप्लाई के साथ भी कर सकते हैं यहां पर

अग लिख दिया मल्टीप्लाई इक्वल टू तो क्या

होगा 4 * 1 दोनों मल्टीप्लाई हो जाएंगे

आउटपुट में फर आएगा वहीं पर माइनस लिख

दिया तो माइनस में क्या होगा इस स्टेटमेंट

का मतलब है a = a - b तो a है 1 b है 4 1

- 4 - 3 आ जाएगा तो a में हमारे पास

प्रिंट होकर आना चाहिए -3 इसको टैली कर

लेते हैं आउटपुट में आया -3 तो इस तरीके

से जब भी एक्सप्रेशंस को छोटा करना हो

क्योंकि हम लेफ्ट और राइट में सेम ऑपरेंट

यूज़ कर रहे हैं तो क्या करेंगे माइनस

इक्वल टू लिख देंगे मल्टीप्लाई इक्वल टू

सेम फॉर डिवाइड सेम फॉर मॉड्यूल ये होते

हैं हमारे सबसे आसान ऑपरेटर्स हमारे

असाइनमेंट ऑपरेटर्स तो इस तरीके से हमारे

जो बेसिक ऑपरेटर्स थे बेसिक इंस्ट्रक्शंस

थे हमने कंप्लीट कर लिए हैं अब हम कुछ-कुछ

प्रॉब्लम्स करेंगे यह प्रॉब्लम्स करने के

बाद जो चीजें अभी हमने पढ़ी हैं चैप्टर टू

में व हमारे दिमाग के अंदर बैठ जाएंगी

सबसे पहला सवाल करते हैं राइट अ प्रोग्राम

टू चेक इफ अ नंबर इज़ डिविजिबल बाय टू ऑर

नॉट

अब नंबर इज डिविजिबल बाय टू और नॉट का

प्रोग्राम हमें लिखना है कोई भी नंबर मान

लो x हमें दिया है x की वैल्यू पाच हो

सकती है छ हो सकती है 10 हो सकती है देखना

है यह टू से डिवाइड होगा या नहीं होगा जो

भी नंबर किसी दूसरे नंबर से डिवाइड हो

जाता है जैसे मान लीजिए 4 ू से डिवाइड हो

जाता है 10 5 से डिवाइड हो जाता है तो

रिमाइंडर क्या देता है जीरो देता है 4 डि

बा 2 भी रिमाइंडर हमें जीरो देगा तो यहां

पे हमें दिमाग लगाना है कि रिमाइंडर टू दे

दे जो भी नंबर दूसरे से डिवाइड हो जा

तो यहां हम इस्तेमाल करेंगे अपने मॉडलो

ऑपरेटर का तो क्या करेंगे किसी भी नंबर एक

को इनपुट ले लेंगे इनपुट में हमने ले लिया

एकस को अब x का मॉडलो देख लेंगे ू के साथ

अगर यह मॉडलो जीरो हो जाता है एक केस है

कि जीरो हो गया मतलब हो गया डिवाइड एक केस

है जीरो नहीं हुआ जीरो के अलावा मान लो न

प्रिंट होर आ गया ू आ गया मानव या माइन फ

कुछ भी आ गया जीरो के अलावा तो मतलब नॉट

डिवाइड हो जाएगा तो सिंपली क्या करना है

एक नंबर इनपुट लेंगे यूजर से फिर उसका

मॉड्यूल चेक कर लेंगे टू के साथ अगर

मॉड्यूल जीरो रिटर्न कर रहा है तो मतलब

डिवाइड होता है नहीं तो नहीं होता अब इसके

लिए कोड लिखकर देख लेते हैं सबसे पहले

एक्स को हम कर लेते हैं डिक्लेयर फिर

स्कैन एफ करके सबसे पहले प्रिंट एफ कर

देते

हैं एंटर

अ नंबर यहां पर हमारे पास नंबर एंटर होगा

फिर उसको हम कर लेंगे

स्कैन परसेंटेज डी

एंड x अब दोबारा प्रिंट कर लेंगे हम

परसेंटेज

डी कैसे चेक करेंगे डिवाइड होता है या

नहीं होता हम लिख देंगे x

मॉडलो

2 इक्वल टू इक्व

0 यहां पर हमने दो को कंबाइन किया एरिथ

मेे ऑपरेटर को कंबाइन किया किसके साथ अपने

रिलेशनल ऑपरेटर के साथ मॉड्यूल लिया पहले

और फिर रिलेशनल आया अब जब हमने ऑपरेटर

प्रेसीडें देखा था तो उसमें क्या था हमारे

एरिदमेटोसस

ऑपरेटर्स नीचे थे तो यहां पर सबसे पहले x

का मॉड्यूल निकलेगा टू के साथ अगर वो

वैल्यू जीरो के इक्वल होती है तो प्रिंट

होगा ट्रू यानी वन मतलब ये डिवाइड हो जाता

है अगर नहीं होती तो प्रिंट होगा जीरो

मतलब ये डिवाइड नहीं होता है तो इसको सेव

कर लेते हैं आउटपुट अपना देखते हैं हम

एंटर करते हैं नंबर फाइव फाइव के लिए

प्रिंट हुआ जीरो क्योंकि फाइव जो है टू के

साथ डिवाइड नहीं होता वहीं पर इसको दोबारा

रन करें अबकी बार एंटर करेंगे 10

10 में प्रिंट हुआ वन क्योंकि 10 हमारा टू

के साथ डिवाइड हो जाता है जब भी 10 एंटर

किया 10 का मॉड्यूल निकला पहले टू के साथ

फिर मॉड्यूल क्या आया रो उस रो को हमने रो

से ही कंपेयर कर दिया तो आ गया ट्रू तो