Multiple Inheritance (Lecture 50)-SWavU8klosU

C ++ में प्रोग्रामिंग के मॉड्यूल(module) 35 में आपका स्वागत है।
 इस मॉड्यूल(module) में, हम C ++ में मल्टीपल(multiple) इनहेरिटेंस(inheritance) के बारे में बात करेंगे।
 हमने पहले से ही C ++ में इनहेरिटेंस(inheritance) तंत्र पर चर्चा की है; हमने पोलीमोर्फिज्म(polymorphism) पदानुक्रम(hierarchy) के संदर्भ में डाइनैमिक(dynamic) बंधन या पोलीमोर्फिज्म(polymorphism) पर भी चर्चा की है।
 इसलिए, हम यहाँ विशेष रूप से C ++ के कई इनहेरिटेंस(inheritance) पहलू पर एक नज़र डालने की कोशिश करेंगे।
 यह कुछ हद तक उन्नत विषय है।
 इसलिए हम एक शीर्ष स्तर पर कई इनहेरिटेंस(inheritance) को कवर करेंगे, और हम कुछ अंतिम मुद्दों को आप सभी के लिए प्रयोग करेंगे।
 यह मॉड्यूल(module) आउटलाइन है और यह आपके द्वारा देखी जाने वाली प्रत्येक स्लाइड के बाईं ओर उपलब्ध होगा।
 एकाधिक इनहेरिटेंस(inheritance) इनहेरिटेंस(inheritance) का एक विशिष्ट रूप है जहां एक विशेष क्लास(class) में दो या अधिक आधार क्लास(class) होते हैं।
 हमने इनहेरिटेंस(inheritance) का प्रतिनिधित्व देखा है, इसलिए टीए एक छात्र है जिसे हम जानते हैं कि इसका प्रतिनिधित्व कैसे किया जाए, अगर हम इसे देखते हैं, तो मुझे खेद है, अगर हम इस भाग को देखते हैं तो हमें पता है कि यह टीए एक छात्र है।
 इसी तरह टीए एक शिक्षक है, इसलिए यहां इसका प्रतिनिधित्व करता है।
 यह एक ऐसा परिदृश्य है जहां एक टीए या टीचिंग सहायक एक छात्र है, वह पाठ्यक्रमों में भाग लेती है और कुछ डिग्री को पूरा करने की कोशिश करती है, साथ ही वह ट्यूटोरियल सहायता और असाइनमेंट मूल्यांकन और इतने पर कुछ कोर्स करने में मदद करती है।
 इसलिए वह कई ऑपरेशन करती हैं जो शिक्षकों के लिए सामान्य हैं।
 तो यह देखते हुए हम कहेंगे कि छात्र और शिक्षक दोनों टीए के आधार क्लास(class) हैं।
 और जब ऐसा होता है तो हम कहेंगे कि हमारे पास कई उत्तराधिकार की स्थिति है।
 तो, यहाँ हम कई उत्तराधिकारियों का एक और उदाहरण दिखाते हैं।
 एक कर्मचारी क्लास(class) है जो रूट क्लास की तरह है जहां एक संगठन के सभी कर्मचारी हैं, इसलिए हम कह सकते हैं कि प्रबंधक आईएसए कर्मचारी।
 यह प्रबंधक ISA कर्मचारी का प्रतिनिधित्व करता है।
 हम यह भी कह सकते हैं कि निदेशक आईएसए कर्मचारी।
 इसलिए, प्रबंधक प्रबंधन, निदेशक कंपनी की नीतियों को निर्देशित करता है।
 फिर हमारे पास एक प्रबंध निदेशक है, जो एक प्रबंधक होने के साथ-साथ एक निर्देशक भी है।
 इसलिए, कई इनहेरिटेंस(inheritance) की स्थिति है जो यहां होगी।
 जब एक से अधिक इनहेरिटेंस(inheritance) होता है, तो दो चीजें होती हैं एक है प्रत्येक व्यक्ति इनहेरिटेंस(inheritance) में शामिल है कि कई इनहेरिटेंस(inheritance) में उन सभी नियमों का उपयोग करना होगा जो हमने इनहेरिटेंस(inheritance) के लिए सीखे हैं, लेकिन इसके अलावा कुछ जटिलताएं भी हो सकती हैं जिनके बारे में हमें चर्चा करनी होगी।
 फिर आमतौर पर अगर हमारे पास एक से अधिक इनहेरिटेंस(inheritance) है तो यह सामान्य है कि हमारे पास कुछ आधार क्लास(class) है जो विभिन्न वर्गों के बीच आम है जो कई इनहेरिटेंस(inheritance) के आधार के रूप में काम करते हैं।
 तो, यहाँ हम किसी प्रकार की हीरे की संरचना बनाते हुए देखते हैं, जहाँ हमारे पास व्युत्पन्न क्लास(class) का अंतिम पत्ता स्तर क्लास(class) है, हमारे यहाँ मध्यवर्ती आधार क्लास(class) हैं, जो पत्ती क्लास(class) का व्युत्पन्न क्लास(class) वास्तव में इनहेरिटेंस(inheritance) में मिला है।
 बदले में, ये मध्यवर्ती कक्षाएं कुछ संयोजन अवधारणा से विशेषज्ञ होती हैं।
 क्योंकि निश्चित रूप से अगर हम कई तरह से इनहेरिटेंस(inheritance) में मिल रहे हैं तो यह प्रबंध निदेशक निश्चित रूप से प्रबंध और निदेशक से कई गुना इनहेरिटेंस(inheritance) में मिला है क्योंकि इसमें दोनों के बीच कुछ समानता है।
 इसलिए यह उम्मीद की जाती है कि प्रबंधक और निदेशक स्वयं कुछ सामान्य गुण और कुछ सामान्य ऑपरेशन होंगे जो कर्मचारी के संदर्भ में यहां प्रस्तुत किए गए हैं।
 C++ में मल्टीपल(multiple) इनहेरिटेंस(inheritance) या मल्टीपल(multiple) इनहेरिटेंस(inheritance) की परिभाषा के संदर्भ में एक सामान्य बेस क्लास होना अनिवार्य नहीं है, लेकिन यह विशिष्ट है कि हम अक्सर एक सामान्य बेस क्लास होंगे जो पूरी स्थिति का प्रतिनिधित्व करते हैं।
 इसलिए, हम वास्तविक वाक्यात्मक विवरण में जाएंगे।
 हम कहते हैं कि व्युत्पन्न एक बेस 1 है, व्युत्पन्न एक बेस 2 है, यह एक सामान्य परिदृश्य है।
 और जब हमारे पास है कि यह एक क्लास(class) आधार 1 है, तो यह एक क्लास(class) आधार 2 है, दो आधार क्लास(class) हैं।
 और हम व्युत्पन्न क्लास(class) या गुणा इनहेरिटेंस(inheritance) में मिली विशिष्ट कक्षाएं लिखते हैं; सार्वजनिक base1, सार्वजनिक base2।
 इससे पहले, जब हमारे पास एकल इनहेरिटेंस(inheritance) था, यदि कोई एकल इनहेरिटेंस(inheritance) है जिसे आप यहां रोकते हैं, तो यहां हम जारी रखते हैं कि हम अल्पविराम का उपयोग करते हैं और अगले आधार क्लास(class) को लिखना जारी रखते हैं, जो व्युत्पन्न भी इनहेरिटेंस(inheritance) में मिला है।
 ऐसा नहीं है कि हालांकि मैं ऐसे उदाहरण दिखा रहा हूं जहां 2 आधार क्लास(class) हैं, लेकिन यह 2 आधार वर्गों तक सीमित नहीं है, मेरे पास कई या दो या अधिक या एक से अधिक संख्या में आधार क्लास(class) हो सकते हैं।
 और यह भी जैसा कि हम जानते हैं कि C ++ में मूल उत्तराधिकार तंत्र यानी उत्तराधिकार तंत्र मैं जो मतलब है, आईएसए संबंध सार्वजनिक इनहेरिटेंस(inheritance) के संदर्भ में दर्शाया गया है और हमने लंबे समय से चर्चा की है कि इसका क्या मतलब है।
 लेकिन साथ ही हम जानते हैं कि C ++ में इनहेरिटेंस(inheritance) के अन्य रूप हैं, विशेष रूप से कुछ ऐसा जो निजी इनहेरिटेंस(inheritance) के रूप में जाना जाता है, जो कि आधार क्लास(class) के सदस्यों की दृश्यता को केवल निजी पहुंच तक सीमित करके उन्हें व्युत्पन्न क्लास(class) में बदल देता है।
 हमने देखा कि यह जो कुछ है वह हमें आईएस के एक शब्दार्थ की तरह देता है, जिसे हम एक ऐसे शब्दार्थ के रूप में लागू करते हैं जहाँ हम यह दर्शाने की कोशिश करते हैं कि यदि हम एक आधार क्लास(class) से निजी इनहेरिटेंस(inheritance) में प्राप्त कर रहे हैं तो हम यह कह रहे हैं कि यह आधार क्लास(class) वास्तव में लागू होता है व्युत्पन्न वर्ग।
 इसलिए जब हम एक से अधिक इनहेरिटेंस(inheritance) करते हैं, तो यह आवश्यक नहीं है कि ये सार्वजनिक हों, ये मिश्रित हो सकते हैं यदि आप वास्तव में ये सभी निजी हो सकते हैं, तो इसका मतलब यह होगा कि दोनों आधार क्लास(class) व्युत्पन्न क्लास(class) के कुछ हिस्सों को लागू कर रहे हैं , यह भी हो सकता है कि यह सार्वजनिक है और यह निजी है इसलिए यदि ऐसा है तो इसका मतलब यह होगा कि व्युत्पन्न मूल रूप से आईएसए संबंध के अर्थ में आधार एक से विशेषता है।
 जबकि, क्लास(class) आधार दो कार्यान्वित करता है या व्युत्पन्न क्लास(class) को लागू करने में मदद करता है, यह एक बुनियादी तंत्र है जो हमारे पास है।
 इसलिए, हम शब्दार्थ को देखने की कोशिश करेंगे।
 मेरा सुझाव है कि आप इस स्लाइड की तुलना इनहेरिटेंस(inheritance) के शब्दार्थ से करें जो हमने पहले की थी।
 उन सभी शब्दार्थों को बनाए रखा जाता है ताकि जब आप एकल इनहेरिटेंस(inheritance) से एकाधिक इनहेरिटेंस(inheritance) की ओर बढ़ें तो मूल गुण समान रहें।
 इसलिए, व्युत्पन्न क्लास(class) अब सभी आधार वर्गों के सभी डेटा सदस्यों को इनहेरिटेंस(inheritance) में मिला है।
 यह सिर्फ एक आधार क्लास(class) नहीं है, यह सभी आधार वर्गों के सभी डेटा सदस्यों को इनहेरिटेंस(inheritance) में मिला है और यह नए डेटा सदस्यों को जोड़ सकता है।
 यह सभी बेस कक्षाओं के सभी सदस्य कार्यों को इनहेरिटेंस(inheritance) में देता है फिर से यह किसी भी आधार क्लास(class) के किसी भी सदस्य फ़ंक्शन(function) को ओवरराइड(override) कर सकता है या किसी भी आधार क्लास(class) के किसी भी फ़ंक्शन(function) को अधिभारित कर सकता है।
 ये सभी पहले थे, कई आधार वर्गों का यह संदर्भ नहीं था, इसलिए शब्दार्थों में ऐसा नहीं था, लेकिन अब चूंकि कई आधार क्लास(class) हैं, इसलिए ये सभी संभव होंगे।
 तो, इनहेरिटेंस(inheritance) का मतलब यह होगा कि आधार क्लास(class) के हर एक के सभी गुण और संचालन इनहेरिटेंस(inheritance) में मिले होंगे और वे उपयुक्त रूप से अतिभारित या ओवरराइड(override) हो सकते हैं।
 एक्सेस(access) स्पेसिफिकेशन(specification) में निजी, निजी होने का एक ही शब्दार्थ होगा, बेस क्लास के लिए पूरी तरह से प्रतिबंधित।
 इसलिए, व्युत्पन्न क्लास(class) किसी भी आधार क्लास(class) के निजी डेटा सदस्यों तक नहीं पहुंच पाएगा।
 यदि मैं किसी बेस क्लास के कुछ डेटा सदस्यों के लिए संरक्षित का उपयोग करता हूं, तो वे डेटा सदस्य व्युत्पन्न क्लास(class) में उपलब्ध होंगे।
 निर्माण और विनाश के संदर्भ में, हम निर्माणकर्ता के संदर्भ में देखेंगे।
 सभी बेस क्लास ऑब्जेक्ट का निर्माण करना होगा, क्योंकि सभी बेस क्लास ऑब्जेक्ट व्युत्पन्न क्लास ऑब्जेक्ट का हिस्सा बन जाएंगे।
 अब, हमारे पास दो या अधिक आधार क्लास(class) हैं, जो व्युत्पन्न क्लास(class) से प्राप्त होते हैं।
 इसलिए हमें उस आदेश को भी समझने की जरूरत है जिसमें इन आधार वर्गों के निर्माणकर्ता निष्पादित हो जाएंगे।
 इसलिए यह सूची क्रम के अनुसार होगा जैसा कि हम देखेंगे और जब यह विनाश के क्रम में आ जाएगा तब वही सिद्धांत जो हमने पहले देखा था कि पहले वाला क्लास(class) नष्ट हो गया है, तब आधार क्लास(class) नष्ट हो जाता है, चूंकि कई बेस क्लास ऑब्जेक्ट हैं।
 इसलिए वे उलटे क्रम में नष्ट हो जाएंगे, जिसमें वे मूल रूप से निर्मित थे।
 यह एकाधिक इनहेरिटेंस(inheritance) के लिए शब्दार्थ का सारांश है।
 इसमें कुछ और विवरण हैं जो उदाहरणों से गुजरते ही सामने आएंगे।
 हम डेटा सदस्यों के विशिष्ट शब्दार्थ से शुरू करते हैं।
 इसलिए यह सभी आधार वर्गों के सभी डेटा सदस्यों को इनहेरिटेंस(inheritance) में मिला है और नए डेटा सदस्यों को जोड़ सकता है।
 अब लेआउट के संदर्भ में, हमने लेआउट के बारे में चर्चा की है कि, लेआउट में यदि एक व्युत्पन्न क्लास(class) को आधार क्लास(class) से इनहेरिटेंस(inheritance) में मिला है तो इसमें आधार क्लास(class) की वस्तुओं का उदाहरण है।
 अब, चूंकि कई आधार क्लास(class) हैं, इसलिए प्रत्येक आधार क्लास(class) के लिए इसका एक उदाहरण होगा।
 फिर से, कुछ एकल इनहेरिटेंस(inheritance) के मामले में C ++ बेस क्लास इंस्टेंसेस की सापेक्ष स्थिति की गारंटी नहीं देता है।
 उन्हें कैसे व्यवस्थित किया जाएगा कि क्या पहले बेस क्लास ऑब्जेक्ट होंगे तब व्युत्पन्न क्लास(class) ऑब्जेक्ट सदस्य होंगे और इसी तरह, उस विशिष्ट आदेश को मानक द्वारा नहीं दिया गया है।
 यदि हम उदाहरण में देखें तो आपके पास दो सदस्यों i और डेटा के साथ बेस क्लास b1 है।
 मेरे पास दो सदस्यों के साथ एक और बेस क्लास बी 2 है; जम्मू और डेटा।
 और मेरे पास एक व्युत्पन्न क्लास(class) है जो आधार 1 के साथ-साथ आधार 2 से निकलता है और यह एक सदस्य k जोड़ता है।
 यदि मैं आधार 1 प्रकार की एक वस्तु को देखता हूं तो उसमें एक सदस्य i और एक सदस्य डेटा होगा, अगर मैं व्युत्पन्न आधार क्लास(class) b आधार 2 की वस्तु को देखता हूं तो इसका एक उदाहरण है कि इसमें एक सदस्य j और डेटा होगा।
 इसलिए जब हम एक व्युत्पन्न क्लास(class) वस्तु का निर्माण करते हैं तो बेस 1 ऑब्जेक्ट का एक उदाहरण होगा जिसमें एक क्लास(class) में बेस 2 क्लास(class) का उदाहरण होगा और हमारे पास व्युत्पन्न में जो भी डेटा सदस्य हैं, उनके पास होगा।
 तो, आप स्पष्ट रूप से देख सकते हैं कि यह डेटा सदस्यों के शब्दार्थों का एक प्रत्यक्ष विस्तार है जो हमारे पास था या लेआउट का शब्दार्थ जो कि हमारे पास इनहेरिटेंस(inheritance) के मामले में था।
 बेशक, जैसा कि मैंने कहा कि कुछ नुकसान हो सकते हैं।
 उदाहरण के लिए, जैसा कि आप यहाँ देख सकते हैं कि base1 ने एक सदस्य डेटा घोषित किया है और base2 में भी इसी नाम से एक सदस्य है।
 चूंकि आधार क्लास(class) व्युत्पन्न क्लास(class) से स्वतंत्र हैं इसलिए आप यह नियंत्रित नहीं कर सकते हैं कि उनके पास एक ही नाम के सदस्य नहीं होंगे।
 जब उनके पास एक ही नाम के सदस्य होते हैं तो ऑब्जेक्ट व्युत्पन्न होता हैएड इस ऑब्जेक्ट में एक ही नाम से दो डेटा सदस्य हैं।
 अगर मैं कहता हूं कि मेरी वस्तु डी से व्युत्पन्न है, तो मैं व्युत्पन्न डेटा लिखना चाहता हूं, जिसे मैं लिखने के लिए अधिकृत हूं क्योंकि डेटा यहां संरक्षित है और साथ ही यहां संरक्षित है इसलिए व्युत्पन्न क्लास(class) की उन तक पहुंच है।
 लेकिन अगर मैं इसे लिखने की कोशिश करता हूं तो कंपाइलर कहेगा कि मैं भ्रमित हूं, क्योंकि एक ही नाम से दो सदस्य हैं।
 यह अस्पष्टता का मामला है इसलिए यदि दो आधार वर्गों में दो और आधार वर्गों में एक ही नाम से डेटा सदस्य हैं तो जिम्मेदारी उस अस्पष्टता को हल करने के लिए प्रोग्रामर या व्युत्पन्न क्लास(class) के डिजाइनर के साथ झूठ होगी।
 आपको कक्षा नाम क्वालिफायर के साथ सदस्यों को स्पष्ट रूप से संदर्भित करना होगा।
 यह संकलक द्वारा स्वीकार्य नहीं होगा, लेकिन मैं डी लिख सकता हूं।
 आधार 1 :: डेटा, अगर मैं इसे लिखता हूं तो इसका मतलब यह डेटा सदस्य होगा या इसका मतलब होगा कि यह डेटा सदस्य ऑब्जेक्ट में है यदि यह डी है।
 लेकिन अगर मैं d.base2 :: data लिखता हूं, तो इसका मतलब यह होगा कि यह डेटा सदस्य इसलिए कि रिज़ॉल्यूशन अतिरिक्त रूप से करने की आवश्यकता है।
 यह एक जोड़ा जटिलता है जो कई उत्तराधिकार के संदर्भ में होगा।
 अब, हम मेम्बर फंक्शन्स - ओवरराइड्स और ओवरलोड्स पर चलते हैं।
 जैसा कि मैंने पहले ही कहा है कि सभी सदस्य कार्य सभी आधार वर्गों से इनहेरिटेंस(inheritance) में मिले हैं और आप किसी भी सदस्य कार्य को ओवरराइड(override) कर सकते हैं, एक आधार क्लास(class) से सदस्य फ़ंक्शन(function) को अधिभारित कर सकते हैं।
 और एकल इनहेरिटेंस(inheritance) में जैसे स्थैतिक सदस्य फ़ंक्शंस(functions) और सामने फ़ंक्शंस(functions) बेस क्लास द्वारा भी इनहेरिटेंस(inheritance) में नहीं मिले हैं।
 अगर हम एक उदाहरण देखें, तो बस इसे ध्यान से आधार वर्गों के एक ही सेट पर देखें; बेस क्लास बेस 1, क्लास बेस 2, और क्लास व्युत्पन्न जो कि बेस 1 के साथ-साथ बेस 2 से भी माहिर है।
 यहां, मेरे पास दो मेंबर फंक्शन्स और जी हैं, और यहां बेस 2 में मेरे पास एक मेम्बर फंक्शन है।
 और जो मैंने किया है, वह व्युत्पन्न क्लास(class) में f है।
 मैंने उसी हस्ताक्षर के साथ एक सदस्य फ़ंक्शन(function) शामिल किया है जिसका अर्थ है कि यह ओवरराइडिंग का मामला है।
 तो, व्युत्पन्न क्लास(class) f1 से f सदस्य फ़ंक्शन(function) को ओवरराइड(override) कर रहा है।
 बेस 1 में एक सदस्य फ़ंक्शन(function) जी भी है और व्युत्पन्न क्लास(class) का नाम जी द्वारा किसी भी सदस्य फ़ंक्शन(function) का कोई उल्लेख नहीं है, इसलिए यह जी बस इनहेरिटेंस(inheritance) में मिलता है और इसका उपयोग करने में सक्षम होगा।
 और जब यह g का उपयोग करता है तो इसका मतलब होगा बेस क्लास के बेस 1 का जी मेम्बर फंक्शन।
 बेस क्लास 2 में एक सदस्य फ़ंक्शन(function) एच है और व्युत्पन्न क्लास(class) अलग हस्ताक्षर के साथ एक सदस्य फ़ंक्शन(function) एच का परिचय देता है।
 हम जानते हैं कि क्या प्रभाव होगा, यह h नया h व्युत्पन्न :: h, base2 को छिपाएगा :: h जो पूर्णांक ले रहा था और अब आप स्ट्रिंग पैरामीटर के साथ व्युत्पन्न क्लास(class) वस्तु के लिए h को कॉल कर पाएंगे।
 इसलिए यह ओवरलोडिंग का मामला है।
 यह सरल है कि व्युत्पन्न क्लास(class) में किटी में एक नया सदस्य फ़ंक्शन(function) ई जोड़ा जा सकता है और इसका उपयोग किया जा सकता है।
 इस संदर्भ में, अगर हमारे पास एक व्युत्पन्न क्लास(class) ऑब्जेक्ट c है अगर मैं c dot f 1 करता हूं, तो व्युत्पन्न क्लास(class) में f फ़ंक्शन(function) को बुलाया जाएगा क्योंकि base1 :: f को ओवरराइड(override) किया गया है।
 अगर हम c डॉट जी कहते हैं तो यह बेस 1 का एक सदस्य कार्य होगा क्योंकि इसे इनहेरिटेंस(inheritance) में मिला है, अगर हम सी डॉट एच को साथ में बुलाते हैं, तो यह वह जगह है जहां मैंने निरंतर चार स्टार प्रकार के पैरामीटर का उपयोग किया है जो स्वचालित रूप से डाली जाएगी।
 तार।
 इसलिए व्युत्पन्न में ओवरलोडेड एच फ़ंक्शन(function) को बेस क्लास फ़ंक्शन(function) नहीं कहा जाएगा क्योंकि वह छिपा हुआ है, और अगर मैं सी डॉट ई को चरित्र के साथ कहता हूं तो यह ई सदस्य फ़ंक्शन(function) को कॉल करेगा जिसे व्युत्पन्न क्लास(class) में पेश किया गया है।
 यह ओवरराइडिंग और ओवरलोडिंग की मूल कहानी है, जो निश्चित रूप से होगा और निश्चित रूप से डेटा सदस्य की तरह यह आपके दिमाग में हो रहा होगा कि 2 आधार वर्गों के पास एक फ़ंक्शन(function) है जिसका नाम समान है।
 अगर 2 बेस क्लासेज के मेंबर फंक्शन के लिए एक समान नाम हो तो क्या होगा।
 इसलिए मैं स्पष्ट करता हूं कि इस स्लाइड में, फिर से मेरे पास आधार 1, बेस 2 है, व्युत्पन्न क्लास(class) समान आधार वर्गों से प्राप्त होता है।
 जो अंतर बनाया जा रहा है, वह है कि मैं यहां एफ हूं और मैं यहां बेस 1 और बेस 2 दोनों में हूं और उनके हस्ताक्षर समान हैं।
 मैंने बेस 1 में यहां जी किया है, मैं बेस 2 में जी यहां हूं उनके हस्ताक्षर अलग हैं।
 फिर आगे के क्षण में इस भाग को अनदेखा करें।
 तब व्युत्पन्न क्लास(class) में हम कहते हैं कि आपके पास इस भाग को अनदेखा करने के लिए सदस्य कार्य नहीं है, इस पर आपको अभी विचार नहीं करना चाहिए।
 अब, मैं c dot f लिखने की कोशिश करता हूँ सवाल यह है कि c dot f क्या है? क्या यह आधार 1 डॉट एफ है; base1 :: f या यह बेस 2 कोलन कोलोन है f आपके पास जानने का कोई तरीका नहीं है क्योंकि इसे f के दो वर्जन मिले हैं।
 C dot g क्या है? मैंने एक पैरामीटर 5 पास किया है, जिसमें उम्मीद है कि संकलक यह हल करने में सक्षम होगा कि यह बेस 1 :: g है, क्योंकि मुझे खेद है कि एक छोटा प्रकार है यहां यह इंट नहीं होना चाहिए, यह इंट होना चाहिए।
 अगर मैं सी डॉट जी 5 कहता हूं तो मुझे उम्मीद है कि बेस 2 :: जी कहा जाएगा, लेकिन दुर्भाग्य से कंपाइलर ऐसा नहीं कर पाएगा।
 कारण यह करने में सक्षम नहीं होगा कि यह एक तथ्य है कि अधिभार केवल एक ही नाम रिक्त स्थान के बीच हल किया जाता है।
 यदि आपके पास दो अलग-अलग नाम स्थान हैं, तो संकलक के पास कोई ट्रैक नहीं है कि नाम क्या होने जा रहे हैं।
 इसलिए, बेस 1 में जी फ़ंक्शन(function) और बेस 2 में जी फ़ंक्शन(function) दो अलग-अलग वर्गों के दो अलग-अलग नाम रिक्त स्थान में हैं, इसलिए ओवरलोड रिज़ॉल्यूशन यहां किक नहीं करता है।
 अतः फलस्वरूप, c.g(5) या c. g() बिना किसी पैरामीटर के दोनों वास्तव में अस्पष्ट भी हो जाएंगे।
 जिस्ट में इन चारों कॉल अस्पष्ट हो जाएगा और संकलक उन दोनों के बीच हल करने में सक्षम नहीं होगा।
 इसलिए, यदि आप उन्हें उस अस्पष्टता को हल करना चाहते हैं, तो आपके पास यह कहने का एक सरल तरीका है कि जो मूल मुद्दा है वह यहां है, जैसा कि आपके पास आधार 1 और आधार 2 से इनहेरिटेंस(inheritance) में मिला है, आपको फ़ंक्शन(function) एफ की दो प्रतियां मिलती हैं, जो व्युत्पन्न में आना चाहते हैं।
 कक्षा।
 अब, हमने मूल क्लास(class) फ़ंक्शन(function) के लिए उपयोग की घोषणा के बारे में सीखा है, इसलिए आप इसका उपयोग कर सकते हैं।
 मान लीजिए कि आप बेस 1 कोलन कोलोन एफ का उपयोग करते हुए कहते हैं, यदि आप कहते हैं कि मैं बेस 1 कोलोन कोलोन एफ का उपयोग कर रहा हूं तो यह क्या होगा, यह फ़ंक्शन(function) व्युत्पन्न में शामिल किया जाएगा और यह फ़ंक्शन(function) शामिल नहीं होगा, यह फ़ंक्शन(function) बेस दो का फ़ंक्शन(function) होगा छिपा हुआ।
 इसी तरह मैं जी फ़ंक्शन(function) के लिए भी कर सकता हूं, कह सकता हूं कि मैं बेस 2 कोलोन जी का उपयोग कर रहा हूं जिसका मतलब है कि यह जी फ़ंक्शन(function) शामिल होगा, लेकिन बेस वाले जी फ़ंक्शन(function) छिपाए जाएंगे।
 इस संदर्भ में अब अगर मैं c dot f को कॉल करना चाहूंगा तो यह बेस 1 कॉलन कोलन एफ कहेगा क्योंकि मैं इसका उपयोग कर रहा हूं।
 अगर मैं c. g(5) इसे बेस २ कॉलन कोलोन जी कहा जाएगा क्योंकि मैं बेस के जी फंक्शन का उपयोग कर रहा हूं।
 अब इसमें यदि मैं भी चाहता हूं, तो ऐसी स्थिति है कि किसी मामले में मैं वास्तव में बेस के एफ फ़ंक्शन(function) का उपयोग करना चाहता हूं 2 तब जैसे मैंने डेटा सदस्यों के मामले में किया था, मैं स्पष्ट रूप से सी डॉट बेस 2 कोलोन कोलोन एफ 3 लिख सकता हूं, जिस स्थिति में यह वास्तव में बेस दो क्लास(class) के एफ फ़ंक्शन(function) को कॉल करेगा।
 हालांकि व्युत्पन्न क्लास(class) में मैंने कहा है कि मैं बेस 1 कोलन कोलन एफ का उपयोग कर रहा हूं।
 वास्तव में उपयोग क्या करता है, मूल रूप से उपयोग करने से मुझे शॉर्ट कट करने की अनुमति मिलती है कि मुझे बेस क्लास नाम के साथ सदस्य फ़ंक्शन(function) के नाम को अर्हता प्राप्त करने की आवश्यकता नहीं है और मैं इसे डिफ़ॉल्ट के रूप में उपयोग कर सकता हूं जैसा कि मैं यहां कर रहा हूं, लेकिन मैं हमेशा करता हूं वास्तव में सदस्य फ़ंक्शन(function) के लिए योग्य नाम प्रदान करने का विकल्प है, जैसे मैंने डेटा सदस्य के लिए किया था और उस रूप में अन्य सदस्यों का उपयोग करें।
 तो, यह वही है जो एकल इनहेरिटेंस(inheritance) पर आवश्यक है जो बहुत ही सामान्य होगा क्योंकि यह काफी संभावना है कि जिन आधार वर्गों से आप इनहेरिटेंस(inheritance) में प्राप्त कर रहे हैं उनमें एक या अधिक सदस्य कार्य हो सकते हैं जो आपस में एक ही नाम के हों।
 जैसा कि हमने देखा है कि यह वास्तव में उनके हस्ताक्षर के मामले में कोई फर्क नहीं पड़ता है कि वे क्या मायने रखते हैं उनका एक ही नाम है, और यदि उनका एक ही नाम है, तो व्युत्पन्न क्लास(class) उन्हें बिना किसी योग्यता के उपयोग के नहीं कर सकता है।
 आधार के एक्सेस(access) सदस्यों के पास आने से संरक्षित एक्सेस(access) किसी भी व्युत्पन्न क्लास(class) ऑब्जेक्ट को बेस क्लास के किसी भी आधार क्लास(class) के संरक्षित सदस्यों तक पहुंचने की अनुमति देगा, जिसमें छिपाने के मामले में कुछ भी जोड़ना नहीं है यहाँ कई इनहेरिटेंस(inheritance) हैं।
 इसलिए, एकल इनहेरिटेंस(inheritance) के मामले में हमने जो कुछ भी सीखा है वह बस लागू होगा इसलिए हम इस पहलू पर और चर्चा छोड़ेंगे।
 मुझे कंस्ट्रक्टर(constructor), डिस्ट्रक्टोर(destructor) पर ले जाने दें।
 व्युत्पन्न क्लास(class) के कंस्ट्रक्टर(constructor), विध्वंसक बेस क्लास के सभी कंस्ट्रक्टर(constructor) डिस्ट्रक्टर्स को इनहेरिट करेंगे, लेकिन एक अलग शब्दार्थ में जैसा कि हमने सिंगल इनहेरिटेंस(inheritance) के मामले में देखा था क्योंकि यह सीधे तौर पर इनहेरिटेंस(inheritance) में नहीं मिल सकता है क्योंकि इसका एक अलग नाम है, यह इसमें नाम जोड़ता है बेस क्लास और निश्चित रूप से आप किसी भी तरह से कंस्ट्रक्टर(constructor), डिस्ट्रक्टर को ओवरराइड(override) या ओवरलोड नहीं कर सकते हैं।
 इसलिए, अगर हम इसके साथ देखते हैं तो हम देख सकते हैं कि बेस क्लास हैं, यहाँ एक कंस्ट्रक्टर(constructor) है।
 व्युत्पन्न क्लास(class) के पास एक कंस्ट्रक्टर(constructor) है और, खेद है कि दूसरे आधार क्लास(class) के पास एक अन्य कंस्ट्रक्टर(constructor) है और व्युत्पन्न क्लास(class) में है; यहाँ आधार एक के निर्माता को आमंत्रित कर रहा है।
 तो क्या होगा? अब, इसे दोनों बेस क्लास ऑब्जेक्ट का निर्माण करना होगा; तथ्य यह है कि आधार 1 का आह्वान करने का अर्थ है कि आधार 1 निर्माणकर्ता को इसके माध्यम से आमंत्रित किया जाएगा और चूंकि यह आधार 2 को छोड़ दिया गया है, इसलिए आधार 2 में एक डिफ़ॉल्ट निर्माणकर्ता होना चाहिए जो उसके बाद लागू किया जाएगा।
 इसलिए, यदि मैंने बस आधार 1 का निर्माण किया है और आधार 2 के पास डिफ़ॉल्ट निर्माता नहीं है, तो मेरे पास संकलन त्रुटि होगी, क्योंकि व्युत्पन्न क्लास(class) वस्तु का निर्माण करने में सक्षम होने के लिए मुझे आधार 1 और आधार 2 दोनों प्रकार की वस्तुओं के निर्माण की आवश्यकता है ।
 इसलिए, यदि हम उदाहरण देखते हैं, तो यह बेस 1 प्रकार की वस्तु है; यह बेस 2 प्रकार की एक वस्तु है जो हम निर्माण कर सकते हैं।
 यहां आप एक व्युत्पन्न प्रकार की वस्तु का निर्माण देख सकते हैं जहाँ आधार क्लास(class) 1 का उदाहरण 5 3 है जो इसके माध्यम से बनाया गया है।
 बेस क्लास 2 का उदाहरण डिफ़ॉल्ट रूप से है, इसलिए इसमें 0 0 सदस्य हैं और यह व्युत्पन्न क्लास(class) का डेटा सदस्य है।
 यह निर्माण प्रक्रिया की मूल गतिशीलता है।
 यदि आप बेस क्लास कंस्ट्रक्टर(constructor) और डिस्ट्रक्टर्स और इतने पर और व्युत्पन्न क्लास कंस्ट्रक्टर(constructor) डिस्ट्रक्टर(destructor) में संदेश डालते हैं, तो आप देख पाएंगे कि पहले बेस क्लास १ का निर्माण किया गया है क्योंकि यह पहले है सूची में, फिर बेस क्लास 2 क्योंकि यह सूची में दूसरे स्थान पर है, और फिर व्युत्पन्न क्लास(class) का निर्माण और विनाश बिल्कुल रिवर्स ऑर्डर में होता है।
 यह इनहेरिटेंस(inheritance) का मूल तंत्र है जो किसी विशेष व्युत्पन्न क्लास(class) समस्या के लिए आधार क्लास(class) के कई मामलों के संदर्भ में आगे बढ़ता है।