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

18

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.)

user3.1415927
la source
J'ai eu un problème similaire et je l'ai fait. J'apprends aussi, donc je ne peux pas dire si c'est une solution valide ou non, mais cela a fonctionné. Voir ci-dessous une partie du code utilisant des vecteurs, il m'a fallu un peu de temps pour commencer à les comprendre et je ne suis toujours pas un expert en aucun cas: #include <string> #include <vector> #include <iostream> #include <algorithm> #include <string.h> utilisant l'espace de noms std; int main () {nom de chaîne; adresse de chaîne; ville de chaîne; pays de chaîne; réponse chaîne; vecteur <vecteur <chaîne>> personData; for (;;) {vector <string> myTempData; cout << "entrez le nom ou n pour quitter" << endl; getline (cin, nom); if (name == "n") {bre
Misterxp

Réponses:

22

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 .

jfpoilpret
la source
4
1) ARRAY_SIZE = sizeof myArray / sizeof myArray[0];, vous pouvez ainsi changer le type de myArray sans introduire de bugs. Pour la même raison, myArray = realloc(myArray, size * sizeof *myArray);. BTW, lancer la valeur de retour de malloc()ou realloc()est également inutile. 2) La vérification myArray != 0dans la version C est inutile, car elle realloc(NULL, sz)est équivalente à malloc(sz).
Edgar Bonet
const int ARRAY_SIZE = 10; int myArray [ARRAY_SIZE]; Pensez-vous vraiment que c'est possible?. Cela donnerait une erreur de tableau modifiée de manière variable en C.
Arun Joe Cheriyan
@ArunCheriyan en CI ne sait pas, mais en C ++ il se compile et fonctionne parfaitement. Comme Arduino est basé sur C ++, il n'y a pas de problème ici.
jfpoilpret
0

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.

user2973
la source
Coder les tailles symboliquement au lieu de littéralement peut offrir deux avantages: 1) Un symbole bien choisi documente, ou du moins suggère, la raison du choix; et 2) lorsque d' autres parties du programme ou le besoin de module pour être adaptés à ce choix, une expression en utilisant le même symbole peut faire que automatique, ce qui rend l' entretien plus facile.
JRobert
[Un peu hors sujet, mais] "utilisateur" est ambigu car il peut signifier l'une des nombreuses personnes. Cela implique généralement l'utilisateur final, le consommateur du produit final, sauf indication contraire. Ce pourrait être le prochain programmeur, le consommateur immédiatement suivant de votre code, qui pourrait en fait être vous (typique, selon ma propre expérience) un an ou plus après que j'en ai oublié les détails internes les plus infimes). Ou un concepteur de système qui inclut votre code en tant que module prêt à l'emploi dans son produit. Je suppose que vous vouliez dire le deuxième "utilisateur".
JRobert
0

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.

MichaelT
la source
0

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].

NibboNSX
la source