DevC++ Was sind arrays, und wozu dienen sie?

Hallo Liebe Community,

Ich habe seit eine Woche begonnen mit den DevC++ zu lernen, ich habe dazu einen Buch....Naja ich habe im Prinzip die grundlagen verstanden (bzw. Variabel Typen, While,for,do Loops, Konatsnten mit #define und enum benutzen, If ,else, funktionen, Void funktionen die keinen werte zurueckgeben, cin, cout, die main() funktion, klassen und Objekte, String Objekte......)

Das und andere dinge habe ich komplett verstanden aber als ich zu diese Arrays angekommen bin habe ich fast nicht verstanden wo zu sie dienen und wie man sie benutzen kann.

Was ich von euch erwarte ist eine erklaerung zu diese gennanten Arrays, also wie man sie benutzt und wozu sie dienen in eine simple sprache die ich verstehe, einen guten beispiel kann nicht schaden.

Aber bitte nicht in eine komplizierte Sprache, da mein Deutsch auf einen sehr niedrigen Niveu ist.

Danke im vorraus, Altair66

Array ist ein strukturierter Datentyp und umfasst eine feste Anzahl von Elementen eines anderen Datentyps (z.B. Integer)

Einzelne Elemente vom Array können durch einen Indexwert angesprochen werden.

Bsp:

Code:

---

array[1] := 123
array[2] := 456

<schreibe array[1]> auf den Bildschirm
-> Ausgabe auf dem Bildschirm : 123


<schreibe array[2]> auf den Bildschirm
-> Ausgabe auf dem Bildschirm : 456

---

Man spart sich somit viel schreibarbeit.
Nehmen wir mal ein Beispiel, du willst ein Spiel schreiben, wo 4 Spieler mitspielen können. Um jetzt nicht variablen Spieler1, Spieler2, Spieler3, Spieler4 deklarieren zu müssen, kannst du nun einfach sagen Spieler[x], wobei x die Nummer des Spielers steht. Dann mann man sehr leicht eine Schleife basteln, die z.B. von 1 bis 3 zählt, wobei x den Schleifenzähler bekommt. Dann kannst du mit einer einzigen Variabel alles abfrühstücken.

Zitat:

---

Zitat von Whiz-zarD

Array ist ein strukturierter Datentyp und umfasst eine feste Anzahl von Elementen eines anderen Datentyps (z.B. Integer)

Einzelne Elemente vom Array können durch einen Indexwert angesprochen werden.

Bsp:

Code:

---

array[1] := 123
array[2] := 456

<schreibe array[1]> auf den Bildschirm
-> Ausgabe auf dem Bildschirm : 123


<schreibe array[2]> auf den Bildschirm
-> Ausgabe auf dem Bildschirm : 456

---

Man spart sich somit viel schreibarbeit.
Nehmen wir mal ein Beispiel, du willst ein Spiel schreiben, wo 4 Spieler mitspielen können. Um jetzt nicht variablen Spieler1, Spieler2, Spieler3, Spieler4 deklarieren zu müssen, kannst du nun einfach sagen Spieler[x], wobei x die Nummer des Spielers steht. Dann mann man sehr leicht eine Schleife basteln, die z.B. von 1 bis 3 zählt, wobei x den Schleifenzähler bekommt. Dann kannst du mit einer einzigen Variabel alles abfrühstücken.

---

Hmmm, ja es macht sinn!

Ok ich will mal etwas anderes von dir:
Kannst du mir diesen QuellCode erklaeren:

Code:

---

// Tic-Tac-Toe Board
// Demonstrates multidimensional arrays

#include <iostream>

using namespace std;

int main()
{
    const int ROWS = 3;
    const int COLUMNS = 3;
    char board[ROWS][COLUMNS] = { {'O', 'X', 'O'},
                                  {' ', 'X', 'X'},
                                  {'X', 'O', 'O'} };

    cout << "Here's the tic-tac-toe board:\n";
    for (int i = 0; i < ROWS; ++i)
    {
        for (int j = 0; j < COLUMNS; ++j)
            cout << board[i][j];
        cout << endl;
    }

    cout << "\n'X' moves to the empty location.\n\n";
    board[1][0] = 'X';

    cout << "Now the tic-tac-toe board is:\n";
    for (int i = 0; i < ROWS; ++i)
    {
        for (int j = 0; j < COLUMNS; ++j)
            cout << board[i][j];
        cout << endl;
    }

    cout << "\n'X' wins!";

    return 0;
}

---

Also ich verntehe manche dinge aber auch manche nicht, ich wuerde mich freuen wenn mir einer das oben erklaert!

LB, Altair66

Zitat:

---

Zitat von Altair66

Also ich verntehe manche dinge aber auch manche nicht, ich wuerde mich freuen wenn mir einer das oben erklaert!

---

Welche Teile verstehst du denn nicht?

Dein beschriebenes Beispiel ist ein zweidimensionales Array: Array[y][x]

So sieht der Array "board" aus

Code:

---

board[ROWS][COLUMNS]

 |0    1    2
---------------> COLUMNS
0|O    X    O
 |
1|    X    X
 |
2|X    O    O
 |
 V
ROW

Row    = Spalte
Column = Zeile

---

board[1][0] ist noch leer.

Code:

---

cout << "Here's the tic-tac-toe board:\n";
for (int i = 0; i < ROWS; ++i)
    {
        for (int j = 0; j < COLUMNS; ++j)
            cout << board[i][j];
        cout << endl;
    }

---

Hier wird nichts weiteres getan, als nur das zweidimensionale Array (also das Spielfeld), mittels zwei verschaltete For-Schleifen, auf dem Bildschirm auszugebeben.

Code:

---

cout << "\n'X' moves to the empty location.\n\n";
    board[1][0] = 'X';

---

Hier wird nun der leere Platz [1][0] mit einem X gefüllt.

Code:

---

cout << "Now the tic-tac-toe board is:\n";
for (int i = 0; i < ROWS; ++i)
    {
        for (int j = 0; j < COLUMNS; ++j)
            cout << board[i][j];
        cout << endl;
    }

---

Es wird wieder, mittels zwei verschaltete For-Schleifen das Array mit dem hinzugefügten Wert, auf dem Bildschirm ausgegeben.

Zitat:

---

Zitat von Whiz-zarD

Dein beschriebenes Beispiel ist ein zweidimensionales Array: Array[y][x]

So sieht der Array "board" aus

Code:

---

board[ROWS][COLUMNS]

 |0    1    2
---------------> COLUMNS
0|O    X    O
 |
1|    X    X
 |
2|X    O    O
 |
 V
ROW

Row    = Spalte
Column = Zeile

---

board[1][0] ist noch leer.

Code:

---

cout << "Here's the tic-tac-toe board:\n";
for (int i = 0; i < ROWS; ++i)
    {
        for (int j = 0; j < COLUMNS; ++j)
            cout << board[i][j];
        cout << endl;
    }

---

Hier wird nichts weiteres getan, als nur das zweidimensionale Array (also das Spielfeld), mittels zwei verschaltete For-Schleifen, auf dem Bildschirm auszugebeben.

Code:

---

cout << "\n'X' moves to the empty location.\n\n";
    board[1][0] = 'X';

---

Hier wird nun der leere Platz [1][0] mit einem X gefüllt.

Code:

---

cout << "Now the tic-tac-toe board is:\n";
for (int i = 0; i < ROWS; ++i)
    {
        for (int j = 0; j < COLUMNS; ++j)
            cout << board[i][j];
        cout << endl;
    }

---

Es wird wieder, mittels zwei verschaltete For-Schleifen das Array mit dem hinzugefügten Wert, auf dem Bildschirm ausgegeben.

---

Oh danke sehr, aber wie soll der Computer wissen welche reihe man ein neues wert gebel will, also ich will jetzt die Spalten einen neues wert geben, wie kann man etwas eingeben das der Computer weis in welche dimension will man etwas aendern, verstehst du was ich meine?

Danke im vorraus, Altair66

Schau dir das Bild mit dem Array genauer an. Da steht schon die Antwort ;)

