Probleme mit Mehrfachvererbung

Reply to Probleme mit Mehrfachvererbung on Thu, 22 Jun 2006 20:12:51 GMT

Xargo — Thu, 22 Jun 2006 20:12:51 GMT

Hallo zusammen,

Ich soll ein Schachspiel implementieren, allerdings ist es meiner Meinung nach ehr ein allgemeines Problem, das ich hab und deshalb poste ich es hier.

Für die Figuren gibt es eine Oberklasse "U7A1_Spielfigur".
Von dieser Klasse werden unter anderem der Läuefer ("U7A1_Laeufer") und der Turm ("U7A1_Turm") abgeleitet.
Die Dame setzt sich nun ja aus Läufer und Turm zusammen, also möchte ich, dass sie von diesen beiden erbt.

Das ist der Code der Dame:

#include "U7A2_Dame.h"

bool U7A2_Dame::zieheNach(unsigned int zeile,
													unsigned int spalte, 
													std::map< std::pair< unsigned int, unsigned int> , U7A1_Spielfigur*>& feind_figuren,
													std::map< std::pair< unsigned int, unsigned int> , U7A1_Spielfigur*>& freund_figuren)
{
	if ( ( position_.first == zeile) || ( position_.second == spalte) )
	{
		return U7A1_Turm::zieheNach(zeile, spalte, feind_figuren, freund_figuren);
	}
	else
	{
		return U7A1_Laeufer::zieheNach(zeile, spalte, feind_figuren, freund_figuren);
	}
}

virtual bool U7A2_Dame::kannZiehenNach(unsigned int zeile,
															unsigned int spalte, 
															std::map< std::pair< unsigned int, unsigned int> , U7A1_Spielfigur*>& feind_figuren,
															std::map< std::pair< unsigned int, unsigned int> , U7A1_Spielfigur*>& freund_figuren)

{
	if ( ( position_.first == zeile) || ( position_.second == spalte) )
	{
		return (*this).U7A1_Turm::kannZiehenNach(zeile, spalte, feind_figuren, freund_figuren);
	}
	else
	{
		return U7A1_Laeufer::kannZiehenNach(zeile, spalte, feind_figuren, freund_figuren);
	}
}

std::string U7A2_Dame::alsString()
{
  std::string resultat = "";

  if (schwarz_)
  {
		resultat = std::string("Q");
  }
  else
  {
  	// Wenn dieser String auf die Kommandozeile ausgegeben wird, 
  	// so wird die Textfarbe auf rot gesetzt.
		resultat = std::string("\033[31mQ");		
  }
  return resultat;
}

bool U7A2_Dame::figurImWeg(const std::pair< unsigned int, unsigned int >& ziel,
													const std::pair< unsigned int, unsigned int >& hindernis)
{
	if ( ( position_.first == ziel.first) || ( position_.second == ziel.second) )
	{
		return (*this).U7A1_Turm::figurImWeg(ziel, hindernis);
	}
	else
	{
		return U7A1_Laeufer::figurImWeg(ziel, hindernis);
	}
}

Wenn ich jetzt die Dame compilieren will, erhalte ich folgenden Fehler:

U7A2_Dame.C: In member function `virtual bool U7A2_Dame::zieheNach(unsigned int, unsigned int, std::map, U7A1_Spielfigur*, std::less >, std::allocator, U7A1_Spielfigur*> > >&, std::map, U7A1_Spielfigur*, std::less >, std::allocator, U7A1_Spielfigur*> > >&)':

U7A1_Turm.h:53: Fehler: >>virtual bool U7A1_Turm::zieheNach(unsigned int, unsigned int, std::map, U7A1_Spielfigur*, std::less >, std::allocator, U7A1_Spielfigur*> > >&, std::map, U7A1_Spielfigur*, std::less >, std::allocator, U7A1_Spielfigur*> > >&)<< ist privat

U7A2_Dame.C:21: Fehler: in diesem Zusammenhang

U7A1_Laeufer.h:52: Fehler: >>virtual bool U7A1_Laeufer::zieheNach(unsigned int, unsigned int, std::map, U7A1_Spielfigur*, std::less >, std::allocator, U7A1_Spielfigur*> > >&, std::map, U7A1_Spielfigur*, std::less >, std::allocator, U7A1_Spielfigur*> > >&)<< ist privat

U7A2_Dame.C:25: Fehler: in diesem Zusammenhang

U7A2_Dame.C: At global scope:

U7A2_Dame.C:34: Fehler: virtuelle Deklaration einer "ausseren Klasse

U7A2_Dame.C: In member function `virtual bool U7A2_Dame::kannZiehenNach(unsigned int, unsigned int, std::map, U7A1_Spielfigur*, std::less >, std::allocator, U7A1_Spielfigur*> > >&, std::map, U7A1_Spielfigur*, std::less >, std::allocator, U7A1_Spielfigur*> > >&)':

