¿Cómo puedo declarar una matriz de tamaño variable (Globalmente)

Me gustaría hacer tres matrices de la misma longitud. De acuerdo con la documentación , las matrices deben definirse como int myArray[10];donde 10 puede ser sustituido por una longitud conocida (otro entero) o rellenado con una matriz {2, 3, 5, 6, 7}.

Sin embargo, cuando intentó declarar un valor int arrSize = 10;y luego una matriz sobre la base de ese tamaño int myArray[arrSize];, me sale el siguiente: error: array bound is not an integer constant.

¿Hay alguna manera de determinar de forma variable los tamaños de matriz, o solo necesito codificarlos? (Me enseñaron que el hardcoding es malo y que hay que evitarlo a toda costa).

Su pregunta tiene 2 partes en realidad.

1 / ¿Cómo puedo declarar el tamaño constante de una matriz fuera de la matriz?

Puedes usar una macro

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

o usar una constante

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

Si inicializó la matriz y necesita saber su tamaño, puede hacer lo siguiente:

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

el segundo sizeofes sobre el tipo de cada elemento de su matriz, aquí int.

2 / ¿Cómo puedo tener una matriz cuyo tamaño es dinámico (es decir, no se conoce hasta el tiempo de ejecución)?

Para eso necesitará una asignación dinámica, que funciona en Arduino, pero generalmente no se recomienda, ya que esto puede hacer que el "montón" se fragmente.

Puedes hacer (forma 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));
}

O (forma 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];

Para obtener más información sobre problemas con la fragmentación del montón, puede consultar esta pregunta .

El tamaño de la matriz debe conocerse en el momento de la compilación. De lo contrario, debe asignar memoria dinámicamente utilizando:

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

donde x (un número entero) se puede establecer en el código de la aplicación (puede cargarlo desde eeprom si desea que sea una configuración persistente pero configurable).

Sin embargo, si solo desea declarar algunas matrices del mismo tamaño, solo tiene que declarar el número como una constante como esta:

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

Creo que no codificar las cosas solo tiene sentido si razonablemente esperas que el usuario quiera cambiar la configuración en algún momento. No sé si ese es el caso.

Si conoce la longitud máxima de la matriz, simplemente inicialice la matriz a esa longitud y use un número entero para decirle al programa cuánto de esa matriz usar. Si es la diferencia entre 7,10 bytes, entonces no está desperdiciando tanta asignación de memoria.

Sé que llego un poco tarde aquí, pero en teoría no se pueden crear matrices regulares usando una variable para definir la cantidad de elementos que la matriz tendrá como en:

int arrSize;
int myArray[arrSize];

Esto mostrará un error ya que al declarar la matriz, el programa espera que el valor entre paréntesis sea constante. Sin embargo, hay una manera en la que podría crear una matriz con una variable que defina la cantidad de valores que estas matrices tendrá a través de la asignación de memoria dinámica para conjuntos de valores (este método se ha probado solo con matrices monodimensionales, no se ha probado multidimensional todavía), y es algo como esto:

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

Después de esto, todo lo que queda por hacer es asignar un valor para cada elemento creado en la instancia myArray (que ya es una matriz) como lo haría para una matriz normal creada como myArray [arrSize].