ArgomentiArguments

Gli argomenti in una chiamata di funzione hanno formato seguente:The arguments in a function call have this form:


expression  
(  
expression-list <SUB>opt</SUB> )  /* Function call */  

In una chiamata di funzione, expression-list è un elenco di espressioni (separate da virgole).In a function call, expression-list is a list of expressions (separated by commas). I valori di queste ultime espressioni sono gli argomenti passati alla funzione.The values of these latter expressions are the arguments passed to the function. Se la funzione non accetta argomenti, expression-list deve includere la parola chiave void.If the function takes no arguments, expression-list should contain the keyword void.

Un argomento può essere un qualsiasi valore con tipo di base, struttura, unione o puntatore.An argument can be any value with fundamental, structure, union, or pointer type. Tutti gli argomenti vengono passati per valore.All arguments are passed by value. Questo significa che una copia dell'argomento viene assegnata al parametro corrispondente.This means a copy of the argument is assigned to the corresponding parameter. La funzione non conosce la posizione di memoria effettiva dell'argomento passato.The function does not know the actual memory location of the argument passed. La funzione utilizza questa copia senza influire sulla variabile da cui la copia è stata derivata in origine.The function uses this copy without affecting the variable from which it was originally derived.

Sebbene non sia possibile passare matrici o funzioni come argomenti, è possibile passare puntatori a questi elementi.Although you cannot pass arrays or functions as arguments, you can pass pointers to these items. I puntatori consentono a una funzione di accedere a un valore per riferimento.Pointers provide a way for a function to access a value by reference. Poiché un puntatore a una variabile contiene l'indirizzo della variabile stessa, la funzione può utilizzare questo indirizzo per accedere al valore della variabile.Since a pointer to a variable holds the address of the variable, the function can use this address to access the value of the variable. Gli argomenti del puntatore consentono a una funzione di accedere a matrici e funzioni, anche se matrici e funzioni non possono essere passate come argomenti.Pointer arguments allow a function to access arrays and functions, even though arrays and functions cannot be passed as arguments.

L'ordine in cui gli argomenti vengono valutati può variare in base a compilatori e a livelli di ottimizzazione diversi.The order in which arguments are evaluated can vary under different compilers and different optimization levels. Gli argomenti e tutti gli effetti collaterali, tuttavia, vengono valutati completamente prima dell'inserimento della funzione.However, the arguments and any side effects are completely evaluated before the function is entered. Per informazioni sugli effetti collaterali, vedere Effetti collaterali.See Side Effects for information on side effects.

In una chiamata di funzione l'elenco expression-list viene valutato e le conversioni aritmetiche consuete vengono eseguite su ogni argomento della chiamata.The expression-list in a function call is evaluated and the usual arithmetic conversions are performed on each argument in the function call. Se un prototipo è disponibile, il tipo di argomento risultante viene confrontato con il parametro corrispondente del prototipo.If a prototype is available, the resulting argument type is compared to the prototype's corresponding parameter. Se non corrispondono, viene eseguita una conversione o viene generato un messaggio di diagnostica.If they do not match, either a conversion is performed, or a diagnostic message is issued. Sui parametri è possibile eseguire anche le conversioni aritmetiche consuete.The parameters also undergo the usual arithmetic conversions.

Il numero di espressioni in expression-list deve corrispondere al numero di parametri, a meno che il prototipo o la definizione della funzione non specifichi in modo esplicito un numero variabile di argomenti.The number of expressions in expression-list must match the number of parameters, unless the function's prototype or definition explicitly specifies a variable number of arguments. In questo caso, il compilatore controlla il numero di argomenti corrispondenti ai nomi di tipi nell'elenco di parametri e li converte, se necessario, come descritto in precedenza.In this case, the compiler checks as many arguments as there are type names in the list of parameters and converts them, if necessary, as described above. Per altre informazioni, vedere Chiamate con un numero variabile di argomenti.See Calls with a Variable Number of Arguments for more information.

Se l'elenco di parametri del prototipo include solo la parola chiave void, il compilatore prevede zero argomenti nella chiamata di funzione e zero parametri nella definizione.If the prototype's parameter list contains only the keyword void, the compiler expects zero arguments in the function call and zero parameters in the definition. Se vengono rilevati eventuali argomenti, viene generato un messaggio di diagnostica.A diagnostic message is issued if it finds any arguments.

EsempioExample

In questo esempio vengono utilizzati puntatori come argomenti:This example uses pointers as arguments:

int main()  
{  
    /* Function prototype */  

    void swap( int *num1, int *num2 );  
    int x, y;  
    .  
    .  
    .  
    swap( &x, &y );  /* Function call */  
}  

/* Function definition */  

void swap( int *num1, int *num2 )  
{  
    int t;  

    t = *num1;  
    *num1 = *num2;  
    *num2 = t;  
}  

In questo esempio la funzione swap viene dichiarata in main in modo che abbia due argomenti, rappresentati rispettivamente dagli identificatori num1 e num2, costituiti entrambi da puntatori a valori int.In this example, the swap function is declared in main to have two arguments, represented respectively by identifiers num1 and num2, both of which are pointers to int values. I parametri num1 e num2 nella definizione in stile prototipo vengono dichiarati come puntatori a valori di tipo int.The parameters num1 and num2 in the prototype-style definition are also declared as pointers to int type values.

Nella chiamata di funzioneIn the function call

swap( &x, &y )  

l'indirizzo di x viene archiviato in num1, mentre l'indirizzo di y viene archiviato in num2.the address of x is stored in num1 and the address of y is stored in num2. Ora per la stessa posizione sono presenti due nomi, denominati anche alias.Now two names, or "aliases," exist for the same location. I riferimenti a *num1 e *num2 in swap sono effettivamente riferimenti a x e y in main.References to *num1 and *num2 in swap are effectively references to x and y in main. Le assegnazioni in swap scambiano effettivamente il contenuto di x e y.The assignments within swap actually exchange the contents of x and y. Di conseguenza, non è necessaria alcuna istruzione return.Therefore, no return statement is necessary.

Il compilatore esegue il controllo dei tipi sugli argomenti in relazione a swap poiché il prototipo swap include i tipi di argomento per ogni parametro.The compiler performs type checking on the arguments to swap because the prototype of swap includes argument types for each parameter. Gli identificatori tra parentesi del prototipo e della definizione possono essere uguali o diversi.The identifiers within the parentheses of the prototype and definition can be the same or different. L'aspetto importante è che i tipi degli argomenti corrispondano a quelli degli elenchi di parametri sia nel prototipo che nella definizione.What is important is that the types of the arguments match those of the parameter lists in both the prototype and the definition.

Vedere ancheSee Also

Chiamate di funzioneFunction Calls