Passare un array come argomento a una funzione in C

Ho scritto una funzione contenente array come argomento e la chiamo passando il valore di array come segue.

void arraytest(int a[])
{
    // changed the array a
    a[0]=a[0]+a[1];
    a[1]=a[0]-a[1];
    a[0]=a[0]-a[1];
}

void main()
{
    int arr[]={1,2};
    printf("%d \t %d",arr[0],arr[1]);
    arraytest(arr);
    printf("\n After calling fun arr contains: %d\t %d",arr[0],arr[1]);
}

Quello che ho trovato è che anche se sto chiamando la arraytest()funzione passando i valori, la copia originale di int arr[]è cambiata.

Puoi spiegare perché?

Quando si passa un array come parametro, this

void arraytest(int a[])

significa esattamente lo stesso di

void arraytest(int *a)

così si sta modificando i valori nella principale.

Per ragioni storiche, gli array non sono cittadini di prima classe e non possono essere trasmessi per valore.

Se vuoi passare un array monodimensionale come argomento in una funzione , dovresti dichiarare un parametro formale in uno dei tre modi seguenti e tutti e tre i metodi di dichiarazione producono risultati simili perché ognuno dice al compilatore che sta andando un puntatore intero essere ricevuto .

int func(int arr[], ...){
    .
    .
    .
}

int func(int arr[SIZE], ...){
    .
    .
    .
}

int func(int* arr, ...){
    .
    .
    .
}

Quindi, stai modificando i valori originali.

Grazie !!!

Non stai passando l'array come copia. È solo un puntatore che punta all'indirizzo in cui è in memoria il primo elemento dell'array.

Stai passando l'indirizzo del primo elemento dell'array

Gli array in C vengono convertiti, nella maggior parte dei casi, in un puntatore al primo elemento dell'array stesso. E più in dettaglio, gli array passati alle funzioni vengono sempre convertiti in puntatori.

Ecco una citazione di K & R2nd :

Quando un nome di array viene passato a una funzione, ciò che viene passato è la posizione dell'elemento iniziale. All'interno della funzione chiamata, questo argomento è una variabile locale, quindi un parametro del nome di un array è un puntatore, cioè una variabile contenente un indirizzo.

Scrittura:

void arraytest(int a[])

ha lo stesso significato della scrittura:

void arraytest(int *a)

Quindi, nonostante tu non lo stia scrivendo esplicitamente, è come se stai passando un puntatore e quindi stai modificando i valori nel main.

Per di più suggerisco davvero di leggere questo .

Inoltre, puoi trovare altre risposte su SO qui

Stai passando il valore della posizione di memoria del primo membro della matrice.

Pertanto, quando inizi a modificare l'array all'interno della funzione, stai modificando l'array originale.

Ricorda che lo a[1]è *(a+1).

In C, ad eccezione di alcuni casi speciali, un riferimento a un array "decade" sempre a un puntatore al primo elemento dell'array. Pertanto, non è possibile passare un array "per valore". Un array in una chiamata di funzione verrà passato alla funzione come puntatore, il che è analogo al passaggio dell'array per riferimento.

EDIT: ci sono tre casi speciali in cui un array non decade in un puntatore al suo primo elemento:

1. sizeof anon è lo stesso di sizeof (&a[0]).
2. &anon è lo stesso di &(&a[0])(e non proprio lo stesso di &a[0]).
3. char b[] = "foo"non è lo stesso di char b[] = &("foo").

Passaggio di un array multidimensionale come argomento a una funzione. Passare un array uno dim come argomento è più o meno banale. Diamo uno sguardo al caso più interessante di passaggio di un array 2 dim. In C non puoi usare un puntatore al costrutto puntatore ( int **) invece di 2 array dim. Facciamo un esempio:

void assignZeros(int(*arr)[5], const int rows) {
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < 5; j++) {
            *(*(arr + i) + j) = 0;
            // or equivalent assignment
            arr[i][j] = 0;
        }
    }

Qui ho specificato una funzione che prende come primo argomento un puntatore a un array di 5 numeri interi. Posso passare come argomento qualsiasi 2 array dim che ha 5 colonne:

int arr1[1][5]
int arr1[2][5]
...
int arr1[20][5]
...

Potresti avere l'idea di definire una funzione più generale che possa accettare qualsiasi 2 array dim e modificare la firma della funzione come segue:

void assignZeros(int ** arr, const int rows, const int cols) {
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            *(*(arr + i) + j) = 0;
        }
    }
}

