ich habe folgendes Problem:

Ich möchte eine Funktion choose_oppenent(...){} schreiben, die drei verschiedene Klasseninstanzen per Parameter annimmt und über einen integrierten Zufallsgenerator einen Gegner für den Spieler bestimmt.

Zuerst habe ich da an sowas gedacht, allerdings funktioniert das nicht:

template <class X>
 X choose_oppenent( CKrieger a, CBogenschütze b, CMagier c ){
	return b; // Bogenschütze soll zurückgegeben werden
}

Dann habe ich mir folgendes überlegt:

template <class X, class Y, class Z>
 X choose_oppenent( X a, Y b, Z c ){
	return c; // das klappt
}

Das funktioniert und kann so auch ausgegeben werden:

cout << random(a,b,c);

Allerdings wäre mir obige Variante lieber, da ich eh nur drei verschiedene Klassen habe. Wie aber erstelle ich eine Funktion mit unbekanntem Rückgabetyp, geht das? Gibt es vielleicht eine bessere Möglichkeit?

Gruß,

Kay

Dann musst du im nachhinein halt mit CEinheit weiter arbeiten, was kein Problem sein sollte, sofern du deinen Code sauber strukturierst.

Übrigens ist die ungarische Notation out.

Der Gegner soll ja nicht plötzlich alle Attacken der Klasse CEinheit haben, sondern nur die, die für ihn bestimmt sind.

// C++ für Spieleprogrammierer
// Listing 7.14
// Virtuelle Funktionen
//
#include <iostream>

using namespace std;

// Klassen
//

// Basisklasse
//
class CRaumschiff
{
	protected:

		// Membervariablen
		int m_Farbe;
		int m_Energie;

	public:

		// Memberfunktionen
		CRaumschiff ()
		{
			m_Farbe = 0;
			m_Energie = 1000;
			cout << "Neues Raumschiff erstellt" << endl;
		}

		virtual ~CRaumschiff () {cout << "Destruktor Basisklasse\n";}

		virtual void Starten () {cout << "Raumschiff startet!\n";}
		virtual void Landen  () {cout << "Raumschiff landet!\n";}

};

// Abgeleitete Klasse für den Minenleger
//
class CMinenleger : public CRaumschiff
{
	private:

		// Membervariablen
		int m_Minen;

	public:

		// Memberfunktionen
		CMinenleger ()
		{
			m_Minen = 10;
			cout << "Neuer Minenleger erstellt" << endl;
		};

		~CMinenleger () {cout << "Destruktor Minenleger\n";}

		void Starten () {cout << "Minenleger startet!\n";}
		void Landen  () {cout << "Minenleger landet!\n";}

};

// Hauptprogramm
//
int main ()
{
	// Variablen
	//
	CRaumschiff *Schiff; // Ein Raumschiff

	Schiff = new CMinenleger; // Ein Minenleger soll es sein

	// Minenleger führt einige Aktionen aus
	Schiff->Starten ();
	Schiff->Landen ();

	delete Schiff;  // Raumschiff zerstören

	return 0;
}

...und das ist der wichtige Teil den du meintest, oder?
Schiff = new CMinenleger;

...und wenn mein Bogenschütze jetzt als CEinheit rückgegeben wird, ist er immernoch ein Bogenschütze, oder nicht?

...und das ist der wichtige Teil den du meintest, oder?
Schiff = new CMinenleger;

...und wenn mein Bogenschütze jetzt als CEinheit rückgegeben wird, ist er immernoch ein Bogenschütze, oder nicht?

Ganz genau. Du kannst eben nicht mehr auf die Details vom Bogenschützen zugreifen, aber das sollte auch nicht nötig sein. Die als virtual markierten Funktionen die in Bogenschützen überschrieben wurden, werden auch nachwievor vom Bogenschützen und nicht von CEinheit aufgerufen.

ich erhalte folgende Fehlermeldung:

error C2664: 'randomClass': Konvertierung des Parameters 1 von 'CEinheit *' in 'CRitter *' nicht möglich

Siehst du vielleicht woran das liegt?

// C++ für Spieleprogrammierer
// Listing 7.14
// Virtuelle Funktionen
//
#include <iostream>

using namespace std;

class CEinheit
{
	protected:

		int m_Farbe;
		int m_Energie;

	public:

		CEinheit ()
		{
			m_Farbe = 0;
			m_Energie = 1000;
			cout << "Neues Raumschiff erstellt" << endl;
		}

		virtual ~CEinheit () {cout << "Destruktor Basisklasse\n";}

		virtual void Starten () {cout << "Raumschiff startet!\n";}
		virtual void Landen  () {cout << "Raumschiff landet!\n";}

};

class CBogenschütze : public CEinheit
{
	private:

		int m_Minen;

	public:

		CBogenschütze ()
		{
			m_Minen = 10;
			cout << "Neuer Bogenschütze erstellt" << endl;
		};

		~CBogenschütze () {cout << "Destruktor Bogenschützer\n";}

		void Starten () {cout << "Bogenschütze startet!\n";}
		void Landen  () {cout << "Bogenschütze landet!\n";}

};

class CRitter : public CEinheit
{
	private:
		int m_Minen;

	public:

		CRitter ()
		{
			m_Minen = 10;
			cout << "Neuer Ritter erstellt" << endl;
		};

		~CRitter () {cout << "Destruktor Minenleger\n";}

		void Starten () {cout << "Ritter startet!\n";}
		void Landen  () {cout << "Ritter landet!\n";}

};

CEinheit* randomClass(CRitter *a, CBogenschütze *b)
{

  return a; // Impliziter Upcast von CBogenschütze* nach CEinheit*
}

