Cours interactif sur les notions fondamentales des sous-programmes en algorithmique : fonctions, procédures, paramètres, variables et passage de données.

Curriculum tunisiens

Niveaux :

• 2ème TI
• 3ème SI
• 3ème Scientifiques
• 4ème Scientifiques

Simulation : https://aminefr85.github.io/sous-programmes-algo/

1. Énoncé du problème fil conducteur
2. Programme principal
3. Définition d'une procédure
4. Définition d'une fonction
5. Entête de définition
6. Paramètres formels
7. Paramètres effectifs
8. Variable locale
9. Variables globales
10. Passage par valeur
11. Passage par adresse
12. Saisie contrôlée
13. Remplissage contrôlé d'un tableau
14. La fonction vérif
15. Résumé des concepts clés

Une équipe participe à un jeu de réflexion. Pour que cette équipe gagne, il faut que le produit P des scores obtenus par chaque joueur soit divisible par le nombre des joueurs.

Écrire un algorithme d'un programme qui permet de :

• Remplir un tableau TN par les N noms des joueurs (chaînes alphabétiques)
• Remplir un tableau TS par N scores aléatoires entre 0 et 50
• Calculer le produit P des scores > 0
• Afficher "vous avez gagné" si P est divisible par N, sinon "vous avez perdu"

Le programme principal (ou programme appelant) est le programme maestro : c'est celui qui fait appel aux autres modules et qui organise l'envoi et la réception des données entre les différentes parties du programme.

Cet acheminement des informations entre le PP et les modules s'appelle le passage de données.

On distingue deux modes de passage :

• Passage par valeur
• Passage par variable (par adresse)

La définition d'une procédure se fait par le mot clé Procédure.

Puisque ce module ne contient pas de retourner à la fin, il est considéré comme une procédure.

Procédure nom_procedure (parametre1 : type1, parametre2 : type2)
Début
    # instructions
    # pas de retourner
Fin

La définition d'une fonction se fait par le mot clé Fonction.

Puisque ce module retourne un seul résultat de type simple (ex. booléen), il est considéré comme une fonction.

Une fonction se termine toujours par le mot clé retourner.

Fonction verif (ch : chaîne) : booléen
Début
    # instructions
    retourner t
Fin

C'est l'entête de définition d'un module. L'entête contient :

• Le nom du module
• Les différents paramètres formels (Entrées)

Procédure nom_module (param1 : type1, param2 : type2)

Fonction nom_module (param1 : type1) : type_retour

Les noms des paramètres formels ne sont pas importants en eux-mêmes, mais plutôt :

• Le nombre de paramètres
• L'ordre des types de ces paramètres

qui doivent être en accord avec les paramètres effectifs.

Exemple concret :

→ On a un accord en nombre, type et ordre des paramètres effectifs et formels.

Les valeurs de ces paramètres vont remplacer les paramètres formels lors de l'appel.

Exemple :

Le professeur de Mathématiques vous propose la fonction suivante :

Soit f(x) = x², puis il vous demande de calculer f(2)

• x → paramètre formel : le nom ne change rien au fonctionnement de f
• 2 → paramètre effectif : le changement de cette valeur implique un changement de résultat de f

Ce sont des objets déclarés dans un sous-programme et ne sont utilisables qu'à l'intérieur de celui-ci.

Procédure exemple()
Variables
    i : entier      ← variable locale, invisible depuis l'extérieur
Début
    i <-- 0
Fin

Ce sont des objets déclarés dans la partie déclaration des variables du programme principal et sont utilisables par le programme principal et par les sous-programmes.

Programme principal
Variables
    N : entier          ← variable globale
    TN : tableau de chaînes
    TS : tableau d'entiers
    P  : entier

Dans ce mode de passage, le programme appelant envoie une copie de la valeur du paramètre effectif au module appelé. Toute modification apportée à cette valeur ne concerne plus le programme appelant.

Analogie : L'enseignant distribue les feuilles du TP. Les feuilles du TP ne sont pas à remettre — elles sont donc passées par valeur.

Procédure afficher(t : tab, n : entier)   ← t et n passés par valeur

Aussi appelé passage par variable (ou par référence).

Dans ce mode, le programme appelant envoie non seulement la valeur du paramètre effectif, mais aussi l'adresse du paramètre lui-même. Toute modification dans le programme appelé affecte le programme appelant.

Analogie : L'enseignant distribue les feuilles de l'examen. Les feuilles sont à remettre à l'enseignant — elles sont donc passées par adresse.

Procédure remplir(Var t : tab, n : entier)  ← t passé par adresse (Var)

En algorithme, l'opération de saisie simple (sans contrôle) utilise l'instruction lire(var).

Parfois, on doit appliquer un contrôle de saisie, c'est-à-dire n'accepter que des valeurs respectant une ou plusieurs conditions. Dans ce cas, on utilise la structure itérative répéter .. jusqu'à.

répéter
    lire(var)
jusqu'à  condition_valide

Le remplissage d'un tableau se fait toujours case par case via la boucle Pour. Quand les valeurs doivent respecter des conditions, on combine la boucle Pour avec une saisie contrôlée :

pour i de 0 à n-1 faire         # parcours du tableau t
    répéter                      # contrôle de saisie
        lire(t[i])               # saisie
    jusqu'à  conditions
fin pour

Exemple — remplir TN avec des chaînes alphabétiques :

pour i de 0 à N-1 faire
    répéter
        lire(TN[i])
    jusqu'à  verif(TN[i]) = vrai
fin pour

Cette fonction permet de vérifier si une chaîne ch est alphabétique ou non.

La fonction vérif (parfois appelée valid) est organisée en 3 parties :

Fonction verif (ch : chaîne) : booléen
Variables
    i : entier
    t : booléen
Début
    # 1. Initialisation
    i <-- 0
    t <-- vrai

    # 2. Parcours de la chaîne et recherche de l'intrus
    répéter
        si "A" ≤ ch[i] ≤ "Z" alors
            i <-- i + 1
        sinon
            t <-- faux
        fin_si
    jusqu'à  (i = long(ch))  ou  (t = faux)

    # 3. Retour du résultat
    retourner t
Fin

Cours interactif créé avec iSpring — Algorithmique, sous-programmes