Langage de programmation C (VI). Fonctions et Macros
Fonctions
Comme dans d'autres langages de haut niveau, C nous permet d'écrire des sous-programmes. Selon le langage, les sous-programmes sont appelés différemment, étant la procédure, la fonction, la routine, les sous-programmes les plus courants. Les différentes dénominations se différencient par des caractéristiques différentes de peu d'importance. Ainsi, lorsque nous disons fonction, par exemple dans le cas de C, le sous-programme est supposé retourner implicitement un résultat. La procédure ne retourne pas de résultats implicites.
Cependant, l'objectif des fonctions C, comme tous les sous-programmes, est de faciliter la conception et l'écriture dans le programme, car avec elles il est possible de séparer un problème complexe en d'autres plus simples, en résolvant chacun avec un programme plus simple. Cette technique, appelée programmation descendante ou modulaire, est actuellement largement diffusée par l'amélioration de l'efficacité (tant dans le développement que dans la correction) des programmeurs.
Voyons un exemple, comme le cas du factoriel. Dans les deux chapitres précédents, nous avons réalisé différents programmes qui calculent le factoriel, mais toujours dans un seul programme. Ce n'est pas la seule option, puisque le calcul du factoriel peut être programmé définitivement dans un sous-programme ou une fonction et utilisé à partir de différents programmes principaux comme expliqué dans le programme 1.
Dans le programme 2, vous pouvez voir l'utilisation de la même fonction,
m / (m - n)! n° n° 1
pour calculer l'expression à travers la formule (m / n).
Dans le second programme, nous n'avons pas écrit le code du factoriel et il faudra indiquer au compilateur que la fonction sera compilée séparément. C'est pourquoi on devra indiquer le type de factoriel, en spécifiant le caractère externe. Avec ce schéma, le module objet généré lors de la compilation de la définition de la fonction factorielle est lié à celui créé par le programme principal en obtenant un seul programme exécutable.
Comme nous l'avons vu dans les exemples, si nous utilisons les fonctions dans les programmes C, nous pouvons faire des allusions de trois types : définition, appel et développement.
Définition de la fonction
Il sert à exprimer ce que fait le sous-programme, en spécifiant le type de résultat de la fonction, le nom, les arguments, la définition des arguments et le corps.
S'il y a plus d'un argument, ils se distinguent par le caractère. Dans l'exemple 1, le nom de la fonction est factoriel, le type de résultat est long, l'argument n, la définition de l'argument int n, et tout ce qui est à côté du corps jusqu'au programme principal. Notez que le programme principal est une fonction appelée main sans argument.
Le format de la définition est le suivant:
Si la fonction retourne des résultats, elle sera effectuée par l'instruction return, qui est normalement la dernière du corps. Si la fonction ne retourne pas de résultats (dans d'autres langages appelée procédure), le void sera écrit comme type de résultat, car si le type de résultat n'est pas mentionné, le retour du nombre entier sera supposé.
La définition des arguments est faite comme définition des données. La seule différence est que ces données sont envoyées depuis d'autres fonctions (ou depuis le programme principal). Par conséquent, ces arguments sont appelés formels et lors de l'appel de la fonction ils seront remplis avec des données spécifiques.
Le corps de la fonction indique le code du sous-programme, indiquant à la fois la définition de ses données et les instructions.
Nous allons écrire la définition qui renvoie le plus grand nombre dans les deux nombres entiers: nous inventons le nom, les grands, par exemple, les paramètres sont deux et en plus les deux nombres entiers (ceux appelés a et b) et le type de résultat est l'un des deux nombres, donc il sera en plus entier. Par conséquent, le chef de la fonction sera:
grands int (a, b)
int a, b; /*paramètres de fonction */
Le corps est très simple et une fois réalisé ici, la variable locale appelée résultat sera utilisée.
1er résultat
/*Variable locale*/ if (a b) résultat = a; else résultat = b; return (résultat)
Budgets
Appel de fonction
Lorsque vous voulez exécuter une fonction, un appel est effectué, de sorte qu'avec les données indiquées dans l'appel (paramètres) le code correspondant à la définition de la fonction est exécuté et le résultat est retourné.
Si la fonction retourne des résultats, l'appel apparaît normalement à droite d'une assignation. Cependant, il peut également apparaître au milieu d'une expression ou comme paramètre d'une autre fonction.
Pensons que nous avons lu deux nombres dans les variables z1 et z2 et que nous voulons écrire le plus grand. Nous avons deux options:
a) int em; ... em = grands (z1, z2) printf (“%d”, em); ... b) printf (“%d”, grands (z1, z2);
Dans le programme 2 décrit initialement, on peut observer que la fonction factorielle est appelée trois fois dans un même programme, mais en utilisant différents paramètres.
Lorsque vous devez obtenir plus d'un résultat dans un sous-programme, vous ne pouvez pas le faire avec return (ce qui permet de retourner un résultat unique). Cela se fera à travers les paramètres définis avec référence (voir chapitre 10).
Développement de la fonction
Lorsque dans un programme, nous appelons une fonction définie dans un autre module, la fonction doit être décrite afin que, faute de définition, le compilateur ne donne pas d'erreur. Ceci a été fait dans l'Exemple 2 et ce qui doit être spécifié dans le rapport est : pour indiquer que le mot-clé externe est défini extérieurement, pour différencier le type de résultat, le nom de la fonction et la fonction ( ). Dans l'exemple qui nous occupe, l'explication serait la suivante.
large int ( );
Lorsque la fonction et l'appel sont dans un même module, il n'est pas nécessaire d'effectuer la conception de la fonction, si la définition de la fonction est écrite avant l'appel, mais il est nécessaire d'envoyer mais sans entrer le mot-clé externe.
Macros
Cet outil de programmation, si commun dans les langages d'assemblage, apparaît dans quelques langages de haut niveau. Par exemple en C.
Les macros sont utilisées pour définir et référencer des sous-programmes simples, mais présentent les différences fonctionnelles suivantes :
- Les appels ne supposent pas l'exécution du sous-programme. Au contraire, le compilateur remplace un appel au corps de la définition. Ainsi, lors de la compilation, les appels disparaîtront et un nouveau code sera compilé.
- les programmes exécutables sont plus longs, mais plus rapides.
- si aucune parenthèse n'est utilisée avec les paramètres, il peut y avoir des problèmes.
- ne sont pas appropriés pour les sous-programmes complexes.
Définir et référencer (appeler) les macros. Le format de la définition est le suivant:
Nous ferions ainsi le cas du plus grand:
#define grandes (x, y) ((x) (y)? (x) : (y)
if
au lieu de la structure, ? L'expression a été utilisée, sinon le résultat ne peut pas être retourné. Les références sont faites comme les appels de la fonction, bien que la façon d'influencer est très différente.
Avec cette référence,
em = grand (zenb1, zenb2);
le remplacement du compilateur en langage machine donnera comme résultat:
em = ((zenb1) (zenb2)? (zenb1) : (zenb2)
C'est pourquoi le compilateur voit un nom macro le remplacer par le corps de la macro, en remplaçant les arguments formels par des paramètres de référence.
Comme vous pouvez le constater, le mécanisme est plus petit que celui des fonctions, il est donc rarement utilisé.
Pour terminer, nous placerons une macro pour calculer la surface du cercle:
#define PI 3.1416
# définit surface (r) PI *(r)*(r)
Zu idazle
Zientzia aldizkaria
