Problem bei 4 gewinnt implementierung

[ReALITY5]

Immer noch der gleiche fehler obwohl ich die dimensionen rausgenommen hab

[Michael E.]

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);

[Swordfish]

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]

[ReALITY5]

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

[Swordfish]

ReALITY5 schrieb:

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

wieso sollte das was ändern?

Greetz, Swordfish

[ReALITY5]

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

[Michael E.]

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.

[ReALITY5]

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);

[Michael E.]

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;
}

[Swordfish]

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

[ReALITY5]

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

[Michael E.]

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?

[Swordfish]

Nein, siehe edit: quote.

Greetz, Swordfish

[ReALITY5]

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?

[winexec*]

Hallo,

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

MFG winexec*

[Michael E.]

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.

[RoboTact]

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);
}

[Swordfish]

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

Greetz, Swordfish

[Michael E.]

Swordfish schrieb:

@Michael E.: Jaaaa, das nenn ich elegant

Es ist halt ne beschissene Abfrage, das geht nicht elegant

@RoboTact: Hä?

Ich denk mal, das ist ne wörtliche Übersetzung von "As Michael E. said".

[*D*Evil]

Hmm insgesammt könnte man das auch einfach so lösen... k die If könnte man wirklich durch ne Schleife ersetzen... aber ansonnsten:

// 4Win.cpp
#include <iostream>
#include <tchar.h>
#include <conio.h>

int    Close(int** /*ppField*/);
bool   IsPlayerWinner(int /*nPlayer*/, int** /*ppField*/, const int /*nCol*/, const int /*nRow*/, TCHAR* /*lpszPlayername*/);

int _tmain(int /*argc*/, _TCHAR** /*argv*/)
{
	TCHAR	cPlayer1[512];
	TCHAR	cPlayer2[512];
	int		nFieldMax	= 0;
	int**	ppField		= NULL;

	std::cout << _T("=================================================================") << std::endl;
	std::cout << _T("=		Herzlich Willkommen bei 4-Gewinnt		=") << std::endl;
	std::cout << _T("=================================================================\n") << std::endl;
	std::cout << _T("		1. Spieler: ");
	std::cin >> cPlayer1;
	std::cout << _T("		2. Spieler: ");
	std::cin >> cPlayer2;
	std::cout << _T("		Spielfeldumfang (4 - 100): ");
	std::cin >> nFieldMax;

	if (nFieldMax < 4 || nFieldMax > 100)
	{
		std::cout << _T("		Die Eingaben waren nicht korrekt!") << std::endl;
		return (Close(ppField));
	}

	std::cout << _T("\n") << std::endl;

	ppField = new int*[nFieldMax];

	for (int n = 0; n < nFieldMax; ++n)
	{
		ppField[n] = new int[nFieldMax];

		for (int j = 0; j < nFieldMax; ++j)
			ppField[n][j] = 0;
	}

	int		nRow	= 0;
	int		nCol	= 0;

	while (true)
	{
		std::cout << _T("		Geben sie ihre Spalte und Reihe ein, ") << cPlayer1 << std::endl; 
		std::cout << _T("		- Spalte: "); 
		std::cin >> nCol; 
		std::cout << _T("		- Reihe: "); 
		std::cin >> nRow;

		while (nCol > nFieldMax || nRow > nFieldMax || ppField[nCol][nRow] != 0) 
		{ 
			std::cout << _T("		In dieses Feld wurde bereits belegt. Bitte geben Sie ein anderes Feld an!") << std::endl; 
			std::cout << _T("		- Spalte: "); 
			std::cin >> nCol; 
			std::cout << _T("		- Reihe: "); 
			std::cin >> nRow; 
		} 

		ppField[nCol][nRow]		= 1; 

		if (IsPlayerWinner(1, ppField, nCol, nRow, cPlayer1))
			break;

		std::cout << _T("		Geben sie ihre Spalte und Reihe ein, ") << cPlayer2 << std::endl; 
		std::cout << _T("		- Spalte: "); 
		std::cin >> nCol; 
		std::cout << _T("		- Reihe: "); 
		std::cin >> nRow;

		while (nCol > nFieldMax || nRow > nFieldMax || ppField[nCol][nRow] != 0) 
		{ 
			std::cout << _T("		In dieses Feld wurde bereits belegt. Bitte geben Sie ein anderes Feld an!") << std::endl; 
			std::cout << _T("		- Spalte: "); 
			std::cin >> nCol; 
			std::cout << _T("		- Reihe: "); 
			std::cin >> nRow; 
		} 

		ppField[nCol][nRow]		= 2; 

		if (IsPlayerWinner(2, ppField, nCol, nRow, cPlayer2))
			break; 
	}

	return (Close(ppField));
}

int Close(int** ppField)
{
	if (ppField)
		delete [] ppField;

	getch();
    return 0;
}

bool IsPlayerWinner(int nPlayer, int** ppField, const int nCol, const int nRow, TCHAR* lpszPlayername)
{ 
    if ((ppField[nCol][nRow] == nPlayer && ppField[nCol + 1][nRow] == nPlayer && ppField[nCol + 2][nRow] == nPlayer && ppField[nCol + 3][nRow] == nPlayer) ||
		(ppField[nCol][nRow] == nPlayer && ppField[nCol - 1][nRow] == nPlayer && ppField[nCol - 2][nRow] == nPlayer && ppField[nCol - 3][nRow] == nPlayer) ||
		(ppField[nCol][nRow] == nPlayer && ppField[nCol][nRow + 1] == nPlayer && ppField[nCol][nRow + 2] == nPlayer && ppField[nCol][nRow + 3] == nPlayer) ||  
		(ppField[nCol][nRow] == nPlayer && ppField[nCol][nRow - 1] == nPlayer && ppField[nCol][nRow - 2] == nPlayer && ppField[nCol][nRow - 3] == nPlayer) ||
		(ppField[nCol][nRow] == nPlayer && ppField[nCol + 1][nRow + 1] == nPlayer && ppField[nCol + 2][nRow + 2] == nPlayer && ppField[nCol + 3][nRow + 3] == nPlayer) || 
		(ppField[nCol][nRow] == nPlayer && ppField[nCol + 1][nRow + 1] == nPlayer && ppField[nCol + 2][nRow + 2] == nPlayer && ppField[nCol + 3][nRow + 3] == nPlayer))
	{
		std::cout << _T("		") << lpszPlayername << _T(" hat gewonnen!") << std::endl; 
		return true;
	}

	return false;
}