Come posso dichiarare un array di dimensioni variabili (a livello globale)

Mi piacerebbe realizzare tre array della stessa lunghezza. Secondo la documentazione , le matrici devono essere definite come int myArray[10];dove 10 può essere sostituito con una lunghezza nota (un altro numero intero) o riempito con un array {2, 3, 5, 6, 7}.

Tuttavia, quando ho tentato di dichiarare un valore int arrSize = 10;e poi una serie sulla base di tale dimensione int myArray[arrSize];, ottengo il seguente: error: array bound is not an integer constant.

Esiste un modo per determinare in modo variabile le dimensioni dell'array o devo solo codificarle? (Mi è stato insegnato che l'hardcoding è male e qualcosa da evitare a tutti i costi.)

La tua domanda ha 2 parti in realtà.

1 / Come posso dichiarare la dimensione costante di un array all'esterno dell'array?

Puoi usare una macro

#define ARRAY_SIZE 10
...
int myArray[ARRAY_SIZE];

o usa una costante

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

se hai inizializzato l'array e devi conoscerne le dimensioni, puoi fare:

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

il secondo sizeofè sul tipo di ciascun elemento dell'array, qui int.

2 / Come posso avere un array la cui dimensione è dinamica (cioè non nota fino al runtime)?

Per questo avrai bisogno di allocazione dinamica, che funziona su Arduino, ma generalmente non è consigliata in quanto ciò può causare la frammentazione dell'heap.

Puoi fare (modo C):

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

Oppure (modo C ++):

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

Per ulteriori informazioni sui problemi con la frammentazione dell'heap, è possibile fare riferimento a questa domanda .

La dimensione dell'array deve essere nota al momento della compilazione. Altrimenti dovresti allocare la memoria in modo dinamico usando:

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

dove x (un numero intero) può essere impostato nel codice dell'applicazione (è possibile caricarlo da eeprom se si desidera che sia un'impostazione persistente ma configurabile).

Tuttavia, se si desidera dichiarare solo matrici della stessa dimensione, è sufficiente dichiarare il numero una costante come questa:

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

Penso che non codificare le cose abbia senso solo se ci si aspetterebbe ragionevolmente che l'utente voglia cambiare l'impostazione a un certo punto. Non so se sia così.

Se conosci la lunghezza massima dell'array, inizializza l'array a quella lunghezza e usa un numero intero per dire al programma quanto dell'array usare. Se è la differenza tra 7,10 byte, non stai sprecando così tanta memoria.

So di essere un po 'in ritardo qui, ma in teoria matrici regolari non possono essere create usando una variabile per definire la quantità di elementi che l'array avrà come in:

int arrSize;
int myArray[arrSize];

Ciò visualizzerà un errore poiché quando si dichiara l'array, il programma prevede che il valore tra parentesi sia una costante. Tuttavia, esiste un modo in cui è possibile creare un array con una variabile che definisce la quantità di valori che questi array avranno attraverso l'allocazione dinamica della memoria per i set di valori (questo metodo è stato testato solo con array monodimensionali, non ho provato per multidimensionale) e va così:

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

Successivamente, tutto ciò che resta da fare è assegnare un valore per ogni elemento creato nell'istanza myArray (che ormai è già un array) come faresti per un normale array creato come myArray [arrSize].