Was bedeuten die zahlen bei einem array

[Data Types]

Beschreibung

Ein Array ist eine Sammlung von Variablen, auf die mit einer Indexnummer zugegriffen wird. Arrays in der Programmiersprache C ++, in der Arduino-Skizzen geschrieben sind, sind zwar kompliziert, aber die Verwendung einfacher Arrays ist relativ unkompliziert.

Array erstellen / deklarieren

Alle folgenden Methoden sind gültige Methoden zum Erstellen (Deklarieren) eines Arrays.

  int myInts[6];
  int myPins[] = {2, 4, 8, 3, 6};
  int mySensVals[6] = {2, 4, -8, 3, 2};
  char message[6] = "hello";

Du kannst ein Array deklarieren, ohne es wie in myInts initialisieren zu müssen.
In myPins deklarieren wir ein Array, ohne explizit eine Größe zu wählen. Der Compiler zählt die Elemente und erstellt ein Array der entsprechenden Größe.
Schließlich können wir das Array wie in mySensVals sowohl initialisieren als auch skalieren. Beachte, dass beim Deklarieren eines Arrays vom Typ char ein weiteres Element als Initialisierung erforderlich ist, um das erforderliche Nullzeichen zu enthalten.

Zugriff auf ein Array

Arrays sind nullindiziert, das heißt, bezogen auf die Array-Initialisierung oben, befindet sich das erste Element des Arrays am Index 0.

mySensVals[0] == 2, mySensVals[1] == 4, und so weiter.

Das bedeutet auch, dass in einem Array mit zehn Elementen der Index neun das letzte Element ist. Daher:

int myArray[10]={9, 3, 2, 4, 3, 2, 7, 8, 9, 11};
// myArray[9] enthält 11
// myArray[10] ist ungültig und enthält zufällige Informationen (andere Speicheradresse)

Aus diesem Grund solltet du beim Zugriff auf Arrays vorsichtig sein. Beim Zugriff auf das Ende eines Arrays (mit einer Indexnummer, die größer ist als die von dir deklarierte Arraygröße - 1), wird aus dem Speicher gelesen, der für andere Zwecke verwendet wird. Das Lesen an diesen Orten wird wahrscheinlich nicht viel bewirken, außer ungültige Daten liefern. Das Schreiben in zufällige Speicherorte ist definitiv eine schlechte Idee und kann oft zu unglücklichen Ergebnissen wie Abstürzen oder Programmstörungen führen. Dies kann auch ein schwieriger Fehler sein.

Im Gegensatz zu BASIC oder JAVA überprüft der C ++ - Compiler nicht, ob der Array-Zugriff innerhalb der zulässigen Grenzen der von Ihnen angegebenen Array-Größe liegt.

So weist du einem Array einen Wert zu:

mySensVals[0] = 10;

So rufst du einen Wert aus einem Array ab:

x = mySensVals[4];

Arrays und FOR-Schleifen

Arrays werden oft innerhalb von Schleifen bearbeitet, wobei der Schleifenzähler als Index für jedes Array-Element verwendet wird. Wenn du beispielsweise die Elemente eines Arrays über den seriellen Anschluss ausgeben möchtest, kannst du Folgendes tun:

for (byte i = 0; i < 5; i = i + 1) {
  Serial.println(myPins[i]);
}

C Kurs - also ein Array ist wenn man viele Variablen...

1. Syntax

Wie wir Variablen deklarieren wissen wir noch
     int x;
was aber wenn wir 100 Variablen brauchen, oder vielleicht 100000? Es wäre irgendwie unpraktisch jetzt zu schreiben:
int x1, x2, x3, x4, x5,   ....   x98, x99, x100;
Die Lösung für diese Probleme sind Arrays (schwierig ins deutsche zu übersetzen, vielleicht indizierter Variablenblock?).

Die Syntax für die Deklaration eines Array ist recht einfach:
     int x_array[100];
zuerst kommt der Typ der Variablen, z.B. int, dann folgt der Name des Array, danach in eckigen Klammern [ ] die Größe des Arrays, also die gewünschte Anzahl der Array-Elemente.

Will man auf ein Element des Arrays zugreifen, so gibt man einfach den Index des Elementes in eckigen Klammern an:
     x_array[42] = 987; // in das 43. Element des Arrays wird 987 geschrieben
     meine_variable = x_array[66]; //das 67. Element wird gelesen und der Variablen meine_variable zugewiesen

In C ebenso wie in auf C basierenden Programmiersprachen(z.B. Java, Perl usw) sind die Arrays 'zero based indexed', d.h. das erste Element des Arrays hat den Index Null, das bedeutet deklariert man in seinem Programm int y[50]; dann erhält man ein Array mit den Indexzahlen y[0] bis y[49]. Dies ist im ersten Moment etwas gewöhnungsbedürftig, aber auch nicht unpraktisch.

