ParametriParameters

Gli argomenti sono nomi dei valori passati a una funzione da una chiamata di funzione.Arguments are names of values passed to a function by a function call. I parametri sono i valori che la funzione prevede di ricevere.Parameters are the values the function expects to receive. In un prototipo di funzione, le parentesi dopo il nome della funzione contengono un elenco completo dei parametri della funzione e dei relativi tipi.In a function prototype, the parentheses following the function name contain a complete list of the function's parameters and their types. Le dichiarazioni di parametro specificano i tipi, le dimensioni e gli identificatori dei valori archiviati nei parametri.Parameter declarations specify the types, sizes, and identifiers of values stored in the parameters.

SintassiSyntax

function-definition:function-definition:
declaration-specifiers optattribute-seq optdeclarator declaration-list optcompound-statementdeclaration-specifiers optattribute-seq optdeclarator declaration-list optcompound-statement

/* attribute-seq è specifico di Microsoft //* *attribute-seq is Microsoft Specific */

declarator :declarator :
pointer optdirect-declaratorpointer optdirect-declarator

direct-declarator:/* Dichiaratore di funzione */direct-declarator:/* A function declarator */
direct-declarator ( parameter-type-list ) /* Dichiaratore nuovo stile */direct-declarator ( parameter-type-list ) /* New-style declarator */

parameter-type-list: /* Elenco di parametri */parameter-type-list: /* A parameter list */
parameter-listparameter-list

parameter-list ,...parameter-list ,...

parameter-list:parameter-list:
parameter-declarationparameter-declaration

parameter-list , parameter-declarationparameter-list , parameter-declaration

parameter-declaration:parameter-declaration:
declaration-specifiers declaratordeclaration-specifiers declarator

declaration-specifiers abstract-declarator optdeclaration-specifiers abstract-declarator opt

parameter-type-list è una sequenza di dichiarazioni di parametro separate da virgole.The parameter-type-list is a sequence of parameter declarations separated by commas. Il formato di ogni parametro in un elenco di parametri è il seguente:The form of each parameter in a parameter list looks like this:

[register]  type-specifier [declarator]   

I parametri di funzione dichiarati con l'attributo auto generano errori.Function parameters declared with the auto attribute generate errors. Gli identificatori dei parametri vengono utilizzati nel corpo della funzione per fare riferimento ai valori passati alla funzione.The identifiers of the parameters are used in the function body to refer to the values passed to the function. È possibile assegnare un nome ai parametri in un prototipo, ma i nomi diventano esterni all'ambito alla fine della dichiarazione.You can name the parameters in a prototype, but the names go out of scope at the end of the declaration. I nomi dei parametri possono essere pertanto assegnati in modo analogo o diverso nella definizione di funzione.Therefore parameter names can be assigned the same way or differently in the function definition. Questi identificatori non possono essere ridefiniti nel blocco più esterno del corpo della funzione, ma possono essere ridefiniti nei blocchi interni e annidati come se l'elenco di parametri fosse un blocco di inclusione.These identifiers cannot be redefined in the outermost block of the function body, but they can be redefined in inner, nested blocks as though the parameter list were an enclosing block.

Ogni identificatore in parameter-type-list deve essere preceduto dall'identificatore di tipo appropriato, come illustrato nell'esempio seguente:Each identifier in parameter-type-list must be preceded by its appropriate type specifier, as shown in this example:

void new( double x, double y, double z )  
{  
    /* Function body here */  
}  

Se nell'elenco di parametri è presente almeno un parametro, l'elenco può terminare con una virgola seguita da tre punti (, ...). Questa costruzione, denominata "notazione con i puntini di sospensione", indica un numero variabile di argomenti passati alla funzione.If at least one parameter occurs in the parameter list, the list can end with a comma followed by three periods (, ...). This construction, called the "ellipsis notation," indicates a variable number of arguments to the function. Per altre informazioni, vedere Chiamate con un numero variabile di argomenti. Tuttavia, una chiamata alla funzione deve avere almeno un numero di argomenti pari al numero dei parametri prima dell'ultima virgola.(See Calls with a Variable Number of Arguments for more information.) However, a call to the function must have at least as many arguments as there are parameters before the last comma.

Se alla funzione non deve essere passato alcun parametro, l'elenco dei parametri viene sostituito dalla parola chiave void.If no arguments are to be passed to the function, the list of parameters is replaced by the keyword void. Questo utilizzo di void è diverso dal relativo utilizzo come identificatore di tipo.This use of void is distinct from its use as a type specifier.

L'ordine e il tipo di parametri, incluso qualsiasi utilizzo della notazione con i puntini di sospensione, devono essere identici in tutte le dichiarazioni di funzione, se presenti, e nella definizione di funzione.The order and type of parameters, including any use of the ellipsis notation, must be the same in all the function declarations (if any) and in the function definition. I tipi degli argomenti dopo le conversioni aritmetiche consuete devono essere compatibili con l'assegnazione dei tipi dei parametri corrispondenti.The types of the arguments after usual arithmetic conversions must be assignment-compatible with the types of the corresponding parameters. Per informazioni sulle conversioni aritmetiche, vedere Conversioni aritmetiche comuni. Gli argomenti dopo i puntini di sospensione non vengono controllati.(See Usual Arithmetic Conversions for information on arithmetic conversions.) Arguments following the ellipsis are not checked. Un parametro può avere qualsiasi tipo fondamentale, di struttura, unione, puntatore o matrice.A parameter can have any fundamental, structure, union, pointer, or array type.

Il compilatore, se necessario, esegue le conversioni aritmetiche consuete in modo indipendente su ogni parametro e ogni argomento.The compiler performs the usual arithmetic conversions independently on each parameter and on each argument, if necessary. Dopo la conversione, nessun parametro è più breve di int e nessuno è di tipo float, a meno che il tipo del parametro venga specificato in modo esplicito come float nel prototipo.After conversion, no parameter is shorter than an int, and no parameter has float type unless the parameter type is explicitly specified as float in the prototype. Ciò significa, ad esempio, che la dichiarazione di un parametro come char equivale alla dichiarazione dello stesso come int.This means, for example, that declaring a parameter as a char has the same effect as declaring it as an int.

Vedere ancheSee Also

Definizioni di funzioni CC Function Definitions