C++-Programmierung/ Objektorientierte Programmierung/ Mehrfachvererbung

In diesem Abschnitt geht es um mehrfache Vererbung und damit Ableitung von mehreren Basisklassen.

Eine Klasse kann von mehreren Basisklassen erben:

class A
{
  int x;

  //...
};

class B 
{
  double y;

  //...
};

class C : public A, public B
{
  char z;

  //...
};

Die Klasse C vereint die Funktionalitäten von A und B und fügt noch etwas hinzu.

Die Idee davon ist, dass verschiedene Funktionalitäten in einer Klasse vereint werden. Im folgenden Beispielprogramm wird dieses Vorgehen dargestellt.

#include <string>
#include <iostream>

class Person
{
	std::string m_strName;
public:
	std::string Name() const { return m_strName; }
	void Name(std::string val) { m_strName = val; }
	void Name(const char * val) { m_strName.assign(val); }
};

class Gehaltsempfaenger
{
	unsigned int m_nMonatsgehalt;
public:
	unsigned int Monatsgehalt() const { return m_nMonatsgehalt; }
	void Monatsgehalt(unsigned int val) { m_nMonatsgehalt = val; }
};

class Freizeitbeschaeftigung
{
	std::string m_strAktion;
public:
	std::string Aktion() const { return m_strAktion; }
	void Aktion(std::string val) { m_strAktion = val; }
	void Aktion(const char * val) { m_strAktion.assign(val); }
};

class Mitarbeiter : 
	public Person, 
	public Gehaltsempfaenger, 
	public Freizeitbeschaeftigung
{
public:
	Mitarbeiter(const char * szName, const unsigned int nMonatsgehalt, const char * szFreizeittaetigkeit)
	{ Name(szName); Monatsgehalt(nMonatsgehalt); Aktion(szFreizeittaetigkeit);}
	void auszahlenGehalt(void)
	{
		std::cout << Name() << " bekommt das Monatsgehalt von " 
			<< Monatsgehalt() << " Euro ausgezahlt" << std::endl;
	}
	void entspannenFreizeit(void)
	{
		std::cout << Name() << " " << Aktion() << std::endl;
	}
};

int main(int argc, char* argv[])
{
	Mitarbeiter ma1("Christian", 1000, "spielt Skat");
	ma1.auszahlenGehalt();
	ma1.entspannenFreizeit();
	return 0;
}

Ausgabe:

Christian bekommt das Monatsgehalt von 1000 Euro ausgezahlt
Christian spielt Skat

Der Vorteil dieser Vorgehensweise ist eine bessere Wiederverwend-barkeit/-ung und eine Kapselung der Schnittstellen.

Schon anhand dieses Beispiels kann eine Person, die eine Freizeitbeschäftigung hat, aber kein Gehalt bekommt, als neue Klasse angelegt werden.

class Kunde: public Person, public Freizeitbeschaeftigung
{
	/* ... */ 
};

Die Klasse Kunde hat damit die Eigenschaften von Person und Freizeitbeschaeftigung erhalten, aber nicht von Gehaltsempfaenger.

Wichtig ist bei allen Mehrfachvererbungen das Einhalten einer sinnvollen Hierarchie. Was würde passieren, wenn wir von unseren Beispielklassen Kunde und Mitarbeiter ableiten? Lesen Sie daher weiter. Im nächsten Abschnitt wird genauer darauf eingegangen.

Ein weiterer wichtiger Punkt ist die Namensgebung in allen parallel verwendeten Klassen. Würde die Freizeitaktion sowie der Personenname jeweils unter m_strName öffentlich gespeichert, müsste in den abgeleiteten Klassen mit dem Bereichsauflösungsoperator :: auf die passenden Mitgliedsvariablen zugegriffen werden.

class Hemd
{
public:
	std::string m_strFarbe;
};

class Hose
{
public:
	std::string m_strFarbe;
};

class Bekleidung : public Hemd, public Hose
{
	void ausgeben(void)
	{
		std::cout << "Hose in " << Hose::m_strFarbe << " Hemd in " << Hemd::m_strFarbe;
	}
};

Die Verwendung der Mehrfachvererbung ist nicht in jedem Fall einfach zu realisieren, kann schnell unübersichtlich werden und erfordert bei größeren Projekten eine gute Disziplin. Weiterhin sollte sie nicht in übertriebenem Maße verwendet werden. In einigen Fällen ist eine Mitgliedsvariable an Stelle einer Ableitung die bessere Wahl.