Anfängerfrage zu mehrdimensionalen Arrays (Absolut blutiger Beginner)

Sacume

Hallo Leute! Ich hab das Buch "C++ für Spieleprogrammierer" und bin jetzt bei den Arrays angelangt. Dort ist ein Beispiel-Code für mehrdimensionale Arrays.
Bildschirmausgabe:

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

Hi Sacume,

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?

Sacume

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?
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!

Karte[x][y] = value
ist eine Zuweisung des wertes "value" zur Arrayposition [x][y]

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)

Sacume schrieb:

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?

out schrieb:

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

Belli

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.
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.

Huch, danke qweqweqwe. Ich meinte natürlich
Karte [0][0] =0
Karte [0][1] =1
Karte [0][2] =2
Karte [1][0] =3
Karte [1][1] =4
Karte [1][2] =5
Karte [2][0] =6
Karte [2][1] =7
Karte [2][2] =8
Für ein Array [3][3] .

Sacume

Wow, dieses Forum ist echt super!
Ich habs verstanden, was ich ehrlich gesagt nicht erwartet hatte.
Vielen Dank an alle für diese schnellen und vorallem guten Antworten!