Questo codice verrà compilato ma si riceverà un errore di runtime quando si tenta di assegnare i valori allo stesso modo della prima funzione. Quindi in C un array multidimensionale non è la stessa cosa dei puntatori a puntatori ... a puntatori. An int(*arr)[5]è un puntatore a un array di 5 elementi, an int(*arr)[6] è un puntatore a un array di 6 elementi e sono puntatori a diversi tipi!

Bene, come definire gli argomenti delle funzioni per dimensioni superiori? Semplice, seguiamo semplicemente lo schema! Ecco la stessa funzione regolata per prendere una matrice di 3 dimensioni:

void assignZeros2(int(*arr)[4][5], const int dim1, const int dim2, const int dim3) {
    for (int i = 0; i < dim1; i++) {
        for (int j = 0; j < dim2; j++) {
            for (int k = 0; k < dim3; k++) {
                *(*(*(arr + i) + j) + k) = 0;
                // or equivalent assignment
                arr[i][j][k] = 0;
            }
        }
    }
}

Come ti aspetteresti, può prendere come argomento qualsiasi 3 array dim che hanno nella seconda dimensione 4 elementi e nella terza dimensione 5 elementi. Qualunque cosa del genere andrebbe bene:

arr[1][4][5]
arr[2][4][5]
...
arr[10][4][5]
...

Ma dobbiamo specificare tutte le dimensioni fino alla prima.

Utilizzo di array standard in C con decadimento del tipo naturale da array a ptr

@Bo Persson afferma correttamente nella sua ottima risposta qui :

Quando si passa un array come parametro, this

void arraytest(int a[])

significa esattamente lo stesso di

void arraytest(int *a)

Tuttavia, lasciatemi aggiungere anche che le due forme precedenti anche:

1. significa esattamente lo stesso di

    void arraytest(int a[0])
   

2. che significa esattamente lo stesso di

    void arraytest(int a[1])
   

3. che significa esattamente lo stesso di

    void arraytest(int a[2])
   

4. che significa esattamente lo stesso di

    void arraytest(int a[1000])
   

5. eccetera.

In ognuno degli esempi di array sopra, il tipo di parametro di input decade in unint * e può essere chiamato senza avvisi e senza errori, anche con le opzioni di compilazione -Wall -Wextra -Werrorattivate (vedi il mio repository qui per i dettagli su queste 3 opzioni di compilazione), come Questo:

int array1[2];
int * array2 = array1;

// works fine because `array1` automatically decays from an array type
// to `int *`
arraytest(array1);
// works fine because `array2` is already an `int *` 
arraytest(array2);

È un dato di fatto, il valore "dimensioni" ( [0], [1], [2], [1000], etc.) all'interno del parametro array qui è apparentemente solo per scopi di / estetica auto-documentazione, e può essere un qualsiasi numero intero positivo ( size_ttipo credo) che si desidera!

In pratica, tuttavia, dovresti usarlo per specificare la dimensione minima dell'array che ti aspetti che la funzione riceva, in modo che durante la scrittura del codice sia facile per te tracciare e verificare. Lo standard MISRA-C-2012 ( acquista / scarica il PDF della versione 236-pg 2012 dello standard per £ 15,00 qui ) arriva fino a dichiarare (enfasi aggiunta):

Regola 17.5 L'argomento della funzione corrispondente a un parametro dichiarato di avere un tipo array deve avere un numero appropriato di elementi.

...

Se un parametro viene dichiarato come un array con una dimensione specificata, l'argomento corrispondente in ciascuna chiamata di funzione dovrebbe puntare a un oggetto che ha almeno tanti elementi quanti sono l'array.

...

L'uso di un dichiaratore di matrice per un parametro di funzione specifica l'interfaccia della funzione in modo più chiaro rispetto all'utilizzo di un puntatore. Il numero minimo di elementi attesi dalla funzione è dichiarato esplicitamente, mentre ciò non è possibile con un puntatore.

In altre parole, raccomandano di utilizzare il formato di dimensione esplicito, anche se lo standard C tecnicamente non lo impone - almeno aiuta a chiarire a te come sviluppatore e agli altri che usano il codice, quale matrice di dimensioni si aspetta la funzione di passare.

Forzare l'indipendenza dai tipi sugli array in C

Come sottolinea @Winger Sendon in un commento sotto la mia risposta, possiamo forzare C a considerare un tipo di array diverso in base alla dimensione dell'array !