U7A1_Turm.h:37: Fehler: >>virtual bool U7A1_Turm::kannZiehenNach(unsigned int, unsigned int, std::map, U7A1_Spielfigur*, std::less >, std::allocator, U7A1_Spielfigur*> > >&, std::map, U7A1_Spielfigur*, std::less >, std::allocator, U7A1_Spielfigur*> > >&)<< ist privat

U7A2_Dame.C:37: Fehler: in diesem Zusammenhang

U7A1_Laeufer.h:36: Fehler: >>virtual bool U7A1_Laeufer::kannZiehenNach(unsigned int, unsigned int, std::map, U7A1_Spielfigur*, std::less >, std::allocator, U7A1_Spielfigur*> > >&, std::map, U7A1_Spielfigur*, std::less >, std::allocator, U7A1_Spielfigur*> > >&)<< ist privat

U7A2_Dame.C:41: Fehler: in diesem Zusammenhang

(Sorry das ich soviel Code poste, weiß nicht wies besser geht...)

Ich hab leider keine Ahnung, was ich falsch mache....

Wäre super, wenn ihr mir helfen könntet...

MfG Xargo

Reply to Probleme mit Mehrfachvererbung on Thu, 22 Jun 2006 20:57:34 GMT

camper — Thu, 22 Jun 2006 20:57:34 GMT

der wesentliche teil - die klassendefinitionen fehlen hier. schliesslich beschwert er sich, dass gewissen funktionen privat sind. das ein dame ein turm und ein läufer ist, halte ich für eine gewagte konstruktion. schliesslich brauchst du z.b. für eine rochade einen echten turm. im übrigen ist es dann wohl erforderlich, dass spielfigur eine virtuelle basis von turm und läufer ist.

Reply to Probleme mit Mehrfachvererbung on Thu, 22 Jun 2006 21:45:44 GMT

Xargo — Thu, 22 Jun 2006 21:45:44 GMT

Okay hier sind mal die Header-Dateien der Dame, des Läufers und des Turms.
Rochade muss nicht implementiert werden und das mit dem Dame = Läufer und Turm ist leider so vorgegeben

Dame

#ifndef U7A2_DAME_H
#define U7A2_DAME_H

#include "U7A1_Turm.h"
#include "U7A1_Laeufer.h"

class U7A2_Dame
	: public U7A1_Turm, public U7A1_Laeufer
{

	virtual ~U7A2_Dame();

	// Funktion:          zieheNach
  //
  // Parameter:         zeile                    Zeilenindex der Zielposition
  //                    spalte                   Spaltenindex der Zielposition
	//                    feind_figuren            die gegnerischen Figuren
	//                    freund_figuren           die eigenen Figuren
	//
	// Rueckgabewert:     bool
	//
	// Beschreibung:      Diese Methode versetzt die U7A1_Spielfigur nach (zeile, spalte), falls der Zug moeglich ist
	//                    und gibt 'true' zurueck. Ist der Zug nicht moeglich, so wird 'false' zurueckgegeben.

	virtual bool zieheNach(unsigned int zeile,
																unsigned int spalte, 
																std::map< std::pair< unsigned int, unsigned int> , U7A1_Spielfigur*>& feind_figuren,
																std::map< std::pair< unsigned int, unsigned int> , U7A1_Spielfigur*>& freund_figuren);

	// Funktion:          kannZiehenNach
	//
	// Parameter:         zeile                    Zeilenindex der Zielposition
	//                    spalte                   Spaltenindex der Zielposition
	//                    feind_figuren            die gegnerischen Figuren
	//                    freund_figuren           die eigenen Figuren
	//
	// Rueckgabewert:     bool
	//
	// Beschreibung:      Diese Methode testet, ob die U7A1_Spielfigur nach (zeile, spalte) ziehen kann.
	//                    Ist dies der Fall, so wird 'true', andernfalls 'false' zurueckgegeben.
	virtual bool kannZiehenNach(unsigned int zeile,
															unsigned int spalte, 
															std::map< std::pair< unsigned int, unsigned int> , U7A1_Spielfigur*>& feind_figuren,
															std::map< std::pair< unsigned int, unsigned int> , U7A1_Spielfigur*>& freund_figuren);

	// Funktion:          alsString
	//
	// Parameter:         void
	//
	// Rueckgabewert:     std::string
	//
	// Beschreibung:      Diese Methode gibt den Buchstaben der U7A1_Spielfigur zurueck. Hierbei ist:
	//
	//                    P: Bauer (pawn)
	//                    N: Springer (knight)
	//                    B: Laeufer (bishop)
	//                    R: Turm (rook)
	//                    Q: Koenigin (queen)
	//                    K: Koenig (king)
	//
	//                    Der Buchstabe wird schwarz dargestellt, wenn 'schwarz_' 'true' ist, 
	//                    andernfalls rot.
    virtual std::string alsString();

	protected:

	// Funktion:          figurImWeg
	//
	// Parameter:         ziel                    Das Ziel des Zuges
	//                    hindernis               Ein potentielles Hindernis (eine andere Figur)
	//
	// Rueckgabewert:     bool
	//
	// Beschreibung:      Diese Methode testet, ob auf dem Weg von der eigenen Position
	//                    zum Ziel das potentielle Hindernis 'hindernis' im Weg steht.
	//                    Ist dies der Fall, gibt die Methode 'true' zurueck, andernfalls
	//                    gibt sie 'false' zurueck.
	virtual 	bool figurImWeg(const std::pair< unsigned int, unsigned int >& ziel,
													const std::pair< unsigned int, unsigned int >& hindernis);

};