Man kann Array gleich bei der Deklaration in einem Block mit geschweiften Klammern initialisieren, z.B so:
      int arr1[5] = {1, 2, 3, 4, 5};

2. Speicherstruktur eines Arrays

Sie erinnern sich das eine Variable ein Stück Speicherplatz im Hauptspeicher Ihres Computers ist. Bei der Deklaration eines Arrays wird der Compiler angewiesen n-mal nacheinander den Speicherplatz für diese Variable zu reservieren. Man hat anschließen einen zusammenhängen Block von Slots des Variablentyps im Hauptspeicher stehen, der für die Array Elemente reserviert ist. Folgende Abbildung sollte dies veranschaulichen:

Wichtig: viele Compiler initialisieren den Array bei er Deklaration gleich mit Nullen, dies ist sehr praktisch, leider tun andere Compiler dies nicht. In den einzelnen Slots steht dann das drin, was schon vorher drinstand also garbage (Müll). Wenn man sich nicht völlig sicher ist, das die Software an der man gerade sitzt, niemals von jemand anderem weiterentwickelt wird, sollte man den Array (oder das Array???, der Berliner würde sagen 'dem Array') in einer Schleife initialisieren.

3. Arraygrenzen

Wichtig: C überprüft die Arraygrenzen nicht.
z.B.

int x[100], index;

index = -25;
x[1000] = 42; // -> BUMM
// oder vielleicht
x[index] = 0; // -> BANG

wird anstandslos kompiliert obwohl der Array eigentlich nur 100 integer Elemente hat. Man bekommt keine Warnung und nichts. Führt man das Programm jetzt aus wird in die Speicheradresse die 1000 * integer von der Arraystartadresse entfernt ist, 42, eingefügt. Dies kann zu allen möglichen führen, z.B. das Programm stürzt ab. Unter alten Betriebssystemen ohne Speicherschutz, konnte man auf diese Weise sogar den ganzen Rechner zum Absturz bringen. Oder in einem anderen Array taucht plötzlich ein unsinniger Wert auf, oder schlimmer, der Wert ist nicht unsinnig sondern sogar plausibel. Oder an dieser Stelle steht vielleicht zufällig unbenutzter, freier Speicherplatz, dann merkt man von dem Fehler erstmal nichts.

Der zweite Teil des Beispiels, x[index] = 0; soll zum einen verdeutlichen, das man als Index natürlich eine integer Variable einsetzen kann, welche dann auch einen unsinnigen Wert, hier -25, enthalten kann.

4. mehrdimensionale Array

Wem ein eindimensionaler Array nicht reicht, der kann sich auch mehrdimensionale Arrays deklarieren:

// Deklarationen
int x[100][50]; // zweidimensionaler Array - etwa 20 Kilobyte; 4 Bytes pro int * 100 * 50
float y[100][50][100]; // dreidimensionaler Array - etwa 2 Megabyte; 4 Bytes pro float * 100 * 50 * 100
char z[100][50][100][100]; // vierdimensionaler Array - etwa 50 Megabyte -> Vorsicht, so langsam wirds sehr groß

// Zuweisungen
x[1][2] = 666;
y[1][2][3] = 777.77;
z [1][2][3][4] = 'a';

Das sieht auch aller recht klar und verständlich aus oder? Man gibt einfach in weiteren eckigen Klammer die gewünschte Größe der nächsten Dimension an.

Wie viele Dimensionen man anlegen kann ist abhängig vom Compiler und steht irgendwo in dessen Handbuch, bei mir waren es bis jetzt immer ausreichend genug (ich hatte auch noch nie mehr als 3).

Die maximale Größe des Speicherplatzes für einen Array ist auch nicht unendlich.Die natürliche Grenze ist der maximal zur Verfügung stehende freie Speicherplatz, mehr ist halt nicht da. Unter alten Compilern auf älteren Betriebssystemen (MSDOS) gab es hier auch andere Einschränkungen, 16 Kilobyte, 32 Kilobyte 64 Kilobyte durften je nach Speichermodell nicht überschritten werden.

Folgende Abbildung soll veranschaulichen wie ein mehrdimensionaler Array im Hauptspeicher angelegt wird:

5. Array an eine Funktion übergeben

Einen eindimensionalen Array an eine Funktion zu übergeben ist völlig simpel, man schreibt in den Funktionskopf seine Arrayvariable, und im innern der Funktion benutzt man ihn einfach. Meist ist es schlau, noch die Größe des Arrays, die Anzahl seiner Elemente, mit zu übergeben. Dann kann man auch verschieden große Arrays mit ein und der selben Funktion bearbeiten. Natürlich gilt auch hier, der Compiler überprüft die Arraygrenzen nicht, deshalb braucht man die Größe des Arrays meistens sowieso, es sei denn die Größe ist immer gleich und man kennt sie.

