3. Klassendeklaration Implementierung in C++

Klassendeklaration Implementierung in C++

  • ?

    Ich habe ein kleines BlackJack Spiel in C++ geschrieben mit unterschiedlichen Klassen jedoch alle in einer .cpp Datei.

    Mein Problem ist, dass manche Klassen auf andere zugreifen sollen. Jedoch reicht das inkludieren der jeweiligen Klassen nicht aus 😞

    Wäre sehr über einige Antworten erfreut 😃 #

    #include <iostream>
#include <vector>
#include <algorithm> 
#include <ctime>
#include <string>

using namespace std;

class Karten
{
private:
	char m_karte;         //  'A'   ,'2', '3', '4', '5', '6', '7', '8', '9', 'Z', 'D', 'B', 'K'
	int m_wert,         //1 or 11 , 2  , 3  ,  4,   5 ,  6 ,  7 ,  8 ,  9,  10, 10,  10, 10
		m_symbol;             //0 Pik, 1 Kreuz, 2 Herz, 3 Karo
	string m_nameS;           // Namen der Symbole
	bool m_vergeben;        //Überprüft, ob eine Karte schon gezogen wurde.

	int zuordnen();

public:
	Karten(char, int);
	Karten(const Karten&);

	int getWert()		const;
	int getSymbol()	        const;
	string getName()	const;
	bool getIstVergeben()   const;
	char getKarten()        const;

	void setVergeben(bool x);

	void nameKarten();
};

int Karten::zuordnen()
{
	if (m_karte == 'A')         return 11;
	else if (m_karte == 'Z' ||
		     m_karte == 'B' ||
		     m_karte == 'D' ||
		     m_karte == 'K')   return 10;
	else                       return (m_karte - '0');
}

Karten::Karten(char karteV, int symbol)
{
	m_karte = karteV;
	m_wert = zuordnen();
	m_symbol = symbol;
	m_vergeben = false;
}

Karten::Karten(const Karten& karte)
{
	m_karte = karte.getKarten();
	m_wert = karte.getWert();
	m_symbol = karte.getSymbol();
	m_nameS = karte.getName();
	m_vergeben = karte.getIstVergeben();
}

int Karten::getWert() const
{
	return m_wert;
}

int Karten::getSymbol() const
{
	return m_symbol;
}

std::string Karten::getName() const
{
	return m_nameS;
}

bool Karten::getIstVergeben() const
{
	return m_vergeben;
}

char Karten::getKarten() const
{
	return m_karte;
}

void Karten::setVergeben(bool x)
{
	m_vergeben = x;
}

void Karten::nameKarten()
{
	switch (m_symbol)
	{
	case 0: m_nameS = "Pik";  break;
	case 1: m_nameS = "Kreuz";break;
	case 2: m_nameS = "Herz"; break;
	case 3: m_nameS = "Karo";
	}
	if      (m_karte == 'A') cout << "Ass";
	else if (m_karte == 'B') cout << "Bube";
	else if (m_karte == 'D') cout << "Dame";
	else if (m_karte == 'K') cout << "Koenig";
	else                     cout << m_wert;
							 cout << "  " << m_nameS << endl;
}

class Deck
{
private:
	vector<Karten*> m_deck;

public:
	Deck();

	void neuesDeck();
	void mischen();
	Karten geben();
};

Deck::Deck()
{
	//Initialize the deck: 
	neuesDeck();
	mischen();
}

void Deck::neuesDeck()
{
	for (int i = 1; i <= 13; ++i)
	{
		char c;
		switch (i) {
		case 1:  c = 'A'; break;
		case 2:  c = '2'; break;
		case 3:  c = '3'; break;
		case 4:  c = '4'; break;
		case 5:  c = '5'; break;
		case 6:  c = '6'; break;
		case 7:  c = '7'; break;
		case 8:  c = '8'; break;
		case 9:  c = '9'; break;
		case 10:  c = 'Z'; break;
		case 11:  c = 'B'; break;
		case 12:  c = 'D'; break;
		case 13:  c = 'K';
		}
		for (int n = 0; n <= 3; ++n)
		{
			m_deck.push_back(new Karten(c, n));
		}
	}
}

void Deck::mischen()
{
	random_shuffle(m_deck.begin(), m_deck.end()); // aus std
}

Karten Deck::geben()
{
	for (int i = 0; i < m_deck.size(); ++i)
	{
		if (!m_deck[i]->getIstVergeben())
		{
			m_deck[i]->setVergeben(1);
			return (*m_deck[i]);
		}
	}
}

class Hand
{

private:
	vector<Karten> m_hand;

public:

	void init(Karten, Karten);
	void anzeigen();
	void anzeigenDealer();
	void neueKarte(Karten);

	int getAnzKarten();
	int getSummeWert();
};

void Hand::init(Karten karte1, Karten karte2)
{
	m_hand.push_back(karte1);
	m_hand.push_back(karte2);
}

void Hand::anzeigen()
{
	for (vector<Karten>::iterator iter = m_hand.begin();
		iter != m_hand.end(); (++iter))
	{
		iter->nameKarten();
	}
}

void Hand::anzeigenDealer()
{
	m_hand[0].nameKarten();
}

void Hand::neueKarte(Karten karte)
{
	cout << "\nGezogen: ";
	karte.nameKarten();

	m_hand.push_back(karte);
}

int Hand::getSummeWert()
{
	int summe = 0;
	for (vector<Karten>::iterator iter = m_hand.begin();
		iter != m_hand.end(); (++iter))
	{
		summe += iter->getWert();
	}
	return summe;
}

int Hand::getAnzKarten()
{
	return m_hand.size();
}