Innanzitutto, devi riconoscere che nel mio esempio appena sopra, usando int array1[2];così: arraytest(array1);fa array1decadere automaticamente in un file int *. TUTTAVIA, se prendi l' indirizzo di array1 invece e chiami arraytest(&array1), ottieni un comportamento completamente diverso! Ora, NON decade in un int *! Invece, il tipo di &array1è int (*)[2], che significa "puntatore a un array di dimensione 2 di int" o "puntatore a un array di dimensione 2 di tipo int" . Quindi, puoi FORZA C per verificare l'indipendenza dai tipi su un array, in questo modo:

void arraytest(int (*a)[2])
{
    // my function here
}

Questa sintassi è difficile da leggere, ma simile a quella di un puntatore a funzione . Lo strumento online, cdecl , ci dice che int (*a)[2]significa: "dichiara a come puntatore all'array 2 di int" (puntatore all'array di 2 ints). NON confondere questo con la versione senza parentesi:, int * a[2]che significa: "dichiara a come array 2 di puntatore a int" (array di 2 puntatori a int).

Ora, questa funzione RICHIEDE che tu la chiami con l'operatore indirizzo ( &) in questo modo, utilizzando come parametro di input un PUNTATORE AD UNA SERIE DELLA DIMENSIONE CORRETTA !:

int array1[2];

// ok, since the type of `array1` is `int (*)[2]` (ptr to array of 
// 2 ints)
arraytest(&array1); // you must use the & operator here to prevent
                    // `array1` from otherwise automatically decaying
                    // into `int *`, which is the WRONG input type here!

Questo, tuttavia, produrrà un avviso:

int array1[2];

// WARNING! Wrong type since the type of `array1` decays to `int *`:
//      main.c:32:15: warning: passing argument 1 of ‘arraytest’ from 
//      incompatible pointer type [-Wincompatible-pointer-types]                                                            
//      main.c:22:6: note: expected ‘int (*)[2]’ but argument is of type ‘int *’
arraytest(array1); // (missing & operator)

Puoi provare questo codice qui .

Per forzare il compilatore C a trasformare questo avviso in un errore, in modo che DEVI sempre chiamare arraytest(&array1);utilizzando solo un array di input della dimensione e del tipo corretti ( int array1[2];in questo caso), aggiungi -Werroralle opzioni di compilazione. Se esegui il codice di prova sopra su onlinegdb.com, fallo facendo clic sull'icona dell'ingranaggio in alto a destra e fai clic su "Extra Compiler Flags" per digitare questa opzione. Ora, questo avviso:

main.c:34:15: warning: passing argument 1 of ‘arraytest’ from incompatible pointer type [-Wincompatible-pointer-types]                                                            
main.c:24:6: note: expected ‘int (*)[2]’ but argument is of type ‘int *’    

si trasformerà in questo errore di build:

main.c: In function ‘main’:
main.c:34:15: error: passing argument 1 of ‘arraytest’ from incompatible pointer type [-Werror=incompatible-pointer-types]
     arraytest(array1); // warning!
               ^~~~~~
main.c:24:6: note: expected ‘int (*)[2]’ but argument is of type ‘int *’
 void arraytest(int (*a)[2])
      ^~~~~~~~~
cc1: all warnings being treated as errors

Nota che puoi anche creare puntatori "type safe" ad array di una data dimensione, in questo modo:

int array[2];
// "type safe" ptr to array of size 2 of int:
int (*array_p)[2] = &array;

... ma non lo consiglio necessariamente , poiché mi ricorda molte delle buffonate C ++ utilizzate per forzare la sicurezza dei tipi ovunque, al costo eccezionalmente alto della complessità della sintassi del linguaggio, della verbosità e della difficoltà di architettura del codice, e che non mi piace e ho inveito molte volte in passato (es: vedi "I miei pensieri su C ++" qui ).

Per ulteriori test e sperimentazioni, vedere anche il collegamento appena sotto.

Riferimenti

Vedi i link sopra. Anche:

1. La mia sperimentazione di codice online: https://onlinegdb.com/B1RsrBDFD

Gli array vengono sempre passati per riferimento se si utilizza a[]o *a:

int* printSquares(int a[], int size, int e[]) {   
    for(int i = 0; i < size; i++) {
        e[i] = i * i;
    }
    return e;
}

int* printSquares(int *a, int size, int e[]) {
    for(int i = 0; i < size; i++) {
        e[i] = i * i;
    }
    return e;
}