Bug in der Tic Tac Toe implementierung

ReALITY5

Ich habe einen bug in der Tic Tac Toe implementierung der wie folgt aus sieht,
wenn ich an bestimmten stellen den Spielstein setze, werde statt nur 1 Spielstein 2 gesetzt.

1.  #include<iostream>
   2. #include<iomanip>
   3. using namespace std;
   4.  
   5. class tic_tac_toe
   6. {
   7. private:
   8.     char Spielfeld[2][2];
   9. public:
  10.     void Spieler1_zug();
  11.     void Spieler2_zug();
  12.     void anzeigen();
  13.     void gewonnen_s1();
  14.     void gewonnen_s2();
  15.     tic_tac_toe();
  16. };
  17.  
  18. tic_tac_toe::tic_tac_toe()
  19. {
  20.     Spielfeld[0][0]='.';
  21.     Spielfeld[0][1]='.';
  22.     Spielfeld[0][2]='.';
  23.     Spielfeld[1][0]='.';
  24.     Spielfeld[1][1]='.';
  25.     Spielfeld[1][2]='.';
  26.     Spielfeld[2][0]='.';
  27.     Spielfeld[2][1]='.';
  28.     Spielfeld[2][2]='.';
  29. }
  30.  
  31.  
  32. void tic_tac_toe::Spieler1_zug()
  33. {
  34.     int reihe=0;
  35.     int    spalte=0;
  36.     cout<<"Reihe: ";
  37.     cin>>reihe;
  38.     cout<<"Spalte: ";
  39.     cin>>spalte;
  40.     Spielfeld[reihe-1][spalte-1]='x';
  41. }
  42.  
  43. void tic_tac_toe::Spieler2_zug()
  44. {
  45.     int reihe=0;
  46.     int spalte=0;
  47.     cout<<"Reihe: ";
  48.     cin>>reihe;
  49.     cout<<"Spalte: ";
  50.     cin>>spalte;
  51.     Spielfeld[reihe-1][spalte-1]='o';
  52. }
  53.  
  54. void tic_tac_toe::anzeigen()
  55. {
  56.     int i;
  57.     int y;
  58.     for(i=0;i<3;i++)
  59.     {
  60.         for(y=0;y<3;y++)
  61.         {
  62.             cout<<setw(2)<<Spielfeld[y][i];
  63.         }
  64.         cout<<"\n\n";
  65.     }
  66. }
  67.  
  68. void tic_tac_toe::gewonnen_s2()
  69. {
  70.     if(Spielfeld[0][0]=='o' && Spielfeld[0][1]=='o' && Spielfeld[0][2]=='o')
  71.     {
  72.         cout<<"Spieler 2 hat gewonnen!"<<endl;
  73.         void anzeigen();
  74.         exit(0);
  75.     }
  76.     if(Spielfeld[1][0]=='o' && Spielfeld[1][1]=='o' && Spielfeld[1][2]=='o')
  77.     {
  78.         cout<<"Spieler 2 hat gewonnen!"<<endl;
  79.         void anzeigen();
  80.         exit(0);
  81.     }
  82.     if(Spielfeld[2][0]=='o' && Spielfeld[2][1]=='o' && Spielfeld[2][2]=='o')
  83.     {
  84.         cout<<"Spieler 2 hat gewonnen!"<<endl;
  85.         void anzeigen();
  86.         exit(0);
  87.     }
  88.     if(Spielfeld[0][1]=='o' && Spielfeld[1][1]=='o' && Spielfeld[2][1]=='o')
  89.     {
  90.         cout<<"Spieler 2 hat gewonnen!"<<endl;
  91.         void anzeigen();
  92.         exit(0);
  93.     }
  94.     if(Spielfeld[0][0]=='o' && Spielfeld[1][0]=='o' && Spielfeld[2][0]=='o')
  95.     {
  96.         cout<<"Spieler 2 hat gewonnen!"<<endl;
  97.         void anzeigen();
  98.         exit(0);
  99.     }
 100.     if(Spielfeld[0][2]=='o' && Spielfeld[1][2]=='o' && Spielfeld[2][2]=='o')
 101.     {
 102.         cout<<"Spieler 2 hat gewonnen!"<<endl;
 103.         void anzeigen();
 104.         exit(0);
 105.     }
 106.     if(Spielfeld[0][0]=='o' && Spielfeld[1][1]=='o' && Spielfeld[2][2]=='o')
 107.     {
 108.         cout<<"Spieler 2 hat gewonnen!"<<endl;
 109.         void anzeigen();
 110.         exit(0);
 111.     }
 112.     if(Spielfeld[0][2]=='o' && Spielfeld[1][1]=='o' && Spielfeld[2][0]=='o')
 113.     {
 114.         cout<<"Spieler 2 hat gewonnen!"<<endl;
 115.         void anzeigen();
 116.         exit(0);
 117.     }
 118. }
 119.  
 120. void tic_tac_toe::gewonnen_s1()
 121. {
 122.     if(Spielfeld[0][0]=='x' && Spielfeld[0][1]=='x' && Spielfeld[0][2]=='x')
 123.     {
 124.         cout<<"Spieler 1 hat gewonnen!"<<endl;
 125.         void anzeigen();
 126.         exit(0);
 127.     }
 128.     if(Spielfeld[1][0]=='x' && Spielfeld[1][1]=='x' && Spielfeld[1][2]=='x')
 129.     {
 130.         cout<<"Spieler 1 hat gewonnen!"<<endl;
 131.         void anzeigen();
 132.         exit(0);
 133.     }
 134.     if(Spielfeld[2][0]=='x' && Spielfeld[2][1]=='x' && Spielfeld[2][2]=='x')
 135.     {
 136.         cout<<"Spieler 1 hat gewonnen!"<<endl;
 137.         void anzeigen();
 138.         exit(0);
 139.     }
 140.     if(Spielfeld[0][1]=='x' && Spielfeld[1][1]=='x' && Spielfeld[2][1]=='x')
 141.     {
 142.         cout<<"Spieler 1 hat gewonnen!"<<endl;
 143.         void anzeigen();
 144.         exit(0);
 145.     }
 146.     if(Spielfeld[0][0]=='x' && Spielfeld[1][0]=='x' && Spielfeld[2][0]=='x')
 147.     {
 148.         cout<<"Spieler 1 hat gewonnen!"<<endl;
 149.         void anzeigen();
 150.         exit(0);
 151.     }
 152.     if(Spielfeld[0][2]=='x' && Spielfeld[1][2]=='x' && Spielfeld[2][2]=='x')
 153.     {
 154.         cout<<"Spieler 1 hat gewonnen!"<<endl;
 155.         void anzeigen();
 156.         exit(0);
 157.     }
 158.     if(Spielfeld[0][0]=='x' && Spielfeld[1][1]=='x' && Spielfeld[2][2]=='x')
 159.     {
 160.         cout<<"Spieler 1 hat gewonnen!"<<endl;
 161.         void anzeigen();
 162.         exit(0);
 163.     }
 164.     if(Spielfeld[0][2]=='x' && Spielfeld[1][1]=='x' && Spielfeld[2][0]=='x')
 165.     {
 166.         cout<<"Spieler 1 hat gewonnen!"<<endl;
 167.         void anzeigen();
 168.         exit(0);
 169.     }
 170. }
 171.  
 172. int main()
 173. {
 174.     tic_tac_toe tic;
 175.     while(1)
 176.     {
 177.         tic.anzeigen();
 178.         tic.Spieler1_zug();
 179.         tic.gewonnen_s1();
 180.         tic.anzeigen();
 181.         tic.Spieler2_zug();
 182.         tic.gewonnen_s2();
 183.     }
 184. }

