Apprendre C/C++ Étape par Étape - Page 6

06. Étape par Étape C/C++ — Programmation C - Fonctions

Fonctions

| | 1. Fonctions numériques

2. Fonctions de chaîne
3. Fonctions de test de caractères | | | V. Fonctions définies par l’utilisateur | | | 1. Fonctions simples
4. Fonction avec arguments
5. Fonction avec retours
6. Fonction avec récursion | | | VI. Pointeurs et Fonctions | | | 1. Passage de paramètres par référence
7. Appel par valeur
8. Appel par référence | | | VII. Local Vs Global | | | VIII. Spécificateurs de classe de stockage | | | Classe de stockage automatique
   Classe de stockage d’enregistrement
   Classe de stockage statique
   Classe de stockage externe |

I. Introduction

Voici un programme pour imprimer l’adresse d’une personne deux fois, qui est écrit dans les deux méthodes en utilisant des fonctions et sans utiliser de fonctions. Cela démontrera l’avantage des fonctions.

| | #include
int main()
{
printf(“\nNom de la Personne”);
printf(“\nRue, Appartement//Numéro de Maison “);
printf(“\ncode postal, Ville”);
printf(“\nPays”);

printf(“\nNom de la Personne”);
printf(“\nRue, Appartement//Numéro de Maison “);
printf(“\ncode postal, Ville”);
printf(“\nPays”);

return 0;
} | #include
void address()
{
printf(“\nNom de la Personne”);
printf(“\nRue, Appartement//Numéro de Maison “);
printf(“\ncode postal, Ville”);
printf(“\nPays”);
}

int main()
{
address();
address();

return 0;
} |

II. Définition de Fonction

Un bloc d’instructions, qui a la capacité d’accepter des valeurs en tant qu’arguments et de renvoyer des résultats au programme appelant. Donc, une fonction est un bloc d’instructions autonome qui effectue une tâche spécifique.

III. Types de fonctions

| | - Fonctions intégrées/ Fonctions de bibliothèque/ Fonctions prédéfinies

• Fonctions définies par l’utilisateur |

IV. Fonctions de Bibliothèque

Les fonctions de bibliothèque sont conçues par le fabricant du logiciel, elles sont chargées dans le disque chaque fois que le logiciel est chargé.

Les fonctions suivantes sont des exemples de fonctions de bibliothèque.

1. Fonctions Numériques

2. Fonctions de Chaîne

3. Fonctions de Test de Caractères

Il existe une énorme bibliothèque de fonctions disponibles, je vous en ai donné une petite portion. Pour plus de fonctions de bibliothèque, consultez le manuel d’aide.

V. Fonctions Définies par l’Utilisateur

Les programmes que vous avez déjà vus effectuent des divisions de travail. Lorsque vous appelez gets, puts, ou strcmp, vous n’avez pas à vous soucier de la façon dont les entrailles de ces fonctions fonctionnent.

Ces fonctions et environ 400 autres sont déjà définies et compilées pour vous dans la bibliothèque Turbo C. Pour les utiliser, vous devez simplement inclure le fichier d’en-tête approprié dans votre programme, “La bibliothèque d’exécution,” dans la référence de bibliothèque pour vous assurer que vous comprenez comment appeler les fonctions, et quelle valeur (le cas échéant) elle renvoie.

Mais vous devrez écrire vos propres fonctions. Pour ce faire, vous devez diviser votre code en sections discrètes (fonctions) qui effectuent chacune une tâche unique et compréhensible pour vos fonctions, vous pouvez les appeler tout au long de votre programme de la même manière que vous appelez les fonctions de bibliothèque C.

Étapes pour implémenter une fonction

| | 1. Déclaration

2. Appel de Fonction
3. Définition |

| | • Chaque fonction doit être déclarée au début du programme.
• La définition de la fonction contient le code réel de la tâche d’exécution.
• Si une fonction est définie au début du programme, il n’est pas nécessaire de déclarer la fonction. |

Un exemple de fonction pour démontrer l’implémentation

| | / 32_egfun.c /
#include

void address(); / Déclaration /

int main()
{
address(); / Appel de Fonction /
address(); / Appel de Fonction /

return 0;
}

void address() / Définition /
{
printf(“\nNom de la Personne”);
printf(“\nRue, Appartement//Numéro de Maison “);
printf(“\ncode postal, Ville”);
printf(“\nPays”);
} |

Les fonctions définies par l’utilisateur peuvent être divisées en 4 types en fonction de la manière dont nous les appelons.

| | 1. Fonctions Simples

2. Fonction avec Arguments
3. Fonction avec Retours
4. Fonction avec Récursion |

1. Fonctions Simples

Effectue une tâche spécifique uniquement, pas besoin d’arguments ni de valeurs de retour.

Exemple de Fonction Simple

| | / 33_line.c /
#include
void line(); / Déclaration /
int main()
{
line(); / Appel de Fonction /
return 0;
}
void line() / Définition /
{
int i;
for(i =1;i<80; i++)
putch(‘*’);
} |

2. Fonction avec Arguments

Une fonction qui accepte des arguments est connue sous le nom de fonction avec arguments.

Ex.

| | / 34_argu.c /
void line(char ch, int n)
int main()
{
line(“-“, 50);
line(“*”, 8);
return 0;
}
void line(char ch, int n)
{
int i;
for( i = 1; i<=n; i++ )
putch(ch);
} |

3. Fonction avec Valeurs de Retour

Une fonction qui peut renvoyer des valeurs au programme appelant est connue sous le nom de fonction avec valeurs de retour.

Ex.

| | / 35_retu.c /
int abs(int n);
int main()
{
int res;
printf(“%d”, abs(-35))

res = abs(-34); / Appel de Fonction/

printf(“%d”, res);
return 0;
}
void abs(int n)
{
if( n < 0 )
n = n * -1;
return n;
} |

4. Fonction avec Récursion

Si une instruction dans le corps d’une fonction appelle la même fonction, on parle de ‘récursion’. Parfois appelée ‘définition circulaire’, la récursion est donc le processus de définition de quelque chose en termes de lui-même.

Exemples de Fonctions Récursives

| | / Le programme suivant démontre l’appel de fonction de lui-même /
int main( )
{
printf(“\nBonjour”);
main( ); / Une fonction, qui peut s’appeler elle-même /
return 0;
} Ne pas exécuter ce programme, c’est encore une explication donc le programme n’est pas logiquement valide.

Le même résultat peut être atteint en utilisant une autre fonction : void disp( );

int main( )
{
disp( );
return 0;
}

void disp( )
{
printf(“\nBonjour”);
disp( );
} |

Le programme doit se terminer à un certain point, donc la clé de la récursion réside dans l’interruption douce, qui peut être définie à l’aide d’une instruction conditionnelle.
Vérifiez l’exemple suivant :

| | / 36_recursion.c /
int i = 1;      / Déclaration d’une variable globale /
void disp( );
int main( )
{
disp( );
return 0;
}

void disp( )
{
printf(“\nBonjour %d “, i);
i ++;
if( i < 10 ) / si la valeur de i est inférieure à 10 alors appeler la fonction à nouveau /
disp( );
} |

| | Programme pour trouver le facteur du nombre donné :
/ 37_fact.c /
int factorial(int x);
void main
{
int a, fact;
printf(“\nEntrez un nombre quelconque “); scanf(“%d”, &a);
fact = factorial(a);
printf(“\nLe facteur est = %d”, fact);
}
int factorial(int x)
{
int f = 1, i;
for( i = x; i>=1; i–)
f = f i;
return f;
} | Pour trouver le facteur d’un nombre donné en utilisant la récursion
/ 38_fact.c /
int rec_fact(int x);
int main( )
{
int a, fact;
printf(“\nEntrez un nombre quelconque “); canf(“%d”, &a);
fact = rec_fact(a);
printf(“\nLa valeur du facteur est = %d”, fact);
return 0;
}
int f = 1;
int rec_fact(int x)
{
if( x > 1)
f = x rec_fact(x-1);
return f;
} |

VI. Pointeurs et Fonctions

| | Passage de Paramètres par Référence
Appel par valeur
Appel par Référence |

1. Passage de Paramètres par Référence

Le pointeur peut être utilisé dans la déclaration de fonction et cela rend une fonction complexe facilement représentée ainsi que accessible. La définition de la fonction utilise des pointeurs, de deux manières

| | – Appel par valeur

• Appel par référence |

Le mécanisme d’appel par référence est rapide par rapport au mécanisme d’appel par valeur car dans l’appel par référence, l’adresse est passée et la manipulation avec les adresses est plus rapide que les variables ordinaires. De plus, une seule zone de mémoire est créée pour chacun des paramètres réels.

Lorsqu’une partie du programme, les arguments réels, appelle une fonction et que les valeurs modifiées dans la fonction seront renvoyées à la partie appelante du programme sous une forme modifiée. Cela s’appelle appel par référence ou appel par adresse. L’utilisation d’un pointeur comme argument de fonction dans ce mécanisme permet aux objets de données d’être modifiés globalement, c’est-à-dire à l’intérieur de la fonction ainsi qu’à l’intérieur de la partie appelante du programme. Lorsqu’un pointeur est passé à la fonction, l’adresse de l’argument est passée aux fonctions et le contenu de cette adresse est accessible globalement. Les modifications apportées aux paramètres formels (paramètres utilisés dans la fonction) affectent la valeur originale des paramètres réels (paramètres utilisés dans l’appel de fonction dans le programme appelant).

Ex.

| | / 39_func.c /

void func_c( int *x );

int main()
{
int i = 100;
int *a;
a = &i;
printf(“\nLa valeur est %d”, i);
func_c(a);
printf(“\nLa valeur est %d”, i);
return 0;
}

void func_c( int x )
{
(x) ++;
printf(“\nLa valeur dans la fonction est %d “, *x);
} |

Dans le programme ci-dessus, il y a totalement trois déclarations ‘printf’, deux dans la fonction main() et une dans le sous-programme de fonction. En raison de l’effet de la première déclaration printf, la valeur de i est imprimée comme 100. Plus tard, un appel de fonction est effectué et à l’intérieur de la fonction, la valeur est modifiée et devient 101 en raison de l’incrément. La valeur modifiée est à nouveau renvoyée à main() et est imprimée comme 101.

Ainsi, la sortie est :

| | La valeur est 100
La valeur dans la fonction est 101
La valeur est 101 |

Plus sur les Appels de Fonction

Ayant eu le premier contact avec les pointeurs, revenons maintenant à ce que nous avions initialement prévu d’apprendre – les deux types d’appels de fonctions : appel par valeur et appel par référence. Les arguments peuvent généralement être passés à la fonction de l’une des deux manières :

| | a. En envoyant les valeurs des arguments
b. En envoyant les adresses des arguments |

2. Appel par Valeur

Dans la première méthode, la ‘valeur’ de chacun des arguments réels dans la fonction appelante est copiée dans les arguments formels correspondants de la fonction appelée. Avec cette méthode, les modifications apportées aux arguments formels dans la fonction appelée n’ont aucun effet sur les valeurs des arguments réels dans la fonction appelante. Le programme suivant illustre l’Appel par Valeur.

| | / 40_callbyvalue.c /
void swap( int x, int y )
int main( )
{
int a = 10, b = 20;
swap( a ,b );
printf(“\n a = %d, b = %d “, a, b);
return 0;
}
void swap( int x, int y )
{
int t;
t = x;
x = y;
y = t;
printf(“\nx = %d, y = %d”, x, y);
} |

La sortie du programme ci-dessus serait :

| | x = 20 y = 10
A = 10 b = 20 |

Notez que la valeur de a et b reste inchangée après l’échange de la valeur de x et y.

3. Appel par Référence

Cette fois, les adresses des arguments réels dans la fonction appelante sont copiées dans les arguments formels de la fonction appelée. Cela signifie qu’en utilisant ces adresses, nous aurions accès aux arguments réels et donc nous pourrions les manipuler. Le programme suivant illustre ce fait.

| | / 41_callbyref.c /

void swap( int x, int y )

int main()
{
int a = 10, b = 20;
swap( &a, &b);
printf(“\na = %d, b = %d”, a, b);
return 0;
}

void swap( int x, int y )
{
int t;
t = x; x = y; y = t;
} |

La sortie du programme ci-dessus serait :

| | A = 20, b = 10 |

Notez que ce programme parvient à échanger les valeurs de a et b en utilisant leurs adresses stockées dans x et y. En général, dans la programmation C, nous faisons un appel par valeur. C’est-à-dire qu’en général, vous ne pouvez pas modifier les arguments réels. Mais si désiré, cela peut toujours être réalisé par un appel par référence.

Utiliser l’appel par Référence intelligemment

nous pouvons créer une fonction, qui peut renvoyer plus d’une valeur à la fois, ce qui n’est pas possible ordinairement. Cela est montré dans le programme donné ci-dessous.

| | / 42_callbyref.c /
void areaperi(int r, float a, float p)
int main()
{
int radius;
float area, perimeter;
printf(“\nEntrez le rayon d’un cercle :”); scanf(“%d”, &radius);

areaperi(radius, &area, &perimeter);

printf(“\nAire = %f “, area);
printf(“\nPérimètre = %f”, perimeter);
return 0;
}
void areaperi(int r, float a, float p)
{
a = 3.14 r r; p = 2 3.14 r;
} |

Et voici la sortie :

| | Entrez le rayon d’un cercle 5
Aire = 78.500000
Périmètre = 31.400000 |

Ici, nous faisons un appel mixte, dans le sens où nous passons la valeur de radius mais, l’adresse de area et perimeter. Et puisque nous passons les adresses, tout changement que nous faisons dans les valeurs stockées à l’adresse contenue dans les variables a et p, rendrait le changement effectif dans main. C’est pourquoi lorsque le contrôle revient de la fonction areaperi( ) nous sommes capables de sortir les valeurs de area et perimeter.
Ainsi, nous avons pu renvoyer deux valeurs d’une fonction appelée, et donc, avons surmonté la limitation de l’instruction return, qui ne peut renvoyer qu’une seule valeur d’une fonction à la fois.

VII. Variables Locales Vs Globales

Selon la portée des identifiants, les variables sont déclarées comme de types.

| | / 42_globalid.c /
int i=4000; / Déclaration de variable globale/
int main()
{
int a=10, b=20; / Variable Locale /
int i=100; / Variable Locale /
printf(“%d %d”, a, b);
printf(“\nLocal i : %d”, i); / Accès à la variable Locale /
printf(“\nGlobal i : %d “, ::i); / Accès à la variable Globale /
return 0;
} |

Remarque : L’opérateur de résolution de portée ( :: ) peut être disponible uniquement en C++.

VIII. Spécificateurs de Classe de Stockage

Jusqu’à ce point de vue, nous sommes déjà familiers avec la déclaration de variables. Pour définir complètement une variable, il faut mentionner non seulement son ‘type’ mais aussi sa ‘Classe de Stockage‘.
Selon cette section, les variables n’ont pas seulement un ‘type de données’, elles ont également une ‘Classe de Stockage’.

Les Classes de Stockage sont de 4 Types

| | 1. Classe de Stockage Automatique

2. Classe de Stockage d’Enregistrement
3. Classe de Stockage Statique
4. Classe de Stockage Externe |

1. Classe de Stockage Automatique

Ex :

| | / 43_auto.c /
#include
int main()
{
auto int i, j;
printf(“%d %d”, i, u);
return 0;
} |

2. Classe de Stockage d’Enregistrement

Ex :

| | / 44_register.c /
#include
int main( )
{
register int i, j;
for(i=1;i<=10;i++)
printf(“\n%d”, i);
return 0;
} |

3. Classe de Stockage Statique

Ex :

| | / 45_static.c /
#include
void add();
int main()
{
add();
add();
add();
return 0;
}
void add()
{
static int i = 1;
printf(“%d\n”,i++);
} |

4. Classe de Stockage Externe

Ex :

| | / 46_extern.c /
#include
int i;
void add(); / Variable Externe /
int main( )
{
extern j=10; / Variable Externe /
for(i=1;i<=10;i++)
add();
return 0;
}
void add( )
{
j++;
printf(“%d %d\n”, i, j);
} |