#endif

Turm

#ifndef U7A1_TURM_H
#define U7A1_TURM_H

#include "U7A1_Spielfigur.h"

class U7A1_Turm
	: virtual public U7A1_Spielfigur
{

		virtual ~U7A1_Turm();

		// Funktion:          kannZiehenNach
    //
    // Parameter:         zeile                    Zeilenindex der Zielposition
    //                    spalte                   Spaltenindex der Zielposition
    //                    feind_figuren            die gegnerischen Figuren
    //                    freund_figuren           die eigenen Figuren
    //
    // Rueckgabewert:     bool
    //
    // Beschreibung:      Diese Methode testet, ob die U7A1_Spielfigur nach (zeile, spalte) ziehen kann.
    //                    Ist dies der Fall, so wird 'true', andernfalls 'false' zurueckgegeben.
    virtual bool kannZiehenNach(unsigned int zeile,
																unsigned int spalte, 
																std::map< std::pair< unsigned int, unsigned int> , U7A1_Spielfigur*>& feind_figuren,
																std::map< std::pair< unsigned int, unsigned int> , U7A1_Spielfigur*>& freund_figuren);

    // Funktion:          zieheNach
    //
    // Parameter:         zeile                    Zeilenindex der Zielposition
    //                    spalte                   Spaltenindex der Zielposition
    //                    feind_figuren            die gegnerischen Figuren
    //                    freund_figuren           die eigenen Figuren
    //
    // Rueckgabewert:     bool
    //
    // Beschreibung:      Diese Methode versetzt die U7A1_Spielfigur nach (zeile, spalte), falls der Zug moeglich ist
    //                    und gibt 'true' zurueck. Ist der Zug nicht moeglich, so wird 'false' zurueckgegeben.
    virtual bool zieheNach(unsigned int zeile,
			   									 unsigned int spalte, 
			   									 std::map< std::pair< unsigned int, unsigned int> , U7A1_Spielfigur*>& feind_figuren,
			   									 std::map< std::pair< unsigned int, unsigned int> , U7A1_Spielfigur*>& freund_figuren);

    // Funktion:          alsString
    //
    // Parameter:         void
    //
    // Rueckgabewert:     std::string
    //
    // Beschreibung:      Diese Methode gibt den Buchstaben der U7A1_Spielfigur zurueck. Hierbei ist:
    //
    //                    P: Bauer (pawn)
    //                    N: Springer (knight)
    //                    B: Laeufer (bishop)
    //                    R: Turm (rook)
    //                    Q: Koenigin (queen)
    //                    K: Koenig (king)
    //
    //                    Der Buchstabe wird schwarz dargestellt, wenn 'schwarz_' 'true' ist, 
    //                    andernfalls rot.
    virtual std::string alsString();

		protected:

    // Funktion:          figurImWeg
    //
    // Parameter:         ziel                    Das Ziel des Zuges
    //                    hindernis               Ein potentielles Hindernis (eine andere Figur)
    //
    // Rueckgabewert:     bool
   	//
    // Beschreibung:      Diese Methode testet, ob auf dem Weg von der eigenen Position
    //                    zum Ziel das potentielle Hindernis 'hindernis' im Weg steht.
    //                    Ist dies der Fall, gibt die Methode 'true' zurueck, andernfalls
    //                    gibt sie 'false' zurueck.
    virtual bool figurImWeg(const std::pair< unsigned int, unsigned int >& ziel,
			    									const std::pair< unsigned int, unsigned int >& hindernis);
};