Gib mal Beispiele wo das passiert. Noch was:

Bitte das nächste mal die Zeilenzahlen entfernen....
2)Das Programm hat noch mehr Bugs: überschreitung der Zeilen und Spaltengrenzen wird nicht überprüft; man kann die felder so oft wie man will belegen

volkard

und
void anzeigen();
statt
anzeigen();
bei der benutzung von anzeigen.

und exit(0) muss auch irgendwann weg.

ReALITY5

Der Bug mit dem 2fach Zug Passiert, wenn man folgende felder belegt

. x x
. . .
x x .

x steht für die bug felder

Das mit der Prüfung auf Feldüberschreitung und Feldbelegung will ich danach machen, wenn ich weiss, das es funktioniert

volkard

ReALITY5 schrieb:

Das mit der Prüfung auf Feldüberschreitung und Feldbelegung will ich danach machen, wenn ich weiss, das es funktioniert

machs kleich. feldgrenzenüberschreitung kann nähmlich dran schult sein.

He ich will ja nix sagen aba wäre es nicht sinvoller anstatt der ganzen if-clauses lieber zu checken ob ne lineare Funktion möglich is bzw.:

wenn 1 1 besetzt is und 2 3 auch (also vom Gegner) dann die differenz, (1/2),zum zweiten Vektor dazuaddieren und schauen ob das Feld besetzt ist, wenn nicht dann einen drauf setzen.

