Neelesh said:
This might be slightly off-topic.
Many books on C++ consider multiple inheritence as an "advanced"
concept. Bruce Eckel says in TICPP, volume 2 that "there was (and
still is) a lot of disagreement about whether [multiple inheritence]
is essential in C++".
Are there any disadvantages of using multiple inheritence?
It may not be essential, but it's pretty useful at times, and is
certainly used in the standard C++ library (iostream for example
combines istream and ostream).
I wouldn't say that there are any real disadvantages other than added
complexity, but it all depends on your application.
Here's a simple example:
#include <iostream>
using namespace std;
class refillable
{
protected:
int max;
int current;
public:
int gauge() { return current; }
bool fill(int amount)
{
if ( amount <= max )
current = amount;
else current = max;
}
bool consume()
{
if ( !current )
return false;
--current;
return true;
}
};
class Battery: public refillable
{
public:
Battery() { max = 100; current = 100; }
bool charge()
{
if ( current < max )
++current;
return true;
}
};
class Fuel: public refillable
{
public:
Fuel() { max = 500; current = 0; }
};
class Lubricant: public refillable
{
public:
Lubricant() { max = 20; current = 20; }
};
class Engine
{
protected:
bool running;
public:
Fuel gas;
Lubricant oil;
Battery battery;
virtual bool start()
{
if ( !gas.gauge() || !oil.gauge() || !battery.gauge() )
return false;
gas.consume();
battery.consume();
return (running = true);
}
virtual bool stop() { running = false; return true; }
virtual bool isRunning() { return running; }
};
class Transmission
{
public:
typedef enum { gReverse = -1, gNeutral = 0, gFirst, gSecond,
gThird, gFourth, gFifth } gear_type;
virtual gear_type inGear() { return in_gear; }
virtual bool changeGear(gear_type gear) { in_gear = gear; return
true; }
Transmission() { in_gear = gNeutral; }
protected:
gear_type in_gear;
};
class Vehicle: virtual public Engine, virtual public Transmission
{
};
