Ich programmiere gerade Snake mit Klassen.
Mein Feld dafür steht, meine Wand und mein Kopf auch und die Ausgabe dafür funktioniert auch so weit.

Jetzt gilt es diesen Kopf zu bewegen,wenn eine Taste gedrückt wird, sprich dann den Kopf auf ein neues Feld zu setzen.
Die Header-Datei für mein Spiel sieht folgendermaßen aus:

class Spiel
{
private:
	Feld* f[60][60]; //Zeiger auf Feldobjekte, logisch
	View* v;
	Wand* w;
	Kopf* k;
	int refreshRate;
	bool running;
	bool goLeft;
	bool goRight;
	bool goDown;
	bool goUp;
public:
	Spiel(); //stellt Wände und Kopf korrekt auf
	~Spiel(); //löscht wieder alles
	int getKeyboardInput();
	void gameLoop(); //Spieleschleife
	void bewegeKopf();
	void show();
};

void Spiel::bewegeKopf()
	{
		int x = k->getKopfx();
		int y = k->getKopfy();
		int keyIn = getKeyboardInput();
		if(keyIn != 0) // Es wurde eine Taste gedrückt
	{
		switch(keyIn)
		{
		case 27: // [ESC]
			running = false;
			break;
		case 224: // Special key
		int keyIn2= getKeyboardInput(); // Wenn es eine Spezialtaste ist, den zweiten Code holen
		switch(keyIn2)
			{
			case 75:  // [<-] 
					y = y--;
					k->setFeld(x,y); //!!!!!!!!!//
					goLeft = true;	
					goRight = false;
					goUp = false;
					goDown = false;
				// Stein bewegen...
				break;
			case 77: // [->]
					y = y++;
					k->setFeld(x,y); //!!!!!!!!!//
					goRight = true;
					goLeft = false;
					goUp = false;
					goDown = false;
				// Stein bewegen...
				break;
			case 80: // [ v ]
					x = x++;
					k->setFeld(x,y); //!!!!!!!!//
					goDown = true;
					goLeft = false;
					goUp = false;
					goRight = false;
				// Stein bewegen...
				break;
			case 72: y = y--;// [ ^ ]
					k->setFeld(x,y); //!!!!!!!!!!//
					goUp = true;
					goDown = false;
					goLeft = false;
					goRight = false;
					break;
			}
				break;
		}
	}
	}

An den Stellen 19, 28, 37 und 45 rufe ich meine Methode setFeld(int x, int y) auf, die in der Kopf-Klasse steht. Die Header-Datei wie folgt:

class Kopf
{
private:
	Feld* f;
	Kopf* k;
	char zeichen;

public:
	Kopf(Feld*, char);
	~Kopf();
	void setFeld(int x, int y);
	int getKopfx();
	int getKopfy();
	void setZeichen (char);
	Feld* getFeld();
	char getZeichen();
	void show (View* v); //zeichnet zeichen auf View v an der angegebenen Feldposition
};

setFeld sieht folgendermaßen aus:

void Kopf::setFeld(int x, int y)
	{
	f[x][y]->setKopf(k);
	}

Genau bei dieser Methode liegt jetzt mein Problem. Ich arbeite mit Visual-Studio.
Folgende Fehlermeldung ist an der eckigen Klammerauf von [y] zu sehen:
--> Kein "[]"-Operator stimmt mit diesen Operanden überein. Operandentypen sind Feld [int]

Man sagte mir, das Problem wäre, dass der Array "dumm" ist und nicht weiß, dass er es hier mit einem zweidimensionalen Feld zu tun hat. Aber was kann ich tun, damit er kapiert, dass es sich um ein zweidimensionales Feld handelt? Also, dass ich die Werte von x und y so übergeben kann und er an der Stelle dann auch meinen Kopf setzt?

Ich weiß, dass es wesentlich einfachere Lösungen gibt, Snake zu programmieren, aber unser Kurs sollte es auf die kompliziertere Weise tun.

Ich hoffe sehr, dass mir hier jemand weiterhelfen kann. Wenn der Code nicht ausreichend ist, um das Problem nachvollziehen zu können, kann ich meinen gesamten Code posten. (wird aber recht viel)
Bin über jede Antwort sehr dankbar!

Viele Grüße
Blubbi4