und immer alle Punkte so überprüfen.

mfg, hoffe ich habs gut genug erklärt

ahaja und eben auch checken ob das feld zu den neun erlaubten Feldern gehört.

Airdamn

char Spielfeld[2][2];

das sind 2x2 Felder, Du brauchst aber 3x3

ReALITY5

Airdamn schrieb:

char Spielfeld[2][2];
das sind 2x2 Felder, Du brauchst aber 3x3

Das nullte array element wird doch mit gezählt, oder?

Stimmt ja, bei einem char array wird das letze element für die binäre 0 verwendet

volkard

ReALITY5 schrieb:

Airdamn schrieb:
char Spielfeld[2][2];
das sind 2x2 Felder, Du brauchst aber 3x3
Das nullte array element wird doch mit gezählt, oder?

ja, aber nicht das mit index 2.
Airdamn hat den fehler gefunden, wüde ich sagen.

Airdamn

char feld[2]; // sind 2 chars
// Zugriff
feld[0] = 'x';
feld[1] = 'o';

beim anlegen von Arrays gibst Du die Größe des Arrays an.
Beim Zugriff beginnt der Index bei 0 und endet bei n-1, wobei n die Größe des Arrays ist.

camper

ReALITY5 schrieb:

Airdamn schrieb:
char Spielfeld[2][2];
das sind 2x2 Felder, Du brauchst aber 3x3
Das nullte array element wird doch mit gezählt, oder?

es gibt kein 'nulltes' element, wohl aber eines mit dem index 0 (das wäre das erste element). umgekehrt wird der index aber nur bis 1 - die dimensionsangaben bei der deklaration bestimmen die anzahl der elemente, nicht den höchsten index.

ReALITY5

Wenn ich jetzt eine abfrage machen will, ob das feld belegt ist, verfängt sich das in einer endlosschleife, die funktion folgt:

void tic_tac_toe::Spieler2_zug()
{
	int reihe=0;
	int spalte=0;
	while(Spielfeld[reihe-1][spalte-1]=='x')
	{
	cout<<"Reihe: ";
	cin>>reihe;
	cout<<"Spalte: ";
	cin>>spalte;
	}
	Spielfeld[reihe-1][spalte-1]=='y';
}

volkard

ich denke eher an

void tic_tac_toe::Spieler2_zug()
{
	int reihe=0;
	int spalte=0;
	do	{
	cout<<"Reihe: ";
	cin>>reihe;
	cout<<"Spalte: ";
	cin>>spalte;
	}while(reihe>=1 && reihe<=3 && spalte>=1 && spalte <=3 && Spielfeld[reihe-1][spalte-1]!='y')
	Spielfeld[reihe-1][spalte-1]=='y';
}

Airdamn

@ReALITY:

Spielfeld[reihe-1][spalte-1]=='y';

ist ein Vergleich, keine Zuweisung...vielleicht solltest Du Deinen Code mal genauer angucken :p

ReALITY5

Der will jetzt immer noch net, jetzt is die ganze Zeit Spieler 1 am Zug

void tic_tac_toe::Spieler1_zug()
{
    int reihe=0;
    int spalte=0;
    while(Spielfeld[reihe-1][spalte-1]=='o')
    {
    cout<<"Reihe: ";
    cin>>reihe;
    cout<<"Spalte: ";
    cin>>spalte;
    }
    Spielfeld[reihe-1][spalte-1]='x';
}

ReALITY5

Ich habe das Problem gelöst mit der mehrfachbelegung und dem abfragen ob das feld schon belegt ist bzw ob das feld überhapt in der aaray grenze ist. Für alle die auch ein tic tac toe implementieren wollen hier meine implementierung

#include<iostream>
#include<iomanip>
using namespace std;

