A kérdésednek valójában 2 része van.

1 / Hogyan tudom deklarálni a tömb állandó méretét a tömbön kívül?

használjon makrót

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

vagy használjon konstans

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

ha inicializálta a tömböt, és tudnia kell a méretét, akkor megteheti:

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

a második a sizeof a tömb minden elemének típusánál szerepel, itt int.

2 / Hogyan lehet egy tömb, amelynek mérete dinamikus ( azaz futásidejéig nem ismert)?

Ehhez dinamikus elosztásra lesz szükség, amely működik az Arduino-n, de általában nem ajánlott, mivel ez a "halom" szétaprózódását okozhatja. p>

Megteheti (C út):

  // Declarationint * myArray = 0; int myArraySize = 0; // Allocation (le t feltételezzük, hogy a méret tartalmaz néhány futás közben felfedezett értéket, // pl. valamilyen külső forrásból nyert) if (myArray! = 0) {myArray = (int *) realloc (myArray, size * sizeof (int));} else {myArray = (int *) malloc (size * sizeof (int)) ;}  

Vagy (C ++ módon):

  // Declarationint * myArray = 0; int myArraySize = 0; // Allocation (tegyük fel, hogy a méret tartalmaz futás közben felfedezett valamilyen érték, // pl. valamilyen külső forrásból vagy más programlogikából származik) if (myArray! = 0) {delete [] myArray;} myArray = new int [size];  

Ha többet szeretne tudni a kupac töredezettségével kapcsolatos problémákról, olvassa el ezt a kérdést.

A tömb méretét a fordítás idején ismerni kell. Ellenkező esetben dinamikusan kell kiosztania a memóriát a következő használatával:

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

ahol x (egész szám) használható legyen beállítva az alkalmazáskódban (betöltheti az eeprom-ból, ha állandó, de konfigurálható beállítást szeretne).

Ha azonban csak néhány azonos méretű tömböt szeretne deklarálni, egyszerűen deklarálnunk kell a számot egy ilyen állandóvá:

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

Úgy gondolom, hogy a keménykódolás nélküli dolgoknak csak akkor van értelme, ha ésszerűen elvárnád, hogy a felhasználó valamikor megváltoztassa a beállítást. Nem tudom, hogy így van-e.

Ha ismeri a tömb maximális hosszát, csak inicializálja a tömböt erre a hosszúságra, és egész szám segítségével mondja meg a programnak, hogy a tömb mekkora részét használja. Ha ez a 7,10 bájt közötti különbség, akkor nem pazarolja a memória kiosztását.

Tudom, hogy itt egy kicsit elkéstem, de elméletileg nem lehet szabályos tömböket létrehozni egy változó segítségével, hogy meghatározzuk a tömbben lévő elemek mennyiségét, mint:

  int arrSize; int myArray [arrSize];  

Ez hibát jelenít meg, mivel a tömb deklarálásakor a program arra számít, hogy a zárójelek közötti érték állandó lesz. Van azonban egy módja annak, hogy létrehozhat egy tömböt egy változóval, amely meghatározza az értékek mennyiségét, amelyeknek a tömböknek rendelkeznie kell az értékkészletek dinamikus memória-allokációjával (ezt a módszert csak monodimenziós tömbökkel tesztelték, még nem próbálták többdimenziós), és valami ilyesmi történik:

  // Először hozzon létre egy mutatót a létrehozandó halmaz számára elválasztandó memóriaterülethezintint * myArray; int arrSize; // Ezután definiálja azt a változót, amely meghatározza a tömbben lévő elemek mennyiségét, adhat neki értéket, amikor csak akarja, mindaddig, amíg ez az int meg van adva, mielőtt a myArray értékei be vannak állítva myArray = (int *) calloc (arrSize, sizeof (int)) // Itt állíthatja be, hogy a myArray példányt (amelynek memóriaterületét a mutató létrehozása már elkülönítette) az int típusú elemek maximális memóriaértékű arrSize elemére választják szét (bájtban) megegyezik az int típusú változók számára elérhető maximális értékkel  

Ezek után már csak annyit kell tennie, hogy hozzárendel egy értéket a myArray példányban létrehozott minden elemhez (ami már egy Array by now), mint egy myArray [arrSize] néven létrehozott normál tömb esetén.