Recap of C (Lecture 02)-ubKxyn4WTs8

में प्रोग्रामिंग(programming) हम मॉड्यूल 1 में C प्रोग्रामिंग(programming) के बारे में चर्चा कर रहे हैं।
 यह पार्ट -2 है, हम करेंगे अब बात करते हैं।
 पहले के भाग में आपने C के मूल अवधारणाओं को देखा है जिसमें डेटा(data) प्रकार, चर(variables), संचालक(operators), एक्सप्रेससीओन्स(expressions) और कथन विशेष रूप से नियंत्रण कथन शामिल हैं।
 अब, हम आगे बढ़ेंगे और हम C में विभिन्न व्युत्पन्न प्रकारों(derived types) के बारे में बात करेंगे जैसा कि आप जानते हैं कि C में सबसे आम व्युत्पन्न प्रकार(derived type) सरणियाँ(arrays) हैं।
 एरे डेटा(data) आइटम्स का एक संग्रह है।
 तो, एक चर(variables) एक एकल डेटा(data) आइटम(item) है, यह एक एकल मूल्य है; जहाँ सरणी(array) प्रतिबंध के साथ एक या एक से अधिक डेटा(data) आइटम(item) का एक संग्रह है कि सभी डेटा(data) आइटम(item) एक ही प्रकार के होने चाहिए।
 इसलिए, अगर मैं कहूं कि int की एक सरणी(array) है, तो उस सरणी(array) में सभी मानों को int होना होगा।
 अगर मैं कहूं कि सरणी(array) टाइप चार(char) की है, तो हर तत्व को टाइप कैरेक्टर का होना चाहिए।
 सरणियों(arrays) के संदर्भ में, पहली चीज जो हमें करने की आवश्यकता है वह यह है कि किसी सरणी(array) को घोषित करने की आवश्यकता है जैसे हमें किसी भी चर(variables) को घोषित करने की आवश्यकता है, इसलिए हम इस सरणी(array) को घोषित करते हैं।
 इसलिए, स्वाभाविक रूप से, हमें नाम निर्दिष्ट करने की आवश्यकता है; हमें यह कहने की आवश्यकता है कि किसी सरणी(array) के तत्व का प्रकार क्या है; और हमें यह भी निर्दिष्ट करने की आवश्यकता है कि एक सरणी(array) का समर्थन करने वाले तत्वों की अधिकतम संख्या क्या है।
 अब, तत्वों की यह अधिकतम संख्या कई अलग-अलग तरीकों से निर्दिष्ट की जा सकती है।
 और जैसा कि हम देखेंगे कि यह एक पहलू है जिसमें C ++ में सरणियाँ(arrays) C में सरणियों(arrays) से कुछ भिन्न होंगी, लेकिन C में एक विशिष्ट सरणी(array) को कोने कोष्ठक 10 के भीतर डबल बैलेंस के रूप में परिभाषित किया जाएगा, जो कहेगा कि शेष राशि डबल का एक सरणी(array) है प्रकार के तत्व और अधिकतम 10 ऐसे तत्व हो सकते हैं।
 अन्यथा, हम एक आकार को एक मैनिफ़ेस्ट(manifest) कॉन्स्टैंट(constant) द्वारा परिभाषित कर सकते हैं और इसका उपयोग ऐरे को परिभाषित करने के लिए कर सकते हैं।
 फिर सरणी(array) को भी आरंभ किया जा सकता है, हम दूसरे भाग में जा रहे हैं।
 इसलिए, सरणियों(arrays) को भी आरंभ किया जा सकता है, अगर मैं सिर्फ एक सरणी(array) घोषित करता हूं, तो तत्वों का कोई निर्दिष्ट मूल्य नहीं है, लेकिन मैं सरणी(array) को आरंभीकृत करने के साथ ही घोषित कर सकता हूं।
 इसलिए, अगर मैं कहता हूं कि 'int primes[5]' को उन मूल्यों की सूची के साथ आरंभ किया गया है, जो अल्पविराम द्वारा अलग किए गए हैं और घुंघराले ब्रेसिज़ की एक जोड़ी के भीतर संतुष्ट हैं, तो उस सूची में पहला मान सरणी(array) के पहले तत्व पर जाता है जैसा कि आप जानते हैं 0 वें सूचकांक तत्व।
 सूची में दूसरा दूसरे तत्व पर जाता है, जो कि इंडेक्स एक और इसी तरह है।
 दिलचस्प रूप से सी में, सरणियों(arrays) को विशेष रूप से व्यक्त आकार के बिना भी आरंभ करने की अनुमति है।
 इसलिए, मैं वास्तव में आकार देने के बिना केवल अपराध लिख सकता हूं और सी संकलनकर्ता क्या करता है, यह आरंभीकरण सूची दें; यह पता लगाता है कि आपने कितने तत्वों के साथ इसे इनिशियलाइज़ किया है, और यह मान लेता है कि यह ऐरे का आकार है या उन कई एलिमेंट्स होंगे।
 इसलिए, अगर primes को केवल 2, 3, 5, 7 और 11 की सूची के साथ आरंभ किया जाता है, तो 5 तत्व हैं, इसलिए यह पांच तत्वों की एक सरणी(array) बन जाएगा।
 और मैंने ऐसे मामलों में भी दिखाया है, क्योंकि आप नहीं जानते कि आकार क्या है, आकार की गणना करने का सबसे विश्वसनीय तरीका क्या है जो आपको लगता है कि आपके द्वारा हर तत्व के आकार से विभाजित सरणी(array) का कुल आकार क्या है निश्चित रूप से उन तत्वों की संख्या प्राप्त करें जिनमें सरणी(array) शामिल है।
 यह भी संभव है कि आपके पास एक बड़ा सरणी(array) हो और इसे तत्वों की कम संख्या के साथ प्रारंभ करें; प्रारंभ हमेशा से होगा।
 और ऐसे मामलों में बचे हुए तत्वों को 0 में आरंभीकृत किया जाएगा, लेकिन आप इसमें आरंभीकरण सूची नहीं रख सकते हैं जो कि उस एर के आकार से बड़ा है जो एक त्रुटि होगी।
 एक सरणी(array) चाहे वह इनिशियलाइज्ड हो या इनिशियलाइज्ड न हो, प्रत्येक एलीमेंट द्वारा एक्सेस की जा सकती है।
 इसलिए, सरणी(array) तत्वों तक पहुंचने के लिए, हम देख सकते हैं कि हम सूचकांक का उपयोग करते हैं और हम उस तत्व को पढ़ या एक्सेस कर सकते हैं, जो उस सरणी(array) स्थान पर मौजूद हैं।
 इसी तरह, मैं इसे एक अभिव्यक्ति के बाएँ हाथ पर भी नहीं लिख सकता था और किसी ऐरे तत्व को असाइनमेंट बना सकता था।
 C मान लेता है कि परिभाषित किया गया हर सरणी(array) एकल तत्व की तरह है।
 इसलिए, मैं सरणियों(arrays) और सरणियों(arrays) के सरणियों(arrays) और सरणियों(arrays) के सरणियों(arrays) को परिभाषित कर सकता हूं और इसी तरह; और इस तरह, मैं कई आयामों में विस्तार कर सकता हूं।
 तो, इन्हें बहुआयामी सरणियाँ(arrays) कहा जाता है।
 तो, बहुआयामी सरणी(array) का सबसे सरल एक द्वि-आयामी(dimensional) सरणी(array) होगा, जिसे हम आमतौर पर गणित में कहते हैं, हम आमतौर पर उन्हें मैट्रिक्स के रूप में कहते हैं।
 तो, यह दो आयामों के साथ दिया गया है; एक पंक्तियों की संख्या और स्तंभों की संख्या है।
 इसलिए, यदि हम int mat [3] [4] को परिभाषित करते हैं, तो इसका मतलब है कि इस पूरी मैट सरणी(array) में 3 पंक्तियाँ और 4 कॉलम हैं जो हमारे पास हैं।
 तो, यह इसे दो आयामी(dimensional) बनाता है; स्वाभाविक रूप से यदि यह दो आयामी(dimensional) है, तो इसे एक्सेस करने के लिए दो सूचकांक पंक्ति सूचकांक और स्तंभ सूचकांक की आवश्यकता होती है।
 आप इसे 3, 4 किसी भी उच्च आयाम तक बढ़ा सकते हैं जैसा कि आवश्यक है, लेकिन यह कम सामान्य है कि आपके पास नियमित उपयोग में 3 या उच्चतर आयामी(dimensional) सरणियाँ(arrays) होंगी।
 सरणियों(arrays) के आगे स्ट्रक्चरस(structure) हैं।
 तो, जैसे सरणी(array) एक संग्रह है और हम धीरे-धीरे कंटेनर(container) शब्द का उपयोग करना शुरू करेंगे, जो कि सी में इतना सामान्य नहीं है, लेकिन हम सी ++ में देखेंगे और विशेष रूप से मानक पुस्तकालय जो सी ++ के साथ आता है, आमतौर पर उपयोग किए जाने वाले शब्दों को कंटेनर(container) कहा जाता है क्योंकि कंटेनर(container) एक ऐसी चीज है जिसमें अन्य तत्व हो सकते हैं।
 एरे एक कंटेनर(container) है; यह विशिष्ट व्यवहार के साथ डेटा(data) आइटमों का एक संग्रह है जो सभी आइटम(item) उसी प्रकार के होते हैं जैसा हमने देखा है।
 अब, इसके विपरीत स्ट्रक्चर(structure) भी एक कंटेनर(container) है; यह डेटा(data) आइटम(item) का एक संग्रह है, लेकिन यहां डेटा(data) आइटम(item) विभिन्न प्रकार के हो सकते हैं; यह आवश्यक नहीं है कि उन्हें विभिन्न प्रकारों का होना चाहिए, लेकिन वे विभिन्न प्रकारों के हो सकते हैं।
 इसलिए, यदि मैं एक स्ट्रक्चर(structure) में देखता हूं, तो इन डेटा(data) आइटमों को अक्सर सदस्य कहा जाता है; और हम किसी स्ट्रक्चर(structure) के कैरक्टर(character) या डेटा(data) आइटम(item) का मतलब करने के लिए इस शब्द सदस्य या डेटा(data) सदस्य का अधिक से अधिक उपयोग करेंगे, हम एक जटिल संख्या बनाने का एक सरल उदाहरण दिखाते हैं।
 जैसा कि हम जानते हैं कि जटिल संख्याओं के दो कैरक्टर(character) होते हैं – वास्तविक(real) भाग और काल्पनिक(imaginary) भाग।
 तो, प्रत्येक भाग एक डबल हो सकता है।
 तो, हम परिभाषित करते हैं कि स्ट्रक्चर(structure) परिसर के साथ जो हमें बताता है कि दो कैरक्टर(character) हैं; इस स्थिति में, दोनों एक ही प्रकार के होते हैं और फिर C को इस स्ट्रक्चर(structure) प्रकार का एक चर(variables) घोषित किया जाता है।
 हम अगले एक में भी कर सकते हैं; हम दिखाते हैं कि आपके पास वास्तव में एक स्ट्रक्चर(structure) है जहां कैरक्टर(character) विभिन्न प्रकार के हैं।
 तो, पुस्तक स्ट्रक्चर(structure) में पहले दो कैरक्टर(character) शीर्षक और लेखक हैं; वे खुद चरित्र के सरणियाँ(arrays) हैं जो मूल रूप से इसका मतलब है कि वे शीर्षक नाम और लेखक के नाम के सी तार बन जाएंगे; और तीसरा कैरक्टर(character) वास्तव में एक पूर्णांक(integer) है, जो पुस्तक आईडी को रख रहा है।
 स्ट्रक्चरस(structures) को उनके नाम के अनुसार सीधे परिभाषित किया जा सकता है, और कीवर्ड स्ट्रक्चर(structure) का उपयोग करके हम इसका उपयोग कर सकते हैं या स्ट्रक्चर(structure) और स्ट्रक्चर(structure) का नाम एक साथ दिया जा सकता है और प्रकार डीआईआर कीवर्ड के उपयोग द्वारा उपनाम दिया जा सकता है।
 टाइप डीफ़, लघु परिभाषा का संक्षिप्त रूप है।
 और जैसा कि हम C ++ में जाते हैं, हम इस बारे में अधिक बात करेंगे कि टाइप डीफ़ वास्तव में एक प्रकार की परिभाषा क्यों नहीं है, यह एक प्रकार का मिथ्या नाम है, लेकिन ऐतिहासिक रूप से इसमें इस कीवर्ड का उपयोग किया गया है, और इसका उपयोग C में जारी है, लेकिन यह मूल रूप से उपनाम है।
 यह केवल एक और नाम है जो कि स्तृक्त(struct) की पुस्तकों के संरचनात्मक परिसर को दिया गया है, जैसा कि हमारे पास है।
 यह बस आसान हो जाता है।
 यदि आप उपयोग करते हैं, तो एक प्रकार का def है तो आप इसे सीधे उपयोग कर सकते हैं।
 इसलिए, यदि हम स्ट्रक्चरस(structures) की पहुंच के लिए आते हैं तो हम देख सकते हैं कि चूंकि जटिल का उपयोग करने के लिए केवल स्तृक्त(struct) जटिल के रूप में परिभाषित किया गया था, इसलिए हमें स्तृक्त(struct) जटिल और फिर चर(variables) नाम का अनुसरण करना होगा।
 लेकिन यहां पुस्तकों को टाइप डीफ़ द्वारा परिभाषित किया गया था, इसलिए पुस्तकों को उन संरचनात्मक पुस्तकों के साथ लिखने की आवश्यकता नहीं है जिन्हें मैं सिर्फ किताबें लिख सकता हूँ, इसने स्तृक्त(struct) पुस्तक के लिए कुल नाम दिया है।
 तो, इसे इस तरह से उपयोग करना आसान हो जाता है।
 अब, किसी भी स्ट्रक्चर(structure) चर(variables) को एक साधारण चर(variables) की तरह आरंभीकृत किया जा सकता है; और अंकन उसी तरह से होता है जिस तरह से हमने एरे को इनिशियलाइज़ किया है।
 इसके विपरीत, सरणियों(arrays) में, घुंघराले ब्रेसिज़ के भीतर गठित सूची का मतलब अलग-अलग घटकों या सरणी(array) के विभिन्न अनुक्रमित तत्वों से है; स्ट्रक्चर(structure) के मामले में, इसका मतलब विभिन्न घटकों या सरणी(array) के डेटा(data) सदस्य हैं; और जिस तरह से आप इन आरंभीकरण मूल्यों को सूचीबद्ध करते हैं, जिस तरह से डेटा(data) सदस्यों को ऊपर से नीचे के क्रम में सूचीबद्ध किया जाता है।
 इसलिए, यदि हम इस कोड(code) में दिए गए विशिष्ट मामलों को देखते हैं, तो आपके पास हम 2.0, 3.5 के साथ आरंभिक जटिल x दिखा रहे हैं, जिसका अर्थ है कि 2.0 का पहला कैरक्टर(character) जो 're' है, का प्रारंभिक मूल्य होगा।
 तो, आप बस उन्हें ऊपर से नीचे तक पढ़ें और इस सूची को बाएं से दाएं और उनके अनुरूप पढ़ें।
 तो, 3.5 im 'का प्रारंभिक मूल्य होगा।
 तो, अगर हम इस तरह से सोचते हैं, तो x एक जटिल संख्या 2.0 + j 3.5 बन जाएगा।
 यह संभव है कि हम केवल एक या कुछ सदस्यों को ही इनिशियलाइज़ करते हैं, लेकिन आप ऐसा केवल शुरुआती भाग से ही कर सकते हैं।
 आपपुनः ‘re' को छोड़ नहीं सकते हैं और केवल 'im' को प्रारंभ कर सकते हैं, लेकिन आपपुन ‘re’ को प्रारंभ कर सकते हैं जैसा कि आप यहाँ 4.2 के साथ कर रहे हैं और ‘im' को छोड़ दें, जिसका उल्लेख यहाँ नहीं किया गया है।
 तब स्ट्रक्चर(structure) के हर कैरक्टर(character) को डॉट नोटेशन द्वारा देखा जा सकता है, जिस डॉट ऑपरेटर(operator) को हम यहां दिखा रहे हैं।
 तो, यदि x एक जटिल चर(variables) है, एक स्ट्रक्चर(structure) चर(variables) है, और फिर इस चर(variable) x के ‘re’ भागको x.re के रूप में लिखा जाता है।
 इसी प्रकार यहाँ पुस्तक उपरोक्त प्रकार की पुस्तकों की स्ट्रक्चर(structure) है, इसलिए इसमें ‘आईडी' कैरक्टर(character) है जो कि पुस्तक है।
 इसलिए, हम स्ट्रक्चर(structure) कैरक्टर(character) को एक्सेस करने के लिए डॉट नोटेशन का उपयोग करते हैं।
 इसलिए, हम दो सबसे अधिक इस्तेमाल किए जाने वाले सी के बीच देख सकते हैं, सी में दो सबसे शक्तिशाली कंटेनरों में पहुंच के दो अलग-अलग तरीके हैं; सभी तत्व समान प्रकार के होते हैं।
 इसे स्थिति द्वारा एक्सेस किया जाता है, इसे स्थितीय अभिगम कहा जाता है, क्योंकि आप शुरुआत से शुरू होने वाले सरणी(array) में पता लगाना चाहते हैं, पहला, दूसरा, इसलिए आप बस संख्या से जाते हैं, इसलिए सरणी(array) को अनुक्रमित कंटेनर(container) भी कहा जाता है, क्योंकि आप संख्या के आधार पर तत्वों तक पहुँच सकते हैं।
 इसके विपरीत, स्ट्रक्चर(structure) में, तत्व विभिन्न घटकों के होते हैं जो विभिन्न प्रकार के होते हैं।
 इसलिए, सूची में पहला कैरक्टर(character) क्या है या सूची में तीसरा कैरक्टर(character) क्या है, इत्यादि का अधिक महत्व नहीं है।
 इसलिए, आप तत्वों को नाम से एक्सेस करते हैं।
 अब यह भी एक शैली है, जिसे हम विभिन्न भाषाओं में देखेंगे कि क्या आप किसी चीज़ को नाम से एक्सेस कर सकते हैं या आप किसी चीज़ को स्थिति से एक्सेस कर सकते हैं, और एक्सेस के ऐसे ही मुद्दे सामने आएंगे जब हम फंक्शन की दलीलों के बारे में भी बात करेंगे जो सी तुम्हें पता है भी स्थिति से है।
 और मैं बस यही चाहूंगा कि ये प्रोग्रामिंग(programming) लैंग्वेज के कुछ सामान्य पहलू हैं, जिनके बारे में आपको सावधान रहना होगा जब आपके पास तत्वों की एक सूची होगी कि यह किस स्थिति के बीच पहुंच तंत्र है या यह नाम से है।
 तो, स्ट्रक्चर(structure) में, हम एक तरह का देखते हैं; सरणी(array) में, हम दूसरे को देखते हैं।
 अब C पर चलते हुए एक अन्य प्रकार के संग्रह कंटेनर(container) का समर्थन करता है, जो स्ट्रक्चरस(structures) की तरह बहुत अधिक है, उन्हें संघ कहा जाता है।
 अब, केवल अंतर यह है कि आप जिस कीवर्ड का उपयोग करते हैं, उसके बजाय आप यूनियन कीवर्ड का उपयोग करते हैं।
 जिस तरह से आप निर्दिष्ट करते हैं या जिस तरह से आप सदस्यों तक पहुंचते हैं, वह स्ट्रक्चर(structure) और संघ के बीच समान है।
 लेकिन अलग-अलग क्या है जिस तरह से मेमोरी आवंटित की जाती है।
 यदि आपके पास दो, तीन अलग-अलग सदस्यों के साथ एक स्ट्रक्चर(structure) है, तो जब उस स्ट्रक्चर(structure) प्रकार का एक चर(variables) बनाया जाता है, तो सभी सदस्यों को क्षेत्र आवंटित किया जाता है।
 इसलिए, यदि आप इस स्ट्रक्चर(structure) में वापस जाते हैं, तो आप देखेंगे कि जटिल स्ट्रक्चर(structure) को परिभाषित करने के बाद यहां दो कैरक्टर(character) हैं, ये दोनों कैरक्टर(character) वास्तव में आवंटित किए गए हैं।
 इसलिए, यदि हम मानते हैं कि प्रत्येक डबल पाठ बाइट्स है, तो पूरे जटिल स्ट्रक्चर(structure) का आकार 8 बाइट्स प्लस 8 बाइट्स है जो 16 बाइट्स है, क्योंकि दोनों मौजूद हैं।
 इसके विपरीत, संघ में, यह आवंटन केवल सबसे बड़े कैरक्टर(character) के लिए मेमोरी(memory) में किया जाता है।
 इसलिए, आप यह सुनिश्चित करते हैं कि आपकी मूल धारणा जैसा कि नाम संघ का सुझाव हैयह इन सभी क्षेत्रों का एक संघ है, इसलिए किसी भी समय केवल घटकों में से किसी एक का अस्तित्व होगा।
 इसलिए, स्वाभाविक रूप से यदि आप उनमें से केवल एक का प्रतिनिधित्व कर रहे हैं, तो आपको सबसे बड़ी एक के लिए पर्याप्त जगह चाहिए जो कि केवल तार्किक चीज है।
 इसलिए, यदि हम इस संघ पैकेट को देखते हैं तो हम देखेंगे कि पैकेट में 3 कैरक्टर(character) इंट डबल और चार(char) प्रकार के हैं।
 इसलिए, यदि हम एक 32-बिट मशीन में आकार के बारे में एक उचित धारणा लेते हैं, तो int 4 बाइट्स होगा, डबल 8 बाइट्स और चार(char) संभवतः 2 बाइट्स होंगे।
 तो, पैकेट का आकार 8 बाइट्स होगा जो सबसे बड़े कैरक्टर(character) के आकार का दोगुना है।
 तो, दिलचस्प पहलू यह है कि एक तरफ आपको पूरे रिकॉर्ड के आकार को कम करने की अनुमति देता है, पूरे कंटेनर(container) का आकार, यदि आप जानते हैं कि आपको एक ही समय में सभी घटकों की आवश्यकता नहीं है।
 तो इसका दूसरा पहलू यह है कि जब आप इनिशियलाइज़ करते हैं तो आप केवल पहले कंपोनेंट की वैल्यू को इनिशियलाइज़ कर रहे थे क्योंकि निश्चित रूप से यहाँ क्योंकि आपके पास केवल एक कंपोनेंट हो सकता है, हमारे पास केवल एक कंपोनेंट के लिए स्पेस है।
 इनिशियलाइज़ेशन में कंपोनेंट्स की लिस्ट की लिस्ट अलग-अलग इनिशियलाइज़ नहीं कर सकते डेटा(data) सदस्य।
 और हमने देखा है कि प्रारंभ में आंशिक रूप से प्रदान किया जा सकता है, मैंने पहले एक या पहले दो या पहले तीन को यहाँ प्रारंभ किया है क्योंकि केवल एक डेटा(data) सदस्य है केवल एक ही मूल्य है जिसे आप प्रारंभ कर सकते हैं और वह है इसका प्रकार पहला मूल्य।
 अन्यथा, आपको करना होगा कि आपको शुरू करने की आवश्यकता नहीं होगी बल्कि आप बस कैरक्टर(character) को ले लेंगे और उसे असाइन करेंगे।
 अतः, एक्सेस के संदर्भ में, एक ही डॉट नोटेशन डॉट ऑपरेटर(operator) विभिन्न घटकों को एक्सेस करने के लिए उपयोगी होगा, लेकिन बिंदु यह है कि आपको यह याद रखना होगा कि केवल एक मूल्य बनाए रखा गया है, हालांकि हमारे पास तीन कैरक्टर(character) हैं केवल एक ही वैल्यू है ।
 इसलिए, इस बात पर निर्भर करता है कि आपके द्वारा उस कैरक्टर(character) के मूल्य तक पहुंचने के दौरान आपके द्वारा निर्दिष्ट किया गया कैरक्टर(character) क्या मान्य होगा।
 यदि आप एक अलग कैरक्टर(character) का उपयोग करते हैं तो अंतिम क्या सौंपा गया था तो आपको अप्रत्याशित परिणाम मिलेगा।
 इसलिए, इस एक्सेस कोड(code) में अगर आप थोड़ा ध्यान से देखेंगे, तो आप कोड(code) के पहले भाग में देखेंगे कि हमने iData को जो हम को सौंपा है, और फिर हम iData को एक्सेस करते हैं, इसलिए 2 मुद्रित है।
 डबल डेटा(data) में, हम 2.5 डेटा(data) डबल एक्सेस 2.2 करते हैं, इसलिए डबल डेटा(data) हम 2.2 एक्सेस करते हैं, प्रिंट किया जाता है।
 चार(char) डेटा(data) में, हम निरंतर कैरक्टर(character) को प्रदान करते हैं, हम उस a को प्रिंट करते हैं।
 इसलिए, हम जो भी आप अंतिम उपयोग करते हैं, वे मुद्रित होते हैं।
 अब, अगले में, हम एक दिलचस्प चीज दिखाते हैं, जिसे हमने iData में एक पूर्णांक(integer) भाग दिया है जिसे हमने 97 को सौंपा है, और फिर हमने पूर्णांक(integer) डेटा(data) तक पहुंच बनाई; जाहिर है, 97 आखिरी छपा है।
 लेकिन अगर बिना कुछ बताए हम इसे dData के रूप में एक्सेस करते हैं तो आपको कुछ 2.1999 मिलते हैं जो कि बहुत सार्थक नहीं है।
 तो, यह इसलिए हो रहा है क्योंकि dData, डबल डेटा(data) में 8 बाइट्स का आकार बड़ा है; जब आपने iData को सौंपा था जिसका अर्थ है कि आपने केवल 4 बाइट्स सौंपे हैं; शेष 4 बाइट्स में कुछ पुराने कचरा मूल्य हैं।
 तो, आप के रूप में क्या मिलता है dData पूरी तरह से गलत है।
 अंतिम दिलचस्प बात यह है कि यदि आप इसे C डेटा(data) के रूप में एक्सेस करते हैं तो आप वास्तव में 97 को C डेटा(data) के रूप में एक्सेस कर रहे हैं, और आप देख रहे हैं कि आपको 'a' क्यों, 97 ASCII का कोड(code) 'a' मिल रहा है।
 अब दिलचस्प बात यह है कि C डेटा(data) संभवतः यहाँ 1 बाइट है, जिसका अर्थ है कि इसमें 255 तक मूल्य संयोग हो सकते हैं जो आपने 4 बाइट के int को दिया है जो 255 से कम होता है।
 तो, हम आसानी से समझ सकते हैं कि इस इंट में उच्च तीन बाइट्स सभी शून्य हैं।
 इसलिए, जब मैं इसे एक चरित्र के रूप में एक्सेस करता हूं तो मुझे सिर्फ 97 मिलते हैं जो मैंने वहां संग्रहीत किए हैं।
 तो, ऐसा लगता है जैसे मुझे सही मान मिला है जो कि एक का कोड(code) है।
 जिस बिंदु पर मैं प्रकाश डालने की कोशिश कर रहा हूं वह यह है कि यह एक ऐसा मूल्य है जो निवास करता है, क्योंकि केवल एक मेमोरी(memory) स्थान है; जब आप संघ का उपयोग कर रहे हों तो आपको इस बारे में बहुत सावधान रहना होगा।
 C में कारण संघ इस तथ्य के लिए दिया गया था कि यदि आपको एक समुच्चय बनाना है, यदि आपको एक कंटेनर(container) बनाना है जो विभिन्न प्रकार के डेटा(data) से निपट सकता है, तो आमतौर पर आपको उस तरह का संदर्भ देना होगा जहां संघ का उपयोग किया जाता है यदि आप एक नेटवर्क कनेक्शन के बारे में सोचते हैं, और आपके पास एक नेटवर्क पोर्ट है, जहां विभिन्न प्रकार के डेटा(data) आ रहे हैं, तो विभिन्न प्रकार के डेटा(data) पैकेट आ रहे हैं, और आप नहीं जानते कि संभावित पैकेट से किस तरह का डेटा(data) पैकेट आएगा 10 डेटा(data) पैकेट से।
 लेकिन आप जानते हैं कि किसी भी समय केवल एक प्रकार का डेटा(data) पैकेट आएगा, केवल एक डेटा(data) पैकेट आएगा तब आप इस डेटा(data) पैकेट को संग्रहीत करने के लिए प्रोग्रामिंग(programming) स्ट्रक्चर(structure) को कैसे परिभाषित करते हैं।
 अब, आप एक ऐसी स्ट्रक्चर(structure) नहीं बनाना चाहते हैं, जिसमें इन 10 विभिन्न प्रकार के डेटा(data) पैकेटों को संग्रहीत करने की संभावना हो, क्योंकि यह अनावश्यक रूप से बहुत अधिक जगह लेगा।
 लेकिन एक ही समय में, इस तथ्य का उपयोग करते हुए कि केवल एक प्रकार का पैकेट 1.0 समय पर आएगा आप इस संघ स्ट्रक्चर(structure) का उपयोग कर सकते हैं एक संग्रह के रूप में भी कि यह कैसे सी में इसका उपयोग किया गया है।
 और हम इस संदर्भ में देखेंगे C ++ में संघ की इस अवधारणा के बहुत सारे प्रभाव होंगे C ++ हमें एक बहुत मजबूत विशेषता प्रदान करता है जो कि वस्तु अभिविन्यास पर आधारित है जिसे विरासत और विशेषज्ञता के रूप में जाना जाता है।
 और हम देखेंगे कि यूनियन का उपयोग किए बिना C ++ में समान प्रभाव कैसे बनाए जा सकते हैं, इसलिए यह सिर्फ आपकी टिप्पणियों के लिए है, हम बाद में विवरणों के साथ आएंगे जब हम C ++ के उस स्तर पर जाएंगे।
 ( अब सी प्रोग्रामिंग(programming) के सबसे दिलचस्प और संभवतः सबसे शक्तिशाली फीचर में से एक है जो सामने आता है।
 सी प्रोग्रामिंग(programming), यदि आप भाषा के इतिहास से थोड़ा-बहुत परिचित हैं, और मैं आपसे इसे मिलवाने के लिए एक उपयुक्त बिंदु चाहता हूं, तो यह है कि सी पहले विश्वविद्यालय में कंप्यूटर वैज्ञानिकों, प्रोफेसरों के एक समूह द्वारा किया गया था , और पेशेवरों का एक समूह, हम एक ऑपरेटिंग सिस्टम लिखने की कोशिश कर रहे थे, जो बाद में यूनिक्स(UNIX) के रूप में लोकप्रिय हो गया, आप सभी लिनक्स का उपयोग करते हैं जो कि बहुत बाद की पीढ़ी है।
 इसलिए, जब वे यूनिक्स(UNIX) लिखने की कोशिश कर रहे थे, तो यूनिक्स(UNIX) के लिए कोड(code) लिखने की कोशिश कर रहे थे, उन्हें एक प्रोग्रामिंग(programming) भाषा की आवश्यकता थी, क्योंकि अन्यथा आप कोड(code) कैसे लिखते हैं।
 अब यूनिक्स(UNIX) से पहले, उस प्रकार की कोई उच्च स्तरीय प्रोग्रामिंग(programming) भाषा नहीं थी जिसे आप C या C ++ या java या python में देखते हैं, जहाँ आप एक ऑपरेटिंग सिस्टम लिख सकते हैं, क्योंकि जब आप एक ऑपरेटिंग सिस्टम लिखना चाहते हैं, तो आपको करने की आवश्यकता नहीं है केवल मूल्यों के साथ व्यवहार करें, लेकिन आपको मेमोरी(memory) से निपटने की भी आवश्यकता है।
 क्योंकि प्रोग्राम आखिरकार, मेमोरी में संग्रहीत हो जाएंगे, जहां डेटा(data) मेमोरी में रहेगा।
 इसलिए, जब हम एक प्रोग्राम लिखते हैं, तो हम केवल चर(variables) के साथ काम कर रहे हैं, हम सिर्फ मूल्यों के बारे में रुचि रखते हैं।
 हम इन विचारों को मेमोरी(memory) में संग्रहीत किए जाने के बारे में सोचकर, बिना अजगर या जावा में एक संपूर्ण कार्यक्रम लिख सकते हैं, लेकिन आप यह मानते हुए एक ऑपरेटिंग सिस्टम नहीं लिख सकते।
 आपको उस प्रोग्रामिंग(programming) लैंग्वेज को मेमोरी की जानकारी या उस एड्रेस के बारे में पता होना चाहिए, जहाँ वैल्यू जमा हो जाती है।
 इसलिए यह विभिन्न कारणों में से एक था, जिसके लिए केर्निग(Kerning), रिची(Ritchie), मॉरिस(Morris) हिर और अन्य सभी की टीम, हम यूनिक्स(UNIX) टीम में थे, जिन्हें एक प्रोग्रामिंग(programming) लैंग्वेज करने की जरूरत थी, और उन्होंने जल्दी से C डिजाइन किया, जो बाद में उनके लिए एक डिफ़ॉल्ट भाषा बन गई।
 हम सभी, बाकी के रूप में वे कहते हैं कि यह इतिहास है, लेकिन यह वह उत्पत्ति है जिसके लिए सी ने पहली बार पते को डेटा(data) के रूप में प्रबंधित करने की मजबूत अवधारणा पेश की और जो हम कहते हैं वह एक पॉइंटर(pointer) है।
 मैं आपको इसका कारण बताना चाहता था कि आपको इसकी आवश्यकता क्यों है, लेकिन जब आपके पास पते के साथ व्यवहार करने की यह विशेषता है कि सी बहुत मजबूत पृष्ठभूमि देता है; जिसमें C विभिन्न प्रकार की डेटा(data) स्ट्रक्चरस(structure) बना सकता है जैसा कि आप सभी ने पहले ही कर लिया है।
 जैसे आप बिना पॉइंटर्स के कोई लिस्ट करने के बारे में सोच भी नहीं सकते; यह संभव है, यह संभव है कि आप दो सरणियों(arrays) का उपयोग करके एक लिंक सूची बना सकते हैं।
 सूचकांक को रखने के लिए एक सरणी(array) जहां आपको अगला तत्व मिलेगा; और वास्तव में मूल्यों के लिए एक और सरणी(array) है, लेकिन यह कुछ नहीं है, जो कुशल है जो स्केलेबल है जो लोग क्या करेंगे; इसलिए, आप हमेशा पॉइंटर्स का उपयोग करेंगे।
 इसलिए, पोइंटरस(pointers) अगले व्युत्पन्न प्रकार(derived type) हैं जैसा कि आप सभी जानते हैं।
 तो, यह एक चर(variables) है जिसका मान एक मेमोरी एड्रेस है।
 और पॉइंटर(pointer) का प्रकार पॉइंटर(pointer) द्वारा ही तय किया जाता है, सभी पॉइंटर्स पते हैं।
 तो, पता जिसमें केवल एक प्रकार है जो इंगित प्रकार का है, लेकिन उनका प्रकार इस आधार पर तय किया जाता है कि वे वास्तव में किस प्रकार के मूल्य की ओर इशारा कर रहे हैं।
 इसलिए, अगर मेरे पास एक int *ip है तो यह पूर्णांक(integer) प्रकार के मान की ओर इशारा करता है।
 तो, हम कहेंगे यह int * टाइप है।
 अब, पॉइंटर(pointer) का उपयोग करने के लिए, आप इससे परिचित होंगे तब मेरे पास एक वैरिएबल हो सकता है जो कि 20 के लिए इनिशियलाइज़ है, मेरे पास एक प्वॉइंट आईपी है जिसे मैं इंगित करने के लिए उपयोग करूंगा, जो इंट * आईपी है और एक विशेष ऑपरेटर(operator) है एम्परसेंड जैसा कि आप जानते हैं कि मैं मेमोरी स्थान का पता प्राप्त करने के लिए किसी भी चर(variables) के साथ उपयोग कर सकता हूं, जहां यह चर(variables) संग्रहीत किया जाएगा।
 तो, मैं उस पते को ले जा सकता हूं और उस पते को पॉइंटर(pointer) वैरिएबल आईपी में स्टोर कर सकता हूं।
 और एक बार जब मैंने ऐसा कर लिया है, तो अगर मैं चर(variables) i या i का पता प्रिंट करने की कोशिश करता हूं, तो मैं पते या आईपी के मूल्य को प्रिंट करता हूं, जो वास्तव में वह पता है जिसे मैंने यहां संग्रहीत किया है, तो वे निश्चित रूप से समान होंगे जो हम दिखा रहे हैं यहाँ।
 अब उस पते को देखते हुए, मैं वास्तव में यह पता लगा सकता हूं कि स्टार या ऑपरेटर(operator) की सामग्री का उपयोग करके उस इंगित स्थान पर क्या मूल्य मौजूद है।
 इसलिए, यहां पॉइंटर(pointer) के साथ, हम हमेशा ऑपरेटरों की सामग्री के साथ-साथ पते का भी उपयोग करेंगे।
 अब पोइंटरस(pointers) कई अलग-अलग तरीकों से उपयोग किए जा सकते हैं; प्रोग्रामिंग(programming) भाषा में विभिन्न मुहावरों को बनाने के मामले में वे बहुत शक्तिशाली थे।
 पहला और सबसे आम पॉइंटर(pointer) और एक सरणी(array) के बीच का द्वंद्व है; और सबसे आसानी से एक आयामी(dimensional) सरणी(array) के संदर्भ में देखा जाता है।
 तो, सरणी(array) स्थानों की एक श्रृंखला है; और पॉइंटर(pointer) सरणी(array) के शुरुआती स्थान का पता है।
 इसलिए, मैं एरे को ले जा सकता हूं और इसे पॉइंटर(pointer) वैरिएबल में असाइन कर सकता हूं।
 और फिर अगर मैं सिर्फ *p करता हूं, तो यह मुझे वह कंटेंट देता है, जो एरे के शुरुआती स्थान पर कंटेंट होगा, जो कि 0 होगा।
 मैं एक पॉइंटर(pointer) को बढ़ा सकता हूं और यह एक बहुत ही दिलचस्प कॉन्सेप्ट है, अगर मैं इंक्रीमेंट करता हूं एक पॉइंटर(pointer) तो वह राशि जिसके द्वारा इसे बढ़ाया जाता है वह 1 नहीं है, जिस राशि से इसे बढ़ाया जाता है वह उस प्रकार के तत्व का आकार है जिसे वह उस प्रकार के मान की ओर इशारा करता है जिसे वह इंगित कर रहा है।
 इसलिए, यदि यह एक इंट की ओर इशारा कर रहा है और सिस्टम में sizeof(इंट) 4 है, तो पॉइंटर(pointer) वैल्यू वास्तव में 4 से बढ़ेगा, ताकि एरे के संदर्भ में अब आप दूसरे स्थान की ओर इशारा कर रहे हैं।
 तो, आप देख सकते हैं कि यदि मैं * + + p करता हूं, तो यह पहले बढ़ेगा।
 तो, यह अब 1 तत्व की ओर इशारा कर रहा है और फिर यह 1 तत्व लेता है, जो मूल रूप से 2 है।
 इसी तरह, मैं कर सकता हूं मैं एक अभिव्यक्ति के रूप में p + 1 ले सकता हूं, p + 1; इसी तरह पॉइंटर(pointer) का वर्तमान स्थान प्लस 1 तत्व का आकार है जो कि हो सकता है।
 पॉइंटर्स का उपयोग स्ट्रक्चरस(structures) के साथ किया जा सकता है, अगर हम इसका उपयोग करते हैं तो हम तत्वों को * p द्वारा एक्सेस कर सकते हैं, और फिर * p एक स्ट्रक्चर(structure) है जो इसे डॉट री की ओर इशारा करता है जो कि उस स्ट्रक्चर(structure) का एक कैरक्टर(character) है।
 इसे डी रेफरेंस ऑपरेटर(operator) द्वारा छोटा किया जा सकता है क्योंकि यह C में दिया गया है, आप यह सब जानते हैं।
 इसलिए, हम इसे छोड़ देंगे तो पॉइंटर्स को डायनेमिक एलोकेशन के संदर्भ में भी इस्तेमाल किया जा सकता है।
 इसलिए, मैं डाइनैमिक(dynamic) रूप से मॉलोक का उपयोग करके आवंटित कर सकता हूं, और मुझे एक संकेतक मिलता है जिसमें एक निर्दिष्ट प्रकार नहीं है हम कह सकते हैं कि यह एक शून्य तारा है।
 और हम एक कास्टिंग का उपयोग कर सकते हैं जो कि प्रोग्रामर द्वारा उस पूर्णांक(integer) प्रकार के मान के लिए जबरन किया जाना है।
 यह यहां दिया गया एक दिलचस्प कोड(code) है, मैं विवरण के माध्यम से नहीं जाऊंगा; समझने की कोशिश करें कि यह कोड(code) पॉइंटर्स के साथ हेरफेर करने के लिए कैसे काम करता है।
 और यदि आपके कोई प्रश्न हैं, तो आप हमसे ब्लॉग पर पूछ सकते हैं।
 और हम डाइनैमिक(dynamic) रूप से सरणियों(arrays) को आवंटित करने के लिए पॉइंटर्स का उपयोग कर सकते हैं।
 इसके साथ, रिकैप के इस हिस्से में, हमने मुख्य रूप से विभिन्न व्युत्पन्न प्रकारों(derived types) के बारे में बात की है।
 सबसे पहले, हमने कंटेनरों, सरणियों(arrays), स्ट्रक्चरस(structures) और यूनियनों के बारे में बात की है; सी प्रदान करने वाले तीन मुख्य प्रकार के कंटेनर(container); और हमने पोइंटरस(pointers) के माध्यम से विभिन्न चर(variables) और पतों को प्रबंधित करने की बात की है।
 अगले में, हम कार्यों के बारे में बात करेंगे।