Chercher et corriger méthodiquement

L'essentiel

Devant un programme qui ne fonctionne pas, la tentation est de modifier une ligne « pour voir », puis une autre. On finit souvent avec plus d'erreurs qu'au départ, sans savoir laquelle des modifications a aidé. Un informaticien procède comme un enquêteur : il établit les faits, formule une hypothèse, la vérifie, puis consigne ce qu'il a trouvé.

Trois familles d'erreurs

Lire un message d'exception

Une exception s'affiche en anglais, en quelques lignes. Trois informations suffisent : le type, le message et la ligne.

Unhandled exception. System.DivideByZeroException: Attempted to divide by zero.
   at Program.<Main>$(String[] args) in C:\Cours\Pas\Program.cs:line 14

Ici : une division entière par zéro, à la ligne 14 de Program.cs. Les exceptions les plus fréquentes à ce stade sont FormatException (un Parse sur un texte qui n'est pas un nombre) et DivideByZeroException (une division entière par zéro).

La méthode en six étapes

• Reproduire : trouver des entrées précises qui font échouer le programme à tout coup. « Ça marche pas » n'est pas un cas ; « 2 trajets, 120 km et 80 km, donnent 1 571,43  au lieu de 7,70  » en est un.
• Localiser : repérer la première valeur qui s'écarte de l'attendu. Pour un long programme, on divise pour régner : on vérifie une valeur au milieu du traitement ; si elle est juste, l'erreur est après, sinon elle est avant.
• Comprendre : formuler la cause en une phrase et la prouver par une valeur observée. Expliquer le code à voix haute, ligne par ligne, même à un objet inanimé (la méthode du canard en caoutchouc), révèle souvent l'erreur.
• Corriger : faire une seule modification, la plus petite possible.
• Vérifier : rejouer le cas qui échouait, puis tous les autres tests (non-régression).
• Documenter : consigner l'erreur dans le journal de correction.

Exemple complet : le covoiturage

Le programme doit calculer le coût de l'essence partagé entre les passagers d'un covoiturage, pour plusieurs trajets. La voiture consomme 7 L aux 100 km, et l'essence coûte 1,65  le litre. Cas de test : 2 trajets de 120 km et 80 km, 3 personnes. Résultat attendu : 14,0 L, 23,10 , soit 7,70  par personne.

const double Consommation = 7;     // litres aux 100 km
const double PrixLitre = 1.65;

Console.Write("Nombre de trajets : ");
int nbTrajets = int.Parse(Console.ReadLine() ?? "");
Console.Write("Nombre de personnes : ");
int nbPersonnes = int.Parse(Console.ReadLine() ?? "");

double totalKm = 0;
int trajet = 1;
while (trajet <= nbTrajets)
{
    Console.Write($"Distance du trajet {trajet} (km) : ");
    double km = double.Parse(Console.ReadLine() ?? "")
    totalKm += km;
}

double litres = totalKm * 100 / Consommation;
double cout = litres * PrixLitre;
double parPersonne = cout / nbPersonnes;
Console.WriteLine($"Essence : {litres:F1} L, {cout:C}");
Console.WriteLine($"Par personne : {parPersonne:C}");

Le programme contient trois erreurs, une de chaque famille. On les corrige dans l'ordre où elles se présentent :

1. Compilation : le premier message est CS1002 : ; attendu, ligne 14. Il manque le point-virgule à la fin de la lecture de km.
2. Exécution : une fois le programme compilé, il redemande sans fin « Distance du trajet 1 ». Au débogueur, trajet vaut toujours 1 : la progression trajet++; manque dans la boucle.
3. Logique : le programme se termine, mais affiche 2857,1 L et 1 571,43  par personne. Un point d'arrêt après le calcul de litres montre 2857,14 alors qu'on attend 14 : la formule est inversée. Les litres valent totalKm * Consommation / 100.

Exercices

int total = 0;
int nbValeurs = 0;
int valeur = -1;
while (valeur != 0)
{
    Console.Write("Nombre de pas (0 pour terminer) : ");
    valeur = int.Parse(Console.ReadLine() ?? "");
    if (valeur != 0)
    {
        total += valeur;
        nbValeurs++;
    }
}
int moyenne = total / nbValeurs;
Console.WriteLine($"Moyenne : {moyenne} pas par jour");

Console.Write("Montant emprunté : ");
double montant = double.Parse(Console.ReadLine() ?? "");
Console.Write("Versement mensuel : ");
double versement = double.Parse(Console.ReadLine() ?? "");

double solde = montant;
int mois = 1;
double dernier = 0;
while (solde >= 0)
{
    if (solde < versement)
    {
        dernier = solde;
    }
    else
    {
        dernier = versement;
    }
    solde -= dernier;
    mois++;
}
Console.WriteLine($"Nombre de versements : {mois}");
Console.WriteLine($"Dernier versement : {dernier:C}");

const double Rabais = 0.10;
const double SeuilRabais = 100;
const double TauxTps = 0.05;
const double TauxTvq = 0.09975;

Console.Write("Prix unitaire : ");
double prix = double.Parse(Console.ReadLine() ?? "");
Console.Write("Quantité : ");
int quantite = int.Parse(Console.ReadLine() ?? "");

double sousTotal = prix * quantite;
if (sousTotal >= SeuilRabais)
{
    sousTotal = sousTotal * Rabais;
}
double tps = sousTotal * TauxTps;
double tvq = sousTotal * TauxTvq;
double total = sousTotal + tps + tvq;
Console.WriteLine($"Total : {total:C}");

Console.Write("Nombre entier (2 ou plus) : ");
int n = int.Parse(Console.ReadLine() ?? "");

bool estPremier = true;
for (int diviseur = 2; diviseur * diviseur < n; diviseur++)
{
    if (n % diviseur == 0)
    {
        estPremier = false;
    }
}

if (estPremier)
{
    Console.WriteLine($"{n} est premier.");
}
else
{
    Console.WriteLine($"{n} n'est pas premier.");
}

Solutions

if (nbValeurs == 0)
{
    Console.WriteLine("Aucune donnée.");
}
else
{
    int moyenne = total / nbValeurs;
    Console.WriteLine($"Moyenne : {moyenne} pas par jour");
}

Je fais le point

• Je sais reconnaître une erreur de compilation, d'exécution ou de logique.
• Je sais lire le premier message du compilateur et un message d'exception.
• Je sais reproduire une erreur avec un cas précis avant de la corriger.
• Je sais localiser une erreur en divisant le traitement en deux.
• Je sais ne faire qu'une correction à la fois, puis rejouer tous les tests.
• Je sais tenir un journal de correction.