Also eine simple 3x3-"Karte"
Ich verstehe jedoch nicht, welcher Wert bei "cout << Karte[x][y]" angezeigt wird.
Müsste er nicht zwei Werte (x und y) anzeigen? Ich versteh das Prinzip nicht so ganz und hoffe, ihr könnt mir helfen.

Ich verstehe zudem nicht, was genau passiert, wenn "Karte[x][y] = Zähler" stattfindet. Ist der Zähler bei 0, heißt das, dass dann "Karte[0][0]" ist?
Ich hoffe, ihr versteht mein Problem!
Hier noch die Bildschirmausgabe und darunter der Code!

______________
012
345
678
______________

int main()
{
	int ende;
	const int Breite  = 3;
	const int Hoehe = 3;

	int x, y;
	int Karte[Breite][Hoehe];

	int Zaehler = 0;

	for (y=0; y<Hoehe; y++)
	{
		for (x=0; x<Breite; x++)
		{
			Karte[x] [y] = Zaehler;
			Zaehler++;
		}
	}

	for(y=0; y<Hoehe; y++)
	{
		for(x=0; x<Breite; x++)
		{
			cout << Karte[x] [y];
		}

		cout << endl;
	}

return 0;
}

ich habe oft das Gefühl, dass das "Dimensionsdenken" nur irreführend ist. Ich würde daher einfach C++-ig denken. Also, es gibt Regeln die besagen, wie man eine Deklaration zu lesen hat.

int Karte[3][3];

Die Deklaration von Karte liest man so: Karte ist ein Array von 3 Arrays von 3 int s. So, du hast dir also ein Array names Karte erstellt. Jedes Element dieses Arrays IST WIEDERUM ein Array (mit 3 int s).
Nun willst du mal einen Zugriff machen, z.B. cout << Karte[1][2] . Damit wollen wir also das zweite (1+1) Element von Karte ansprechen, also das zweite Array. Von diesem zweite Array wollen wir nun das dritte (2+1) Element ansprechen, also den dritten int .

Beispiel:

int Karte[3][3] = { /*Array Nr.1:*/ {0,1,2}, /*Array Nr.2:*/ {3,4,5}, /*Array Nr.3:*/ {6,7,8} };

cout << Karte[1][2]

Wie gesagt, wir wollen nun den dritten int vom zweiten Array 5

Ist es nun verständlich?

richtig?
Dann hab ichs einigermaßen Verstanden. Vielen Lieben Dank dafür!!
Aber dennoch verstehe ich dann nicht, was bei

"Karte[x][y] = Zähler" passiert.

Da der Zähler ja immer nur einen Wert annehmen kann, würde die Schleife doch nur 3 mal durchlaufen und wie folgt definieren.
Karte[0][0]
Karte[1][1]
Karte[2][2]
Stattdessen zählt er aber 8 mal und gibt die Werte von 0-8 zurück!

x,y geben die "Koordinaten" in deinem 2D-Array an und "value" den Wert den Du an der Stelle speichern willst.

Ein Schachbrett könnten wir mit einem Array der Dimension [8][8] modellieren.
Dann wäre Schachbrett[3][2] eben die Figur (abhängig vom Typ des Arrays) an der Stelle (3,2)

Aaaah das würde dann folgendes Bedeuten.
Karte [1][1] =0
Karte [1][2] =1
Karte [1][3] =2
Karte [2][1] =3
Karte [2][2] =4
Karte [2][3] =5
Karte [3][1] =6
Karte [3][2] =7
Karte [3][3] =8
(UND FALLS MAN 4 ARRYS ERSTELLEN SOLLTE)
Karte [4][1] =9
Karte [4][2] =10
Karte [4][3] =11

richtig?

Fast. Wir fangen natürlich immer bei 0 an. Du musst unterscheiden zwischen Größe und Index. Bei der Deklaration eines Arrays gibst du die Größe an, z.B. 4. Elemente sprichst du aber mit einem Index an, in dem Fall 0...3.
Also:
Karte [0][0] =0
Karte [0][1] =1
Karte [0][2] =2
Karte [1][3] =3
Karte [1][4] =4
Karte [1][5] =5
Karte [2][6] =6
Karte [2][7] =7
Karte [2][8] =8

Sacume schrieb:

Aber dennoch verstehe ich dann nicht, was bei

"Karte[x][y] = Zähler" passiert.

Da der Zähler ja immer nur einen Wert annehmen kann, würde die Schleife doch nur 3 mal durchlaufen und wie folgt definieren.

Wieso einen Wert? Bei mir steht da Zaehler++; . Bei mir läuft die Schleife auch nicht 3 Mal durch, sondern 3*3 Mal, also 9 verschiedene Werte. Oder meinst du nicht?

Also:
Karte [0][0] =0
Karte [0][1] =1
Karte [0][2] =2
Karte [1][3] =3
Karte [1][4] =4
Karte [1][5] =5
Karte [2][6] =6
Karte [2][7] =7
Karte [2][8] =8

Die Indices der zweiten Dimension hast Du verschissen. Yeah, der OP wird bestimmt immer verwirrter

Aber dennoch verstehe ich dann nicht, was bei

"Karte[x][y] = Zähler" passiert.

Da der Zähler ja immer nur einen Wert annehmen kann, würde die Schleife doch nur 3 mal durchlaufen und wie folgt definieren.
Karte[0][0]
Karte[1][1]
Karte[2][2]
Stattdessen zählt er aber 8 mal und gibt die Werte von 0-8 zurück!

Deine innere for-Schleife wird dreimal durchlaufen:
Karte[0][0]
Karte[1][0]
Karte[2][0]

danach folgt der nächste Durchlauf der äußeren for-Schleife, innerhalb dessen die innere Schleife wiederum dreimal durchlaufen wird:
Karte[0][1]
Karte[1][1]
Karte[2][1]

usw.