Newsgroup: it.comp.lang.c
Titolo: Elementi di un vettore di interi.

Salve.
Con un vettore di caratteri supponiamo char V[10] ="ciao" la funzione
sizeof(V) mi ritorna 10 mentre la strlen(V) mi ritorna 4.
Con un vettore di interi, supponiamo int I[] = {2, 2, 2, 10, 10} la sua
sizeof(I) mi ritorna 20 (4 byte x 5) ma, esiste una funzione che mi
ritorni il numero degli elementi cioe' , in questo caso, 5?
Se volessi utilizzare un ciclo for, da zero al numero degli elementi del
vettore I,  dovrei per forza indicare il numero degli elementi di questo
vettore, p. es., in una variabile apposita LunghezzaVettore=5?
Grazie.
--
  Mauro Sanna
(
mrs...@tin.it
)

 ritorni il numero degli elementi cioe' , in questo caso, 5?
n = seizeof(I)/sizeof(int); se conosci il tipo di I;
n = sizeof(I) / sizeof(I[0]); funziona per qualunque tipo.
-- 
Maurizio Loreti                      
http://wwwcdf.pd.infn.it/~loreti/mlo.html
Un. of Padova, Dept. of Physics - Padova, Italy          
lor...@padova.infn.it

 writes:
:> Con un vettore di interi, supponiamo int I[] = {2, 2, 2, 10, 10} la sua
:> sizeof(I) mi ritorna 20 (4 byte x 5) ma, esiste una funzione che mi
:> ritorni il numero degli elementi cioe' , in questo caso, 5?
: n = seizeof(I)/sizeof(int); se conosci il tipo di I;
: n = sizeof(I) / sizeof(I[0]); funziona per qualunque tipo.
Pero', occhio che non funziona con gli array passati come argomenti
di funzioni. Per esempio:
int main(void) {
  int vector[] = { 1, 2, 3, 4 };
  int vector_size = funz_1(vector);
}
int funz_1(int vector_1[]) {
  return (sizeof(vetcor_1)/sizeof(vector[0]));
}  
qui vector_size vale 1 (mentre l'array ha lunghezza 4).
Questo perche' il compilatore trasforma il vettore in un puntatore
ad un int, e non come puntatore ad un array. Cioe' scrivere:
 int funz_1(int vector_1[]) {
equivale a scrivere:
 int funz_1(int *vector_1) {
Quindi l'espressione di ritorno divide la dimensione di un int (4 byte)
per la dimensione di un altro int (4 byte a sua volta), dando come 
risultato 1.
Quando si passano array come argomenti di funzione, occorre fare attenzione
a questa come ad altre possibili cause di errore: ad esempio, non viene
valutata la corrispondenza tra tipi dei parametri attuali e tipi dei 
parametri formali.
Ciao.
-------------------------------------------------------------------
     Roberto Tagliarino
 
roberto.t...@multiwire.net
-------------------------------------------------------------------

Roberto Tagliarino (
roberto.t...@multiwire.net
) wrote:
[ snip ]
: Pero', occhio che non funziona con gli array passati come argomenti
: di funzioni. Per esempio:
: int main(void) {
:   int vector[] = { 1, 2, 3, 4 };
:   int vector_size = funz_1(vector);
: }
: int funz_1(int vector_1[]) {
:   return (sizeof(vetcor_1)/sizeof(vector[0]));
: }  
: qui vector_size vale 1 (mentre l'array ha lunghezza 4).
: Questo perche' il compilatore trasforma il vettore in un puntatore
: ad un int, e non come puntatore ad un array. Cioe' scrivere:
:  int funz_1(int vector_1[]) {
: equivale a scrivere:
:  int funz_1(int *vector_1) {
: Quindi l'espressione di ritorno divide la dimensione di un int (4 byte)
: per la dimensione di un altro int (4 byte a sua volta), dando come 
: risultato 1.
Domandina: ma sizeof viene valutato a tempo di compilazione o durante 
l'esecuzione ?
Da come si comporta, sembrerebbe essere valutato a tempo di compilazione.
Per cui, quello che passi come argomento della funzione, /e'/ un 'int *'
e ha dimensione 4 byte.
Ciao ciao
Andrea
-- 
"...Unix, MS-DOS, and Windows NT (also known as the Good, the Bad, and 
 the Ugly)."
(by Matt Welsh)

On 22 Aug 1998 08:37:14 +0200 Andrea Foco wrote:
: Domandina: ma sizeof viene valutato a tempo di compilazione o durante 
: l'esecuzione ?
: Da come si comporta, sembrerebbe essere valutato a tempo di compilazione.
: Per cui, quello che passi come argomento della funzione, /e'/ un 'int *'
: e ha dimensione 4 byte.
Infatti e' proprio cosi'. Anche perche' il compilatore, nel caso di
funzioni con array come argomenti, non effettua alcun controllo sui
valori limite.
Di conseguenza, il parametro formale di fatto e' un puntatore a un int
(nel caso che venga passato un array di int).
Ho letto da qualche parte che questo potrebbe non valere piu' in futuro.
Mi pare che lo standard ANSI preveda che le versioni future debbano
distinguere tra argomenti array e argomenti puntatori.
Chi ne sa di piu?
