Bagaimana saya bisa mendeklarasikan array ukuran variabel (Secara global)

Saya ingin membuat tiga array dengan panjang yang sama. Menurut dokumentasi , Array harus didefinisikan sebagai di int myArray[10];mana 10 dapat diganti dengan panjang yang diketahui (integer lain), atau diisi dengan array {2, 3, 5, 6, 7}.

Namun, ketika saya mencoba untuk menyatakan nilai int arrSize = 10;dan kemudian sebuah array berdasarkan ukuran yang int myArray[arrSize];, saya mendapatkan berikut: error: array bound is not an integer constant.

Apakah ada cara untuk menentukan ukuran array secara variatif, atau apakah saya hanya perlu melakukan hardcode? (Saya diajarkan bahwa hardcoding itu buruk dan sesuatu yang harus dihindari dengan cara apa pun.)

Pertanyaan Anda sebenarnya memiliki 2 bagian.

1 / Bagaimana saya bisa mendeklarasikan ukuran konstan array di luar array?

Anda bisa menggunakan makro

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

atau gunakan konstanta

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

jika Anda menginisialisasi array dan Anda perlu tahu ukurannya maka Anda bisa melakukannya:

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

yang kedua sizeofadalah pada jenis setiap elemen array Anda, di sini int.

2 / Bagaimana saya bisa memiliki array yang ukurannya dinamis (tidak diketahui sampai runtime)?

Untuk itu Anda perlu alokasi dinamis, yang berfungsi pada Arduino, tetapi umumnya tidak disarankan karena ini dapat menyebabkan "tumpukan" menjadi terfragmentasi.

Anda dapat melakukan (cara 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));
}

Atau (C ++ way):

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

Untuk lebih lanjut tentang masalah dengan tumpukan tumpukan, Anda bisa merujuk ke pertanyaan ini .

Ukuran array harus diketahui pada waktu kompilasi. Kalau tidak, Anda harus mengalokasikan memori secara dinamis menggunakan:

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

di mana x (bilangan bulat) dapat diatur dalam kode aplikasi (Anda dapat memuatnya dari eeprom jika Anda menginginkannya sebagai pengaturan yang persisten tetapi dapat dikonfigurasi).

Namun jika Anda hanya ingin mendeklarasikan beberapa array dengan ukuran yang sama, Anda hanya perlu mendeklarasikan angka dengan konstanta seperti ini:

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

Saya pikir tidak meng-hardcoding hal-hal hanya masuk akal jika Anda cukup berharap pengguna ingin mengubah pengaturan di beberapa titik. Saya tidak tahu apakah itu masalahnya.

Jika Anda tahu panjang maksimum array, inisialisasi saja array dengan panjang itu dan gunakan integer untuk memberi tahu program berapa banyak array yang digunakan. Jika perbedaannya antara 7,10 byte maka Anda tidak membuang banyak alokasi memori.

Saya tahu saya sedikit terlambat di sini, tetapi secara teori array reguler tidak dapat dibuat menggunakan variabel untuk menentukan jumlah elemen array akan memiliki seperti dalam:

int arrSize;
int myArray[arrSize];

Ini akan menampilkan kesalahan karena ketika mendeklarasikan array, program mengharapkan nilai antara tanda kurung menjadi konstan. Namun, ada cara di mana Anda dapat membuat array dengan variabel yang mendefinisikan jumlah nilai array ini akan memiliki melalui alokasi memori dinamis untuk set nilai (metode ini telah diuji dengan hanya array monodimensional, belum mencoba untuk multidimensi), dan itu berlangsung seperti ini:

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

Setelah ini, yang harus dilakukan hanyalah menetapkan nilai untuk setiap elemen yang dibuat dalam instance myArray (yang sudah menjadi Array sekarang) seperti yang Anda lakukan untuk array normal yang dibuat sebagai myArray [arrSize].