Arguments
Les arguments dans un appel de fonctions ont comme suit :
expression ( expression-list <SUB>opt</SUB> ) /* Function call */
dans un appel de fonction, l'expression- liste est une liste d'expressions (séparées par des virgules).les valeurs de ces dernières expressions sont les arguments passés à la fonction.Si la fonction n'accepte aucun argument, l'expression-liste doit contenir le mot clé void.
Un argument peut être n'importe quelle valeur avec le principe fondamental, une structure, une union, ou le type pointeur.Tous les arguments passés par valeur.Cela signifie qu'une copie de l'argument est assignée au paramètre correspondant.la fonction ne connaît pas l'emplacement de mémoire réel de l'argument passé.la fonction utilise cette copie sans affecter la variable dont elle était initialement dérivée.
Bien que vous ne puissiez pas passer des tableaux ou des fonctions en tant qu'arguments, vous pouvez passer des pointeurs vers ces éléments.Les pointeurs fournissent un moyen à une fonction accède à une valeur par référence.Étant donné qu'un pointeur vers une variable contient l'adresse de la variable, la fonction peut utiliser cette adresse pour accéder à la valeur de la variable.Les arguments de pointeur permettent une fonction aux tableaux et accéder aux fonctions, bien que les tableaux et les fonctions ne puissent pas être passées comme arguments.
L'ordre dans lequel les arguments sont évalués peut varier selon des compilateurs et différents niveaux d'optimisation.Toutefois, les arguments et de les effets secondaires sont complètement évalués avant que la fonction a pas entré.Consultez l' effets secondaires pour plus d'informations sur les effets secondaires.
L'expression-liste dans un appel de fonction est évaluée et les conversions arithmétiques classiques sont exécutées sur chaque argument dans l'appel de fonction.Si un prototype est disponible, le type d'argument résultant est comparé au paramètre correspondant du prototype.S'ils ne correspondent pas, ou une conversion est exécuté, soit un message de diagnostic est publié.Les paramètres entraînent également les conversions arithmétiques classiques.
Le nombre d'expressions dans le expression-liste doit correspondre au nombre de paramètres, à moins que le prototype ou la définition de la fonction spécifie explicitement un nombre variable d'arguments.Dans ce cas, le compilateur active autant d'arguments comme il existe des noms de type dans la liste de paramètres et les convertit si nécessaire, comme décrit ci-dessus.Consultez l' Appels avec un nombre variable d'arguments pour plus d'informations.
Si la liste de paramètres du prototype contient uniquement le mot clé void, le compilateur s'attend pas d'arguments dans l'appel et aux paramètres nuls dans la définition.Un message de diagnostic est publié s'il recherche tous les arguments.
Exemple
cet exemple utilise des pointeurs comme 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;
}
Dans cet exemple, la fonction d' swap est déclarée dans main d'avoir deux arguments, respectivement représentés par les identificateurs num1 et num2, qui sont des pointeurs vers les valeurs d' int .Les paramètres num1 et num2 dans la définition de style du prototype sont également déclarés comme pointeurs vers des valeurs de type d' int .
dans l'appel de fonction
swap( &x, &y )
l'adresse d' x est stockée dans num1 et l'adresse d' y est stockée dans num2.maintenant deux noms, ou « alias, » existent pour le même emplacement.les références à *num1 et à *num2 dans swap sont effectivement des références à x et à y dans main.Les assignations dans swap échangent réellement le contenu d' x et d' y.par conséquent, aucune instruction d' return n'est nécessaire.
Le compilateur effectue le contrôle de type sur les arguments à swap car le prototype d' swap incorpore des types d'argument pour chaque paramètre.Les identificateurs entre parenthèses du prototype et de la définition peuvent être identiques ou différents.Ce qui est essentiel est que les types des arguments correspondent à ceux des listes de paramètres dans le prototype et la définition.