Name: Développement informatique Apprenez à concevoir avant de programmer
Rating: 5 (3 reviews)

Présentation

Dès qu’un programme est long, il devient difficile à lire. Il est intéressant de le découper en plusieurs parties. C’est l’objectif des fonctions.

Un programme peut être scindé en plusieurs morceaux. Chaque morceau est une fonction. Une fonction principale (main) les appelle selon les besoins de l’application.

Dans les exemples vus jusqu’ici, nous avons appelé de nombreuses fonctions de la bibliothèque standard (printf(), gets(), strcpy()…).

Une fonction peut être appelée plusieurs fois. C’est un des grands intérêts des fonctions : ne pas réécrire plusieurs fois le même code.

Nous avons appelé plusieurs fois les fonctions de la bibliothèque standard.

Une fonction est mise au point une fois pour toutes. Cela améliore la fiabilité des applications qui l’utilisent.
La « modularisation » d’un programme autorise la répartition des tâches entre plusieurs développeurs.

Nous avons utilisé le travail des développeurs de la bibliothèque standard.

Premières fonctions

1. Syntaxe

Une fonction a :

un nom, suivi de parenthèses ;
éventuellement des paramètres (écrits entre les parenthèses) ;
éventuellement un type de valeur de retour (à défaut, la fonction doit être déclarée comme void).

2. Calcul du carré et du cube d’un entier

a. Déclarations (prototypes) des fonctions

En début de programme figurent les instructions :


int carre(int nombre); 
int cube(int);

Il s’agit des déclarations des fonctions carre() et cube(). On dit aussi les prototypes des fonctions.

Ces instructions n’ont aucun effet sur l’exécution du programme. Elles sont destinées au compilateur qui s’en sert pour vérifier la correction des appels de ces fonctions. À la lecture des prototypes, il sait que les fonctions reçoivent un paramètre de type int, et qu’elles retournent un entier de type int.

Exemple

Le nom de la première fonction est carre.
nombre est un paramètre de type int.
Elle retourne une valeur de type int.

Il n’est pas nécessaire d’indiquer le nom du paramètre. Son type suffit.

Les instructions suivantes insèrent le code des fichiers stdio.h, stdlib.h et time.h.


#include <stdio.h> 
#include <stdlib.h> 
#include <time.h>

Ces fichiers contiennent les prototypes des fonctions...

Le passage de paramètres à une fonction

Cette section illustre l’importance des pointeurs pour transmettre des paramètres à une fonction. L’exemple choisi est le développement d’une fonction d’échange des valeurs de deux variables de type int. Dans la première version, la plus naturelle, la fonction reçoit la valeur des entiers à inverser. Mais elle ne fonctionne pas. Dans la deuxième version, la fonction reçoit l’adresse des entiers à inverser. Le résultat est cette fois correct.

1. Échange de deux valeurs entières (première version)

a. Programme

La fonction echange() reçoit en paramètres deux entiers. Son but est d’échanger les valeurs contenues dans ces variables.


#include <stdio.h> 
void echange(int, int);

La fonction echange() permute les valeurs contenues dans n1 et n2 :


void echange(int n1, int n2) 
{ 
    int permut; 
 
    printf("Avant echange : n1 = %d, n2 = %d\n", n1, n2); 
    permut = n1; 
    n1 = n2; 
    n2 = permut; 
    printf("Apres echange : n1 = %d, n2 = %d\n", n1, n2); 
}

Le programme principal appelle la méthode echange() en lui communiquant les variables i et j :


