Différents types de fonctions

Une fonction est un code pour accomplir une certaine opération. Il a un nom pour son identification. Ici, nous ne sommes pas intéressés à définir la fonction. Nous discutons ici différents types de fonctions et leur application.

Façons de définir une fonction

Il existe quatre types de programmes disponibles dans la langue C. Ils sont:

1. Ne prend rien, ne retourne rien.

2. Prend quelque chose, ne retourne rien.

3. Ne prend rien, retourne quelque chose.

4. Prend quelque chose, renvoie quelque chose.

1. Ne prend rien, ne retourne rien

Exemple de programmation 1

#inclure
vide main ()

void add (vide);
ajouter ();

void add ()

int a, b, c;
printf ("Entrez deux numéros");
scanf ("% d% d", & a, & b);
c = a + b;
printf ("sum is =% d", c);

Sortir

Explication

Chaque fois que nous voulons compiler un programme, le compilateur doit connaître la signification de chaque mot écrit dans un programme qui signifie qu'il doit déclarer chaque fonction ou variable dans le programme. Pour cette fonction, une déclaration est requise. Dans la déclaration de fonction, nous écrivons 3 choses

1. Type de retour
2. Nom de FM
3. Argument

Mais dans le cas d'une fonction prédéfinie, une déclaration est écrite dans le fichier d'en-tête. Par exemple: clrscr () - -> La déclaration est effectuée dans le fichier et la fonction est définie dans le fichier de bibliothèque. Turbo C ++ 3.0 Compilateur déclare automatiquement la fonction définie par l'utilisateur. Mais nous devons déclarer une fonction. Nous écrivons uniquement le nom et le paramètre passés dans l'argument de la fonction d'appel.

2. Prend quelque chose, ne retourne rien

Exemple de programmation 2

#inclure
void add (int, int); // Déclaration de fonction dans le monde
vide main ()

int x, y;
void add (int, int); // Déclaration de fonction localement
printf ("Entrée 2 numéros");
scanf ("% d% d", & x, & y); // Arguments réels
ajouter (x, y);

void add (int x, int y) // arguments formels

INT C;
C = x + y;
printf ("sum is% d", c);

Sortir

Explication

Si nous voulons ajouter les deux valeurs de deux variables qui sont déclarées à l'intérieur du main () et l'ajouter dans un nom de fonction différent ajoute (), nous utilisons la méthode de ne rien retirer. Dans ce cas, la valeur de X et Y est transmise à la fonction ADD lorsque Add () appelle dans la fonction principale. Pour cela, il est appelé appel par valeur.

Chaque fois que nous passons une valeur en tant qu'argument à une fonction d'appel, ces arguments sont appelés argument réel.

Et dans une définition de fonction, à l'intérieur de la parenthèse d'une fonction, nous déclarons la variable qui recevra la valeur de la variable adoptée par la fonction d'appel, qui est appelée argument formel.

Le nom de l'argument réel et de la variable d'argument formel peut être le même car le compilateur ne confonde pas dans ce cas; Il sait que la variable x, y qui est déclarée à l'intérieur de Main () et x, y déclaré dans Add () sont différentes variables.

Dans la fonction d'appel, nous passons simplement la valeur des variables qui sont déclarées à l'intérieur de Main (). Pour cela, nous écrivons Add (x, y);

3. Ne prend rien, retourne quelque chose

Exemple de programmation 3

#inclure
int add (void);
vide main ()

int s;
S = add ();
printf ("Sum is% d", s);

int add ()

int a, b, c;
printf ("Entrez deux numéros");
scanf ("% d% d", & a, & b);
c = a + b;
Retour C;

Sortir

Explication

Ne prend rien signifie, lorsque même main () appelle une fonction pour ajouter (), cela signifie qu'il ne prend aucun argument. Son signifie que ajouter () prendre la valeur des variables de l'utilisateur et effectuer l'ajout.

Retour quelque chose signifie ajouter (); Ici, renvoyez le résultat ajouté au main () pour utiliser le mot-clé Retour. Lorsque ADD () renvoie la valeur, ces valeurs doivent être conservées dans une (s) variable (s) de type de données int en main () dans Main (). Car ici le type de retour est int. C'est moyen s = add () est remplacé par, s = valeur de rendement.

Pour cela, dans la définition de la fonction d'ajout (), nous devons ici mentionner le type de retour d'ajout (), voici int. Dans le cas d'un retour, nous ne renvoyons qu'une seule valeur. Donc, retourne (a, b, c) -> c'est faux. Cela signifie qu'il ne renvoie que la valeur de C car il est écrit au moins à l'intérieur de la parenthèse.

Lorsqu'une fonction renvoie une valeur, il faut comprendre que le contrôle va également revenir à la fonction d'appel.

Si nous écrivons un code après l'instruction RETOUR, ce code particulier n'a pas été d'effet sur le programme alors que le contrôle se déplace vers la fonction d'appel.

Aucune fonction ne peut accéder à la variable déclarée par l'autre fonction. Parce que toute variable déclarée à l'intérieur d'une fonction est traitée comme une variable locale.

Ainsi, dans main (), nous devons imprimer la valeur de S au lieu de C car C est la variable qui est déclarée à l'intérieur de l'ajout ().

4. Prend quelque chose, renvoie quelque chose

Exemple de programmation 4

#inclure
int add (int, int);
vide main ()

int s, x, y;
printf ("Entrée 2 numéros");
scanf ("% d% d", & x, & y);
S = add (x, y);
printf ("Sum is% d", s);

int add (int a, int b)

INT C;
c = a + b;
Retour C;

Sortir

Explication

Takes quelque chose ne renvoie rien du programme est le même que le ne retourne rien ne renvoie quelque chose; La seule différence est que, comme il est par Takes, quelque chose est dans la nature, donc la valeur de deux nombres doit être transmise dans la fonction d'appel.

Cela signifie que l'utilisateur prend la valeur du clavier utilisé par le main (). Cette valeur est transmise à l'ajout ().

Donc, c'est sur le type d'appel par valeur. Sinon, la procédure de retour est la même que la procédure ne prend rien, renvoie quelque chose.

Conclusion

Apprenant les différents types de fonctions en C, nous avons conclu que chaque type de fonction donne le même résultat. Mais chacun d'eux a un mécanisme différent. Chacun d'eux est nécessaire en fonction de l'exigence du programme. Nous devons donc connaître chaque type de fonction.