class tic_tac_toe
{
private:
	char Spielfeld[3][3];
public:
	void Spieler1_zug();
	void Spieler2_zug();
	void anzeigen();
	void gewonnen_s1();
	void gewonnen_s2();
	int check2(int reihe,int spalte);
	int check1(int reihe,int spalte);
	tic_tac_toe();
};

tic_tac_toe::tic_tac_toe()
{
	Spielfeld[0][0]='.';
	Spielfeld[0][1]='.';
	Spielfeld[0][2]='.';
	Spielfeld[1][0]='.';
	Spielfeld[1][1]='.';
	Spielfeld[1][2]='.';
	Spielfeld[2][0]='.';
	Spielfeld[2][1]='.';
	Spielfeld[2][2]='.';
}

void tic_tac_toe::Spieler1_zug()
{
    int reihe=0;
    int spalte=0;
    while(reihe<1 || reihe>3 || spalte<1 || spalte>3 || Spielfeld[reihe-1][spalte-1]=='o' || Spielfeld[reihe-1][spalte-1]=='x')
    {
    cout<<"Reihe: ";
    cin>>reihe;
    cout<<"Spalte: ";
    cin>>spalte;
    }
    Spielfeld[reihe-1][spalte-1]='x';
}

void tic_tac_toe::Spieler2_zug()
{
    int reihe=0;
    int spalte=0;
    while(reihe<1 || reihe>3 || spalte<1 || spalte>3 || Spielfeld[reihe-1][spalte-1]=='o' || Spielfeld[reihe-1][spalte-1]=='x')
    {
    cout<<"Reihe: ";
    cin>>reihe;
    cout<<"Spalte: ";
    cin>>spalte;
    }
    Spielfeld[reihe-1][spalte-1]='o';
}

void tic_tac_toe::anzeigen()
{
	int i;
	int y;
	for(i=0;i<3;i++)
	{
		for(y=0;y<3;y++)
		{
			cout<<setw(2)<<Spielfeld[y][i];
		}
		cout<<"\n\n";
	}
}

void tic_tac_toe::gewonnen_s2()
{
	if(Spielfeld[0][0]=='o' && Spielfeld[0][1]=='o' && Spielfeld[0][2]=='o')
	{
		cout<<"Spieler 2 hat gewonnen!"<<endl;
		void anzeigen();
		exit(0);
	}
	if(Spielfeld[1][0]=='o' && Spielfeld[1][1]=='o' && Spielfeld[1][2]=='o')
	{
		cout<<"Spieler 2 hat gewonnen!"<<endl;
		void anzeigen();
		exit(0);
	}
	if(Spielfeld[2][0]=='o' && Spielfeld[2][1]=='o' && Spielfeld[2][2]=='o')
	{
		cout<<"Spieler 2 hat gewonnen!"<<endl;
		void anzeigen();
		exit(0);
	}
	if(Spielfeld[0][1]=='o' && Spielfeld[1][1]=='o' && Spielfeld[2][1]=='o')
	{
		cout<<"Spieler 2 hat gewonnen!"<<endl;
		void anzeigen();
		exit(0);
	}
	if(Spielfeld[0][0]=='o' && Spielfeld[1][0]=='o' && Spielfeld[2][0]=='o')
	{
		cout<<"Spieler 2 hat gewonnen!"<<endl;
		void anzeigen();
		exit(0);
	}
	if(Spielfeld[0][2]=='o' && Spielfeld[1][2]=='o' && Spielfeld[2][2]=='o')
	{
		cout<<"Spieler 2 hat gewonnen!"<<endl;
		void anzeigen();
		exit(0);
	}
	if(Spielfeld[0][0]=='o' && Spielfeld[1][1]=='o' && Spielfeld[2][2]=='o')
	{
		cout<<"Spieler 2 hat gewonnen!"<<endl;
		void anzeigen();
		exit(0);
	}
	if(Spielfeld[0][2]=='o' && Spielfeld[1][1]=='o' && Spielfeld[2][0]=='o')
	{
		cout<<"Spieler 2 hat gewonnen!"<<endl;
		void anzeigen();
		exit(0);
	}
}

