3. Problem bei 4 gewinnt implementierung

Problem bei 4 gewinnt implementierung

  • R

    Ich habe ein Problem mit einer 4 gewinnt implementierung.der quelltext folgt

    #include<iostream>
using namespace std;

int gewonnen_s1(int feld[7][6],int s,int r);
int gewonnen_s2(int feld[7][6],int s,int r);

int main()
{
    int reihe,spalte;
    int spielfeld[7][6]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
    while(1)
    {
	cout<<"\nGeben sie ihre Spalte und Reihe ein, Spieler 1: \n";
	cout<<"\nSpalte: \n";
	cin>>spalte;
	cout<<"\nReihe: \n";
	cin>>reihe;
	while(spielfeld[spalte][reihe]!=0)
	{
	    cout<<"\nDieses Feld ist schon belegt\n";
	    cout<<"\nSpalte: \n";
	    cin>>spalte;
	    cout<<"\nReihe: \n";
	    cin>>reihe;
	}
	spielfeld[spalte][reihe]=1;
	int gewonnen_s1(spielfeld[7][6],spalte,reihe);
	cout<<"\nGeben sie ihre Spalte und Reihe ein, Spieler 2: \n";
	cout<<"\nSpalte: \n";
	cin>>spalte;
	cout<<"\nReihe: \n";
	cin>>reihe;
	while(spielfeld[spalte][reihe]!=0)
	{
	    cout<<"\nDieses Feld ist schon belegt\n";
	    cout<<"\nSpalte: \n";
	    cin>>spalte;
	    cout<<"\nReihe: \n";
	    cin>>reihe;
	}
	spielfeld[spalte][reihe]=2;
	int gewonnen_s2(spielfeld[7][6],spalte,reihe);
    }
}

int gewonnen_s2(int feld[7][6],int s, int r)
{
    if(feld[s][r]==2 && feld[s+1][r]==2 && feld[s+2][r]==2 && feld[s+3][r]==2)
    {
	cout<<"Spieler 2 hat gewonnen!";
    }
    if(feld[s][r]==2 && feld[s-1][r]==2 && feld[s-2][r]==2 && feld[s-3][r]==2)
    {
	cout<<"Spieler 2 hat gewonnen!";
    }
    if(feld[s][r]==2 && feld[s][r+1]==2 && feld[s][r+2]==2 && feld[s][r+3]==2)
    {
	cout<<"Spieler 2 hat gewonnen!";
    }
    if(feld[s][r]==2 && feld[s][r-1]==2 && feld[s][r-2]==2 && feld[s][r-3]==2)
    {
	cout<<"Spieler 2 hat gewonnen!";
    }
    if(feld[s][r]==2 && feld[s+1][r+1]==2 && feld[s+2][r+2]==2 && feld[s+3][r+3]==2)
    {
	cout<<"Spieler 2 hat gewonnen!";
    }
    if(feld[s][r]==2 && feld[s+1][r+1]==2 && feld[s+2][r+2]==2 && feld[s+3][r+3]==2)
    {
	cout<<"Spieler 1 hat gewonnen!";
    }
    return 0;
}