#endif

Und Läufer

#ifndef U7A1_LAEUFER_H
#define U7A1_LAEUFER_H

#include "U7A1_Spielfigur.h"

class U7A1_Laeufer
	: virtual public U7A1_Spielfigur
{
		virtual ~U7A1_Laeufer();

	// Funktion:          kannZiehenNach
    //
    // Parameter:         zeile                    Zeilenindex der Zielposition
    //                    spalte                   Spaltenindex der Zielposition
    //                    feind_figuren            die gegnerischen Figuren
    //                    freund_figuren           die eigenen Figuren
    //
    // Rueckgabewert:     bool
    //
    // Beschreibung:      Diese Methode testet, ob die U7A1_Spielfigur nach (zeile, spalte) ziehen kann.
    //                    Ist dies der Fall, so wird 'true', andernfalls 'false' zurueckgegeben.
    virtual bool kannZiehenNach(unsigned int zeile,
																unsigned int spalte, 
																std::map< std::pair< unsigned int, unsigned int> , U7A1_Spielfigur*>& feind_figuren,
																std::map< std::pair< unsigned int, unsigned int> , U7A1_Spielfigur*>& freund_figuren);

    // Funktion:          zieheNach
    //
    // Parameter:         zeile                    Zeilenindex der Zielposition
    //                    spalte                   Spaltenindex der Zielposition
    //                    feind_figuren            die gegnerischen Figuren
    //                    freund_figuren           die eigenen Figuren
    //
    // Rueckgabewert:     bool
    //
    // Beschreibung:      Diese Methode versetzt die U7A1_Spielfigur nach (zeile, spalte), falls der Zug moeglich ist
    //                    und gibt 'true' zurueck. Ist der Zug nicht moeglich, so wird 'false' zurueckgegeben.
    virtual bool zieheNach(unsigned int zeile,
			   									 unsigned int spalte, 
			   									 std::map< std::pair< unsigned int, unsigned int> , U7A1_Spielfigur*>& feind_figuren,
			   									 std::map< std::pair< unsigned int, unsigned int> , U7A1_Spielfigur*>& freund_figuren);

    // Funktion:          alsString
    //
    // Parameter:         void
    //
    // Rueckgabewert:     std::string
    //
    // Beschreibung:      Diese Methode gibt den Buchstaben der U7A1_Spielfigur zurueck. Hierbei ist:
    //
    //                    P: Bauer (pawn)
    //                    N: Springer (knight)
    //                    B: Laeufer (bishop)
    //                    R: Turm (rook)
    //                    Q: Koenigin (queen)
    //                    K: Koenig (king)
    //
    //                    Der Buchstabe wird schwarz dargestellt, wenn 'schwarz_' 'true' ist, 
    //                    andernfalls rot.
    virtual std::string alsString();

		protected:

    // Funktion:          figurImWeg
    //
    // Parameter:         ziel                    Das Ziel des Zuges
    //                    hindernis               Ein potentielles Hindernis (eine andere Figur)
    //
    // Rueckgabewert:     bool
   	//
    // Beschreibung:      Diese Methode testet, ob auf dem Weg von der eigenen Position
    //                    zum Ziel das potentielle Hindernis 'hindernis' im Weg steht.
    //                    Ist dies der Fall, gibt die Methode 'true' zurueck, andernfalls
    //                    gibt sie 'false' zurueck.
    virtual bool figurImWeg(const std::pair< unsigned int, unsigned int >& ziel,
			    									const std::pair< unsigned int, unsigned int >& hindernis);
};

#endif

Wäre super, wenn mir jemand helfen könnte, warum der Compiler motzt...

VIelen Dank

Reply to Probleme mit Mehrfachvererbung on Thu, 22 Jun 2006 22:11:58 GMT

camper — Thu, 22 Jun 2006 22:11:58 GMT

der defaultzugriff auf member für klassen, die mit class deklariert werden, ist privat. folglich kannst du diese funktionen in läufer und turm nicht per qualifiziertem aufruf aus dame heraus aufrufen. deklariert dort einfach alles public. sinnvollerweise sollte das auch in dame passieren.

Reply to Probleme mit Mehrfachvererbung on Thu, 22 Jun 2006 22:27:50 GMT

Xargo — Thu, 22 Jun 2006 22:27:50 GMT

Super danke...
Aber das war eigentlich fast zu einfach