Ich habe es dort grafisch aufgezeichnet, wo du welches Feld, für dein Beispiel, findest. Wenn du die Wörter Rows und Columns ins deutsche Übersetzt, solltest du auch auf die Lösung kommen.

Nehmen wir mal an, wir wollen das Feld rechts-unten ändern. Im Moment ist da noch ein 'O' drinnen., die Koordinaten sind Rows = 2 und Columns = 2. (Ich hoffe, du weisst, wie man ein Koordinatensystem liest). Also musst du dann auch board[2][2] ansprechen.

Für das leere Feld links-mitte wäre es Row = 1 und Column = 0.
Also board[1][0].

Ach ja, eine Sache mal am Rande: die Sprache, die du lernst, heißt C++. Dev-C++ ist nur eine Entwicklungsumgebung dazu, also nicht viel mehr als ein Texteditor.

Zitat:

---

Zitat von DFYX

Ach ja, eine Sache mal am Rande: die Sprache, die du lernst, heißt C++. Dev-C++ ist nur eine Entwicklungsumgebung dazu, also nicht viel mehr als ein Texteditor.

---

Danke aber das war nicht noetig^^
Ich hab auch einbissien daran erfahrung, naja erfahrung kann man es kaum nennen. (Du bist der dritte der mir es sagt, hehe)

Aber auf alle faelle danke.

@Whiz-zarD:
Ich glaube du hast meine frage nicht richtig verstanden oder ich habe dich nicht verstanden, ich meinte wenn ich jetzt ( Reihe [0] [1] = x;) schreibe in welche der zwei Dimensionen wird dieser wert geaendert, abe eine erklaerung ist glaub ich nicht noetig dnn ich habe es glaube ich verstanden.

Danke im vorraus, Altair66

Zitat:

---

Zitat von Altair66

@Whiz-zarD:
Ich glaube du hast meine frage nicht richtig verstanden oder ich habe dich nicht verstanden, ich meinte wenn ich jetzt ( Reihe [0] [1] = x;) schreibe in welche der zwei Dimensionen wird dieser wert geaendert, abe eine erklaerung ist glaub ich nicht noetig dnn ich habe es glaube ich verstanden.

Danke im vorraus, Altair66

---

Wenn ich das lese, glaub ich nicht, dass du das verstanden hast.
Du hast nur ein einziges zweidimensionales Array.
Zusätzlich hast du noch die Konstanten Row und Collumn, die jeweils auf 3 gesetzt sind. Allerdings muss man darauf achten, dass die For-Schleifen nicht von 1 bis 3 zählen, sondern von 0 bis 2. Weiterhin wird das Array mit folgenden Daten gefüttert:

Code:

---

board[0][0] = 'O'
board[0][1] = 'X'
board[0][2] = 'O'

board[1][0] = ''
board[1][1] = 'X'
board[1][2] = 'X'

board[2][0] = 'X'
board[2][1] = 'O'
board[2][2] = 'O'

---

Falls das immernoch nicht einleuchtend sein sollte, dann lern erstmal lieber eindimensionale Arrays. Wenn die diese verstanden hast, dann erscheinen dir mehrdimensionale Arrays als selbsterklärend, wobei man noch hinzufügen muss, dass Arrays, die mehr als 3 Dimensionen haben, sehr unübersichtlich werden.

Zitat:

---

Zitat von Altair66

[...] wenn ich jetzt ( Reihe [0] [1] = x;) schreibe in welche der zwei Dimensionen wird dieser wert geaendert [...]

---

Stell dir dein Array als ein zusammenhängender Speicher vor.

char board[R][C]; Der Speicher könnte dann so aussehen:
R=0; C=0 | R=0; C=1 | R=0; C=2 | R=1; C=0 | R=1; C=1 | ... | R=2; C=2 (-> höhere Adressen)

Du greifst auf ein 'Element' des Arrays zu, nicht auf eine Dimension. Mehrdimensionale Array dienen lediglich der Übersichtlichkeit oder der Effizienz. Prinzipiell kann man alles mit einem eindimensionalen Array machen.

Zitat:

---

Zitat von Whiz-zarD

[...] wobei man noch hinzufügen muss, dass Arrays, die mehr als 3 Dimensionen haben, sehr unübersichtlich werden.

---

Kommt auf die Betrachtungsweise an ;)

Zitat:

---

Zitat von Brauni90

Mehrdimensionale Array dienen lediglich der Übersichtlichkeit oder der Effizienz.

---

Bessere Veranschaulichung ja, Effizienz nein. Um auf Elemente mehrdimensionaler Arrays zugreifen zu können, sind mehr Operationen nötig als es bei eindimensionalen Arrays der Fall ist. Arrays, egal welcher Dimension (dieser Begriff dient wirklich nur der Veranschaulichung) sind immer eindimensional im Speicher ausgelegt, so dass, um auf Elemente mehrdimensionaler Arrays zugreiffen zu können, Berechnungen notwendig sind.

Eindimensionales Array mit 12 Elementen:

Code:

---

im Speicher
-------------------------------------------------------------
| 0  | 1  | 2  | 3  | 4  | 5  | 6  | 7  | 8  | 9  | 10 | 11 |
-------------------------------------------------------------

bildlich
-------------------------------------------------------------
| 0  | 1  | 2  | 3  | 4  | 5  | 6  | 7  | 8  | 9  | 10 | 11 |
-------------------------------------------------------------