int gewonnen_s1(int feld[7][6],int s, int r)
{
    if(feld[s][r]==1 && feld[s+1][r]==1 && feld[s+2][r]==1 && feld[s+3][r]==1)
    {
	cout<<"Spieler 1 hat gewonnen!";
    }
    if(feld[s][r]==1 && feld[s-1][r]==1 && feld[s-2][r]==1 && feld[s-3][r]==1)
    {
	cout<<"Spieler 1 hat gewonnen!";
    }
    if(feld[s][r]==1 && feld[s][r+1]==1 && feld[s][r+2]==1 && feld[s][r+3]==1)
    {
	cout<<"Spieler 1 hat gewonnen!";
    }
    if(feld[s][r]==1 && feld[s][r-1]==1 && feld[s][r-2]==1 && feld[s][r-3]==1)
    {
	cout<<"Spieler 1 hat gewonnen!";
    }
    if(feld[s][r]==1 && feld[s+1][r+1]==1 && feld[s+2][r+2]==1 && feld[s+3][r+3]==1)
    {
	cout<<"Spieler 1 hat gewonnen!";
    }
    if(feld[s][r]==1 && feld[s+1][r+1]==1 && feld[s+2][r+2]==1 && feld[s+3][r+3]==1)
    {
	cout<<"Spieler 1 hat gewonnen!";
    }
    return 0;
}

    Bitte macht mich nicht auf die endlosschleife aufmerksam, das weiss ich schon.
    der Gcc gibt folgende fehlermeldung aus

    vier_gewinnt.cpp:27: error: initializer expression list treated as compound expression
    vier_gewinnt.cpp:42: error: initializer expression list treated as compound expression
    make: *** [vier_gewinnt] Fehler 1

    0
  • M
     

    int gewonnen_s1(spielfeld[7][6],spalte,reihe);

    Wenn du spielfeld als Parameter übergibst, brauchst du nicht mehr die Dimensionen dahinterzuschreiben.

    0
  • R

    Immer noch der gleiche fehler obwohl ich die dimensionen rausgenommen hab

    0
  • M

    Naja, immerhin schon mal den Fehler rausgemacht, der dir als nächstes um die Ohren geflogen wär ^^

    Bei einem Funktionsaufruf schreibt man kein int davor, wie du es hier gemacht hast:

    int gewonnen_s1(spielfeld,spalte,reihe);

    Du kannst entweder den Rückgabewert fallen lassen

    gewonnen_s1(spielfeld,spalte,reihe);

    oder in einer Variable abspeichern:

    int foo = gewonnen_s1(spielfeld,spalte,reihe);
    0

  • Du solltest zusätzlich den Typ int vor deinen Funktionsaufrufen entfernen!

    BTW: warum geben deine beiden Funktionen eigentlich etwas zurück!?

    Greetz, Swordfish

    [edit] argh. zu langsam. [/edit]

    0
  • R

    Ich habe es vorher mit void versucht, dachte vielleicht nützt es was wenn sie 0 zurückgeben. Dann habe ich es versucht mit einer Pointer übergabe als parameter, dabei meinte der das int[int] sich net verträgt

    0

  • ReALITY5 schrieb:

    [...] dachte vielleicht nützt es was wenn sie 0 zurückgeben [...]

    wieso sollte das was ändern?

    Greetz, Swordfish

    0
  • R

    nachdem ich die dimensionen rausgenommen habe meldet sich der gcc wie folg:

    wladimir@PC:~/Desktop/C> make vier_gewinnt
g++     vier_gewinnt.cpp   -o vier_gewinnt
vier_gewinnt.cpp:102:2: warning: no newline at end of file
vier_gewinnt.cpp: In function ‘int main()’:
vier_gewinnt.cpp:27: error: initializer expression list treated as compound expression
vier_gewinnt.cpp:42: error: initializer expression list treated as compound expression
vier_gewinnt.cpp: In function ‘int gewonnen_s2(int, int, int)’:
vier_gewinnt.cpp:48: error: invalid types ‘int[int]’ for array subscript
vier_gewinnt.cpp:48: error: invalid types ‘int[int]’ for array subscript
vier_gewinnt.cpp:48: error: invalid types ‘int[int]’ for array subscript
vier_gewinnt.cpp:48: error: invalid types ‘int[int]’ for array subscript
vier_gewinnt.cpp:52: error: invalid types ‘int[int]’ for array subscript
vier_gewinnt.cpp:52: error: invalid types ‘int[int]’ for array subscript
vier_gewinnt.cpp:52: error: invalid types ‘int[int]’ for array subscript
vier_gewinnt.cpp:52: error: invalid types ‘int[int]’ for array subscript
vier_gewinnt.cpp:56: error: invalid types ‘int[int]’ for array subscript
vier_gewinnt.cpp:56: error: invalid types ‘int[int]’ for array subscript
vier_gewinnt.cpp:56: error: invalid types ‘int[int]’ for array subscript
vier_gewinnt.cpp:56: error: invalid types ‘int[int]’ for array subscript
vier_gewinnt.cpp:60: error: invalid types ‘int[int]’ for array subscript
vier_gewinnt.cpp:60: error: invalid types ‘int[int]’ for array subscript
vier_gewinnt.cpp:60: error: invalid types ‘int[int]’ for array subscript
vier_gewinnt.cpp:60: error: invalid types ‘int[int]’ for array subscript
vier_gewinnt.cpp:64: error: invalid types ‘int[int]’ for array subscript
vier_gewinnt.cpp:64: error: invalid types ‘int[int]’ for array subscript
vier_gewinnt.cpp:64: error: invalid types ‘int[int]’ for array subscript
vier_gewinnt.cpp:64: error: invalid types ‘int[int]’ for array subscript
vier_gewinnt.cpp:68: error: invalid types ‘int[int]’ for array subscript
vier_gewinnt.cpp:68: error: invalid types ‘int[int]’ for array subscript
vier_gewinnt.cpp:68: error: invalid types ‘int[int]’ for array subscript
vier_gewinnt.cpp:68: error: invalid types ‘int[int]’ for array subscript
make: *** [vier_gewinnt] Fehler 1
    0
  • M

    Die Funktionsdeklarationen und -definitionen darfst du natürlich nicht so verändern. Es muss ja ein Hinweis darauf bleiben, dass du kein einzelnes int-Objekt, sondern ein zweidimensionales Feld von int-Objekten übergeben willst.

    0
  • R

    Ich habe dann jetzt die prototypen in wie folgt geänder

    #include<iostream>