int main() 
{ 
    int i; 
    int j; ...

Tableaux et fonctions : moyenne des valeurs d’un tableau

La fonction développée dans le programme suivant calcule la moyenne des valeurs contenues dans un tableau passé en paramètre.


#include <stdio.h> 
#include <stdlib.h> 
#include <time.h> 
#define DIMENSION 15

La directive de précompilation #define remplace partout dans le code la chaîne DIMENSION par la chaîne 15. C’est une sorte de replace all qui s’exécute avant la compilation. Cela permet de ne changer que cette ligne pour que le programme fonctionne avec un tableau d’une autre dimension.


float moyenne(int tab[], int nombrePostes);

Le premier paramètre du prototype de la fonction moyenne() est déclaré int tab[]. Cette syntaxe signifie que ce paramètre est une adresse de tableau d’entiers. On pourrait également le déclarer : int* tab

Il est possible de laisser le nom des variables dans le prototype. Ils peuvent servir, comme ici, à clarifier la signification des paramètres. Le prototype aurait pu s’écrire : float moyenne(int[], int);


float moyenne(int tab[], int nombrePostes) 
{ 
    int i; 
    float cumul; 
 
    cumul = 0; 
    for (i = 0; i < nombrePostes; i++) 
    { 
        cumul += tab[i]; ...

Tableaux et chaînes : codes ASCII des caractères d’une chaîne

foncchaine() reçoit l’adresse d’une chaîne :


void foncChaine(char* chaine); 
 
int main() 
{ 
    char chaine[81]; 
 
    printf("Entrer une chaine de caracteres : "); 
    gets(chaine); 
 
    foncChaine(chaine); 
    return 0; 
}

Voici le résultat de l’exécution de ce programme :

Paramètres facultatifs de la fonction main : utilisation de argc, argv


#include <stdio.h>

Deux paramètres peuvent être ajoutés à la fonction main() pour communiquer avec le système d’exploitation :

argv est l’adresse d’un tableau qui contient des chaînes (char*).
argc est un entier qui indique le nombre de chaînes contenues dans le tableau.


int main(int argc, char* argv[]) 
{ 
    char* message; 
 
    if(argc > 1) 
    { 
        message = argv[1]; 
    } 
    else 
    { 
        message = "CHARBONNIERE"; 
    } 
 
    printf("MESANGE %s.\n", message); 
 
    return 0; 
}

Voici les résultats d’exécution :

Le programme est exécuté à partir de la fenêtre de commandes DOS.

Il est possible d’ajouter des paramètres après le nom de l’application lors de l’appel. Ces paramètres sont reçus dans le tableau de chaînes argv[]. Le nombre de ces paramètres est indiqué par la variable argc.

Le premier poste du tableau argv[] contient le nom de l’application. argc vaut donc au moins 1.

Ici, l’appel : foncArgcArgv BLEUE a pour effet de mettre "BLEUE" dans argv[1], argc vaut 2.

Travail pratique : fonctions et fractions

1. Sujet

Créer trois fonctions :

Une fonction de saisie de deux nombres de type int.

Cette fonction affiche :

Introduisez le numérateur :

Introduisez le dénominateur :

À chacune des demandes, l’utilisateur tape un entier.

Une fonction de calcul de la somme de deux fractions.

Cette fonction prend comme paramètres :

Le numérateur et le dénominateur de la première fraction.

Le numérateur et le dénominateur de la deuxième fraction.

Elle permet de calculer le numérateur et le dénominateur de la fraction somme.

Une fonction qui affiche une fraction.

Cette fonction prend comme paramètres :

Le numérateur et le dénominateur de la fraction.

Écrire un programme principal qui :

permet de saisir deux fractions (avec contrôle du dénominateur) ;
additionne les deux fractions ;
affiche le résultat.

2. Fonctions et fractions : proposition de correction

La fonction saisie() a pour but de remplir deux entiers, donc de les modifier. Elle doit en recevoir les adresses.
Les quatre premiers paramètres de la fonction somme() sont les numérateurs et dénominateurs des fractions à additionner. On ne souhaite pas les modifier. Il n’est pas nécessaire de transmettre leur adresse. Les deux derniers paramètres, en revanche, sont...

Travail pratique : fonctions et chaînes

1. Objectif

Il s’agit ici de développer quelques fonctions de gestion de chaînes de caractères en vue de constituer une bibliothèque de fonctions utilitaires.

2. Sujet

Reprendre les exercices du TP du chapitre Les chaînes de caractères. Écrire des fonctions pour chacune des fonctionnalités étudiées :

1.	comptage d’une lettre passée en paramètre ;
2.	suppression d’une lettre passée en paramètre ;
3.	inversion de chaîne ;
4.	position du premier et du dernier caractère non blanc d’une chaîne ;
5.	placement d’une sous-chaîne dans une chaîne.

3. Fonctions et chaînes : proposition de correction

a. Exercice 1

La fonction compteLettres() :

reçoit l’adresse de la chaîne à étudier, et la valeur (le code ASCII) de la lettre à compter ;
retourne le résultat du comptage.


int compteLettres(char* ligne, char lettre); 
 
int main() 
{ 
    char ligne[81]; 
    char lettre; 
 
    printf("Entrer une ligne (maximum 80 caracteres) :\n"); 
    gets(ligne); 
    lettre = 'e'; 
 
    printf("\nNombre de '%c' : %d.\n", lettre, compteLettres(ligne, lettre));
    return 0; 
} 
  
int compteLettres(char* ligne, char lettre) 
{ 
    int compteur; 
    char* debut; 
 
    compteur = 0; 
    debut = strchr(ligne, lettre); 
 
    while (debut!= 0) 
    { 
        compteur++; 
        debut++; 
        debut = strchr(debut, lettre); 
    } 
 
    return compteur; 
}