Wie dem auch sei: irgendwo geht die Typinformation verloren. Das ist aber bei Arrays üblich.
Zeig mal die Konstruktoren von Spiel und Kopf.
Apropos "Kopf": das Kopf::f ein Feld* und nichtmal ein Feld** ist verwundert mich.

Und das hier:

y=y--;

sollte wohl ein einfaches

--y;

sein.

Mit "logisch" ist gemeint, dass ich einmal ein "physikalisches" Feld habe (in der view), wo praktisch alles optisch dann auch ausgegeben wird und ein "logisches" Feld mit Pointern. Auf diesen Feldern kann dann alles mögliche drauf stehen (Wand, Kopf, leer)

Hier der Konstruktor von Kopf:

Kopf::Kopf(Feld* f, char zeichen)
	{
		this->f=f;
		this->zeichen=zeichen;
	}

Und hier der Konstruktor von Spiel:

Spiel::Spiel()
	{
		running = true;
		refreshRate = 200;

		v = new View();
		for(int i=0; i<60; i++)
			{
				for (int j=0; j<60; j++)
				{
					f[i][j] = new Feld(i, j);
				}
			}
		//Erstellung der Wand
		int i;
		int j;
		for (i=0; i<60; i++) //höhe
		{
			for (j=0; j<60; j++) //weite//
			{
				if(j==0)
				{
					w = new Wand(f[i][0], '#');
					f[i][0]->setWand(w); //Spalte1
					//v->zeichne(3,4,'b');
				}
				if(i==0)
				{
					w= new Wand(f[0][j], '#');
					f[0][j]->setWand(w);
				}
				if(j==(60-1)) //spalte2
				{
					w= new Wand(f[i][60-1], '#');
					f[i][60-1]->setWand(w);
				//weite
				}
				if(i==(60-1))
				{
					w= new Wand(f[60-1][j], '#');
					f[60-1][j]->setWand(w); //höhe
				}

			}

		}
		k= new Kopf(f[30][30], '@');
		f[30][30]->setKopf(k);
		show();
		gameLoop();
	}

Also, wir haben das ganze auch schon mal ohne Klassen und Pointern gemacht.
Da hat das mit y++ oder y-- aber eigentlich so funtkioniert, wie ich es mir vorgestellt hatte. Wieso sollte es denn --y heißen? Mir ist klar, dass der Wert von y bei der Postfixnotation erst nach dem ";" erniedrigt wird, aber spielt das hier eine Rolle?

Da hat das mit y++ oder y-- aber eigentlich so funtkioniert,

Pures Glück, wenn y=y-- geht.

Blubbi456 schrieb:

bei der Postfixnotation erst nach dem ";" erniedrigt wird, aber spielt das hier eine Rolle?

Zwei Wertänderungen in einem Ausdruck sind pöse. Siehe Sequence Point und Nasendämonen.

Dass es mehr Pointer als nötig sind, ist mir bewusst, aber das war praktisch vorgegeben, damit wir den Umgang damit verstehen ... wobei mich das eher verwirrt muss ich ja sagen ^^;

Hmm - aber ganz so extrem muss es ja nicht sein.
Ausserdem brauchst Du ja nicht lernen, wie man es nicht macht, um zu begreifen, wie man es richtig macht.

Wie dem auch sei: ein zweidimensionales Feld von Pointern ist ineffizient und unnötig kompliziert.
Schau mal, wie sehr sich Dein Code vereinfacht, wenn Dein Spielfeld ein Feld* ist, dass Du im Konstruktor von Spiel allozierst.

struct Feld{
  //...
};
struct Spiel{
  Feld* f;
  Spiel(){
    f = new Feld[60*60];
    // ....
  }
  ~Spiel() { delete[] f; }
  Feld& feld(int zeile, int spalte) { return f[zeile*60+spalte]; }
  const Feld& feld(int zeile, int spalte) const { return f[zeile*60+spalte]; }
  // ...
};

Zeile 11 und 12 ist ein allgemein bekannter Trick um den Zugriff über Zeile und Spalte auf ein eindimensionales Array zu ermöglichen. Nimm Dir ein Stück Karopapier und einen Bleistift um das nachzuvollziehen.
Referenzen ( Feld& als Rückgabe) kennst Du, oder?

Wirklich: Dein Ansatz mit der ganzen manuellen Speicherverwaltung ist nicht mit vernünftigen Aufwand korrekt hinzubekommen.

Viel Erfolg!