Arrays (Daten­fel­der) eindimensional

Lese­zeit: 8 Minu­ten

Du kannst dir ein Array wie einen Schrank mit Schub­la­den vor­stel­len. In jeder Schub­la­de befin­det sich ein Ele­ment. Mit Hil­fe von Arrays kön­nen Daten eines ein­heit­li­chen Typs (z. B. ➨int, bool oder Strings) im Spei­cher abge­legt und jeder­zeit wie­der her­vor geholt wer­den. Mit den ecki­gen Klam­mern wird die Anzahl der Ele­men­te festgelegt.

Arrays kön­nen bereits bei der Defi­ni­ti­on mit Ele­men­ten gefüllt werden.

Arrays mit fes­ten Wer­ten erstellen

Bei­spie­le:

Array mit int:

int LED[5] = {3, 4, 5, 6, 7};

Das Array umfasst 5 Elemente:

Der Zugriff auf ein Ele­ment des Arrays erfolgt über sei­ne Posi­ti­on im Array (dem Index).
Die Zäh­lung beginnt mit 0!

Array mit bool:

bool Status[5] = {1, 0, 1, 0, 1};

Array mit Strings:

String Bauteile[5] = {"Tas­ter", "Poten­tio­me­ter", "Fern­be­die­nung", "Sen­sor", "LED"};

Array mit char

char Buch­sta­ben[] = {"aei­ou"};

Das Pro­gramm zeigt alle Ele­men­te der jewei­li­gen Arrays an:

int LED[5] = {3, 4, 5, 6, 7};
bool Status[5] = {1, 0, 1, 0, 1};
String Bauteile[5] = {"Taster", "Potentiometer", "Fernbedienung", "Sensor", "LED"};
char Buchstaben[5] = {"aeiou"};

void setup()
{
  Serial.begin(9600);
  Serial.println("Array LED");

  for (int i = 0; i < 5; i++)
  {
    Serial.print(String(LED[i]) + " ");
  }
 
  Serial.println();
  Serial.println("--------------------------------------");
  Serial.println("Array Status");

  for (int i = 0; i < 5; i++)
  {
    Serial.print(String(Status[i]) + " ");
  }
 
  Serial.println();
  Serial.println("--------------------------------------");
  Serial.println("Array Bauteile");
 
  for (int i = 0; i < 5; i++)
  {
    Serial.print(Bauteile[i] + " ");
  } 
 
  Serial.println();
  Serial.println("--------------------------------------");
  Serial.println("Array Buchstaben");

  for (int i = 0; i < 5; i++)
  {
    Serial.print(Buchstaben[i]);
  }
}

void loop()
{ 
  // bleibt leer, das Programm läuft nur einmal 
}

So sieht es aus:

char-Array aus einem String erstellen
String Eingabe = "Programmieren ist toll!" 

// Array Satz erstellen 
// Anzahl der Elemente entspricht der Anzahl der Buchstaben  

char Satz[Eingabe.length()];

// der Befehl toCharArray wandelt den String Eingabe in ein char-Array um:
Eingabe.toCharArray(Satz, Eingabe.length() + 1); 
Arrays ohne die Zuwei­sung von Werten
Array mit byte:
void setup()
{
  Serial.begin(9600);

  /* Lösung mit byte
    byte belegt 1 Byte Speicherplatz
    Array mit 10 Elementen anlegen
    sizeof(Zahlen) bestimmt die Größe des Arrays Zahlen
  */
  byte Zahlen[10];
  
  // Elemente zuweisen
  for (int i = 0; i < sizeof(Zahlen) + 1; i++)
  {
    Zahlen[i] = i * 10;
  } 
  Serial.println("Einmaleins: ");
  for (int i = 0; i < sizeof(Zahlen) + 1; i++)
  {
    Serial.println(Zahlen[i]);
  }
}

void loop()
{
  // bleibt leer, Programm läuft nur einmal
}
Array mit int:
void setup()
{
  Serial.begin(9600);

  /* Lösung mit int
    Array mit 10 Elementen anlegen
    sizeof(Zahlen) bestimmt die Größe des Arrays Zahlen
    int belegt 2 Byte Speicherplatz
    -> Größe des Arrays muss durch die Größe des ersten Elements
    geteilt werden sizeof(Zahlen[0])
  */
  int Zahlen[10];

  for (int i = 0; i < sizeof(Zahlen) / sizeof(Zahlen[0]) + 1; i++)
  {
    Zahlen[i] = i * 10;
  } 
  Serial.println("Einmaleins: ");
  for (int i = 0; i < sizeof(Zahlen) / sizeof(Zahlen[0]) + 1; i++)
  {
    Serial.println(Zahlen[i]);
  }
}

void loop()
{
  // bleibt leer, Programm läuft nur einmal
}
Array ver­grö­ßern

Die erstell­ten Arrays sind sta­tisch.
Es kön­nen zur Lauf­zeit kei­ne Ele­men­te hin­zu­ge­fügt wer­den, die über die in den ecki­gen Klam­mern fest­ge­leg­te Anzahl hinausgehen.

Wenn du das Array ver­grö­ßern willst, musst du eine neu­es, grö­ße­res Array defi­nie­ren und die vor­han­den Ele­men­te in das neue Array übertragen.

Das Pro­gramm:

