Fonction principale.
Chaque programme C et C++ doit avoir une fonction principale ; et c'est à vous de décider où vous le placez. Certains programmeurs le placent au début du fichier, d'autres à la fin. Cependant, quelle que soit sa position, vous devez vous rappeler les points suivants : Arguments de la fonction « principale ». La procédure de démarrage de Borland C++ envoie trois paramètres (arguments) à la fonction principale : argc, argv et env. - argc, un entier, est le nombre d'arguments de ligne de commande envoyés à la fonction principale, - argv est un tableau de pointeurs vers des chaînes (char *). Sous DOS 3.x et versions ultérieures, argv est défini comme le chemin complet du programme à lancer. Lors de l'exécution sous des versions antérieures de DOS, argv pointe vers une chaîne nulle (""). argv pointe vers la première ligne de commande après le nom du programme. argv pointe vers la deuxième ligne de commande après le nom du programme. argv pointe vers le dernier argument envoyé à main. argv contient NULL. - env est également un tableau de pointeurs vers des chaînes. Chaque élément env contient une chaîne de la forme ENVVAR=value. ENVVAR est le nom d'une variable d'environnement, telle que PATH ou 87.<значение>il s'agit de la valeur d'une variable d'environnement donnée, par exemple C:\DOS;C:\TOOLS (pour PATH) ou YES (pour 87). Notez cependant que si vous spécifiez certains de ces arguments, vous devez les spécifier dans cet ordre : argc, argv, env. Par exemple, les déclarations d'arguments suivantes sont valides : main() main(int argc) /* valide mais pas très bon */ main(int argc, char *argv) main(int argc, char *argv, char *env) Main (int)declaration argc) n'est pas très pratique car connaissant le nombre de paramètres, vous n'y avez pas accès vous-même. L'argument env est toujours accessible via la variable globale environ. Voir la variable environ (au chapitre 3) et les fonctions putenv et getenv (au chapitre 2). Les paramètres argc et argv sont également disponibles via les variables _argc et _argv. Exemple de programme utilisant argc, argv et env. Il s'agit d'un exemple de programme, ARGS.EXE, qui montre la manière la plus simple d'utiliser les arguments passés à la fonction principale. /* Programme ARGS.C */ #includePage 53 sur 85
1.5.3. Passer des paramètres à la fonction principale
La fonction principale, qui démarre l'exécution d'un programme C, peut être définie avec des paramètres transmis depuis l'environnement externe, par exemple depuis la ligne de commande. L'environnement externe a ses propres règles de représentation des données, ou plutôt, toutes les données sont présentées sous forme de chaînes de caractères. Pour passer ces chaînes à la fonction principale, deux paramètres sont utilisés, le premier paramètre sert à transmettre le nombre de chaînes à transmettre, le second sert à transmettre les chaînes elles-mêmes. Les noms courants (mais non obligatoires) de ces paramètres sont argc et argv. Le paramètre argc est de type int, sa valeur est formée à partir de l'analyse de la ligne de commande et est égale au nombre de mots sur la ligne de commande, incluant le nom du programme appelé (un mot est tout texte qui ne contient pas d'espace personnage). Le paramètre argv est un tableau de pointeurs vers des chaînes, chacune contenant un mot de la ligne de commande. Si un mot doit contenir un espace, il doit être placé entre guillemets lors de son écriture sur la ligne de commande.
La fonction principale peut également avoir un troisième paramètre, généralement appelé argp, et qui sert à transférer à la fonction principale les paramètres du système d'exploitation (environnement) dans lequel le programme est exécuté en langage de programmation C.
L'en-tête de la fonction principale ressemble à ceci :
Si, par exemple, la ligne de commande d'un programme en langage de programmation C ressemble à :
A:\>cprog fonctionnant avec le "programme C" 1
alors les arguments argc, argv, argp sont représentés en mémoire comme le montre le diagramme de la figure 1.
Argc[4]
argv --> -->
-->
-->
-->
argp --> -->
-->
-->
-->
Fig. 1. Disposition des options de ligne de commande
Le système d'exploitation prend en charge la transmission des valeurs pour les paramètres argc, argv, argp, et il est de la responsabilité de l'utilisateur de transmettre et d'utiliser les arguments réels à la fonction principale.
L'exemple suivant est un programme qui imprime les arguments réels transmis à la fonction principale à partir du système d'exploitation et des paramètres du système d'exploitation.
Exemple:
int principal (int argc, char *argv, char *argp)
(int je=0;
printf("\nNom du programme %s", argv);
pour (i=1; i>=argc; i++)
printf("\n l'argument %d est %s", argv[i]);
printf("\nParamètres du système d'exploitation :");
tandis que (*argp)
( printf ("\n %s",*argp);
argp++ ;
}
retour(0);
}
Les paramètres du système d'exploitation sont également accessibles à l'aide de la fonction de la bibliothèque geteuv ; son prototype ressemble à ceci :
char *geteuv (const char *varname);
L'argument de cette fonction spécifie le nom du paramètre d'environnement, dont un pointeur vers la valeur sera renvoyé par la fonction geteuv. Si le paramètre spécifié n'est pas actuellement défini dans l'environnement, la valeur de retour est NULL.
A l'aide du pointeur obtenu par la fonction geteuv, vous pouvez uniquement lire la valeur du paramètre du système d'exploitation, mais vous ne pouvez pas la modifier. La fonction puteuv est utilisée pour modifier la valeur d'un paramètre système.
Le compilateur du langage de programmation C construit un programme C de telle sorte qu'une certaine initialisation soit effectuée au début du programme, comprenant, entre autres, le traitement des arguments transmis à la fonction principale et lui transmettant les valeurs des paramètres d'environnement. Ces actions sont effectuées par les fonctions de bibliothèque _setargv et _seteuv, qui sont toujours placées avant la fonction principale par le compilateur.
Si un programme en langage de programmation C n'utilise pas le passage d'arguments et de valeurs de paramètres du système d'exploitation, alors il est conseillé d'interdire l'utilisation des fonctions de bibliothèque _setargv et _seteuv en les plaçant dans le programme C en langage de programmation, avant la fonction principale, les fonctions portant les mêmes noms, mais qui n'effectuent aucune action (stubs). Le début du programme dans ce cas ressemblera à :
setargv()
}
-setuv()
( retour ; /* fonction vide */
}
int main()
( /* fonction principale sans arguments */
...
...
renturn(0);
}
Dans le programme ci-dessus, lors de l'appel des fonctions de bibliothèque _setargv et _seteuv, les fonctions placées dans le programme par l'utilisateur seront utilisées et n'effectueront aucune action. Cela réduira considérablement la taille du fichier exe résultant.
Borland C++ prend en charge trois arguments pour main(). Les deux premiers sont les traditionnels argc et argv. Ce sont les seuls arguments de main() définis par la norme ANSI C. Ils permettent de transmettre des arguments de ligne de commande au programme. Les arguments de ligne de commande sont les informations qui suivent le nom du programme sur la ligne de commande du système d'exploitation. Par exemple, lorsqu'un programme est compilé à l'aide du compilateur de ligne Borland, il est généralement saisi bcc nom du programme
Où nom du programme est un programme qui doit être compilé. Le nom du programme est transmis au compilateur sous forme d'argument.
Le paramètre argc contient le nombre d'arguments de ligne de commande et est un entier. Il est toujours égal à au moins 1, puisque le nom du programme est considéré comme le premier argument. Le paramètre argv est un pointeur vers un tableau de pointeurs de caractères. Chaque élément de ce tableau pointe vers un argument de ligne de commande. Tous les arguments de ligne de commande sont des chaînes. Tous les nombres sont convertis par le programme au format interne. Le programme suivant imprime « Bonjour » suivi du nom d'utilisateur lorsqu'il est saisi directement après le nom du programme :
#inclure
{
si(argc!=2)
{
printf("Vous avez oublié de saisir votre nom\n");
renvoyer 1 ;
}
printf("Bonjour %s", argv);
renvoie 0 ;
}
Si vous appelez ce nom de programme et que le nom d'utilisateur est Sergey, alors pour démarrer le programme, vous devez taper :
nom Sergueï.
À la suite du programme, les éléments suivants apparaîtront :
"Bonjour Sergueï."
Les arguments de la ligne de commande doivent être séparés par des espaces ou des tabulations. Les virgules, points-virgules et caractères similaires ne sont pas considérés comme des délimiteurs. Par exemple:
Se compose de trois lignes, tandis que
Herbe, Rick, Fred
Il s’agit d’une seule ligne – les virgules ne sont pas des délimiteurs.
Si vous devez transmettre une chaîne contenant des espaces ou des tabulations comme argument unique, vous devez la mettre entre guillemets doubles. Par exemple, voici un argument :
"c'est un test"
Il est important de déclarer argv correctement. La méthode la plus courante est la suivante :
Les parenthèses vides indiquent que le tableau n'a pas de longueur fixe. Vous pouvez accéder éléments individuels en utilisant l'indexation argv. Par exemple, argv pointe vers la première ligne, qui contient toujours le nom du programme. argv pointe vers la ligne suivante et ainsi de suite.
Vous trouverez ci-dessous un petit exemple d'utilisation des arguments de ligne de commande. Il compte à rebours à partir de la valeur spécifiée sur la ligne de commande et émet un signal lorsqu'il atteint zéro. Notez que le premier argument contient un nombre converti en entier à l'aide de la fonction standard atoi(). Si la chaîne "display" est présente comme deuxième argument, alors le compteur lui-même sera affiché à l'écran.
/* programme de comptage */
#inclure
#inclure
#inclure
int principal (int argc, char *argv)
{
int disp, compte ;
si (argc<2)
{
printf("Vous devez saisir la longueur du décompte\n");
printf("sur la ligne de commande. Réessayez.\n");
renvoyer 1 ;
}
if (argc==3 && !strcmp(argv,"display")) disp = 1;
sinon disp = 0 ;
pour(count=atoi(argv); count; -count)
if (disp) printf("%d ", nombre);
printf("%c", "\a"); /* sur la plupart des ordinateurs, il s'agit d'un appel */
renvoie 0 ;
}
Veuillez noter que si aucun argument n'est spécifié, un message d'erreur apparaît. Ceci est plus courant pour les programmes qui utilisent des arguments de ligne de commande pour émettre des instructions si une tentative d'exécution du programme a été effectuée sans les informations correctes.
Pour accéder aux caractères de ligne de commande individuels, ajoutez un deuxième index à argv. Par exemple, le programme suivant affiche tous les arguments avec lesquels il a été appelé, un caractère à la fois :
#inclure
int principal (int argc, char *argv)
{
int t, je;
pour(t=0; t
je = 0 ;
pendant que(argv[t][i])
{
printf("%c", argv[t][i]);
}
printf(" ");
}
renvoie 0 ;
}
Nous devons nous rappeler que le premier index sert à accéder à une chaîne et le second à accéder à un caractère dans une chaîne.
Généralement, argc et argv sont utilisés pour obtenir les commandes source. Il est théoriquement possible d'avoir jusqu'à 32 767 arguments, mais la plupart des systèmes d'exploitation ne permettent même pas de s'en approcher. Généralement, ces arguments sont utilisés pour spécifier un nom de fichier ou des options. L'utilisation d'arguments de ligne de commande donne au programme un aspect professionnel et permet au programme d'être utilisé dans des fichiers batch.
Si vous incluez le fichier WILDARGS.OBJ fourni avec Borland C++, vous pouvez utiliser des modèles dans les arguments de type *.EXE. (Borland C++ gère automatiquement les caractères génériques et incrémente argc en conséquence.) Par exemple, si vous connectez WILDARGS.OBJ au programme suivant, il vous indiquera combien de fichiers correspondent au nom de fichier spécifié sur la ligne de commande :
/* Lier ce programme à WILDARGS.OBJ */
#inclure
int principal (int argc, char *argv)
{
inscrivez-vous dans i;
printf("%d fichiers correspondent au nom spécifié\n", argc-1);
printf("Ce sont : ");
pour(i=1; je
renvoie 0 ;
}
Si nous appelons ce programme WA, puis l'exécutons comme suit, nous obtiendrons le nombre de fichiers avec l'extension EXE et une liste des noms de ces fichiers :
En plus de argc et argv, Borland C++ fournit également un troisième argument de ligne de commande -env. Le paramètre env permet à un programme d'accéder à des informations sur l'environnement du système d'exploitation. Le paramètre env doit suivre argc et argv et est déclaré comme suit :
Comme vous pouvez le voir, env est déclaré de la même manière que argv. Tout comme argv, c'est un pointeur vers un tableau de chaînes. Chaque ligne est une chaîne d'environnement définie par le système d'exploitation. Le paramètre env n'a pas de paramètre argc équivalent qui indique le nombre de lignes d'environnement. Au lieu de cela, la dernière ligne de l'environnement est nulle. Le programme suivant imprime toutes les chaînes d'environnement actuellement définies dans le système d'exploitation :
/* ce programme affiche toutes les lignes d'environnement */
#inclure
int principal (int argc, char *argv, char *env)
{
int t;
pour(t=0; env[t]/ t++)
printf("%s\n", env[t]);
renvoie 0 ;
}
Veuillez noter que bien que argc et argv ne soient pas utilisés par le programme, ils doivent être présents dans la liste des paramètres. C ne connaît pas les noms des paramètres. Leur utilisation est plutôt déterminée par l’ordre dans lequel les paramètres sont déclarés. En fait, vous pouvez appeler le paramètre comme bon vous semble. Puisque argc, argv et env sont des noms traditionnels, il est préférable de continuer à les utiliser afin que toute personne lisant le programme puisse comprendre instantanément qu'il s'agit d'arguments de la fonction main().
Une tâche typique des programmes consiste à rechercher une valeur définie dans une chaîne d'environnement. Par exemple, le contenu de la ligne PATH permet aux programmes d'utiliser des chemins de recherche. Le programme suivant montre comment rechercher des chaînes qui déclarent des chemins de recherche standard. Il utilise la fonction de bibliothèque standard strstr(), qui a le prototype suivant :
Char *strstr(const char *str1, const char *str2);
La fonction strstr() recherche la chaîne pointée par str1 dans la chaîne pointée par str2. Si une telle chaîne est trouvée, un pointeur vers la première position est renvoyé. Si aucune correspondance n'est trouvée, la fonction renvoie NULL.
/* le programme recherche parmi les chaînes d'environnement une ligne contenant PATH */
#inclure
#inclure
int principal (int argc, char *argv, char *env)
{
int t;
pour(t=0; env[t]; t++)
{
si(strstr(env[t], "CHEMIN"))
printf("%s\n", env[t]);
}
renvoie 0 ;
}
Tout programme C commence par un appel à la fonction main(). Cette fonction devrait être dans chaque programme.
Comme toute autre fonction, la fonction main() peut avoir des paramètres. Parfois, lors du démarrage d'un programme, il est utile de lui transmettre certaines informations. Ces informations sont transmises à main() à l'aide d'arguments de ligne de commande. Arguments de ligne de commande– il s'agit d'informations saisies sur la ligne de commande après le nom du programme lorsque le programme est lancé pour exécution en dehors de l'environnement de développement du programme. Par exemple, pour démarrer l'archivage du fichier task.cpp, vous devez taper ce qui suit sur la ligne de commande :
gagner une tâche archtâche.cpp // winrar.exe une tâche archtâche.cpp
où winrar est le nom du programme d'archivage et les lignes " un», « archTâche" Et " tâche. RPC» représente les arguments de ligne de commande qui indiquent au programme de créer une archive (" un") Avec nom archTâcheà partir d'un fichier tâche. RPC.
Lors du passage de paramètres à la fonction main(), celle-ci doit être définie comme ceci :
int main(int argc, char *argv) ( ) // ou void main(...)()
Le paramètre argc contient le nombre d'arguments sur la ligne de commande et est un nombre entier, et il est toujours au moins 1, car le premier argument est toujours le nom du programme (le nom du programme avec le chemin complet du programme).
Le paramètre argv est un pointeur vers un tableau de pointeurs vers des chaînes. Dans ce tableau, chaque élément pointe vers l'argument de ligne de commande suivant. Les crochets vides indiquent que le tableau a une longueur indéfinie. Vous pouvez accéder aux arguments individuels en indexant le tableau argv. Par exemple, argv pointe vers la première chaîne de caractères, qui est toujours le nom du programme ; argv pointe vers le premier argument et ainsi de suite. La liste d'arguments est limitée à NULL, c'est-à-dire argv == NULL.
Pour accéder à un caractère individuel de l'un des arguments de ligne de commande, vous devez utiliser le deuxième index dans argv. Autrement dit, le premier index argv donne accès à la chaîne et le deuxième index donne accès à ses caractères individuels.
Tous les arguments de ligne de commande sont des chaînes, donc la conversion des paramètres numériques au format souhaité doit être fournie dans le programme lors de son développement.
Un exemple de programme avec différentes manières de convertir des nombres au format symbolique en nombres entiers et réels :
#inclure
#inclure
// au démarrage on définit, par exemple, les arguments suivants : 100 2.7
void main(int a, char *b) (
k = strtol(b, &ptr, 10); // ptr = adresse de l'erreur dans la ligne
f = strtod(b, &ptr);
sscanf(b, "%d", &k);
sscanf(b, "%lf", &f);
Les noms argc et argv sont traditionnels, mais pas obligatoires. Ces deux paramètres de la fonction main() peuvent être appelés comme vous le souhaitez.
Un exemple simple d'utilisation d'arguments de ligne de commande :
int main(int argc, char *argv) (
si (argc != 4) (
printf("Paramètres de lancement de programme invalides !\n");
k = atoi(argv); // conversion du paramètre nombre
printf("Bonjour, %s du groupe %s de %d année",
Si le nom du programme est tâche et que votre nom est « Vasya », groupe « PM-11 » de la première année, alors pour démarrer le programme, vous devez entrer dans la ligne de commande :
tâche Vasya PM-11 1
À la suite de l'exécution du programme, le message suivant apparaîtra à l'écran : "Bonjour, Vasya du groupe PM-11 de 1ère année."
Veuillez noter que si tous les arguments de ligne de commande ne sont pas fournis, un message d'erreur s'affichera. Les programmes qui acceptent des arguments de ligne de commande effectuent souvent les opérations suivantes : Lorsque l'utilisateur exécute ces programmes sans saisir les informations requises, ils affichent des instructions sur la manière de spécifier correctement les arguments.
Les arguments de la ligne de commande doivent être séparés par un espace. S'il y a des espaces dans l'argument lui-même, pour éviter qu'il ne fasse plusieurs arguments, cet argument doit être placé entre guillemets. Par conséquent, la totalité de la chaîne citée sera considérée comme un seul argument. Par exemple, le programme peut être lancé comme ceci : tâche « Vasya et Petya » PM-21 2. À la suite de l'exécution du programme, le message apparaîtra à l'écran : « Bonjour, Vasya et Petya de la 2e année PM- 21 groupe."
Qu'est-ce que char *argv ? Ce un tableau dont les éléments sont des pointeurs, c'est tableau de pointeurs. Cela signifie que lors du passage de paramètres à main(), cela peut être défini comme ceci :
void main(int argc, char **argv) (
Tâche. Afficher tous les arguments de la ligne de commande (pas besoin d'afficher le nom du programme).
#inclure
void main(int argc, char *argv)(
pour (i = 1; je< argc; i++)
printf("%s\n", argv[i]);
Deuxième option ================
#inclure
void main(int argc, char **argv)(
while((p=*argv) != NULL) (
printf("%s\n", p);
Généralement, les arguments de ligne de commande sont utilisés pour fournir au programme les données initiales dont il aura besoin lors de son démarrage (par exemple, les arguments de ligne de commande transmettent souvent des données telles que le nom de fichier ou les paramètres de lancement du programme).
Lorsqu'un programme ne nécessite pas de paramètres de ligne de commande, la fonction main() utilise le mot-clé void dans sa liste de paramètres (ou ne spécifie simplement rien).
Comment déboguer AVANT JC. programmes qui nécessitent des arguments de ligne de commande. Dans le menu Exécuter → Arguments... vous devez saisir les arguments de la ligne de commande. Il n'est pas nécessaire de spécifier le nom du programme. Ensuite, vous pouvez simplement exécuter et déboguer le programme dans l'environnement de développement comme d'habitude.
Veuillez suspendre AdBlock sur ce site.
Alors, pourquoi avons-nous besoin de fonctions personnalisées ? Des fonctions définies par l'utilisateur sont nécessaires pour permettre aux programmeurs d'écrire plus facilement des programmes.
Rappelez-vous, nous avons parlé de paradigmes de programmation, plus précisément de programmation structurée. L’idée principale était que n’importe quel programme pouvait être écrit en utilisant seulement trois constructions de base : suivre, conditionner et boucle. Nous allons maintenant en ajouter un de plus à ces structures - des « sous-programmes » - et obtenir un nouveau paradigme. programmation procédurale".
La seule différence est que nous allons écrire des morceaux individuels de notre programme principal (en particulier ceux qui se répètent) sous la forme de fonctions distinctes (sous-programmes, procédures) et les appeler si nécessaire. Essentiellement, le programme va maintenant décrire l'interaction de diverses fonctions.
Ainsi, dans ce didacticiel, nous discuterons en détail de la façon dont les fonctions sont construites en interne. Nous apprendrons également comment créer nos propres fonctions personnalisées.
Comment fonctionnent les fonctions
Rappelons les informations de la première leçon. Toutes les fonctions, y compris celles écrites par l'utilisateur, sont organisées de la même manière. Ils comportent deux parties principales : l’en-tête de fonction et le corps de la fonction.
Inscription 1.
Int main(void)( // en-tête de fonction // le corps de la fonction est écrit entre accolades)
Tout est clair avec le corps de la fonction : il décrit l'algorithme de la fonction. Regardons le titre. Il se compose de trois parties obligatoires :
- type de retour ;
- nom de la fonction ;
- arguments de fonction.
Tout d'abord, le type de retour est écrit, par exemple, int , comme dans la fonction main. Si une fonction ne doit renvoyer aucune valeur au programme, alors le mot-clé void est écrit à cet endroit. Il semblerait que puisque la fonction ne renvoie rien, il n'est alors pas nécessaire d'écrire quoi que ce soit. Soit dit en passant, cela se faisait auparavant en langage C, mais ils l'ont ensuite ajouté pour plus d'uniformité. De nos jours, les compilateurs modernes émettent des avertissements/erreurs si vous ne spécifiez pas de type de retour.
Dans certains langages de programmation, les fonctions qui ne renvoient aucune valeur sont appelées procédures (par exemple Pascal). De plus, il existe différentes syntaxes pour créer des fonctions et des procédures. Il n’existe pas une telle discrimination dans le langage C.
Le nom de la fonction est écrit après le type de retour. Eh bien, après le nom, les types et le nombre d'arguments transmis à la fonction sont indiqués.
Regardons les titres des fonctions que nous connaissons déjà.
Inscription 2.
// une fonction nommée srand qui prend un entier ne renvoie rien void srand(int) // une fonction nommée sqrt qui prend un vrai float renvoie un float float sqrt(float) // une fonction nommée rand qui ne prend aucun argument, renvoie un entier int rand(void) //une fonction nommée pow qui prend deux arguments de type double, renvoie un nombre réel de type double double pow(double, double)
Comment créer votre propre fonction
Afin de créer votre propre fonction, vous devez la décrire entièrement. La règle générale s'applique ici : avant de l'utiliser, déclarez et décrivez comment il doit fonctionner. Pour ce faire, revenons au schéma de la structure du programme en langage C, que nous avions dans la toute première leçon. Marquons-y les endroits où les fonctions peuvent être décrites.
Fig.1 Clarification de la structure du programme. Déclaration de fonctions.
Comme vous pouvez le constater, cela peut être fait à deux endroits.
Examinons un exemple illustrant la création d'une fonction personnalisée pour calculer le maximum de deux nombres.
Inscription 3.
#inclure
Permettez-moi de décrire en détail comment ce programme fonctionnera. Le corps de la fonction principale est exécuté. Les variables entières x, y et m sont créées. Les variables x et y sont lues au clavier. Disons que nous avons entré 3 5, alors x = 3, y = 5. Tout cela devrait être clair pour vous. Maintenant la prochaine ligne
Inscription 4.
M = max_num(x,y);
La variable m doit être affectée à ce qui se trouve à droite du signe =. Nous y avons le nom de la fonction que nous avons nous-mêmes créée. L'ordinateur recherche la déclaration et la description de cette fonction. Il est situé au dessus. Selon cette déclaration, cette fonction doit accepter deux valeurs entières. Dans notre cas, ce sont les valeurs écrites dans les variables x et y. Ceux. numéros 3 et 5. Veuillez noter que ce ne sont pas les variables x et y elles-mêmes qui sont transmises à la fonction, mais uniquement les valeurs (deux nombres) qui y sont stockées. Ce qui est réellement transmis à une fonction lorsqu'elle est appelée dans un programme est appelé les paramètres réels de la fonction.
La fonction max_num commence maintenant à s'exécuter. La première étape consiste à créer une variable temporaire distincte pour chaque paramètre décrit dans l'en-tête de la fonction. Dans notre cas, deux variables entières sont créées nommées a et b. Ces variables se voient attribuer les valeurs des paramètres réels. Les paramètres eux-mêmes, décrits dans l'en-tête de la fonction, sont appelés paramètres formels. Ainsi, les paramètres formels a et b reçoivent respectivement les valeurs des paramètres réels 3 et 5. Maintenant a = 3, b = 5. Plus loin dans la fonction, nous pouvons travailler avec ces variables comme s'il s'agissait de variables ordinaires.
Une variable entière nommée max est créée et reçoit la valeur b. Ensuite, la condition a > b est vérifiée. Si c'est vrai, alors la valeur de la variable max doit être remplacée par un .
Vient ensuite l'instruction return, qui renvoie au programme appelant (la fonction principale) la valeur écrite dans la variable max, c'est-à-dire 5 . Après quoi les variables a, b et max sont supprimées de la mémoire. Et nous revenons à la ligne
Inscription 5.
M = max_num(x,y);
La fonction max_num a renvoyé la valeur 5, ce qui signifie qu'il y a maintenant 5 écrit à droite du signe =. Cette valeur est écrite dans la variable m. Ensuite, la ligne s'affiche à l'écran et le programme se termine.
Relisez attentivement les 4 derniers paragraphes pour bien comprendre le fonctionnement du programme.
En attendant, je vais vous expliquer pourquoi le bloc inférieur de descriptions de fonctions est nécessaire. Imaginez que vous ayez écrit 20 petites fonctions dans votre programme. Et tous sont décrits avant la fonction principale. Ce n'est pas très pratique d'accéder au programme principal aussi longtemps. Pour résoudre ce problème, les fonctions peuvent être décrites dans un bloc inférieur.
Mais il ne sera pas possible d'y transférer simplement l'intégralité du code de fonction, car alors la règle sera enfreinte : avant d’utiliser quelque chose, vous devez le déclarer. Pour éviter ce problème, vous devez utiliser un prototype de fonction.
Le prototype de fonction répète complètement l'en-tête de fonction, suivi de ; . Après avoir spécifié le prototype dans le bloc supérieur, dans celui du bas, nous pouvons déjà décrire complètement la fonction. Pour l'exemple ci-dessus, cela pourrait ressembler à ceci :
Inscription 6.
#inclure
Tout est très simple. Attention, le prototype de fonction n'a pas besoin de préciser les noms des paramètres formels, il suffit d'indiquer simplement leurs types. Dans l’exemple ci-dessus, j’ai fait exactement cela.