Inhalt
Du kannst dir ein Array wie einen Schrank mit Schubladen vorstellen. In jeder Schublade befindet sich ein Element. Mit Hilfe von Arrays können Daten eines einheitlichen Typs (z. B. ⇒int, bool oder Strings) im Speicher abgelegt und jederzeit wieder hervor geholt werden. Mit den eckigen Klammern wird die Anzahl der Elemente festgelegt.
Arrays können bereits bei der Definition mit Elementen gefüllt werden. In diesem Fall muss die Anzahl der Elemente in den eckigen Klammern nicht bestimmt werden.
Arrays mit festen Werten erstellen
Array mit int:
int LED[] = {3, 4, 5, 6, 7};
Das Array umfasst 5 Elemente:
Der Zugriff auf ein Element des Arrays erfolgt über seine Position im Array (dem Index).
Die Zählung beginnt mit 0!
Array mit bool:
bool Status[] = {1, 0, 1, 0, 1};
Array mit Strings:
String Bauteile[] = {“Taster”, “Potentiometer”, “Fernbedienung”, “Sensor”, “LED”};
Array mit char
char Buchstaben[] = {“aeiou”};
Das Programm zeigt alle Elemente der jeweiligen Arrays an:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 | 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
1 2 3 4 5 6 7 8 9 | 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 Zuweisung von Werten
Die Anzahl der Elemente muss in der eckigen Klammer angegeben werden.
Array mit byte:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 | 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:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 | 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 vergrößern
Die erstellten Arrays sind statisch.
Es können zur Laufzeit des Programms keine Elemente hinzugefügt werden, die über die in den eckigen Klammern festgelegte Anzahl hinausgehen.
Wenn du das Array vergrößern willst, musst du eine neues, größeres Array definieren und die vorhandenen Elemente in das neue Array übertragen.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 | 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
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 | 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ä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] + ” ”); } } void loop() { // bleibt leer, das Programm läuft nur einmal } |
Array kopieren
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 | 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änge Array Zahlen: ”); Serial.println(sizeof(Zahlen) / sizeof(Zahlen[0])); Serial.print(“Länge Array NeueZahlen: ”); Serial.println(sizeof(NeueZahlen) / sizeof(NeueZahlen[0])); } void loop() { // bleibt leer, Programm läuft nur einmal } |
Letzte Aktualisierung: