Multiple Inheritance
Written and reviewed by Gagan Bhardwaj · Senior IT Faculty · 15+ years’ experience
What is multiple inheritance?
Multiple inheritance lets a class derive from more than one base class at once, combining their members. You list the bases separated by commas. C++ allows it — many languages do not — but it comes with pitfalls to understand.
A basic example
#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 { }; // both
int main() {
SmartPhone s;
s.photo(); // from Camera
s.call(); // from Phone
}Click
Ring
Name ambiguity
If two bases have a member with the same name, a plain call is ambiguous — qualify it with the class name:
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 → BThe diamond problem
Trouble appears when two bases share a common ancestor. The ancestor gets inherited twice, giving two copies and ambiguity:
Device
/ \
Camera Phone
\ /
SmartPhone ← inherits Device twice!virtual base classes
The fix: make the middle classes inherit the common base as virtual, so only one shared copy exists:
class Device { public: int id = 0; };
class Camera : virtual public Device { }; // virtual
class Phone : virtual public Device { }; // virtual
class SmartPhone : public Camera, public Phone { };
// now SmartPhone has ONE Device, no ambiguity
// SmartPhone s; s.id = 5; // OKWhen to use it
- Combining independent capabilities (interface-like base classes).
- Rarely for ordinary reuse — prefer composition ("has-a") there.
- Always consider whether single inheritance or composition is simpler.
Multiple inheritance is legal and sometimes ideal, but easy to overcomplicate. Reach for it only when it clearly models the design.
Common mistakes
- Ignoring the diamond problem and getting duplicate base copies.
- Forgetting
virtualon the middle classes when a shared base is needed. - Leaving same-named members ambiguous instead of qualifying them.
- Using multiple inheritance where composition would be clearer.
Model a Clock and a Radio, then a ClockRadio that inherits both. Give each base a show() and call them unambiguously with the scope operator.
Summary
- Multiple inheritance derives from several base classes at once.
- Same-named members must be qualified with
Base::. - The diamond problem duplicates a shared ancestor.
virtualbase classes keep just one shared copy.- Use it sparingly; composition is often simpler.
Multiple inheritance क्या है?
Multiple inheritance किसी class को एक साथ एक से ज़्यादा base class से derive होने देती है, उनके members जोड़ते हुए। आप bases को commas से अलग सूचीबद्ध करते हैं। 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
}Click
Ring
नाम ambiguity
अगर दो bases का एक ही नाम वाला member हो, सादा call ambiguous है — इसे class नाम से qualify करें:
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 → BDiamond problem
दिक्कत तब आती है जब दो bases एक साझा पूर्वज साझा करें। पूर्वज दो बार inherit होता है, दो copies और ambiguity देते हुए:
Device
/ \
Camera Phone
\ /
SmartPhone ← Device do baar inherit hota hai!virtual base classes
हल: बीच की classes को साझा base virtual रूप से inherit कराएँ, ताकि केवल एक साझा copy हो:
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 साझा पूर्वज को दोहराता है।
virtualbase classes केवल एक साझा copy रखती हैं।- इसे कम इस्तेमाल करें; composition अक्सर सरल है।
अक्सर पूछे जाने वाले प्रश्न (FAQ)
C++ में multiple inheritance क्या है?
class C : public A, public B, तो C को A और B दोनों की विशेषताएँ मिलती हैं।C++ में diamond problem क्या है?
Virtual base class diamond problem कैसे हल करती है?
virtual घोषित करना जब बीच की classes उससे inherit करें यह सुनिश्चित करता है कि अंतिम class में उस base की केवल एक साझा copy हो। यह दोहराव और ambiguity हटाता है, तो साझा base के members स्पष्ट रूप से access होते हैं।C++ में multiple inheritance में ambiguity कैसे हल करते हैं?
obj.Base1::show()। यह compiler को ठीक बताता है कि आप कौन-सा inherited member चाहते हैं और ambiguity साफ़ करता है।