void setup()
{
  Serial.begin(9600);

  // Array mit 5 Elementen erzeugen, Zählung beginnt mit 0
  String Satzteile[5];

  // Größe des Arrays anzeigen
  Serial.println("Array Satzteile: Gr\u00f6\u00dfe des Arrays: " + 
  String(sizeof(Satzteile) / sizeof(Satzteile[0])));

  // Array mit Daten füllen
  for (int i = 0; i < sizeof(Satzteile) / sizeof(Satzteile[0]); i ++)
  {
    Satzteile[i] = "Wort " + String(i) + " ";
    Serial.print(Satzteile[i]);
  }

  Serial.println();

  // neues Array mit 10 Elementen definieren
  String neueSatzteile[10];

  // Daten aus dem Array Satzteile in das neue Array übertragen
  for (int i = 0; i < sizeof(Satzteile) / sizeof(Satzteile[0]); i ++)
  {
    neueSatzteile[i] = Satzteile[i];
  }

  
  Serial.println("-------------------------------------------------------------------");

  // Größe des Arrays anzeigen
  Serial.println("Array neueSatzteile: Gr\u00f6\u00dfe des Arrays: " + 
  String(sizeof(neueSatzteile) / sizeof(neueSatzteile[0])));

  /*
    neue Daten hinzufügen
    Startposition: Größe des Arrays Satzteile, 
    Ende: Größe des Arrays neueSatzteile
  */
  for (int i = sizeof(Satzteile) / sizeof(Satzteile[0]); i < sizeof(neueSatzteile) / 
  sizeof(neueSatzteile[0]); i ++)
  {
    neueSatzteile[i] = "Wort " + String(i) + " ";
  }

  for (int i = 0; i < sizeof(neueSatzteile) / sizeof(neueSatzteile[0]); i ++)
  {
    Serial.print(neueSatzteile[i]);
  }

  Serial.println();
  Serial.println("-------------------------------------------------------------------");
}

void loop()
{
  // bleibt leer, Programm läuft nur einmal
}
Array löschen
void setup()
{
  Serial.begin(9600);
  byte Zahlen[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
  Serial.println("Das vollst\u00e4ndige Array: ");
  Serial.println("-----------------");
  Serial.println("L\u00e4nge des Arrays: " + String(sizeof(Zahlen)));
  Serial.println("Inhalt des Arrays: ");

  for (int i = 0; i < sizeof(Zahlen); i++)
  {
    Serial.print(Zahlen[i]);
  }

  // Array löschen -> alle Werte mit 0 überschreiben
  memset(Zahlen, 0, sizeof(Zahlen));
  Serial.println("\n-----------------");
  Serial.println("Nach der L\u00f6schung: ");
  Serial.println("-----------------");
  Serial.println("L\u00e4nge des Arrays: " + String(sizeof(Zahlen)));
  Serial.println("Inhalt des Arrays: ");

  for (int i = 0; i < sizeof(Zahlen); i++)
  {
    Serial.print(Zahlen[i]);
  }
  Serial.println("\n-----------------");

  // Array mit Strings
  String Woerter[4] = {"eins", "zwei", "drei", "vier"};
  Serial.println("Das vollst\u00e4ndige Array: ");
  Serial.println("-----------------");
  Serial.println("L\u00e4nge des Arrays: " + String(sizeof(Woerter) / sizeof(Woerter[0])));
  Serial.println("Inhalt des Arrays: ");
  
  for (int i = 0; i < sizeof(Woerter) / sizeof(Woerter[0]); i++)
  {
    Serial.print(Woerter[i] + " ");
  }

  // Array löschen -> alle Werte mit 0 überschreiben
  memset(Woerter, "", sizeof(Woerter));
  Serial.println("\n-----------------");
  Serial.println("Nach der L\u00f6schung: ");
  Serial.println("-----------------");
  Serial.println("L\u00e4nge des Arrays: " + String(sizeof(Woerter) / sizeof(Woerter[0])));
  Serial.println("Inhalt des Arrays: ");

  for (int i = 0; i < sizeof(Woerter) / sizeof(Woerter[0]); i++)
  {
    Serial.print(Woerter[i] + " ");
  }
}

void loop()
{
  // bleibt leer, das Programm läuft nur einmal
}
Array kopie­ren
int Zahlen[5] = {3, 4, 5, 6, 7};
int NeueZahlen[5];

void setup()
{
  Serial.begin(9600);
  Serial.println("Array Zahlen: ");

  // for-Schleife vom ersten (0) bis zum letzten Element des Arrays Zahlen
  for (int i = 0; i < sizeof(Zahlen) / sizeof(Zahlen[0]); i++)
  {
    Serial.print(Zahlen[i]);
  }

  // Array kpieren
  memcpy(NeueZahlen, Zahlen, sizeof(Zahlen));

  Serial.println("\n------------");
  Serial.println("Array NeueZahlen: ");
  for (int i = 0; i < sizeof(NeueZahlen) / sizeof(NeueZahlen[0]); i++)
  {
    Serial.print(NeueZahlen[i]);
  }

  Serial.println("\n------------");
  Serial.print("Laenge Array Zahlen: ");
  Serial.println(sizeof(Zahlen) / sizeof(Zahlen[0]));
  Serial.print("Laenge Array NeueZahlen: ");
  Serial.println(sizeof(NeueZahlen) / sizeof(NeueZahlen[0]));
}

void loop()
{
  // bleibt leer, Programm läuft nur einmal
}

struct Varia­ble size­of Array mehrdimensional

Letzte Aktualisierung: 22. Nov 2020 @ 9:33