next topic »

[on:]

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

[Reply #1 on:]

ciao

Code:

int array[0]={10};

devi scrivere

Code:

int array[1]={10};

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

stefano

[Reply #2 on:]

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

• ')

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!

[Reply #3 on:]

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

Code:

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

[Reply #4 on:]

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.

Code:

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.

[Reply #5 on:]

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

Code:

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.

[Reply #6 on:]

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

Code:

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

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

Code:

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

Code:

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

[Reply #7 on:]

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,