C ++ में प्रोग्रामिंग के मॉड्यूल(module) 11 में आपका स्वागत है।
 हमने पहले से ही मॉड्यूल(module) 5, 6 के माध्यम से 10 के माध्यम से C ++ के प्रक्रियात्मक विस्तार में एक लूप लिया है और हमने अलग-अलग बेहतर सी विशेषताओं को देखा है।
 अब इस मॉड्यूल(module) के बाद से, हम C ++ की मुख्य ऑब्जेक्ट(object)-ओरिएंटेड(oriented) विशेषताओं, क्लासेस(classes) और ऑब्जेक्ट्स(objects) की अवधारणा पर चर्चा करना शुरू करेंगे।
 तो, इस मॉड्यूल(module) का उद्देश्य C ++ में क्लास और ऑब्जेक्ट्स(objects) की अवधारणाओं को समझना है।
 तो, ये वे ऑब्जेक्ट(object)एं हैं जिनसे हम चलेंगे।
 अब, मैं सबसे पहले आपको बताता हूं कि क्लास(class) क्या है, और एक ऑब्जेक्ट(object) क्या है, इसका एक बहुत ही बुनियादी अवलोकन।
 हम धीरे-धीरे प्रदर्शित करेंगे, उदाहरण के माध्यम से इनका वर्णन करेंगे, ताकि प्रत्येक बिंदु स्पष्ट हो जाए।
 जैसा कि हम कहते हैं, एक क्लास(class) एक प्रकार का कार्यान्वयन है।
 एक बयान जो अभी तक पूरी तरह से आपके लिए कुछ नया लगेगा या ध्वनि देगा; जहाँ तक C का संबंध था, हमने या तो प्रकारों में निर्माण किया था या हमारे पास अंतर्निहित प्रकारों से व्युत्पन्न प्रकार थे जैसे संरचना या जैसे पोइन्तेर्स(pointers)।
 लेकिन, अब हम एक उपयोगकर्ता परिभाषित डेटा(data) प्रकार को अपने आप से लागू करने की स्थिति में होंगे और यह उन प्रमुख पाठों में से एक होगा जिन्हें हम वर्तमान मॉड्यूल(module) और अगले कुछ मॉड्यूल(module) से लेने की कोशिश करेंगे।
 जैसा कि हम देखेंगे कि एक क्लास(class) में डेटा(data) सदस्य या विशेषताएँ होंगी, एक क्लास(class) में संचालन, सदस्य कार्य या विधियाँ होंगी; ये केवल एक ही चीज़ के वैकल्पिक नाम हैं।
 हम देखेंगे कि एक क्लास(class) एक नाम स्थान को परिभाषित करता है जो एक बार एक क्लास(class) के नाम को परिभाषित करता है, यह सभी डेटा(data) सदस्यों और विधियों के नामों के लिए एक आस-पास की संपत्ति बन जाता है।
 और इस तरह, एक क्लास(class) डेटा(data) एब्स्ट्रक्शन या ऑब्जेक्ट(object)-ओरिएंटेड(oriented) प्रोग्रामिंग के तथाकथित एनकैप्सुलेशन की पेशकश करेगा।
 सी प्रोग्रामिंग के साथ समानांतर के संदर्भ में, आप कह सकते हैं कि क्लास(class) संरचनाओं के समान है जो डेटा(data) को तार्किक रूप से एकत्रित करता है, लेकिन हम यह दिखाएंगे कि क्लास(class)एं अलग कैसे हो जाती हैं।
 क्लास(class) को परिभाषित करने के लिए, C ++ नाम क्लास(class) द्वारा एक नया कीवर्ड पेश करता है, और क्लासेस(classes) में अलग-अलग पहुंच निर्दिष्ट है; और अंत में, एक क्लास(class) एक ब्लू प्रिंट(print) है और इसे ऑब्जेक्ट(object)ओं के लिए त्वरित किया जा सकता है।
 तो, ऑब्जेक्ट(object) मूल रूप से एक क्लास(class) के उदाहरण हैं; इसलिए, एक क्लास(class) को देखते हुए, मेरे पास उस क्लास(class) के कई उदाहरण हो सकते हैं, एक क्लास(class) हमें ब्लू प्रिंट(print) बताता है, हमें वह प्रारूप बताता है जिसमें किसी ऑब्जेक्ट(object) के लिए डेटा(data) और विधि को व्यवस्थित किया जाना चाहिए।
 और प्रत्येक ऑब्जेक्ट(object) की एक अलग पहचान होगी; इसमें डेटा(data) सदस्यों के अपने मूल्य होंगे जो उस स्थिति को निर्दिष्ट करेंगे जिसमें ऑब्जेक्ट(object) निवास करेगा।
 यह सदस्य कार्यों का समर्थन करेगा, जो उस व्यवहार को परिभाषित करेगा जो वह पेश कर सकता है; एक ऑब्जेक्ट(object) दिया गया है, हम डॉट ऑपरेटर का उपयोग कर पाएंगे, जो हमने संरचनाओं के घटकों तक पहुँचने के संदर्भ में देखा था, वही ऑपरेटर डेटा(data) सदस्यों के साथ-साथ ऑब्जेक्ट(object) के तरीकों का उपयोग करने में सक्षम होगा।
 और इसके अलावा, एक ऑब्जेक्ट(object) को इस सूचक के रूप में एक विशेष सूचक पता होगा; और यह सूचक प्रत्येक और हर विधि को स्पष्ट रूप से पारित कर देगा।
 यह केवल एक संक्षिप्त विवरण है कि कौन सी क्लास(class)एं और ऑब्जेक्ट(object) हैं।
 मुझे यकीन है कि बहुत शुरुआत में यह आप सभी के लिए बहुत मायने नहीं रखता होगा।
 इसलिए, हम एक उदाहरण के साथ शुरू करेंगे, और धीरे-धीरे अगली स्लाइड्स में इनमें से प्रत्येक बिंदु को चित्रित करेंगे।
 तो, आइए हम एक जटिल संख्या(complex number) की एक सरल परिभाषा पर विचार करें।
 हमने यह उदाहरण पहले भी लिया था, जहां हम वास्तव में एक संरचना का उपयोग कर सकते हैं जिसमें दो डेटा(data) सदस्य होते हैं, दो सदस्य एक जटिल संख्या(complex number) के दो घटकों को फिर से और इम्प्रैस करते हैं और इसे एक संरचना के रूप में परिभाषित किया जाता है और हम इसे टाइप करते हैं, जो कि नाम कॉम्प्लेक्स हो।
 इसलिए, एक बार जब हमने ऐसा कर लिया था, तब हम उस संरचना के चर को परिभाषित कर सकते हैं और संरचना के इस घटक के लिए कुछ प्रारंभिक मान रख सकते हैं।
 तो, फिर से 4.2 हो जाएगा, और im 5.3 हो जाएगा।
 इसलिए, यदि हम अब इस जटिल संख्या(complex number) के दो घटकों को एक में प्रिंट(print) करते हैं, तो यह 4.2 और 5.3 के रूप में प्रिंट(print) होगा।
 यह वही है जो आप पहले से जानते हैं; यह वही है जो सी में उपलब्ध है।
 यदि मैं इसे C ++ में समान रूप से लिखना चाहता हूं, तो मैं इसे क्लास(class) के रूप में बदलूंगा और लिखूंगा।
 इसलिए, हम एक struct कॉम्प्लेक्स कर रहे थे और फिर हम typedef के साथ अलियासिंग कर रहे हैं, अब मैं बस एक क्लास कॉम्प्लेक्स लिखता हूं और उस के अंदर मेंबर की परिभाषाएँ डाल देता हूं।
 और बाकी कोड बहुत ही समान तरीके से लिखे जा सकते हैं, केवल यहाँ अंतर होने पर, हम प्रिंटफ का उपयोग कर रहे हैं और यहाँ हम cout का उपयोग कर रहे हैं जैसा कि हमने C ++ के मामले में देखा है हम ऐसा करने के लिए स्ट्रीमिंग ऑपरेटरों का उपयोग करते हैं।
 अब, देखते हैं कि इससे वास्तव में क्या फर्क पड़ता है।
 तो, संरचना C में एक कीवर्ड है, C ++ में क्लास एक नया कीवर्ड है।
 बाकी जो हमने किया है वह वास्तविक घटक के दो घटकों को परिभाषित करने और एकत्र करने के दो तरीकों और एक जटिल संख्या(complex number) के काल्पनिक घटक के बीच बहुत समान है, या तो सी में एक संरचना के माध्यम से या सी ++ में एक क्लास(class) के माध्यम से।
 इसलिए, एकमात्र कंट्रास्ट जिसे हम धीरे-धीरे अब बाहर लाएंगे, जबकि संरचना हमें केवल एकत्र करने की अनुमति देगी, दो घटकों को एक साथ रखेगी, उन्हें एक साथ संदर्भित करेगी जैसा कि हम n1 को दो डबल संख्या 4.2 और 5.3 एक जोड़ी के रूप में संदर्भित कर रहे हैं।
 एक जटिल क्लास(class) को डिजाइन करना भी यही काम करता है।
 लेकिन हम जिस क्लास(class) को देखेंगे, उससे बहुत अधिक चीजें करेंगे जो कि संरचना कर सकती है।
 तो चलिए, हम कुछ अलग और बड़ा उदाहरण लेते हैं।
 यहाँ हम एक आयत(rectangle) को परिभाषित करने की कोशिश कर रहे हैं और यह एक विशेष प्रकार की आयत(rectangle) है जो कहेंगे कि इस आयत(rectangle) में आयत(rectangle) आयत(rectangle) है कि इस आयत(rectangle) का अक्ष x और y- अक्ष के समानांतर है।
 इसलिए, अगर मैं सिर्फ दो कोनों के साथ निर्दिष्ट करता हूं, तिरछे विपरीत कोने, शीर्ष बाएं और आयताकार के नीचे दाएं कोने, तो आयत(rectangle) पूरी तरह से निर्दिष्ट है।
 ऐसा करने के लिए, पहले हम एक संरचना को परिभाषित करते हैं जो हमें दो निर्देशांक x और y के एकत्रीकरण के रूप में अंक देती है और फिर हम दो बिंदु लेते हैं और उन्हें एक आयत(rectangle) के दो तिरछे विपरीत बिंदुओं को नामित करने देते हैं।
 और एक बार यह हो गया तो मैं यहाँ एक आयत(rectangle) को परिभाषित कर सकता हूँ, आयत(rectangle) r।
 आप यहाँ पहले {0, 2} नोटेशन देख सकते हैं, घुंघराले ब्रेसिज़ की पहली जोड़ी के भीतर पॉइंट टॉप लेफ्ट, {5, 7} का मतलब पॉइंट बॉटम राइट है।
 और दोनों का एक साथ मतलब पूरी आयत(rectangle) है।
 तो, टिप्पणियों में, आप देख सकते हैं कि अगर मैं 0, 2 को पहले बिंदु के रूप में निर्दिष्ट करता हूं, तो मैं वास्तव में आर को निर्दिष्ट कर रहा हूं कि आयत(rectangle) का नाम r.TL एक शीर्ष बाएं बिंदु, डॉट x (.x) x coordinate है जो कि मान 0 प्राप्त करता है।
 इसी प्रकार, r.TL.y, जो शीर्ष बाएँ बिंदु का एक घटक है, मान 2 प्राप्त करता है।
 इसलिए, इस आरंभीकरण के माध्यम से इन सभी मूल्यों को सेट किया जा रहा है और फिर मैं उन्हें प्रिंट(print) कर सकता हूं।
 बाहर।
 इसी तरह, मैं क्लास(class) का उपयोग करके पूरी बात लिख सकता हूं।
 अंतर वैसा ही हो रहा है जैसा पहले था।
 मैं इसे इसी तरह से इनिशियलाइज़ कर सकता हूं और मैं इसे कॉउट का उपयोग करके प्रिंट(print) कर सकता हूं।
 तो, यह केवल क्लास(class) का उपयोग करने का एक और उदाहरण दिखा रहा है।
 यहां Rect में डेटा(data) सदस्य - आयत(rectangle), वास्तव में किसी भी मूल प्रकार के नहीं हैं, लेकिन वे उपयोगकर्ता परिभाषित डेटा(data) प्रकार हैं, वे स्वयं क्लास(class) ऑब्जेक्ट(object) हैं, वे उस बिंदु क्लास(class) के उदाहरण हैं जिन्हें मैंने पहले ही परिभाषित किया है।
 आइए एक स्टैक(stack) का तीसरा उदाहरण लेते हैं, जिस पर हम पहले भी चर्चा कर चुके हैं।
 तो, स्टैक(stack) में, हमारे पास मिश्रित डेटा(data) प्रकारों का मिश्रण संयोजन है, हमारे पास स्टैक(stack) के तत्वों को रखने के लिए एक चरित्र सरणी है, यह पात्रों का ढेर है, हमारे पास एक शीर्ष मार्कर है जो स्टैक(stack) पर एक सूचकांक है जो दिखाता है जहां वास्तव में शीर्ष मौजूद है।
 तो, मैं एक स्टैक(stack) चर को यहां या यहां परिभाषित कर सकता हूं; और जाहिर है, इससे पहले कि मैं स्टैक(stack) का उपयोग करना शुरू कर दूं, मुझे यह सुनिश्चित करने की आवश्यकता है कि स्टैक(stack) खाली है जो शीर्ष सूचकांक द्वारा निर्दिष्ट किया गया है माइनस 1(-1)।
 इसलिए, मैं टॉप इंडेक्स -1 को इनिशियलाइज़ करता हूं, और फिर मैं स्टैक(stack) का उपयोग कर सकता हूं, चाहे वह संरचना के माध्यम से परिभाषित किया गया हो या विभिन्न समस्याओं को हल करने के लिए अलग-अलग एल्गोरिदम का उपयोग करके क्लास के माध्यम से परिभाषित किया गया हो।
 तो, ये अलग-अलग उदाहरण हैं, जहां आप यह देख सकते हैं कि, हम दिखाते हैं कि एक क्लास(class) के मूल घटक, वह एक क्लास(class) कीवर्ड के रूप में एक क्लास(class) है, इसका एक नाम है जो नाम और पहचानकर्ता है, इसमें कई डेटा(data) सदस्य हैं ।
 प्रत्येक डेटा(data) सदस्य को एक चर घोषणा शैली के रूप में संरचना में परिभाषित किया गया है और क्लास(class) के नाम का उपयोग करते हुए, हम क्लास(class) प्रकारों के चर घोषित कर सकते हैं जिन्हें उदाहरण के रूप में जाना जाता है।
 तो, यह एक उदाहरण है या इसे एक ऑब्जेक्ट(object) कहा जाता है।
 तो, s क्लास(class) स्टैक(stack) का एक ऑब्जेक्ट(object) है।
 और एक बार हमारे पास उस ऑब्जेक्ट(object) के साथ, हम डेटा(data) सदस्य का उपयोग कर सकते हैं, यहाँ डेटा(data) सदस्य डॉट सदस्य नोटेशन का उपयोग करके शीर्ष पर है।
 तो, हम पहले दिखाते हैं कि एक क्लास(class) एक समुच्चय है जो एक या एक से अधिक डेटा(data) सदस्यों को एक साथ रख सकता है और हमें उस क्लास(class) की ऑब्जेक्ट(object)ओं को तत्काल भरने या सी ++ तंत्र का उपयोग करके उस प्रकार के चर को परिभाषित करने की अनुमति देता है।
 इसलिए, बस पुनरावृत्ति करने के लिए, हमने देखा है कि क्लास(class) एक प्रकार का कार्यान्वयन है जिसे हम इसे और अधिक देखेंगे।
 हमने तीन प्रकारों को एक जटिल प्रकार, एक आयत(rectangle) और बिंदु प्रकार और एक स्टैक(stack) प्रकार करने के तीन प्रयास देखे हैं।
 हमने दिखाया है कि क्लास(class) में डेटा(data) सदस्य होंगे, यह एक नाम स्थान को परिभाषित करता है, जब मैं कहता हूं कि मैं एक जटिल को परिभाषित कर रहा हूं, मेरे सभी परिसर के डेटा(data) सदस्यों का वास्तव में एक नाम है, जो जटिल, क्लास(class) नाम से योग्य है अपने आप।
 और यह तार्किक रूप से डेटा(data) को एकत्रित कर रहा है।
 ऑब्जेक्ट(object)ओं के उदाहरणों के संदर्भ में, हमने दिखाया है कि हर प्रकार के क्लास(class) के लिए, हर तीन क्लास(class) जिन्हें हमने परिभाषित किया है, हम उन या ऑब्जेक्ट(object)ओं के विभिन्न उदाहरणों में परिभाषित कर सकते हैं और डेटा(data) सदस्यों की पहुंच "." डॉट ऑपरेशन के माध्यम से होती है।
 अब तक, हमने जो देखा है, वह ऐसा कुछ है जो संरचनाओं के रूप में हम कर सकते हैं।
 और अब हम क्लास(class) परिभाषा के अनुसार, संरचना में जो हम कर सकते हैं उससे दूर जाने के लिए पहला बड़ा अंतर या पहला बड़ा कदम बनाने जा रहे हैं।
 तो, कृपया इसे बहुत सावधानी से पालन करें।
 हम जटिल उदाहरणों पर वापस लौट रहे हैं।
 तो, यह हिस्सा आम है, आपके पास संरचना की परिभाषा के संदर्भ में यहां डेटा(data) सदस्य हैं, हमारे पास डेटा(data) सदस्यों की क्लास(class) की परिभाषा के समान ही हैं।
 अब, यदि मेरे पास C में इतनी जटिल संख्या(complex number) है, तो मैं स्लाइड के बाईं ओर देख रहा हूं, तो मैं कई प्रकार के फ़ंक्शन(function) को परिभाषित कर सकता हूं, मैं कहता हूं कि मैं एक फ़ंक्शन(function) मानदंड को परिभाषित करता हूं, जो इस तरह की जटिल संख्या(complex number) C को यहां और परिभाषित कर सकता है।
 इसका आदर्श।
 आप सभी जानते हैं कि आदर्श वास्तविक और काल्पनिक भागों के क्लास(class) के इस योग की गणना कैसे करता है।
 और फिर वे उस राशि का एक वर्गमूल लेते हैं, आपको जटिल संख्या(complex number) का मान मिलता है या हम असली प्लस j काल्पनिक घटक प्रकार के नोटेशन प्रिंट(print) में जटिल संख्या(complex number) को प्रिंट(print) करने के लिए एक और फ़ंक्शन(function) लिख सकते हैं यह मान मान और इसी तरह है।
 तो, इन कार्यों को संरचित के साथ लिखा जा सकता है जटिल(complex) प्रकार जिसे मैंने पहले ही सी में परिभाषित किया है और ये सभी हैं जैसा कि हम जानते हैं कि सी फ़ंक्शन(function) या अधिक सामान्यतः वैश्विक(global) कार्य हैं, और फिर मैं प्रिंट(print) करने के लिए उपयोग कर सकता हूं और यदि मैं ऐसा करता हूं तो जटिल संख्या(complex number) प्रिंट(print) आउट हो जाएगी।
 तो, यदि आप बस के रूप में एक नज़र रखना चाहते हैं, यह कैसे प्रिंट(print) करता है, यह वह है जो प्रिंट(print) करता है।
 तो, दी गई जटिल संख्या(complex number) 4.2, 5.3 है, यह प्रिंट(print) करता है कि 4.2+ j 5.3 का मानदंड 6.7624 है।
 अब, हम C ++ की ओर ध्यान से देखते हैं।
 यहां मैं मानक फ़ंक्शन(function) को भी परिभाषित कर रहा हूं, लेकिन अंतर के साथ।
 संरचना में, संरचना के मामले में, संरचना की परिभाषा अलग है, मेरी फ़ंक्शन(function) परिभाषा अलग है, लेकिन यहां मेरी क्लास(class) की परिभाषा, यह जटिल की मेरी पूरी क्लास(class) की परिभाषा है, और मेरा कार्य क्लास(class) की परिभाषा का एक हिस्सा है।
 और इस तरह के कार्यों को बुलाया जाएगा, काफी स्वाभाविक रूप से सदस्य कार्यों को कहा जाएगा जैसे कि पुन: क्लास(class) परिसर का सदस्य है, हम कहते हैं कि यह एक डेटा(data) सदस्य है, इसी तरह "डबल norm ()" यह फ़ंक्शन(function) भी क्लास(class) परिसर का एक सदस्य है।
 और इसे मेम्बर फंक्शन या मेथड कहा जाता है।
 आप यह भी देख सकते हैं कि अन्य फ़ंक्शन(function) प्रिंट(print) भी क्लास(class) की परिभाषा में निहित है और प्रिंट(print) अभी तक एक अन्य सदस्य फ़ंक्शन(function) है।
 तो, यह कुछ सदस्य फ़ंक्शन(function) सी ++ के लिए एक पूरी तरह से नई अवधारणा है, सी में इसका कोई समानांतर मौजूद नहीं है।
 और इस सदस्य फ़ंक्शन(function) के साथ, अब हम कह सकते हैं कि मेरा ऑब्जेक्ट(object) इंस्टेंस, जिसे क्लास कॉम्प्लेक्स दिया गया है, इसका एक उदाहरण है क्लास(class), अब मेरी ऑब्जेक्ट(object) उदाहरण, कहते हैं कि यह उदाहरण C इस संकेतन में विधि का उपयोग कर सकता है।
 इससे पहले, आपने केवल डेटा(data) सदस्य के संदर्भ में नोटेशन देखा था, जो कि "c.re" एक ऐसी चीज़ है जिसे हमने देखा था जिसका मतलब है कि मैं जटिल संख्या(complex number) सी के पुन: डेटा(data) सदस्य का उल्लेख कर रहा हूं लेकिन अब मैं "सी" लिख रहा हूं।
 प्रिंट(print) "जिसका अर्थ है कि ऑब्जेक्ट(object) सी के लिए, उदाहरण के लिए सी, मैं उपयोग कर रहा हूं या मैं विधि प्रिंट(print)() का आह्वान कर रहा हूं।
 यह विधि प्रिंट(print) है जो इसे करने के लिए माना जाता है, यह यह मानकर करेगा कि इन डेटा(data) सदस्यों के पास वे मान हैं जो c ऑब्जेक्ट(object) में हैं और तदनुसार यह काम करेगा, यह प्रिंट(print) आउट होगा।
 इसी तरह, अगर मैं c.norm() लिखता हूं और आह्वान करता हूं, तो यह अन्य सदस्य फ़ंक्शन(function) norm() को लागू करेगा, और मान भी c के मूल्य से आने वाले वास्तविक और काल्पनिक घटकों के साथ व्यवहार करेगा।
 यह पूरी तरह से नई अवधारणा है और यही सदस्य कार्य करेंगे।
 इसलिए, हम विपरीत कर रहे हैं कि सी के रूप में, अगर हम किसी चीज को संरचना के रूप में परिभाषित करते हैं, तो हर ऑपरेशन हमें इसके साथ करने की आवश्यकता है, हमें कुछ वैश्विक(global) कार्यों के माध्यम से करने की आवश्यकता है जिसे कोई भी और हर कोई देख और उपयोग कर सकता है।
 जबकि C ++ में, क्लास(class) अपने आप में, कई सदस्य फ़ंक्शन(function) या पद्धति को परिभाषित कर सकती है, जिसे ऑब्जेक्ट(object) कुछ कार्यों को करने के लिए आवश्यक के रूप में लागू कर सकता है, और यह वह है जिसे ऑब्जेक्ट(object) के व्यवहार के रूप में जाना जाता है जैसा कि हम धीरे-धीरे देखेंगे।
 तो, आइए हम कुछ और उदाहरण देखें।
 आइए हम फिर से आयत(rectangle) बिंदु भाग को वापस लाएँ, इस भाग को आप पहले ही देख चुके हैं, इस भाग को आप पहले ही देख चुके हैं।
 यहां हम संरचना का उपयोग करके सी के लिए एक फ़ंक्शन(function) लिख रहे हैं, यह एक वैश्विक(global) फ़ंक्शन(function) है, जो आयत(rectangle) के क्षेत्र की गणना करता है।
 क्षेत्र की गणना करने का सूत्र सीधा है, मैं उसमें गहराई तक नहीं जाऊंगा, लेकिन यह एक वैश्विक(global) कार्य गणना() है, जो एक आयत(rectangle) को एक पैरामीटर के रूप में लेता है और क्षेत्र की गणना करता है और यह इसी तरह काम करता है।
 इसके विपरीत, C ++ क्लास(class) में, यह मेरा आयत(rectangle) क्लास(class) है, यह वही है जो मेरा आयत(rectangle) क्लास(class) मेरी विधि है, मेरी computeArea() विधि एक सदस्य कार्य है जो क्लास(class) का एक हिस्सा है।
 इसलिए, जब मेरे पास एक आयत(rectangle) आर ऑब्जेक्ट(object) है, तो मैं उसी डॉट नोटेशन का उपयोग करते हुए विधि या सदस्य फ़ंक्शन(function) को लागू करता हूं, और इसका मतलब है कि गणना क्षेत्र काम करेगा, यह मानकर काम करेगा कि आर यहां तात्कालिक है।
 यह काम कर रहा है।
 इसलिए, जब यह TL.x को संदर्भित करता है, तो यह वास्तव में r ऑब्जेक्ट(object) के TL.x को संदर्भित करता है, जिसने इस विशेष विधि को लागू किया है।
 C में यह अधिक है, हम कहते हैं कि यह फ़ंक्शन(function) कॉल है, हम यह कहना जारी रखते हैं कि यह C ++ में भी एक फ़ंक्शन(function) कॉल है, लेकिन जब आप विभिन्न ऑब्जेक्ट्स(objects) के सदस्य फ़ंक्शन(function) का उपयोग करते हैं, तो आप अक्सर कहेंगे कि आप विधि का आह्वान कर रहे हैं किसी ऑब्जेक्ट(object) का।
 एक विधि या एक सदस्य फ़ंक्शन(function), जो इसकी क्लास(class) परिभाषा के एक भाग के रूप में उपलब्ध है, इसलिए यह C ++ में विधियों का मूल विचार है।
 आप देख सकते हैं।
 हम इसमें बहुत विस्तृत नहीं होंगे कि आप अपना समय ले सकते हैं जब आप इसे और अधिक अध्ययन करते हैं, तो यह प्रस्तुति और अधिक।
 आप देख सकते हैं कि यह एक स्टैक(stack) का पूर्ण उदाहरण है, जिसके पास डेटा(data) है।
 ये स्टैक(stack) के चार ऑपरेशन हैं: खाली, शीर्ष, धक्का और पॉप, वैश्विक(global) कार्यों के रूप में सी में दिए गए।
 हम यहां एक स्टैक(stack) का उदाहरण उपयोग करते हैं, इसे इनिशियलाइज़ करते हैं एक टॉप मार्कर, इसका उपयोग करते हैं और एक दिए गए स्ट्रिंग(string) के लिए, हम उस स्ट्रिंग(string) के एक-एक अक्षर को एक के बाद एक स्टैक(stack) में धकेलते हैं, और फिर हम उन्हें तब तक पॉप-अप करते रहते हैं स्टैक(stack) खाली हो जाता है।
 जैसा कि आप जानते हैं कि यह एक स्ट्रिंग(string) को रिवर्स करने के लिए मानक एल्गोरिथ्म है।
 इसलिए, यह कोड इस वैश्विक(global) फ़ंक्शन(function) का उपयोग करके स्ट्रिंग(string) को उलट देगा।
 और अब हम दिखाते हैं कि हम वैसा ही कर सकते हैं जैसा कि हम क्लास कॉम्प्लेक्स का उपयोग करके दिखा रहे हैं, जैसा कि हमने क्लास रेक्टेंगल का उपयोग करके दिखाया है।
 हम बताते हैं कि क्लास(class) स्टैक(stack) के मामले में, मेरे पास डेटा(data) हो सकता है, और मैं इन सभी स्टैक(stack) संचालन को बना सकता हूं क्योंकि हमें उन्हें सदस्य कार्यों में करने और क्लास(class) के एक हिस्से को विधि करने की आवश्यकता है।
 और जैसे ही हम उन्हें क्लास(class) का हिस्सा बनाते हैं, तो हम उनका उपयोग सिर्फ अंतर को देखते हैं।
 यदि आप यहां पुश करते हैं तो आपको यह कहने की जरूरत है कि स्टैक(stack) क्या है और फिर आप यहां क्या धक्का दे रहे हैं, आप कहते हैं कि स्टैक(stack) एस है।
 तो, आप स्टैक(stack) ऑब्जेक्ट(object) के लिए पुश विधि लागू कर रहे हैं और इसलिए आप बस कह रहे हैं कि आप यहां क्या धक्का दे रहे हैं।
 इसी तरह, खाली चेक करने के लिए आप स्टैक(stack) s को ग्लोबल फंक्शन में पास करते हैं, यहाँ खाली एक मेम्बर फंक्शन है।
 तो, आप स्टैक(stack) के लिए ले जाते हैं आप बस विधि को खाली करने की विधि लेते हैं जो हमें यह पता लगाने की विधि प्रदान करेगा कि क्या स्टैक(stack) एस में एक शीर्ष है जो शून्य से 1 के बराबर है।
 इसी तरह, शीर्ष एस को यहां s.top(); के रूप में आमंत्रित किया जाता है।
 pop s को यहाँ s.pop () के रूप में लगाया जाता है।
 तो, आप देख सकते हैं कि यह वैश्विक(global) कार्यों का उपयोग करने के विपरीत है, अब यह विधि मंगलाचरण या सदस्य फ़ंक्शन(function) हमें डेटा(data) के साथ-साथ संचालन, साथ ही साथ उन विधियों या सदस्य को अनुमति देने की अनुमति देता है जो मुझे करने की आवश्यकता है डेटा(data) उन्हें एक एकीकृत बंडल में एक साथ देने के लिए।
 और वह वह है जो ऑब्जेक्ट(object) ओरिएंटेड(oriented) प्रोग्रामिंग के रूप में अधिक उचित, अधिक सटीक एनकैप्सुलेशन या एकत्रीकरण देता है।
 इसलिए, इसके साथ, हम जो हासिल करते हैं, उस क्लास(class) में संचालन और सदस्य कार्य विधियां हैं और यह OOP के रूप में एक डेटा(data) अमूर्तता या एनकैप्सुलेशन प्रदान करता है, हम स्पष्ट रूप से, इसे समझने के लिए और अधिक करेंगे।
 और ऑब्जेक्ट(object)ओं के संदर्भ में हम जानते हैं कि सदस्य कार्य इसके व्यवहार को परिभाषित कर रहे हैं; जैसा कि हमने देखा है कि स्टैक(stack) में सदस्य कार्य जैसे पुश, पॉप, खाली, शीर्ष सभी LIFO व्यवहार को परिभाषित करता है जिसे स्टैक(stack) को करने की आवश्यकता होती है।
 लाभ यह है कि जब हम सी का उपयोग करते हैं और हम वैश्विक(global) कार्यों का उपयोग कर रहे हैं, तो वैश्विक(global) कार्यों को स्टैक(stack) संरचना के बारे में नहीं पता है, स्टैक(stack) संरचना को यह पता नहीं है कि वैश्विक(global) कार्य क्या हैं, मैं इसे पारित कर सकता हूं।
 लेकिन जब मैं एक क्लास(class) करता हूं और उन्हें डेटा(data) सदस्य के साथ जोड़ता हूं और डेटा(data) सदस्य के साथ काम करने वाले तरीके पूरी तरह से एक साथ बंधे होते हैं, तो आप उनके साथ जरूरी व्यवहार करते हैं और हम विशेष रूप से एक्सेस विनिर्देश के बाद देखेंगे कि वे कैसे पूरी तरह से बाध्य हैं हमें C ++ में अधिक संपूर्ण डेटा(data) प्रकार दें।
 अब, अगली अवधारणाएँ जिन्हें हमें समझने की आवश्यकता है, यहाँ परिचय इस संकेत की एक अवधारणा है।
 यह सूचक, "this" वास्तव में C ++ में एक कीवर्ड है, और यह एक नाम है।
 और यह एक अंतर्निहित सूचक है जो किसी ऑब्जेक्ट(object) का पता रखता है।
 इसलिए, अगर मैं किसी ऑब्जेक्ट(object) के बारे में बात कर रहा हूं, तो ऑब्जेक्ट(object) खुद की पहचान, अपनी खुद की पहचान, ऑब्जेक्ट(object) के तरीकों के भीतर अपने स्वयं के पते को इस रूप में संदर्भित कर सकता है।
 और इस सूचक में एक दिलचस्प हस्ताक्षर है।
 तो, आपने कॉन्स्ट पॉइंटर(pointer), कॉन्सेप्ट को पहले ही देख लिया है, इसलिए आप इस सिग्नचर को आसानी से पढ़ सकते हैं कि यह पॉइंटर(pointer) कैसे परिभाषित किया गया है।
 तो, एक क्लास(class) X के लिए, अपनी ऑब्जेक्ट(object) का "this" पॉइंटर(pointer) "x * const" होगा, जो "x *" यह बताता है कि यह एक क्लास(class) प्रकार की ऑब्जेक्ट(object) और const का सूचक है, इस तारे के बाद पॉइंटर(pointer) टाइप हमें बताता है कि यह एक निरंतर पॉइंटर(pointer) है जो कि आप इस पॉइंटर(pointer) के मूल्य को बदल नहीं सकते हैं, जो कि समझ में आता है क्योंकि हम कह रहे हैं कि यह एक ऑब्जेक्ट(object) का पता है।
 तो, यह विभिन्न तरीकों के संदर्भ में सुलभ है।
 इसलिए, यहां मैं केवल कुछ उदाहरण दिखाता हूं।
 यह कुछ भी सार्थक रूप से सार्थक नहीं करता है, लेकिन यह सिर्फ दृष्टांत के लिए है; X एक क्लास(class) है, इसके दो सदस्य हैं।
 और f एक फ़ंक्शन(function) है, जो दो मापदंडों को लेता है और उन्हें ऑब्जेक्ट(object) के दो डेटा(data) सदस्यों के लिए सेट करता है।
 और हम सीधे एम 1 के रूप में डेटा(data) सदस्य को संदर्भित कर सकते हैं या मैं इसे इस सूचक एम 2 द्वारा संदर्भित कर सकता हूं, क्योंकि इसका तात्पर्य यह है कि, अगर मैं किसी ऑब्जेक्ट(object) के बारे में बात कर रहा हूं, तो मेरे पास एक सूचक है जो इस के लिए एक सूचक है ऑब्जेक्ट(object)।
 इसलिए, जब मैं एफ में हूं, तो मेरे पास ऐसा है, मेरे पास इस सूचक का मूल्य है जिसके माध्यम से मैं इस ऑब्जेक्ट(object) में एम 1 और एम 2 का उल्लेख कर सकता हूं।
 इसलिए, यदि आप इस कोड के माध्यम से जाते हैं, तो आप देख पाएंगे कि यह सूचक वास्तव में पता ले रहा है।
 इसलिए, मुख्य कोड में, हमने पता मुद्रित किया है; और फ़ंक्शन(function) f में, हमने इस पॉइंटर(pointer) के मूल्य को प्रिंट(print) किया है और आप देख सकते हैं कि वे समान हैं।
 तो, यह पॉइंटर(pointer) वास्तव में ऑब्जेक्ट(object) के पते को वहन करता है।
 तो, यहाँ, मैं बस, इस सूचक का उपयोग करने के लिए आमतौर पर वैकल्पिक होता हूं जब आप किसी वर्ग के विभिन्न डेटा सदस्यों या विधियों का उपयोग कर रहे हों, लेकिन आप उन्हें k1, k2 जैसे अन्य चर से डेटा सदस्य को अलग करने के लिए उपयोग कर सकते हैं।
 लेकिन कुछ उदाहरण हैं, कुछ परिस्थितियां जहां यह बहुत आवश्यक हो जाता है और हमने यहां केवल दो उदाहरणों में रखा है।
 उदाहरण के लिए, यदि आपके पास एक दोहरी लिंक की गई सूची है और आप एक नोड में डालना चाहते हैं, जो किसी दिए गए नोड के बाद एक नोड सम्मिलित करता है, जो अगले नोड के लिए लिंक को आगे बढ़ाएगा और पिछले नोड के लिए पिछड़े लिंक, आपको पते का उपयोग करना होगा आप जिस नोड में डाल रहे हैं।
 या यदि आप किसी ऑब्जेक्ट(object) को वापस कर रहे हैं, तो आपको उस ऑब्जेक्ट(object) को संदर्भित करना होगा जिसे आप स्वयं वापस कर रहे हैं, हम बाद में इनमें से अधिक उदाहरण देखेंगे।
 इसलिए, मैं चाहूंगा कि आप इसे आज़माएं, लेकिन जब हम इस पर और उदाहरण देंगे तो हम इसे और विस्तार देंगे।
 इसलिए, इसके साथ हमने सीखा है कि किसी क्लास(class) और उसके अनुरूप ऑब्जेक्ट(object) की अवधारणा क्या है।
 हमने एक क्लास(class) के डेटा(data) सदस्यों के बारे में भी सीखा है, और इसी ऑब्जेक्ट(object) के ऑब्जेक्ट(object) के बारे में।
 हमने उन तरीकों के बारे में सीखा है, जिन्हें एक क्लास(class) के लिए परिभाषित किया जा सकता है और किसी ऑब्जेक्ट(object) के लिए लागू किया जा सकता है।
 और हमने देखा है कि हर ऑब्जेक्ट(object) की एक पहचान होती है, जिसे उस ऑब्जेक्ट(object) के तरीकों के "इस" सूचक में कैद किया जा सकता है, और जो उस पते का पता लगाता है जो ऑब्जेक्ट(object) का पता है।
 इस बिंदु पर, मैं यह भी कहना चाहूंगा कि C ++ में, ऑब्जेक्ट(object)ओं की कोई अलग पहचान नहीं है।
 तो, यह पॉइंटर(pointer) या ऑब्जेक्ट(object) का पता हर जगह के पते के रूप में लिया जाता है, जो कि अन्य ऑब्जेक्ट(object)-ओरिएंटेड(oriented) में से कुछ से अलग होता है।