void tic_tac_toe::gewonnen_s1()
{
	if(Spielfeld[0][0]=='x' && Spielfeld[0][1]=='x' && Spielfeld[0][2]=='x')
	{
		cout<<"Spieler 1 hat gewonnen!"<<endl;
		void anzeigen();
		exit(0);
	}
	if(Spielfeld[1][0]=='x' && Spielfeld[1][1]=='x' && Spielfeld[1][2]=='x')
	{
		cout<<"Spieler 1 hat gewonnen!"<<endl;
		void anzeigen();
		exit(0);
	}
	if(Spielfeld[2][0]=='x' && Spielfeld[2][1]=='x' && Spielfeld[2][2]=='x')
	{
		cout<<"Spieler 1 hat gewonnen!"<<endl;
		void anzeigen();
		exit(0);
	}
	if(Spielfeld[0][1]=='x' && Spielfeld[1][1]=='x' && Spielfeld[2][1]=='x')
	{
		cout<<"Spieler 1 hat gewonnen!"<<endl;
		void anzeigen();
		exit(0);
	}
	if(Spielfeld[0][0]=='x' && Spielfeld[1][0]=='x' && Spielfeld[2][0]=='x')
	{
		cout<<"Spieler 1 hat gewonnen!"<<endl;
		void anzeigen();
		exit(0);
	}
	if(Spielfeld[0][2]=='x' && Spielfeld[1][2]=='x' && Spielfeld[2][2]=='x')
	{
		cout<<"Spieler 1 hat gewonnen!"<<endl;
		void anzeigen();
		exit(0);
	}
	if(Spielfeld[0][0]=='x' && Spielfeld[1][1]=='x' && Spielfeld[2][2]=='x')
	{
		cout<<"Spieler 1 hat gewonnen!"<<endl;
		void anzeigen();
		exit(0);
	}
	if(Spielfeld[0][2]=='x' && Spielfeld[1][1]=='x' && Spielfeld[2][0]=='x')
	{
		cout<<"Spieler 1 hat gewonnen!"<<endl;
		void anzeigen();
		exit(0);
	}
}

int main()
{
        int i;
	tic_tac_toe tic;
	while(i=0;i<5;i++)
	{
		tic.anzeigen();
		tic.Spieler1_zug();
		tic.gewonnen_s1();
		tic.anzeigen();
		tic.Spieler2_zug();
		tic.gewonnen_s2();
	}
}

Verbesserungsvorschläge nehm ich gerne an

Ob aus dem Prog noch was wird....

1)Plz for(i=0;i<5;i++) statt while(i=0;i<5;i++) und du könntest das i auch im schleifenkopf deklarieren: for(int i=0;i<5;i++)

2)Ich würde das Reihen Spalten ändern: Reihe ist Vertical Spalte Horizontal

3)es gibt kein Unentschieden

4)gebt mal statt ner zahl zB g+ ein

volkard

ich würde ein array mit 10 elementen nehmen, und das element ann der stelle 0 ungenutzt lassen.
und zwar in folgender bedeutung:
789
456
123
das ist zufällig absichtlich auch die anordnung auf dem ziffernblock der tastatur und damit recht benutzerfreundlich.
linien kann man definieren mit startpunkt und richtung.
123= 1 1
456= 4 1
789= 7 1
147= 1 3
258= 2 3
369= 3 3
159= 1 4
357= 3 2
klingt nach

bool testeReihe(int farbe,int start,int richtung){
   return feld[start]==farbe && feld[start+richtung]==farbe && feld[start+2*richtung]==farbe;
}
bool testeSPielfeld(int farbe){
   if(testeReihe(farbe,4,1)) return true;
...
   if(testeReihe(farbe,3,2)) return true;
   return false;
}

man kann auch die 8 reihendefinitionen in ein array tun und durch das array laufen.