int main ()
{

	CEinheit *Gegner1;
	CEinheit *Gegner2;

	Gegner1 = new CRitter; 
	Gegner2 = new CBogenschütze;

	randomClass(Gegner1, Gegner2); 

	system("pause");
	return 0;
}

Basisklasse:
CEinheit

abgeleitete Klassen:
CKrieger
CMagier
CBogenschütze

Wie kriege ich es jetzt hin, dass ich einen Spieler habe, der zur Laufzeit seine Klasse aussucht und mit dieser dann das ganze Spiel über spielen kann? Ich hab an eine Klasse CSpieler gedacht, die über eine Funktion GetClass oder so ihre Klasse annimmt, allerdings weiß ich nicht was ich für einen Parameter nehmen soll. Wie würdet ihr das lösen?

Dann habe ich aber ja das Problem, dass k keine speziellen Funktionen von Ritter aufrufen kann, sondern nur die von Klasse. Der Ritter soll ja Memberfunktionen haben, also Attacken, die ihn von den anderen unterscheiden.

Das ist ein Designfehler von dir. Überleg wie man es besser machen könnte, mit virtuellen Funktionen.

#include <iostream>

using namespace std;

class CEinheit // pure virtuelle Basisklasse
{
	protected:
		int m_Lebenspunkte; // hat jeder Charakter

	public:

		CEinheit ()
		{
			m_Lebenspunkte = 0;

		}

		virtual ~CEinheit () {cout << "Destruktor Basisklasse\n";}

		virtual void Angriff1  () = 0;
		virtual void Angriff2  () = 0;
		virtual void Angriff3  () = 0;

};

class CBogenschütze : public CEinheit
{
	private:
		int m_Power; // Haben nur Bogenschützen

	public:
		CBogenschütze ()
		{
			m_Power = 60;

		};

		~CBogenschütze () {cout << "Destruktor Bogenschützer\n";}

		void Angriff1  () {cout << "Zing!\n";}
		void Angriff2  () {cout << "Zang!\n";}
		void Angriff3  () {cout << "Zong!\n";}

};

class CRitter : public CEinheit
{
	private:
		int m_Kraft; // Haben nur Ritter

	public:
		CRitter ()
		{
			m_Kraft = 40;
			cout << "Neuer Ritter erstellt" << endl;
		};

		~CRitter () {cout << "Destruktor Ritter\n";}

		void Angriff1  () {cout << "Boom!\n";}
		void Angriff2  () {cout << "Bamm!\n";}
		void Angriff3  () {cout << "Bang!\n";}

};

int main ()
{
	CRitter *pRitter = NULL;
	pRitter = new CRitter;
	pRitter->Angriff1(); // funzt super

	CBogenschütze *pBogenschütze = NULL;
	pBogenschütze = new CBogenschütze;
	pBogenschütze->Angriff2(); // funzt super

	CEinheit *pSpieler = NULL;
	pSpieler = new CRitter; // Spieler soll ein Ritter sein
	pSpieler->Angriff1(); // funzt, ruft Attacke von Ritter auf

	system("pause");
	return 0;
}

Du könntest aber auch mal ganz konkret beschreiben, warum du jetzt unbedingt Zugriff auf einen Ritter brauchst. Das würde wahrscheinlich mehr helfen das Problem zu lösen.

Ich möchte ein Spiel schreiben, bei dem der Spieler gegen einen Computer Gegner kämpft. Wenn er den Ritter wählt, hat er ja andere Attacken als ein Magier zum Beispiel, deswegen ist es so wichtig, dass er ein Ritter bleibt, aber das geht ja jetzt so mit den puren virtuellen Funktionen anscheinend.

Das Problem ist nur die Membervariablen, wie kann ich es anstellen, dass der Ritter auf seine Membervariable m_Kraft zugreifen kann, sprich pSpieler->m_Kraft (davon abgesehen dass es so eh nicht geht weil es private ist).

Diese Membervariablen sind deswegen wichtig, weil ein Bogenschütze Power und nicht Kraft hat, sonst würde ich die ja einfach in die Basisklasse packen. Oder würde man einfach hingehen und anstatt Mana, Power, Kraft, einfach eine Variable namens Ressource machen? Die kann ich ja dann in die Basisklasse packen.

Diese Membervariablen sind deswegen wichtig, weil ein Bogenschütze Power und nicht Kraft hat, sonst würde ich die ja einfach in die Basisklasse packen. Oder würde man einfach hingehen und anstatt Mana, Power, Kraft, einfach eine Variable namens Ressource machen? Die kann ich ja dann in die Basisklasse packen.

Es sollte egal sein, was du vor dir hast! Es sollte dich nicht interessieren, ob das jetzt ein Bogenschütze mit "Power" oder ein Ritter mit "Kraft" ist.
Deine virtuellen Funktionen kümmern sich darum, was im Hintergrund passiert.
Du hast die Funktion "Einheit::attack(Einheit* opponent)", z.B.
Oder von mir aus kapsele die einzelnen Arten von Attacken noch mal in eigenen Klassen.
Es liegt jetzt an dir zu entscheiden, was ein Angriff dann bewirkt. Ein Schlag mit dem Schert auf den Kopf des Gegners könnte nun einen bestimmten Schaden zufügen. Oder gleich den Kopf abtrennen, wenn du keine adäquate Verteidung oder Rüstung aufweisen kannst. Das Ganze ist natürlich ETWAS komplexer als ein simples cout.

Also löse dich von der Vorstellung, auf ein Objekt speziell reagieren zu wollen, sondern gib deiner CEinheit ein Interface, das im Allgemeinen Sinne die einzelnen Interaktionen zulässt.