Mehrfachvererbung

Mehrfachvererbung ist ein erstes interessantes und hilfreiches Feature, dass C++ anderen, neueren Sprachen wie Java oder C# voraus hat, da diese Sprachen zwar Vererbung, aber keine Mehrfachvererbung bieten.

Wozu benötigt man Mehrfachvererbung?

Wie schon in bei der einfachen Vererbung genannt, kennzeichnet die Ist-Ein-Regel, wann ein Objekt abgeleitet wird.

Nun können aber auch Objekte beschrieben werden, die mehreres ist. So ist ein Allesfresser ein Fleischfresser und ein Pflanzenfresser. Die Eigenschaften des Fleischfressers kombiniert mit denen des Pflanzenfressers ergeben einen Allesfresser.

Und so lassen sich Basisklassen gestalten, die so zu kombinieren sind, dass man Programmteile wie Legosteine zusammenfügen kann. So erhält man Datentypen, die die benötigten Eigenschaften besitzen, ohne nennenswerten Programmier- oder Testaufwand.

Implementierung einer Mehrfachvererbung

Nehmen wir als Beispiel eine Klasse Bildschirm, welche die Auflösung speichert und eine Methode besitzt, die die Anzahl der Megapixel zurückliefert:

class Display
{
public:
  int ResolutionX;
  int ResolutionY;
 
  double GetMegaPixel()
  {
    return double(ResolutionX * ResolutionY) / 1000000.0;
  }
 
  Display( int x, int y )
  : ResolutionX( x )
  , ResolutionY( y )
  {}
};

Schauen wir uns nun einen Stromverbraucher an:

class PowerConsumer
{
public:
  int MinimalWatts;
  int MaximalWatts;
 
  inline int GetAverageConsumption()
  {
    return (MinimalWatts + MaximalWatts) / 2;
  }
 
  PowerConsumer( int min, int max )
  : MinimalWatts( min )
  , MaximalWatts( max )
  {}
};

Beide Klassen können wir uns so vorstellen:
Display

Stellen wir uns nun ein Fernsehgerät vor. Ein Fernsehgerät ist ein Display, aber auch ein Stromverbraucher und besitzt alle Eigenschaften und Methoden, die zu diesen beiden Klassen gehören.

Statt nun beides erneut zu implementieren oder wie in Java oder C# üblich eines abzuleiten und das andere neu zu implementieren, lässt sich in C++ nun von beiden Klassen ableiten:

class FullHDTelevision 
  : public Display
  , public PowerConsumer
{
public:
  FullHDTelevision( int minWatts, int maxWatts )
  : Display( 1920, 1080 )
  , PowerConsumer( minWatts, int maxWatts )
  {}
};

Das war’s. Eine Instanz von FullHDTelevision ist ein Display und es ist ein PowerConsumer und besitzt damit auch die Methode GetMegaPixels(), die das Display anbietet, sowie die Methode GetAverageConsumption() aus PowerConsumer. Es ist keine weitere Implementierung notwendig.

Die Referenz auf ein FullHDTelevision kann nun in einer Liste von Display-Instanzen genauso gehalten werden, wie in einer Liste von PowerConsumer-Instanzen. Genauso können Funktionen, die eine Referenz auf eine Display-Instanz oder eine Referenz auf eine PowerConsumer-Instanz benötigen, mit einer FullHDTelevision-Instanz gerufen werden.

Alles in allem verhalten sich Mehrfachableitungen genauso, wie einfache Ableitungen - solange sich die Basisklassen nicht unbeabsichtigt in die Quere kommen. Dies wird als Diamant-Problem bezeichnet.