Newsgroup: it.comp.lang.c++
Titolo: Spiegazione Array

Ciao a tutti,
ho fatto un piccolo esercizio ma non capisco una cosa
# include <iostream>
using namespace std;
int main(){
   //questionario();
   const int risposteUtenti = 10;
   const int numeroPartecipanti = 10;
//  const int risposte[risposteUtenti] =
// {10,10,20,20,30,30,40,40,50,50};
con questa riga vengono memorizzate quante volte 1 2 3 ecc  sono 
presenti nelle parentesi
   const int risposte[risposteUtenti] = {1,1,2,2,3,3,4,4,5,5};
   int partecipanti[numeroPartecipanti] = {0};
Tramite il ciclo for vengono inserite nell'array
   for (int i = 0; i < numeroPartecipanti;i++)
     // partecipanti[risposte[i]]++;
     partecipanti[risposte[i]]++;
   system("PAUSE");
}
La mia domanda è per che se sostituisco questa riga
   const int risposte[risposteUtenti] = {1,1,2,2,3,3,4,4,5,5};
con questa variante
const int risposte[risposteUtenti] = {10,10,20,20,30,30,40,40,50,50};
Il ciclo for non memorizza i dati? Ovvero quante volte sono presenti i 
10 i 20 ecc ma lo fa con gli 1 i 2 ecc?
Ciao
Lele

 10 i 20 ecc ma lo fa con gli 1 i 2 ecc?
'partecipanti' è una array di 10 elementi. Non è permesso, quindi, usare
valori superiore a 9 come indici. Se lo fai, hai un effetto indefinito.
Quando 'risposte' contiene valori superiori 9, il tuo codice ha
comportamento indefinito.
Max

 comportamento indefinito.
quindi se volessi inserire un valore di 90 dovrei scrivere una cosa simile?
const int risposteUtenti = 90; ?
Ciao Lele


No. E' 'partecipanti' che è troppo piccolo, non 'risposte'. Però ho il
sospetto che tu stia facendo un po' di confusione. Riformula bene il
problema che devi risolvere e verifica la strategia che hai usato, senza
andare a tentativi. La regola è: se A è dichiato come
   type  A[ S ];
l'espressione
   A[ n ] 
è valida solo per valori di 'n' tali che 0 <= n < S.
Max

Ciao Max M.
la mia è solo curiosità, volevo sapere se al interno dell'indice 
(partecipanti) che va da 0 a 10 può contenere un  valore di 30 acquisito 
da 'risposteUtenti'
Ciao
Lele

 da 'risposteUtenti'
Boh, non capisco nemmeno la domanda. Nel tuo codice hai scritto:
  partecipanti[risposte[i]]++;
Questo presuppone che risposte[i] sia compreso tra 0 (incluso) e il numero
di elementi di 'partecipanti' (escluso).
Quindi, se la lunghezza di 'partecipanti' č 10, i possibili indici vanno da
0 a 9. Se risposte[i] vale 10 o 30, l'espressione non ha un comportamento
definito.
Max

da 'risposteUtenti'
Non ho capito.
Lele, senza offesa, ma io sospetto che tu stia rinunciando a capire
come funziona esattamente il (tuo?) codice.
Nel codice che hai riportato 'partecipanti' è un array e ha un indice
che va da 0 a numeroPartecipanti-1, quindi 'partecipanti' è
indirizzabile solo in questo range.
Nel codice, viene svolta un'elaborazione e si accede a 'partecipanti'
adoperando come indici i valori contenuti nell'array 'risposte'.
Quindi, siccome gli elementi di 'risposte' fungono da indici per
'partecipanti', ciascun valore contenuto in 'risposte' non deve
superare i limiti del range con cui è indirizzabile 'partecipanti'.
E' per questo che se scrivi:
const int risposte[risposteUtenti] = {10,10,20,20,30,30,40,40,50,50};
Stai riempiendo 'risposte' di indici non validi per 'partecipanti',
perché 'partecipanti' è indirizzabile solo da 0 a
numeroPartecipanti-1, ovvero, sempre secondo il tuo codice, da 0 a 9.
Curiosità soddisfatta?
p.s.: ti è veramente difficile capire questi concetti?

Ciao Max M.
non ti preoccupare sono a posto cosi.
Grazie per l'interesse
Lele

 p.s.: ti è veramente difficile capire questi concetti?
Non prenderla come polemica, no non è che mi è difficile capire questi 
concetti, non sò te ma io utilizzo il metodo leggi, prova, sbaglia, 
sbaglia e capisci.
Precisazione a parte, il codice non è il mio ma copiato da un libro e 
come detto prima per curiosità provo a vedere come si comporta cambiando 
questo o quello e molte volte ti capitano situazioni inaspettate.
Grazie per l'interesse.
Lele

 questo o quello e molte volte ti capitano situazioni inaspettate.
E' proprio il fatto che situazioni come queste siano inaspettate che
mi stranisce, sinceramente.
Quando mi meraviglio del fatto che ti sia difficile capire questi
concetti, mi riferisco in realtà non alle prove che fai, ma
all'approccoio "matematico" di base.
Tu hai un vettore v indirizzabile da 0 a n-1, ma l'indice che usi per
accedervi è il risultato di una funzione:
v[f(x)]
Non ti è chiaro che il risultato f(x) deve stare necessariamente nel
range di indici validi per v?