Comment puis-je déclarer un tableau de taille variable (globalement)

Je voudrais faire trois tableaux de la même longueur. Selon la documentation , les tableaux doivent être définis comme int myArray[10];où 10 peut être remplacé par une longueur connue (un autre entier) ou rempli par un tableau {2, 3, 5, 6, 7}.

Cependant, quand je tentais de déclarer une valeur int arrSize = 10;et un tableau en fonction de cette taille int myArray[arrSize];, je reçois les points suivants: error: array bound is not an integer constant.

Existe-t-il un moyen de déterminer de manière variable la taille des tableaux, ou dois-je simplement les coder en dur? (On m'a appris que le codage en dur est mauvais et quelque chose à éviter à tout prix.)

Votre question comporte en fait 2 parties.

1 / Comment puis-je déclarer la taille constante d'un tableau en dehors du tableau?

Vous pouvez soit utiliser une macro

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

ou utilisez une constante

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

si vous avez initialisé le tableau et que vous devez connaître sa taille, vous pouvez faire:

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

le second sizeofconcerne le type de chaque élément de votre tableau, ici int.

2 / Comment puis-je avoir un tableau dont la taille est dynamique (c'est-à-dire inconnue jusqu'à l'exécution)?

Pour cela, vous aurez besoin d'une allocation dynamique, qui fonctionne sur Arduino, mais n'est généralement pas conseillée car cela peut entraîner la fragmentation du "tas".

Vous pouvez faire (voie 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 (façon 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];

Pour plus d'informations sur les problèmes de fragmentation de segment, vous pouvez vous référer à cette question .

La taille du tableau doit être connue au moment de la compilation. Sinon, vous devez allouer de la mémoire dynamiquement en utilisant:

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

où x (un entier) peut être défini dans le code de l'application (vous pouvez le charger depuis eeprom si vous voulez que ce soit un paramètre persistant mais configurable).

Cependant, si vous voulez simplement déclarer des tableaux de la même taille, il vous suffit de déclarer le nombre une constante comme ceci:

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

Je pense que ne pas coder les choses en dur n'a de sens que si l'on peut raisonnablement s'attendre à ce que l'utilisateur veuille changer le réglage à un moment donné. Je ne sais pas si c'est le cas.

Si vous connaissez la longueur maximale du tableau, il suffit d'initialiser le tableau à cette longueur et d'utiliser un entier pour indiquer au programme la quantité de ce tableau à utiliser. Si c'est la différence entre 7,10 octets, vous ne perdez pas autant d'allocation de mémoire.

Je sais que je suis un peu en retard ici, mais en théorie, les tableaux réguliers ne peuvent pas être créés à l'aide d'une variable pour définir la quantité d'éléments que le tableau aura comme:

int arrSize;
int myArray[arrSize];

Cela affichera une erreur car lors de la déclaration du tableau, le programme s'attend à ce que la valeur entre les crochets soit constante. Pourtant, il existe un moyen de créer un tableau avec une variable définissant la quantité de valeurs que ces tableaux vont avoir grâce à l'allocation de mémoire dynamique pour les ensembles de valeurs (cette méthode a été testée avec des tableaux monodimensionnels uniquement, je n'ai pas essayé depuis multidimensionnel pour le moment), et ça se passe comme ceci:

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

Après cela, tout ce qui reste à faire est d'attribuer une valeur à chaque élément créé dans l'instance myArray (qui est déjà un tableau à présent) comme vous le feriez pour un tableau normal créé en tant que myArray [arrSize].