Problemi con Array

Salve a Tutti,

Ho da poco iniziato con Arduino, sto smanettando con l'uso degli Array, ho qualche discrepanza tra quello che dice la guida online del sito ufficiale e quello che il compilatore mi da quando tento di verificare il codice. in sostanza, il manuale dice che gli array in C sono entità con index "Zero based" ovvero che in un'array di 10 elementi, il primo indirizzo sarà 0, poi 1, poi 2 e così fino all'ultimo, che sarà 9. Un array lo dichiariamo ed inizializziamo così:

int nomearray[8]={10,20,30,40,50,60,70,80,90};

ma tentando di verificarlo nel compilatore del IDE di Arduino, mi da errore di lunghezza array, si stanno inizializzando più valori dell'array dichiarato, se invece di [8] metto [9] l'errore sparisce! idem, se nel manuale si vede che si può dichiarare e inizializzare un'array con index 0 cosi: int array[0]={10}; nella verifica del codice, mi da errore, non ne vuole sapere! ma quale è il problema? forse non inizia da 0? o sto dimenticando qualcosa?

A voi esperti la parola!!

Saluti,
Antonio

ciao

 int array[0]={10};

devi scrivere

 int array[1]={10};

l'indice 0 è la posizione del primo elemento dell'array, tra parentesi indichi la dimensione del array [dim array]

stefano

Ciao Stefano, grazie del tuo intervento, ma non mi è del tutto chiaro perché da quello che ho letto sul sito ufficiale e cito testualmente:

To assign a value to an array:
mySensVals[0] = 10;

It also means that in an array with ten elements, index nine is the last element. Hence:
int myArray[10]={9,3,2,4,3,2,7,8,9,11};
// myArray[9] contains 11
// myArray[10] is invalid and contains random information (other memory address)

ma se inserisco nell'IDE Arduino questo:

int myArray[0]={10}; mi da errore (too many initializers for 'int [0]')

ma se faccio:

int myArray[0]; //array dichiarata ma senza inizializzazione dati,

myArray[0]=10; // assegno all'indice 0 il valore 10

Fatto così Non da nessun errore. Quindi il mio errore è stato non dichiarare prima l'array e poi assegnargli il valore.

Ma se faccio così:

int Array[1]={10}; //dichiaro l'array e la sua dimensione, ed assegno un valore (ma secondo quanto letto nel sito, ne dovrei poter inizializzare due dati e non uno solo. Fatto così non da errori ovvero:

int Array[1]={10}; non da errore.
int Array[0]={10}; da errore.
int Array[0]={}; non da errore.