using namespace std;

void gewonnen_s1(int feld[][],int s,int r);
void gewonnen_s2(int feld[][],int s,int r);
    0
  • M

    Wenn du ne Fehlermeldung bekommst, wärs nett, uns das auch mitzuteilen.

    Dein Code kompiliert, wenn du nur die zwei Zeilen änderst, in denen du deine Funktionen aufrufst.

    #include <iostream>
using namespace std;

int gewonnen_s1(int feld[7][6],int s,int r);
int gewonnen_s2(int feld[7][6],int s,int r);

int main()
{
    int reihe,spalte;
    int spielfeld[7][6]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
    while(1)
    {
    cout<<"\nGeben sie ihre Spalte und Reihe ein, Spieler 1: \n";
    cout<<"\nSpalte: \n";
    cin>>spalte;
    cout<<"\nReihe: \n";
    cin>>reihe;
    while(spielfeld[spalte][reihe]!=0)
    {
        cout<<"\nDieses Feld ist schon belegt\n";
        cout<<"\nSpalte: \n";
        cin>>spalte;
        cout<<"\nReihe: \n";
        cin>>reihe;
    }
    spielfeld[spalte][reihe]=1;
    gewonnen_s1(spielfeld,spalte,reihe);    // Änderung 1
    cout<<"\nGeben sie ihre Spalte und Reihe ein, Spieler 2: \n";
    cout<<"\nSpalte: \n";
    cin>>spalte;
    cout<<"\nReihe: \n";
    cin>>reihe;
    while(spielfeld[spalte][reihe]!=0)
    {
        cout<<"\nDieses Feld ist schon belegt\n";
        cout<<"\nSpalte: \n";
        cin>>spalte;
        cout<<"\nReihe: \n";
        cin>>reihe;
    }
    spielfeld[spalte][reihe]=2;
    gewonnen_s2(spielfeld,spalte,reihe);    // Änderung 2
    }
}

int gewonnen_s2(int feld[7][6],int s, int r)
{
    if(feld[s][r]==2 && feld[s+1][r]==2 && feld[s+2][r]==2 && feld[s+3][r]==2)
    {
    cout<<"Spieler 2 hat gewonnen!";
    }
    if(feld[s][r]==2 && feld[s-1][r]==2 && feld[s-2][r]==2 && feld[s-3][r]==2)
    {
    cout<<"Spieler 2 hat gewonnen!";
    }
    if(feld[s][r]==2 && feld[s][r+1]==2 && feld[s][r+2]==2 && feld[s][r+3]==2)
    {
    cout<<"Spieler 2 hat gewonnen!";
    }
    if(feld[s][r]==2 && feld[s][r-1]==2 && feld[s][r-2]==2 && feld[s][r-3]==2)
    {
    cout<<"Spieler 2 hat gewonnen!";
    }
    if(feld[s][r]==2 && feld[s+1][r+1]==2 && feld[s+2][r+2]==2 && feld[s+3][r+3]==2)
    {
    cout<<"Spieler 2 hat gewonnen!";
    }
    if(feld[s][r]==2 && feld[s+1][r+1]==2 && feld[s+2][r+2]==2 && feld[s+3][r+3]==2)
    {
    cout<<"Spieler 1 hat gewonnen!";
    }
    return 0;
}

int gewonnen_s1(int feld[7][6],int s, int r)
{
    if(feld[s][r]==1 && feld[s+1][r]==1 && feld[s+2][r]==1 && feld[s+3][r]==1)
    {
    cout<<"Spieler 1 hat gewonnen!";
    }
    if(feld[s][r]==1 && feld[s-1][r]==1 && feld[s-2][r]==1 && feld[s-3][r]==1)
    {
    cout<<"Spieler 1 hat gewonnen!";
    }
    if(feld[s][r]==1 && feld[s][r+1]==1 && feld[s][r+2]==1 && feld[s][r+3]==1)
    {
    cout<<"Spieler 1 hat gewonnen!";
    }
    if(feld[s][r]==1 && feld[s][r-1]==1 && feld[s][r-2]==1 && feld[s][r-3]==1)
    {
    cout<<"Spieler 1 hat gewonnen!";
    }
    if(feld[s][r]==1 && feld[s+1][r+1]==1 && feld[s+2][r+2]==1 && feld[s+3][r+3]==1)
    {
    cout<<"Spieler 1 hat gewonnen!";
    }
    if(feld[s][r]==1 && feld[s+1][r+1]==1 && feld[s+2][r+2]==1 && feld[s+3][r+3]==1)
    {
    cout<<"Spieler 1 hat gewonnen!";
    }
    return 0;
}
    0

  • ReALITY5 schrieb:

    Ich habe dann jetzt die Prototypen in wie folgt geändert:

    #include <iostream>
