Wie kann ich ein Array mit variabler Größe deklarieren (global)?

Ich möchte drei Arrays mit der gleichen Länge erstellen. Gemäß der Dokumentation müssen Arrays so definiert werden, int myArray[10];dass 10 durch eine bekannte Länge (eine andere Ganzzahl) ersetzt oder mit einem Array gefüllt werden kann {2, 3, 5, 6, 7}.

Allerdings, wenn ich einen Wert zu erklären versucht , int arrSize = 10;und dann ein Array auf dieser Größe basiert int myArray[arrSize];, erhalte ich die folgende: error: array bound is not an integer constant.

Gibt es eine Möglichkeit, Array-Größen variabel zu bestimmen, oder muss ich sie nur fest codieren? (Mir wurde beigebracht, dass Hardcoding schlecht ist und etwas, das man um jeden Preis vermeiden sollte.)

Ihre Frage besteht eigentlich aus 2 Teilen.

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 verwenden Sie eine Konstante

const int ARRAY_SIZE = 10;
...
int myArray[ARRAY_SIZE];

Wenn Sie das Array initialisiert haben und dessen Größe wissen müssen, können Sie Folgendes tun:

int myArray[] = {1, 2, 3, 4, 5};
const int ARRAY_SIZE = sizeof(myArray) / sizeof(int);

Die zweite sizeofbezieht sich auf den Typ jedes Elements Ihres Arrays int.

2 / Wie kann ich ein Array haben, dessen Größe dynamisch ist (dh erst zur Laufzeit bekannt ist)?

Dafür 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 (C Weg) tun:

// 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];

Weitere Informationen zu Problemen mit der Heap-Fragmentierung finden Sie in dieser Frage .

Die Größe des Arrays muss zur Kompilierungszeit bekannt sein. Andernfalls sollten Sie den Speicher dynamisch zuweisen, indem Sie Folgendes verwenden:

char *chararray = malloc(sizeof(char)*x);

Dabei kann x (eine Ganzzahl) im Anwendungscode festgelegt werden (Sie können es aus eeprom laden, wenn Sie möchten, dass es eine dauerhafte, aber konfigurierbare Einstellung ist).

Wenn Sie jedoch nur einige Arrays derselben Größe deklarieren möchten, müssen Sie die Zahl nur als Konstante deklarieren:

const int arrsize = 10;
char array1[arrsize];
int array2[arrsize];

Ich denke, Dinge nicht hart zu codieren, ist nur dann sinnvoll, wenn Sie vernünftigerweise erwarten, 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 mit dieser Länge und geben Sie dem Programm mit einer Ganzzahl an, wie viel des Arrays verwendet werden soll. Wenn es sich um den Unterschied zwischen 7,10 Byte handelt, verschwenden Sie nicht so viel Speicherplatz.

Ich weiß, dass ich hier etwas spät dran bin, aber theoretisch können reguläre Arrays nicht mit einer Variablen erstellt werden, um die Anzahl der Elemente zu definieren, die das Array haben wird, wie in:

int arrSize;
int myArray[arrSize];

Dies zeigt einen Fehler an, da das Programm beim Deklarieren des Arrays erwartet, dass der Wert zwischen den Klammern eine Konstante ist. Es gibt jedoch eine Möglichkeit, ein Array mit einer Variablen zu erstellen, die die Anzahl der Werte definiert, die dieses Array durch dynamische Speicherzuweisung für Wertemengen haben soll (diese Methode wurde nur mit eindimensionalen Arrays getestet und noch nicht getestet) mehrdimensional noch), und es geht in etwa so:

//First you create a pointer for the memory space to be separated for the set you're creating
int* myArray;
int arrSize; //Then you define the variable that will determine the amount of elements the array is going to have, you can give it a value whenever you want as long as this int is defined before the values in myArray are set 
myArray=(int*)calloc(arrSize,sizeof(int)) //Here, you establish that the instance myArray (whose memory space has already been separated through the creation of the pointer) will be separated into arrSize amount of elements of type int with a maximum memory value (in bytes) equal to the maximum available for the int type variables

Danach müssen Sie nur noch jedem Element, das in der Instanz myArray (die bereits ein Array ist) erstellt wurde, einen Wert zuweisen, wie bei einem normalen Array, das als myArray [arrSize] erstellt wurde.