Arrays (Daten­fel­der) eindimensional

Lese­zeit: 8 Minu­ten
Inhalt

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 wer­den. In die­sem Fall muss die Anzahl der Ele­men­te in den ecki­gen Klam­mern nicht bestimmt werden.

Arrays mit fes­ten Wer­ten erstellen

Bei­spie­le:

Array mit int:

int LED[] = {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 Sta­tus[] = {1, 0, 1, 0, 1};

Array mit Strings:

String Bau­tei­le[] = {"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[] = {3, 4, 5, 6, 7};
bool Status[] = {1, 0, 1, 0, 1};
String Bauteile[] = {"Taster", "Potentiometer", "Fernbedienung", "Sensor", "LED"};
char Buchstaben[] = {"aeiou"};

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

  // auf serielle Verbindung warten
  while (!Serial);
  delay(1000);

  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

Die Anzahl der Ele­men­te muss in der ecki­gen Klam­mer ange­ge­ben werden.

Array mit byte:
void setup()
{
  Serial.begin(9600);

  // auf serielle Verbindung warten
  while (!Serial);
  delay(1000);

  /*
    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);

  // auf serielle Verbindung warten
  while (!Serial);
  delay(1000);

  /* 
    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 des Pro­gramms 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­de­nen Ele­men­te in das neue Array übertragen.

Du musst even­tu­ell die Baud­ra­te her­auf­set­zen, damit die Son­der­zei­chen kor­rekt ange­zeigt werden.

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

  // auf serielle Verbindung warten
  while (!Serial);
  delay(1000);

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

  // Größe des Arrays anzeigen
  Serial.println("Array Satzteile: Größe 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öße 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);

  // auf serielle Verbindung warten
  while (!Serial);
  delay(1000);

  byte Zahlen[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
  Serial.println("Das vollständige Array: ");
  Serial.println("-----------------");
  Serial.println("Länge 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öschung: ");
  Serial.println("-----------------");
  Serial.println("Länge 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[] = {"eins", "zwei", "drei", "vier"};
  Serial.println("Das vollständige Array: ");
  Serial.println("-----------------");
  Serial.println("Länge 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öschung: ");
  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[] = {3, 4, 5, 6, 7};
int NeueZahlen[5];

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

  // auf serielle Verbindung warten
  while (!Serial);
  delay(1000);

  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("L\u00e4nge Array Zahlen: ");
  Serial.println(sizeof(Zahlen) / sizeof(Zahlen[0]));
  Serial.print("L\u00e4nge Array NeueZahlen: ");
  Serial.println(sizeof(NeueZahlen) / sizeof(NeueZahlen[0]));
}

void loop()
{
  // bleibt leer, Programm läuft nur einmal
}
struct struct Variable Varia­ble sizeof sizeof Array mehrdimensional Array mehrdimensional

Letzte Aktualisierung: 3. Okt 2024 @ 11:59