int Array[8];
Array[8]=10,20,30,40,50,60,70,80,90; così funziona! (senza int perché dichiarata prima e senza dati tra parentesi graffe!!

Capisco che il problema è che non ho ancora afferrato del tutto la differenza, dopo tutto è la prima volta con arduino, con C e in generale con le array visto che le ho usate poco in passato, nello stesso sito ufficiale (e in quelli che trattano "C") è chiaro che essendo basati "zero" quindi partono da 0 come dice il testo che ho qui sopra evidenziato (in un'array di dieci elementi, l'ultimo index sarà il 9! quindi se dichiaro ed inizializzo un array con index 0 è plausibile che possa metterci un dato. no?

Beh, significa che dovrò prima dichiararla e poi in secondo momento assegnargli i valori, ma sarebbe stato meglio farlo fin dall'inizio, no? Secondo me vi è qualche inesattezza nella spiegazione.

Comunque grazie della tua disponibilità!

saluti,
Antonio

PS: scusate del lungo "intervento" tenterò di essere più sintetico in futuro! Ciao!

sarebbe roba da sezione software... comunque la risposta ai tuoi dilemmi è che il compilatore di arudino non rileva l'overflow di lettura /scrittura sugli array.
Quindi quando scrivi fuori dal range in effetti scrivi in una zona "arbitraria" della memoria

 int myArrayaa[5]={ 1, 2, 3, 4, 5 };
 //int myArray[1]={999};    //array dichiarata ma senza inizializzazione dati,
 int myArray[0];
int myArraybb[5]={ 6, 7, 8, 9, 10 };    //array dichiarata ma senza inizializzazione dati,


void setup() {
 
  Serial.begin(9600);
 

}


void loop() {
 
int i;

myArray[4]=88;    // assegno all'indice 0 il valore 10   
 

for (i = 0; i<5;i++){ 
 Serial.print("-");
 Serial.print( myArrayaa[i]);
}


for (i = 0; i<5;i++){ 
 Serial.print("-"); 
 Serial.print( myArraybb[i]);
} 


delay (1000);

}

c'è però un aspetto curioso: vedi la dichirazione dell'array da 0 elementi?... così il programma va e stampa i numeri corretti da 1 a 10... se però dichiari l'array centrale di un elemento (riga commentata) quando vai a scrivere fuori range vai a scrivere su arraybb... come ci si aspetterebbe... in pratica per l'allocazione dell'array vuoto sembra che il compilatore si accorga e lo dichiari altrove e non come ci si aspetterebbe tra i due array...

hiperformance71:
Salve a Tutti,

Ho da poco iniziato con Arduino, sto smanettando con l'uso degli Array, ho qualche discrepanza tra quello che dice la guida online del sito ufficiale e quello che il compilatore mi da quando tento di verificare il codice. in sostanza, il manuale dice che gli array in C sono entità con index "Zero based" ovvero che in un'array di 10 elementi, il primo indirizzo sarà 0, poi 1, poi 2 e così fino all'ultimo, che sarà 9. Un array lo dichiariamo ed inizializziamo così:

int nomearray[8]={10,20,30,40,50,60,70,80,90};

ma tentando di verificarlo nel compilatore del IDE di Arduino, mi da errore di lunghezza array, si stanno inizializzando più valori dell'array dichiarato, se invece di [8] metto [9] l'errore sparisce! idem, se nel manuale si vede che si può dichiarare e inizializzare un'array con index 0 cosi: int array[0]={10}; nella verifica del codice, mi da errore, non ne vuole sapere! ma quale è il problema? forse non inizia da 0? o sto dimenticando qualcosa?

A voi esperti la parola!!

Saluti,
Antonio

Il tuo errore è nel non capire la differenza fra l'INIZIALIZZAZIONE dell'array e l'INDICIZZAZIONE dei suoi membri.
Quando lo dichiari devi dargli la DIMENSIONE.

int nomearray[8]={10,20,30,40,50,60,70,80,90}; //ERRORE: array di 8 celle ma 9 valori 
int nomearray[9]={10,20,30,40,50,60,70,80,90};  //GIUSTO: array di 9 celle con 9 valori
int nomearray[8]={10,20,30,40,50,60,70,80}; //GIUSTO: array di 8 celle con 8 valori

Quando invece vuoi accedere ad un elemento, i valori ammessi sono
0...NUMERO ELEMENTI - 1
Quindi nel caso precedente per accedere al 1° elemento usi 0, per accedere all'ultimo usi 9-1=8.

Si possono inizializzare array anche senza valore di elementi tra le [], così:

int nomearray[] = {10, 20, 30, 40, 50, 60, 70, 80, 90};

Ma è meglio inserire il numero di elementi nelle quadre, perchè se i valori non combaciano ci si accorge subito grazie al compilatore.

La dichiarazione ha un senso logico da intepretare così:

int nomearray[8] ; mi riservi 8 spazi di memoria di cui ognuno è grande 16 bit con segno e a questo spazio gli dai il nome nomearray.
Posizione: 0 1 2 3 4 5 6 7
locazione [ ] [ ] [ ] [ ] [ ] [ ] [ ] [ ]
R:fatto
int valore = nomearray[1]; prendi l'elemento 1 e mettilo nella variabile valore
R:fatto

Se scrivi nomearray[8] con l'intenzione di prendere l'ottavo elemente vai fuori dalla memoria che hai chiesto di riservarti.

Ciao.

Io preferisco (quando possibile) limitare al massimo la ridondanza ed usare l'inizializzazione senza specificare la dimensione (così sono sicuro di non sbagliarmi )

int a[] = { 10, 20, 30, 40 };

Quanti elementi ha questo array ? Boh, lo chiedo al compilatore:

#define ARY_LEN(a) (sizeof(a)/(sizeof(a[0])))

for (byte i = 0; i < ARY_LEN(a); i++) {
    Serial.println(a[i]);
}

Molte grazie per le spiegazioni, finalmente ho capito la differenza:

Quando dichiaro l'array, il numero tra parentesi quadre è il numero di elementi, quindi se scrivo: int MyArray[8]; il mio array avrà 8 elementi.

Quando dichiaro ed inizializzo l'array con i parametri tra parentesi graffe, devo mettere il numero di parametri dichiarati, in questo caso 8.

Purtroppo non avevo capito male questo testo:

It also means that in an array with ten elements, index nine is the last element. Hence:
int myArray[10]={9,3,2,4,3,2,7,8,9,11};
// myArray[9] contains 11
// myArray[10] is invalid and contains random information (other memory address)

Mi aveva mandato in confusione la terza e quarta riga, che dice che index=9 conterrebbe il numero 11 (corretto) e che con index=10 sarebbe invalido, non avevo afferrato il concetto (sono 10 elementi, se "leggessi" o "scrivessi" dall'/nell' array il mio ultimo index deve essere 9 ovvero il numero di elementi - 1) FINALMENTE L'HO CAPITA!!!

Molto interessanti quei comandi che permettono di conoscere il numero di elementi di un'array senza averne dichiarato la dimensione, GRAZIE per L'ottima informazione!!

Grazie a Tutti,