Newsgroup: it.comp.lang.c
Titolo: passaggio di array a funzioni..

salve ragazzi.. penso di non aver compreso una cosa
il mio libro dice esplicitamente che alle funzioni possiamo passare solo
variabili scalari e non array interi.. ma se come parametri abbiamo un
array..??
avendo per esempio funzione(int x[10]) come argomento un array e 
passando un puntatore al 1° elemento di un array.. funzione(array)..
l'indirizzo in memoria viene copiato in x[0] e poi tutti gli
altri indirizzi negli altri elementi?
il mio libro non lo spiega molto bene questo procedimento..
ringrazio chi mi risponde!


Talking about music is like dancing about architecture.
                -- Laurie Anderson

 
Non hai capito quello che intendevo io.. io parlo quando come parametro
della funzione si ha un array non un puntatore.. quindi volevo sapere
come si comporta la funzione se si ha funzione(int x[10]);

About Re: passaggio di array a funzioni..

se tu gli passi un puntatore al primo elemento dell'array, la funzione
si comporta come se il parametro della funzione fosse un puntatore ad
int, cioe' accedi a tutti gli elementi dell'array con l'indice (e quello
0 non e' l'indirizzo in memoria dell'array !) ...
comunque, IMVHO, usa il parametro int * e campa felice ;-)))
ciao
es :
# include <stdio.h>
void fzione (int ppp[10]);
int main (void)
{
    int array[10];
    register int conta;
    for (conta=0; conta<10; conta++)
        array[conta] = conta;
	/* prima della funzione */
    for (conta=0; conta<10; conta++)
        printf ("%d\t", array[conta]);
    fzione (array);
	/* dopo la funzione */
    for (conta=0; conta<10; conta++)
        printf ("%d\n", array[conta]);
    return 0;
}
void fzione (int sss[10])
{
    register int conta;
    for (conta=0; conta<10; conta++)
    {
        printf ("in funzione %d\t", sss[conta]);
        sss[conta] = conta*2;




Quindi è come se avviene una sorta di "copia" di indirizzo di array..
nel senso che array[10] viene trattato come puntatore.. e gli viene
copiato l'indirizzo in memoria dell'array passato? (in sostanza il
parametro int array[10] è uguale a int *array.. solo che nel primo si ha
il limite di 10 elementi dell'array passato all'interno della
funzione..) dimmi se sbaglio..


no, non sbagli .... negli argomenti delle funzioni, e' significativo
solo una eventuale seconda (e terza, quarta ...) dimensione ....
cioe', se gli devi passare un array bidimensionale, dovrai dichiarare il
prototipo della funzione cosi'
void funzione (int array[][20]);
cioe' gli devi dire quante sono le colonne, perche' il compilatore deve
mappare la memoria .... il primo dato fra le prime parentesi quadre, il
compilatore non lo pensa proprio .... e' equivalente scrivere
void funzione (int array[10][20]);
quindi, ritornando alla tua domanda iniziale, scrivere 
void funzione (int array[10]); 
e' uguale a 
void funzione (int array[]);
che quindi e' uguale a
void funzione (int *array);
spero di essere stato chiaro ... ciao
P.S.
per i vettori multidimensionali, ti conviene usare l'allocazione
dinamica della memoria, con un puntatore di puntatore, e con il
passaggio dello stesso alla funzione ... ma questa e' una cosa che
troverai sicuramente piu' avanti sul tuo libro ;-)))
