TicTacToe

Dankle für die aufschlussreiche antwort....aber eine frage hab ich trotzdem noch...

hat die variable irgendwie was mit dem enum zu tun? kenst du vielleciht in gute libnk wo man etwas mehr über diese enums erfahren kann?? danke mon3d

enum bedeutet einfach nur Aufzählung.

Also, du kannst dmait sozusagen einen neuen Datentyp erstellen, und dann (fast) so wie int nutzen, der jedoch eben nur die bestimmten Werte annehmen kann.

zB

enum aufz
{
  ele1,
  ele2,
  ele3
};

aufz Var = ele1;

int i = 0;

aufz Var2 = (aufz)i;  // i in aufz umwandeln

So kannst dus auch in deinem Spiel machen, einfach die Variable Wer_ist_dran umgewandelt in aufz in das Array speichern.
Wenn es geht könntest du das Array ja auch als aufz deklarieren

Danke mann das hilf gut weiter...*geistesblitzaufgeh

lch mich jetzt nciht aus..aber einfrgae hab ich trotzdem noch.....

wen du dir das mal anschauen magst:

switch(zahl)
{
case 1:
board[2][0]=1;
....

das ganze klappt nicht ich bekomme nen kompiler fehler invalid conversion from int to broadcell

kann du mri sagen was das heist udn wo das der fehler steckt..kome ums verrecken nicht drauf.....danke----

groovemaster

Offensichtlich hast du enums noch nicht ganz verstanden. Sie werden zwar intern als int behandelt, kann dir aber im Moment nicht sagen ob die Umwandlung von enum in int ohne weiteres standardkonform ist und ob das jeder Compiler problemlos mitmacht. Deshalb sollte man sich von dieser int-Denkweise lösen.
Du kannst ja mal folgendes probieren (was eigentlich kompilieren sollte):

board[2][0] = (BoardCell) 1;

Dafür sind enums aber nicht da und so sind sie auch nicht zu verwenden!
Wenn du einer enum Variable etwas zuweist, dann auch nur die Bezeichner die du im enum-Typ definiert hast, also zB:

board[2][0] = PLAYER1;

Alo irgendwie bin ich einfach zu blöd um das zu kappieren...
ich wil lum goteswilen kein lösung ode rsowas...
aber wenn jemand von euch zeit hätte könte er mir ein simples beispielprogramm schreiben dasmit ich es versteh wie dsa mit den 2 player funzen soll und wie mal den array mit dem emus handhabt..

vielen dank mon3d

nman

Ich hab vor einiger Zeit eine kleine TicTacToe Basisklasse gebastelt anhand der Du die Verwendung von enums verstehen könntest, soll ich die mal posten?
(Unabhängig davon: Lies ein gutes C++-Buch, darin wird die Verwendung von enums - und vieles anderes - erklärt!)

Ja es wäre sehr nett von dir wenn du es posten würdest....

danke im Voraus...

nman

Ich habe das Programm aus dem diese Klasse entnommen ist allerdings schon vor einiger Zeit begonnen und nie fertig gestellt, wenn das nicht sauber genug ist dann wird hoffentlich irgendjemand der sich bessre auskennt als ich darauf hinweisen, ansonsten viel Erfolg damit, mögest Du das bisschen Code verwenden wofür Du es auch brauchst!

Der Header:

// tictactoe.hpp
#ifndef TICTACTOE_HPP
#define TICTACTOE_HPP

#include <stdexcept>
#include <string>

namespace tic
{

class TicTacToe
{
public:
	TicTacToe() {}
	virtual ~TicTacToe() {}
protected:
	enum fieldOwner
	{
		empty,
		player1,
		player2
	};
	class pieceNotSet : public std::logic_error
	{
	public:
		pieceNotSet(const std::string& msg)
			: std::logic_error(msg) {}
	};
	TicTacToe::fieldOwner getWinner() const;
	void placePiece(const TicTacToe::fieldOwner& player,
			const unsigned short x, const unsigned short y);
private:
	fieldOwner board_[3][3];
};

}
#endif

Die Implementierung:

// tictactoe.cpp
#include "tictactoe.hpp"
#include <cassert>

namespace tic
{

TicTacToe::fieldOwner TicTacToe::getWinner() const
{
	// do we have a winner?

	for (unsigned i = 0; i < 3; ++i)
	{
		// check columns
		if (board_[i][0] == board_[i][1] == board_[i][2] != empty)
			return board_[i][0];
		// check rows
		if (board_[0][i] == board_[1][i] == board_[2][i] != empty)
			return board_[0][i];
	}

	// check diagonals
	if (board_[0][0] == board_[1][1] == board_[2][2] != empty)
		return board_[0][0];
	if (board_[2][0] == board_[1][1] == board_[0][2] != empty)
		return board_[2][0];

	// no winner
	return empty;
}

void TicTacToe::placePiece(const TicTacToe::fieldOwner& player,
			const unsigned short x, const unsigned short y)
{
	// make sure player is valid
	assert(player != empty);
	// make sure coordinates are valid
	assert(x < 3 && y < 3);

	if (board_[x][y] == empty)
	{
		board_[x][y] = player;
		return;
	}
	throw pieceNotSet("Field isn't empty.");
}

}

(Ich weiß dass das nicht viel ist aber genug um die Anwendung von enums hierbei zu verstehen ist es wohl doch...)

operator void

Seltsames Interface...dann muss man von der Klasse ableiten, um sie zu benutzen?

nman

Ich hatte geplant dann von dieser Klasse abzuleiten, ja.
Hm, was ist Deiner Ansicht nach an dem Interface seltsam? Ist zwar schon einige Zeit her dass ich das geschrieben habe aber ich finde es nach wie vor ganz ok.

DAnke An alle di rmir geholfen habne....

operator void

Eigentlich finde ich das Spiel schön gekapselt, nur hätte ich da wohl eine ganz normale Klasse mit Wertsemantiken erwartet - also Konstruktor raus (der wird in genau der Form eh automatisch generiert), Destruktor raus und alles, was jetzt protected ist, public. Selbst wenn man das Spiel in irgendeiner Form wrappen würde, wäre Komposition dafür doch angebrachter als Vererbung, ein öffentliches Interface gibt es ja praktisch nicht...natürlich alles IMHO

nman

Klingt vernünftig.
Mein Hintergedanke war damals wohl dass man so die Is-A-Beziehung am besten modellieren kann; daran dass das aus designtechnischer Sicht uU gar nicht so wichtig ist dachte ich damals nicht.

Was sagt der Rest der Belegschaft?

edit: Wird wohl langsam Zeit ein gutes Design-Buch zu lesen...