class Spieler
{
protected:
	Deck m_deck;
	Hand m_hand;
	bool m_imSpiel;
	int stand;

public:
	Spieler(Deck deck);
	void setzen();
	void weitereKarte();
	void ausgabe1();

	int getStand() const;

	bool verloren();
	bool gewonnen();
};

Spieler::Spieler(Deck deck)
{
	m_imSpiel = 1;
	m_deck = deck;
	m_hand.init(deck.geben(), deck.geben());
}

void Spieler::setzen()
{
	m_imSpiel = 0;
	stand = m_hand.getSummeWert();
}

void Spieler::weitereKarte()
{
	if (m_imSpiel) m_hand.neueKarte(m_deck.geben());
	else cout << "Sie können keine weitere Karte ziehen!" << endl;
}

bool Spieler::verloren()
{
	if (m_hand.getSummeWert() > 21)
	{
		cout << "Ihre Hand ist größer als 21" << endl;
		return true;
	}
	return false;
}

bool Spieler::gewonnen()
{
	return (m_hand.getSummeWert() == 21 && m_hand.getAnzKarten() == 2);
}

void Spieler::ausgabe1()
{
	cout << "Ihre Karten: \n";
	m_hand.anzeigen();
}

int Spieler::getStand() const
{
	return stand;
}

class Dealer : public Spieler  //Der Dealer ist ein Spieler
{
public:
	using Spieler::Spieler;

	void ausgabe();
	void spiel(Spieler);
};

void Dealer::ausgabe()
{
	cout << "Dealer's Karten: ";
	m_hand.anzeigenDealer();
	cout << endl;
}

void Dealer::spiel(Spieler spiel)
{
	while (m_hand.getSummeWert() <= 21)
	{
		cout << "Dealer's Karten: ";
		m_hand.anzeigen();
		cout << endl;
		if (m_hand.getSummeWert() > spiel.getStand() && m_hand.getSummeWert() <= 21)
		{
			cout << "Der Dealer gewinnt, da sine Hand ueberlegen ist!" << endl;
			return;
		}
		if (m_hand.getSummeWert() == spiel.getStand())
		{
			cout << "Ein Push! " << endl;
			return;
		}
		weitereKarte();
	}
	if (m_hand.getSummeWert() > 21)
	{
		cout << "Dealer's Hand ist größer als 21." << endl;
		cout << "Sie haben gewonnen!" << endl;
		return;
	}
}

void bedienung()
{
	cout << "Bedienung:" << endl;
	cout << "1 fuer weitere Karte" << endl;
	cout << "2 fuer halten" << endl;
	cout << "\n\n";
	cout << "Viel Spass!! \n\n" << endl;
}

int main()
{
	srand(time(0));

	bedienung();

	Deck deck;
	Spieler benutzer(deck);
	Dealer casino(deck);
	char x;
	bool bbreak = 0;

	benutzer.ausgabe1();
	casino.ausgabe();

	if (benutzer.gewonnen())
	{
		cout << "Sie gewinnen! " << endl;
	}
	else if (casino.gewonnen())
	{
		cout << "Der Dealer gewinnt!" << endl;
	}
	else
	{
		while (!benutzer.verloren())
		{
			cout << "Was wollen Sie tun: ";
			cin >> x;
			if (x == '1')
			{
				benutzer.weitereKarte();
			}
			else if (x == '2')
			{
				benutzer.setzen();
				casino.spiel(benutzer);
				break;
			}
			benutzer.ausgabe1();
			casino.ausgabe();
		}
	}

	return 0;
}
    0
  • C

    Dieser Thread wurde von Moderator/in Martin Richter aus dem Forum MFC (Visual C++) in das Forum C++ (alle ISO-Standards) verschoben.

    Im Zweifelsfall bitte auch folgende Hinweise beachten:
    C/C++ Forum :: FAQ - Sonstiges :: Wohin mit meiner Frage?

    Dieses Posting wurde automatisch erzeugt.

    0
  • Mod

    Was genau ist deine Frage? Wo hakt es?

    Spontan fällt mir auf, dass das Design deiner Klassen recht wirr ist. Was ist beispielsweise dein Konzept bei der Kartenklasse? Mal verhält sie sich wie eine einzelne Karte, mal macht sie Dinge, die eine ganze Menge von Karten erfordert, und überhaupt kann ich sie nicht so recht mit dem Konzept einer oder mehrerer Karten in Verbindung bringen. Das wird dann später sicherlich auch Probleme bei der Benutzung machen, wenn eine einzelne Klasse mehrere disjunkte Konzepte gleichzeitig bedienen soll.

    0
  • M

    xnightman schrieb:

    Mein Problem ist, dass manche Klassen auf andere zugreifen sollen. Jedoch reicht das inkludieren der jeweiligen Klassen nicht aus 😞

    Willst du darauf hinaus, dass du den Code in mehrere Dateien aufteilen willst und Probleme mit den Abhängigkeiten bekommst? Ich seh da jetzt auf den ersten Blick keine besonderen Abhängigkeiten. Im Header möglichst vorwärts deklarieren, in der cpp dann inkludieren. Und du brauchst Header Guards. Und kein using namespace im Header.

    Was ich echt nicht leiden kann, ist wenn man Code auf Deutsch schreibt. Dann kommt auch sowas unglaublich hässliches wie getIstVergeben dabei raus.
    Die ganzen switch cases und die magic numbers gefallen mir auch überhaupt nicht.

    0

  • Dieser Beitrag überschneidet sich mit C++ Programm in Klassen aufteilen, wo ich ihm schon geantwortet hatte.

    0
Anmelden zum Antworten