🟣 OOP · Lesson 46

Multiple Inheritance

Q: Virtual base class diamond problem कैसे हल करती है?

साझा base को virtual घोषित करना जब बीच की classes उससे inherit करें यह सुनिश्चित करता है कि अंतिम class में उस base की केवल एक साझा copy हो। यह दोहराव और ambiguity हटाता है, तो साझा base के members स्पष्ट रूप से access होते हैं।

Multiple inheritance क्या है?

Multiple inheritance किसी class को एक साथ एक से ज़्यादा base class से derive होने देती है, उनके members जोड़ते हुए। आप bases को commas से अलग सूचीबद्ध करते हैं। C++ इसकी अनुमति देता है — कई भाषाएँ नहीं देतीं — पर इसके साथ समझने योग्य कठिनाइयाँ आती हैं।

एक बुनियादी उदाहरण

C++

#include <iostream>
using namespace std;
class Camera { public: void photo() { cout << "Click\n"; } };
class Phone  { public: void call()  { cout << "Ring\n"; } };

class SmartPhone : public Camera, public Phone { };  // dono

int main() {
    SmartPhone s;
    s.photo();   // Camera se
    s.call();    // Phone se
}

Output:
Click
Ring

नाम ambiguity

अगर दो bases का एक ही नाम वाला member हो, सादा call ambiguous है — इसे class नाम से qualify करें:

C++

class A { public: void show() { cout << "A\n"; } };
class B { public: void show() { cout << "B\n"; } };
class C : public A, public B { };
// C c; c.show();        // ERROR: ambiguous
// c.A::show();          // OK → A
// c.B::show();          // OK → B

Diamond problem

दिक्कत तब आती है जब दो bases एक साझा पूर्वज साझा करें। पूर्वज दो बार inherit होता है, दो copies और ambiguity देते हुए:

Diamond

      Device
      /    \
  Camera   Phone
      \    /
    SmartPhone   ← Device do baar inherit hota hai!

virtual base classes

हल: बीच की classes को साझा base virtual रूप से inherit कराएँ, ताकि केवल एक साझा copy हो:

C++

class Device { public: int id = 0; };
class Camera : virtual public Device { };   // virtual
class Phone  : virtual public Device { };   // virtual
class SmartPhone : public Camera, public Phone { };
// ab SmartPhone me EK Device, koi ambiguity nahi
// SmartPhone s; s.id = 5;   // OK

इसे कब इस्तेमाल करें

स्वतंत्र क्षमताओं को जोड़ना (interface-जैसी base classes)।
सामान्य पुनः-इस्तेमाल के लिए शायद ही — वहाँ composition ("has-a") पसंद करें।
हमेशा विचार करें कि single inheritance या composition सरल है या नहीं।

💡 सरल रखें

Multiple inheritance वैध और कभी आदर्श है, पर अति-जटिल करना आसान है। इसे केवल तब चुनें जब यह स्पष्ट रूप से design मॉडल करे।

आम गलतियाँ

Diamond problem अनदेखा करके duplicate base copies पाना।
साझा base चाहिए होने पर बीच की classes पर virtual भूलना।
Same-नाम members को qualify करने के बजाय ambiguous छोड़ना।
Multiple inheritance वहाँ इस्तेमाल करना जहाँ composition साफ़ होता।

🏋️ अभ्यास

एक Clock और एक Radio मॉडल करें, फिर एक ClockRadio जो दोनों inherit करे। हर base को एक show() दें और उन्हें scope operator से स्पष्ट रूप से call करें।

सारांश

Multiple inheritance एक साथ कई base classes से derive होती है।
Same-नाम members को Base:: से qualify करना ज़रूरी है।
Diamond problem साझा पूर्वज को दोहराता है।
virtual base classes केवल एक साझा copy रखती हैं।
इसे कम इस्तेमाल करें; composition अक्सर सरल है।

अक्सर पूछे जाने वाले प्रश्न (FAQ)

C++ में multiple inheritance क्या है?

Multiple inheritance तब है जब कोई class एक साथ एक से ज़्यादा base classes से derive होती है, उन सबसे members inherit करते हुए। आप bases को commas से अलग सूचीबद्ध करते हैं, जैसे class C : public A, public B, तो C को A और B दोनों की विशेषताएँ मिलती हैं।

C++ में diamond problem क्या है?

Diamond problem तब होता है जब कोई class दो ऐसी classes से inherit करे जो दोनों एक साझा base से derive होती हैं, तो साझा base दो बार inherit होता है। यह base के members की दो copies और किसे इस्तेमाल करें इसकी ambiguity पैदा करता है। यह multiple inheritance की मुख्य कठिनाई है।

Virtual base class diamond problem कैसे हल करती है?

साझा base को virtual घोषित करना जब बीच की classes उससे inherit करें यह सुनिश्चित करता है कि अंतिम class में उस base की केवल एक साझा copy हो। यह दोहराव और ambiguity हटाता है, तो साझा base के members स्पष्ट रूप से access होते हैं।

C++ में multiple inheritance में ambiguity कैसे हल करते हैं?

अगर दो base classes का एक ही नाम वाला member हो, आप call को class नाम और scope operator से qualify करते हैं, जैसे obj.Base1::show()। यह compiler को ठीक बताता है कि आप कौन-सा inherited member चाहते हैं और ambiguity साफ़ करता है।

क्या C++ में multiple inheritance की सलाह दी जाती है?

Multiple inheritance शक्तिशाली है पर designs जटिल बना सकती और diamond problem ला सकती है, तो इसे कम इस्तेमाल किया जाता है। यह स्वतंत्र क्षमताओं को जोड़ने के लिए अच्छा काम करती है, जैसे interface-जैसी classes, पर सामान्य code पुनः-इस्तेमाल के लिए composition अक्सर पसंद की जाती है।

← Back to C++ Tutorial

💻 लाइव कोड एडिटर

इस पेज के प्रोग्राम यहीं तैयार हैं — चलाएँ, बदलें और सीखें। कुछ भी इंस्टॉल किए बिना।

OneCompiler द्वारा संचालित। कोड एडिटर में अपने आप आ जाता है — Run दबाकर आउटपुट देखें। अगर एडिटर न खुले तो नए टैब में खोलें.