using namespace std;

void gewonnen_s1( int feld[][], int s, int r );
void gewonnen_s2( int feld[][], int s, int r );

    Nein.

    // Deklaration:
void gewonnen_s1( int feld[ 7 ][ 6 ], int s, int r );

// Definition:

void gewonnen_s1( int feld[ 7 ][ 6 ], int s, int r )
{
    if( feld[ s ][ r ] == 1 && feld[ s + 1 ][ r ] == 1 && feld[ s + 2 ][ r ] == 1 && feld[ s + 3 ][ r ] == 1 )
        cout << "Spieler 1 hat gewonnen!";

    if( feld[ s ][ r ] == 1 && feld[ s - 1 ][ r ] == 1 && feld[ s - 2 ][ r ] == 1 && feld[ s - 3 ][ r ] == 1 )
        cout << "Spieler 1 hat gewonnen!";

    if( feld[ s ][ r ] == 1 && feld[ s ][ r+1 ] == 1 && feld[ s ][ r + 2 ] == 1 && feld[ s ][ r + 3 ] == 1 )
        cout << "Spieler 1 hat gewonnen!";

    if( feld[ s ][ r ] == 1 && feld[ s ][ r - 1 ] == 1 && feld[ s ][ r - 2 ] == 1 && feld[ s ][ r - 3 ] == 1 )
        cout << "Spieler 1 hat gewonnen!";

    if( feld[ s ][ r ] == 1 && feld[ s + 1 ][ r + 1 ] == 1 && feld[ s + 2 ][ r + 2 ] == 1 && feld[ s + 3 ][ r + 3 ] == 1 )
        cout << "Spieler 1 hat gewonnen!";

    if( feld[ s ][ r ] == 1 && feld[ s + 1 ][ r + 1 ] == 1 && feld[ s + 2 ][ r + 2 ] == 1 && feld[ s + 3 ][ r + 3 ] == 1 )
        cout << "Spieler 1 hat gewonnen!";
}

// Aufruf:

gewonnen_s1( spielfeld, spalte, reihe );

    Aber IMHO sind deine Tests, ob ein Spieler gewonnen hat, nicht besonders elegant implementiert.

    Greetz, Swordfish

    0
  • R

    Dein Beitrag war fehler frei. Mein fehler war es entweder überall die dimensionen rauszunehmen oder sie überall reinzuschreiben, thx nochmal 🙂

    das war mein erstesmal das ich was mit matrizen gemacht habe

    0
  • M

    Swordfish schrieb:

    Nein.

    Ich hoff ja mal, dass du vier Minuten für den Beitrag gebraucht hast und dich somit nicht auf mich beziehst, oder?

    0

  • Nein, siehe edit: quote.

    Greetz, Swordfish

    0
  • R

    Ihr meintet doch das meine Prüfung auf den Sieg schlecht implentiert ist, könnt ihr mir sagen wie ich es besser implementieren könnte?

    0
  • W

    Hallo,

    Ich habe es mir nicht angeguckt, aber es sollte in einer Schleife besser gehen.

    MFG winexec*

    0
  • M
     

    enum Direction { up = -6, down = 6, left = -1, right = 1, upRight = -5, upLeft = -7, downRight = 7, downLeft = 5 };

int getNOfEqual(int feld[7][6], int x, int y, Direction dir)
{
	int counter = 0;
	while(6*x+y + (counter+1)*dir < 42 && 6*x+y + (counter+1)*dir > -1 && *(*feld + (6*x+y + (counter+1)*dir)) == feld[x][y])
		++counter;

	return counter;
}

bool hasWon(int feld[7][6], int x, int y)
{
	if(getNOfEqual(feld, x, y, up) + getNOfEqual(feld, x, y, down) > 2)
		return true;

	if(getNOfEqual(feld, x, y, left) + getNOfEqual(feld, x, y, right) > 2)
		return true;

	if(getNOfEqual(feld, x, y, upRight) + getNOfEqual(feld, x, y, downLeft) > 2)
		return true;

	if(getNOfEqual(feld, x, y, upLeft) + getNOfEqual(feld, x, y, downRight) > 2)
		return true;
}

    Schöner find ich das zwar nicht, es deckt aber im Gegensatz zu deiner Implementation alle Fälle ab.

    0
  • R

    Als sagte Michael E.:

    class Gameboard
{
public:
...
  // besser zu einkapseln
  int grid[7][6];
};

void foo(Gameboard& board)
{
  board.grid[1][2] = 3;
}

void test()
{
  Gameboard gameboard;
  foo(gameboard);
}
    0

  • @Michael E.: Jaaaa, das nenn ich elegant 👍 😉
    @RoboTact: Hä?

    Greetz, Swordfish

    0
Anmelden zum Antworten