Ich möchte drei Arrays mit der gleichen Länge erstellen. Laut der Dokumentation müssen Arrays als "int myArray[10]" definiert werden, wobei 10 durch eine bekannte Länge (eine andere ganze Zahl) ersetzt oder mit einem Array "{2, 3, 5, 6, 7" gefüllt werden kann.
Wenn ich jedoch versuche, einen Wert int arrSize = 10;
und dann ein Array basierend auf dieser Größe int myArray[arrSize];
zu deklarieren, erhalte ich folgendes: Fehler: array bound ist keine Integer-Konstante".
Gibt es eine Möglichkeit, die Array-Größen variabel zu bestimmen, oder muss ich sie einfach hart kodieren? (Mir wurde beigebracht, dass Hardcoding schlecht ist und um jeden Preis zu vermeiden ist).
Ihre Frage hat eigentlich 2 Teile.
1/ Wie kann ich die konstante Größe eines Arrays außerhalb des Arrays deklarieren?
Sie können entweder ein Makro verwenden
#define ARRAY_SIZE 10
...
int myArray[ARRAY_SIZE];
oder eine Konstante verwenden
const int ARRAY_SIZE = 10;
...
int myArray[ARRAY_SIZE];
wenn Sie das Array initialisiert haben und seine Größe wissen müssen, können Sie das tun:
int myArray[] = {1, 2, 3, 4, 5};
const int ARRAY_SIZE = sizeof(myArray) / sizeof(int);
das zweite sizeof
bezieht sich auf den Typ jedes Elements des Arrays, hier int
.
2/ Wie kann ich ein Array haben, dessen Größe dynamisch ist (d.h. erst zur Laufzeit bekannt)?
Dazu benötigen Sie eine dynamische Zuweisung, die auf Arduino funktioniert, aber im Allgemeinen nicht empfohlen wird, da dies dazu führen kann, dass der "Heap" fragmentiert wird.
Sie können das tun (C Weg):
// Declaration
int* myArray = 0;
int myArraySize = 0;
// Allocation (let's suppose size contains some value discovered at runtime,
// e.g. obtained from some external source)
if (myArray != 0) {
myArray = (int*) realloc(myArray, size * sizeof(int));
} else {
myArray = (int*) malloc(size * sizeof(int));
}
Oder (C++ Weg):
// Declaration
int* myArray = 0;
int myArraySize = 0;
// Allocation (let's suppose size contains some value discovered at runtime,
// e.g. obtained from some external source or through other program logic)
if (myArray != 0) {
delete [] myArray;
}
myArray = new int [size];
Mehr über Probleme mit Heap-Fragmentierung finden Sie in dieser Frage.
Die Größe des Arrays muss zur Kompilierzeit bekannt sein. Andernfalls sollten Sie den Speicher dynamisch zuweisen:
char *chararray = malloc(sizeof(char)*x);
wobei x (eine ganze Zahl) im Anwendungscode festgelegt werden kann (man könnte es aus dem Eeprom laden, wenn es eine dauerhafte, aber konfigurierbare Einstellung sein soll).
Wenn Sie jedoch nur einige Arrays der gleichen Größe deklarieren wollen, müssen Sie nur die Zahl als Konstante wie folgt deklarieren:
const int arrsize = 10;
char array1[arrsize];
int array2[arrsize];
Ich denke, dass das Nicht-Hardcoding nur dann Sinn macht, wenn man vernünftigerweise davon ausgehen kann, dass der Benutzer die Einstellung irgendwann ändern möchte. Ich weiß nicht, ob das der Fall ist.
Wenn Sie die maximale Länge des Arrays kennen, initialisieren Sie das Array einfach auf diese Länge und verwenden Sie eine Ganzzahl, um dem Programm mitzuteilen, wie viel von diesem Array verwendet werden soll. Wenn es der Unterschied zwischen 7 und 10 Bytes ist, verschwenden Sie nicht so viel Speicherplatz.