Hier kommt auch schon ein Beispiel:

#include <stdio.h>

int main (void)
{
   int i, arr[5] = {1,2,3,4,5}; // Array deklarieren und gleich initialisieren, so geht das auch

   for(i = 0; i < 5; i++) // for Schleife, kommt im n�chsten Kapitel
   {
      printf("arr[%d]: %d\n", i, arr[i]); // Array anzeigen
   }

   ReadWriteIntoArray(5, arr); // Funktion aufrufen

   for(i = 0; i < 5; i++) // for Schleife, kommt im nächsten Kapitel
   {
       printf("arr[%d]: %d\n", i, arr[i]); // Array nochmal anzeigen
   }
   return 0;
}

void ReadWriteIntoArray(int arraysize, int arrvar[]) // Funktion in die zwei Variablen hineingehen
                                                                                     // erstens die Arraygröße und zweitens der Array selber
{
   int i;

   for(i = 0; i < arraysize; i++) // for Schleife, kommt im nächsten Kapitel
   {
      printf("inside: arr[%d]: %d\n", i, arrvar[i]); // Array ausgeben
      arrvar[i]++; // Arrayelement wird verändert
   }
}

Komplizierter wird es, wenn man einen mehrdimensionalen Array an eine Funktion übergeben will. Hier muß man zumindestens die Größe der 2. bis ntnen Dimension angeben, sonst weiß der Compiler nicht, wie er den Speicher organisieren soll. Die der 1. Arraydimension darf man natürlich auch angeben, wenn man sie schon vorher weiß. Sehen Sie sich bitte noch mal die Abbildung des mehrdimensionalen Array an und überlegen, warum man dem Compiler die Größe der 2. und aller weiteren Dimensionen mitteilen muß.

Hier ein Beispielprogramm:

#include <stdio.h>

int main (int argc, const char *argv[])
{
   int i, j;
   int arr[2][3]; // Array wird definiert, zwei Dimensionen
   arr[0][0] = 1; // Array wird initialisiert
   arr[0][1] = 2;
   arr[0][2] = 3;
   arr[1][0] = 11;
   arr[1][1] = 12;
   arr[1][2] = 13;

   for(i = 0; i < 2; i++) // for Schleife, kommt im nächsten Kapitel
      for(j = 0; j < 3; j++)
          printf("arr[%d]: %d\n", i, arr[i]); // Array anzeigen

       ReadWriteIntoArray(2, arr); // Funktion aufrufen

   for(i = 0; i < 2; i++) // for Schleife, kommt im nächsten Kapitel
      for(j = 0; j < 3; j++)
          printf("arr[%d]: %d\n", i, arr[i]); // Array nochmal anzeigen

    return 0;
}

void ReadWriteIntoArray(int arraysize, int arrvar[][4]) // Funktion in die zwei Variablen hineingehen
                                                                                          // erstens die Arraygröße und zweitens
                                                                                          // der zweidimensionale Array selber
                                                                                          // diesmal wird die Größe der zweiten Dimension angegeben
{
   int i, j;

   for(i = 0; i < arraysize; i++)// for Schleife, kommt im nächsten Kapitel
   {
      for(j = 0; j < 4; j++)
      {
         printf("inside: arr[%d][%d]: %d\n", i, j, arrvar[i][j]);
         arrvar[i][j]++; // Arrayelement wird verändert
      }
   }
}

Probieren Sie die beiden Progrämmchen doch einfach mal aus und sehen sich den Output an.
Warum kann man den Array in der Funktion in folgender Zeile:

arrvar[i][j]++; // Arrayelement wird verändert

eigentlich ändern? Nun der Compiler organisiert die Variablenübergabe für Arrays by Reference, d.h es wird ein Pointer übergeben, der direkt auf den Speicherort des Arrays zeigt, wird sp�ter noch mal erklärt. Bei "normalen" Variablen übergibt der Compiler eine Kopie der Variable an die Funktion (by value), er legt einen neuen Speicherbereich an und kopiert dort den Inhalt der Variablen hinein. Bei Arrays tut er dies jedoch nicht, sondern übegint nur einen Pointer auf den Beginn des Speicherbereiches des Arrays. Das hat damit zu tun, das Arrays tendenziell sehr groß werden können und man so den Hauptspeicher sehr schnell verbraucht.

Die C/C++ Standard Referenz von Herb Schildt:

Wie ist ein Array aufgebaut?

Was ist ein Array Wert?

Was ist ein Array und wie wird dieses definiert?

Wie gibt man ein Array aus?