bool testeReihe(int farbe,int start,int richtung){
   return feld[start]==farbe && feld[start+richtung]==farbe && feld[start+2*richtung]==farbe;
}
bool testeSPielfeld(int farbe){
   int start[8]={1,4,7,1,2,3,1,3};
   int richtung[8]={1,1,1,3,3,3,4,2};
   for(int i=0;i<8;++i)
      if(testeReihe(farbe,start[i],richtung[i]) return true;
   return false;
}

Gute Idee Volkard. Hab aber keine Zeit gehabt das in meine Version einzubauen...

#include<iostream>
#include<iomanip>

using namespace std;

struct feld
{
   feld(){isEmpty=true;}
   char ch;//Zeichen
   bool isEmpty;
};

class tic_tac_toe
{
private:
    feld Spielfeld[3][3];
public:
    void zug(char ch);
    void anzeigen();
    bool gewonnen(char ch);
    tic_tac_toe();
    bool unentschieden();
};

bool tic_tac_toe::unentschieden()
{
   for(int i=0;i<3;i++)
   {
      for(int j=0;j<3;j++)
      {
         if(Spielfeld[i][j].isEmpty) return false;
      }
   }
   return true;
}

tic_tac_toe::tic_tac_toe()
{
    Spielfeld[0][0].ch='.';
    Spielfeld[0][1].ch='.';
    Spielfeld[0][2].ch='.';
    Spielfeld[1][0].ch='.';
    Spielfeld[1][1].ch='.';
    Spielfeld[1][2].ch='.';
    Spielfeld[2][0].ch='.';
    Spielfeld[2][1].ch='.';
    Spielfeld[2][2].ch='.';
}

void tic_tac_toe::zug(char ch)
{
    int reihe=0;
    int spalte=0;
    do
    {
       cout<<"Spalte: ";
       cin>>spalte;
       cout<<"Reihe: ";
       cin>>reihe;
    }while(reihe<1 || reihe>3 || spalte<1 || spalte>3 || !Spielfeld[spalte-1][reihe-1].isEmpty);
    Spielfeld[spalte-1][reihe-1].ch=ch;
    Spielfeld[spalte-1][reihe-1].isEmpty=false;
}

void tic_tac_toe::anzeigen()
{
    int i;
    int y;
    for(i=0;i<3;i++)
    {
        for(y=0;y<3;y++)
        {
            cout<<setw(2)<<Spielfeld[y][i].ch;
        }
        cout<<"\n\n";
    }
}

bool tic_tac_toe::gewonnen(char ch)
{
    if(Spielfeld[0][0].ch==ch && Spielfeld[0][1].ch==ch && Spielfeld[0][2].ch==ch)
    {
        return true;
    }
    if(Spielfeld[1][0].ch==ch && Spielfeld[1][1].ch==ch && Spielfeld[1][2].ch==ch)
    {
        return true;        
    }
    if(Spielfeld[2][0].ch==ch && Spielfeld[2][1].ch==ch && Spielfeld[2][2].ch==ch)
    {
        return true;        
    }
    if(Spielfeld[0][1].ch==ch && Spielfeld[1][1].ch==ch && Spielfeld[2][1].ch==ch)
    {
        return true;       
    }
    if(Spielfeld[0][0].ch==ch && Spielfeld[1][0].ch==ch && Spielfeld[2][0].ch==ch)
    {
        return true;        
    }
    if(Spielfeld[0][2].ch==ch && Spielfeld[1][2].ch==ch && Spielfeld[2][2].ch==ch)
    {
       return true;       
    }
    if(Spielfeld[0][0].ch==ch && Spielfeld[1][1].ch==ch && Spielfeld[2][2].ch==ch)
    {
       return true;        
    }
    if(Spielfeld[0][2].ch==ch && Spielfeld[1][1].ch==ch && Spielfeld[2][0].ch==ch)
    {
       return true;        
    }
    return false;
}

int main()
{
    tic_tac_toe tic;
    while(true)
    {
        tic.anzeigen();
        tic.zug('x');
        if(tic.gewonnen('x'))
        {
            cout<<"Spieler 1 hat gewonnen!"<<endl;
            void anzeigen();
            break;
        }
        if(tic.unentschieden())
        {
            cout<<"Unentschieden!"<<endl;
            void anzeigen();
            break;
        }

        tic.anzeigen();
        tic.zug('o');
        if(tic.gewonnen('o'))
        {
            cout<<"Spieler 2 hat gewonnen!"<<endl;
            void anzeigen();
            break;
        }
        if(tic.unentschieden())
        {
            cout<<"Unentschieden!"<<endl;
            void anzeigen();
            break;
        }

    }
    cin.ignore();
    getchar();
    return 0;
}

volkard

ein paar gedanken dazu, die meisten sicherlich schlecht. es geht nur ums ausloten.

#include<iostream>
#include<iomanip>

using namespace std;

struct feld
{
   feld(){isEmpty=true;}
   char ch;//Zeichen
   bool isEmpty;
};
//ch überladen und dreiwertig machen
/*struct feld
{
   feld(){ch='.';)
   char ch;
};*/

class tic_tac_toe
{
private:
    feld Spielfeld[3][3];//andere anordnung, wie bereits gesagt
//    int anzahl;
public:
    void zug(char ch);
    void anzeigen();
    bool gewonnen(char ch);
    tic_tac_toe();
    bool unentschieden();
};

bool tic_tac_toe::unentschieden()
{
   //return anzahl==9
   for(int i=0;i<3;i++)
   {
      for(int j=0;j<3;j++)
      {
         if(Spielfeld[i][j].isEmpty) return false;
      }
   }
   return true;
}

tic_tac_toe::tic_tac_toe()
{
//passiert schon im ctor von feld
    Spielfeld[0][0].ch='.';
    Spielfeld[0][1].ch='.';
    Spielfeld[0][2].ch='.';
    Spielfeld[1][0].ch='.';
    Spielfeld[1][1].ch='.';
    Spielfeld[1][2].ch='.';
    Spielfeld[2][0].ch='.';
    Spielfeld[2][1].ch='.';
    Spielfeld[2][2].ch='.';
}

//bool range(int min,int x,int max){return min<=x && x<=max)

void tic_tac_toe::zug(char ch)
{
    int reihe=0;
    int spalte=0;
    do
    {
       cout<<"Spalte: ";
       cin>>spalte;
       cout<<"Reihe: ";
       cin>>reihe;
    }while(reihe<1 || reihe>3 || spalte<1 || spalte>3 || !Spielfeld[spalte-1][reihe-1].isEmpty);
//while(range(1,reihe,3) || range(1,spalte,3) || Spielfeld[spalte-1][reihe-1]!='.');
    Spielfeld[spalte-1][reihe-1].ch=ch;
//weg    Spielfeld[spalte-1][reihe-1].isEmpty=false;
//++anzahl
}

void tic_tac_toe::anzeigen()
{
//    int i;
//    int y;
    for(/*int */i=0;i<3;i++)//besser x?
    {
        for(/*int */y=0;y<3;y++)
        {
            cout<<setw(2)<<Spielfeld[y][i].ch;
        }
        cout<<"\n\n";
    }
}

bool tic_tac_toe::gewonnen(char ch)
{//einfacher machen, das return ist viel guter als exit
    if(Spielfeld[0][0].ch==ch && Spielfeld[0][1].ch==ch && Spielfeld[0][2].ch==ch)
    {
        return true;
    }
    if(Spielfeld[1][0].ch==ch && Spielfeld[1][1].ch==ch && Spielfeld[1][2].ch==ch)
    {
        return true;        
    }
    if(Spielfeld[2][0].ch==ch && Spielfeld[2][1].ch==ch && Spielfeld[2][2].ch==ch)
    {
        return true;        
    }
    if(Spielfeld[0][1].ch==ch && Spielfeld[1][1].ch==ch && Spielfeld[2][1].ch==ch)
    {
        return true;       
    }
    if(Spielfeld[0][0].ch==ch && Spielfeld[1][0].ch==ch && Spielfeld[2][0].ch==ch)
    {
        return true;        
    }
    if(Spielfeld[0][2].ch==ch && Spielfeld[1][2].ch==ch && Spielfeld[2][2].ch==ch)
    {
       return true;       
    }
    if(Spielfeld[0][0].ch==ch && Spielfeld[1][1].ch==ch && Spielfeld[2][2].ch==ch)
    {
       return true;        
    }
    if(Spielfeld[0][2].ch==ch && Spielfeld[1][1].ch==ch && Spielfeld[2][0].ch==ch)
    {
       return true;        
    }
    return false;
}

int main()
{
    tic_tac_toe tic;
    while(true)//for(;;)
    {
        tic.anzeigen();
        tic.zug('x');
        if(tic.gewonnen('x'))
        {
            cout<<"Spieler 1 hat gewonnen!"<<endl;
//wirkungslos             void anzeigen();
            break;
//return statt break, also diese schleife aus der main() raus
        }
        if(tic.unentschieden())
        {
            cout<<"Unentschieden!"<<endl;
            void anzeigen();
            break;
        }

        tic.anzeigen();
        tic.zug('o');
        if(tic.gewonnen('o'))
        {
            cout<<"Spieler 2 hat gewonnen!"<<endl;
            void anzeigen();
            break;
        }
        if(tic.unentschieden())
        {
            cout<<"Unentschieden!"<<endl;
            void anzeigen();
            break;
        }

    }
    cin.ignore();
    getchar();
    return 0;
}