---

Zweidimensionales Array mit 4x4 Elementen:
(hier im Format xy; im Code wird man mit array[y][x] zugreifen)

Code:

---

im Speicher
---------------------------------------------------------------------------------
| 00 | 01 | 02 | 03 | 10 | 11 | 12 | 13 | 20 | 21 | 22 | 23 | 30 | 31 | 32 | 33 |
---------------------------------------------------------------------------------

bildlich
---------------------
| 00 | 01 | 02 | 03 |
---------------------
| 10 | 11 | 12 | 13 |
---------------------
| 20 | 21 | 22 | 23 |
---------------------
| 30 | 31 | 32 | 33 |
---------------------

---

(Nach dem gleichen Prinzip sind auch alle folgenden mehrdimensionalen Arrays aufgebaut: Die Elemente der vorherigen Dimension sind in der nächsten Dimension Reihen.)

Wie man sehen kann, beginnt die nächste Reihe immer am Ende der vorherigen Reihe. Um also auf ein Element zugreifen zu können, muss man den Offset berechnen, was wie folgt aussieht:

Für eindimensionale Arrays:

Code:

---

Offset = Länge(Element) * x

---

Für zweidimensionale Arrays:

Code:

---

Offset = Länge(Element) * Länge(ReiheX) * y + Länge(Element) * x

---

Für dreidimensionale Arrays:

Code:

---

Offset = Länge(Element) * Länge(ReiheZ) * Länge(ReiheX) * y + Länge(Element) * Länge(ReiheZ) * x + Länge(Element) * z

---

usw.

Man sieht, dass je mehr Dimensionen, desto mehr Operation sind nötig um auf die Elemente zugreifen zu können. Selbst wenn einige der Multiplikationen wegoptimiert werden können, da zur Kompilierzeit bekannt, kann man trotzdem davon ausgehen, dass der Rechneaufwand von Dimension zu Dimension steigt.

Soweit ich das irgendwie mal mit bekommen habe sind Arrays doch einfach nur Zeiger auf einen einfachen Speicherbereich in dem sich die Elemente des Arrays hinter einander befinden. Nun wenn ich jetzt ein mehr-dimensionales Array besitze, habe ich praktisch ein Array eines Arrays ... :rolleyes:

Folglich komme ich zu dem Schluss, dass die Dinge nicht hintereinander sondern "willkührlich" im Speicher liegen. ( oder ist das in C/++ anders? )
Da das eine Array die Zeiger auf den anderen Speicher enthält wo sich die eigendlichen Elemente befinden.

Nein, die Elemente liegen alle nebeneinander und das wird bei allen Implementierungen statischer Arrays der Fall sein, weil die Lokalität für die Effizienz sehr wichtig ist. Das, was du meinst sind dynamische Arrays, die je nach Implementierung als Elemente auch Zeiger auf Arrays haben können, die woanders liegen. Nicht zu verwechseln mit dynamisch erzeugten statischen Arrays.

Habe mich wohl unverständlich ausgedrückt. Mit Effizienz war die Unterstützung durch Hardware gemeint, die im Gegensatz zur hausgemachten 'Implementierung in Software' dennoch einen Vorteil bringen kann. Eigentlich sind es nur Additionen und Multiplikationen. Aber das kann man auch anders implementieren um somit eine bessere Effizienz erreichen.

Hardwareunterstützung für den Zugriff auf mehrdimensionale Arrays? Davon lese ich zum ersten mal, wenn ich ehrlich sein soll. Was kann ich mir darunter vorstellen?

Zitat:

---

Zitat von Brauni90

Eigentlich sind es nur Additionen und Multiplikationen. Aber das kann man auch anders implementieren um somit eine bessere Effizienz erreichen.

---

Falls es rübergekommen ist, als würde ich Zugriffe auf mehrdimensionale Arrays als langsam bezeichnen, so war das nicht beabsichtigt. Das ist natürlich vollkommener Quatsch, denn Integeradditionen und selbst -multiplikationen sind heute sehr schnell, Additionen und Subtraktionen benötigen z.B. nur einen Cycle und bei Operationen auf Arrays ist die Chance groß, dass man diese vektorisieren kann, was das Ganze nochmal um ein Vielfaches schneller macht.
Ich habe es nur so aufgefasst, als würdest du behaupten, Zugriffe auf mehrdimensionale Arrays wären schneller als auf eindimensionale.

Zitat:

---

Zitat von Kyuu

