Como posso declarar uma matriz de tamanho variável (globalmente)

Eu gostaria de fazer três matrizes do mesmo comprimento. De acordo com a documentação , as matrizes devem ser definidas como int myArray[10];onde 10 pode ser substituído por um comprimento conhecido (outro número inteiro) ou preenchido com uma matriz {2, 3, 5, 6, 7}.

No entanto, quando tentou declarar um valor int arrSize = 10;e, em seguida, uma série com base nesse tamanho int myArray[arrSize];, eu recebo o seguinte: error: array bound is not an integer constant.

Existe uma maneira de determinar de forma variável os tamanhos de matriz ou eu apenas preciso codificá-los? (Foi-me ensinado que codificar é ruim e é algo a evitar a todo custo.)

Sua pergunta tem 2 partes, na verdade.

1 / Como posso declarar o tamanho constante de uma matriz fora da matriz?

Você pode usar uma macro

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

ou use uma constante

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

se você inicializou a matriz e precisa saber seu tamanho, pode fazer:

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

o segundo sizeofestá no tipo de cada elemento da sua matriz, aqui int.

2 / Como posso ter uma matriz cujo tamanho seja dinâmico (isto é, desconhecido até o tempo de execução)?

Para isso, você precisará de alocação dinâmica, que funciona no Arduino, mas geralmente não é aconselhável, pois isso pode fazer com que o "heap" fique fragmentado.

Você pode fazer (maneira 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));
}

Ou (maneira 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 obter mais informações sobre problemas com a fragmentação de heap, você pode consultar esta pergunta .

O tamanho da matriz deve ser conhecido em tempo de compilação. Caso contrário, você deve alocar memória dinamicamente usando:

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

onde x (um número inteiro) pode ser definido no código do aplicativo (você pode carregá-lo da eeprom se desejar que seja uma configuração persistente, mas configurável).

No entanto, se você quiser apenas declarar algumas matrizes do mesmo tamanho, basta declarar o número uma constante como esta:

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

Eu acho que não codificar as coisas só faz sentido se você razoavelmente espera que o usuário queira alterar a configuração em algum momento. Não sei se é esse o caso.

Se você souber o comprimento máximo da matriz, basta inicializar a matriz com esse comprimento e use um número inteiro para informar ao programa quanto dessa matriz usar. Se for a diferença entre 7,10 bytes, você não estará desperdiçando tanta alocação de memória.

Eu sei que estou um pouco atrasado aqui, mas em teoria matrizes regulares não podem ser criadas usando uma variável para definir a quantidade de elementos que a matriz terá como em:

int arrSize;
int myArray[arrSize];

Isso exibirá um erro, pois ao declarar a matriz, o programa espera que o valor entre colchetes seja constante. No entanto, existe uma maneira de criar uma matriz com uma variável que define a quantidade de valores que essas matrizes terão por meio da alocação de memória dinâmica para conjuntos de valores (esse método foi testado apenas com matrizes monodimensionais, não tentei multidimensional ainda), e é mais ou menos assim:

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

Depois disso, basta atribuir um valor para cada elemento criado na instância myArray (que já é uma matriz agora), como faria para uma matriz normal criada como myArray [arrSize].