Hardwareunterstützung für den Zugriff auf mehrdimensionale Arrays? Davon lese ich zum ersten mal, wenn ich ehrlich sein soll. Was kann ich mir darunter vorstellen?



Falls es rübergekommen ist, als würde ich Zugriffe auf mehrdimensionale Arrays als langsam bezeichnen, so war das nicht beabsichtigt. Das ist natürlich vollkommener Quatsch, denn Integeradditionen und selbst -multiplikationen sind heute sehr schnell, Additionen und Subtraktionen benötigen z.B. nur einen Cycle und bei Operationen auf Arrays ist die Chance groß, dass man diese vektorisieren kann, was das Ganze nochmal um ein Vielfaches schneller macht.
Ich habe es nur so aufgefasst, als würdest du behaupten, Zugriffe auf mehrdimensionale Arrays wären schneller als auf eindimensionale.

---

Boost-Mode\Heap, HW-Loops vlt?

Ich bin jetzt etwas verwirrt wieso du den zweiten Teil auch zitiert hast, denn dieser hat mit dem ersten nichts zu tun. Außerdem ist mir dein Kommentar zu minimalistisch, um daraus genügend Inhalt zu gewinnen. :0

Es ging mir übrigens nicht darum wie man sequentiellen Zugriff auf Arrays (Dimension irrelevant) hardwareseitig/softwareseitig optimieren kann, da hat man viele Möglichkeiten offen: software pipelining, loop unrolling, SIMD instructions, pointer arithmetic, etc., das ist alles eher uninteressant. Interessant ist ob die obligatorische Berechnung des Offsets bei Ausdrücken der Form 'array[a1]...[an]' hardwareseitig abgenommen werden kann.


Edit: @Mog:

Ah, danke für die Erklärung. :) Mit einem DSP hatte ich bisher nur sehr wenig zu tun (SSE), Hardware Looping ist für mich also Neuland.

Zitat:

---

Zitat von Kyuu

Ich bin jetzt etwas verwirrt wieso du den zweiten Teil auch zitiert hast, denn dieser hat mit dem ersten nichts zu tun. Außerdem ist mir dein Kommentar zu minimalistisch, um daraus genügend Inhalt zu gewinnen. :0

Es ging mir übrigens nicht darum wie man sequentiellen Zugriff auf Arrays (Dimension irrelevant) hardwareseitig/softwareseitig optimieren kann, da hat man viele Möglichkeiten offen: software pipelining, loop unrolling, SIMD instructions, pointer arithmetic, etc., das ist alles eher uninteressant. Interessant ist ob die obligatorische Berechnung des Offsets bei Ausdrücken der Form 'array[a1]...[an]' hardwareseitig abgenommen werden kann.

---

Hardware-Loops. Steht doch dort. ;) Genau dafuer sind die Dinger doch da. Jeder, der schon mal mit einem DSP gearbeitet hat, kennt diese Dinger eigentlich. Im Prinzip ist das nur ein Werk, welches for-schleifen mit einem Index optimal aufloest. Spich: Die Spruenge werden von der Hardware direkt serialisiert, und das Inkrement automatisch in einem Zug gebildet. Wohl gemerkt muss man diese per Hand verwenden - kein Compiler verwendet sie von Haus aus.

Zumindest diese passen nicht in den Haufen, den du gelistet hast. Boost ist wahrscheinlich bereits zu abstrakt, fuer einen Programmierer.

Zitat:

---

Zitat von Kyuu

Hardwareunterstützung für den Zugriff auf mehrdimensionale Arrays? Davon lese ich zum ersten mal, wenn ich ehrlich sein soll. Was kann ich mir darunter vorstellen?

---

Das von Mog bereits beschriebene oder den Optimierungsspielraum, den man dem Compiler damit lässt, sofern dieser das berücksichtigt. Für die meisten Nutzer wird die heutige Hardware so oder so reichen, aber darum geht es nicht. Eher um ein Hinweis auf eine Überlegung zu den damit verbundenen möglichlichen Optimierungen bei Hardware ...

Ich habe durchaus nach konkreten Beispielen gefragt. ^^
Und Optimierungsspielraum lassen impliziert noch lange nicht gewonnene Effizienz.

BTW: Nach Michael A. Jackson lautet die erste Regel für Optimierung "Tu es nicht", die zweite "Tu es noch nicht" (im Sinne von "tu es erst, wenn Handlungsbedarf besteht"). Wenn man das befolgt, lässt man dem Compiler theoretisch sowieso den höchstmöglichen Optimierungsspielraum.