Pour clore cette Partie 2 consacrée aux fonctions et à la programmation modulaire, nous vous proposons trois études de cas représentatives des besoins en ingénierie logicielle : la conception d'un module utilitaire réutilisable, la résolution de problèmes par récursivité et l'orchestration modulaire d'un flux de facturation.
Problème 1 : Boîte à outils mathématique (math_utils)#
Énoncé#
Développez un module autonome composé d'un fichier d'en-tête math_utils.h et de son implémentation math_utils.c. Ce module doit fournir :
1. bool EstPair(int n) : teste si un entier est divisible par 2.
2. bool EstPremier(int n) : teste si un entier est un nombre premier.
3. double Puissance(double base, int exposant) : calcule la puissance d'un nombre (gérant les exposants positifs et nuls).
4. long long SommeConsecutive(int n) : calcule la somme des entiers de 1 à \(n\) (\(\sum_{i=1}^n i = \frac{n(n+1)}{2}\)).
Rédigez un fichier main.c qui importe ce module et valide son fonctionnement.
Solution complète#
1. Fichier math_utils.h#
#ifndef MATH_UTILS_H
#define MATH_UTILS_H
#include <stdbool.h>
/* Prototypes de la bibliothèque utilitaire */
bool EstPair(int n);
bool EstPremier(int n);
double Puissance(double base, int exposant);
long long SommeConsecutive(int n);
#endif /* MATH_UTILS_H */
2. Fichier math_utils.c#
#include "math_utils.h"
bool EstPair(int n)
{
return (n % 2 == 0);
}
bool EstPremier(int n)
{
if (n < 2) return false;
for (int d = 2; d * d <= n; d++)
{
if (n % d == 0) return false;
}
return true;
}
double Puissance(double base, int exposant)
{
if (exposant == 0) return 1.0;
double resultat = 1.0;
for (int i = 0; i < exposant; i++)
{
resultat *= base;
}
return resultat;
}
long long SommeConsecutive(int n)
{
if (n <= 0) return 0;
return ((long long)n * (n + 1)) / 2;
}
3. Programme de test main.c#
#include <stdio.h>
#include "math_utils.h"
int main(void)
{
int testNombre = 17;
printf("=========================================\n");
printf(" TEST DE LA BIBLIOTHEQUE MATH_UTILS \n");
printf("=========================================\n");
printf("Nombre teste : %d\n", testNombre);
printf("Est pair ? : %s\n", EstPair(testNombre) ? "OUI" : "NON");
printf("Est premier ? : %s\n", EstPremier(testNombre) ? "OUI" : "NON");
printf("2 puissance 8 : %.0f\n", Puissance(2.0, 8));
printf("Somme de 1 a 100 : %lld\n", SommeConsecutive(100));
printf("=========================================\n");
return 0;
}
Problème 2 : Décomposition binaire et Tours de Hanoï (Récursivité)#
Énoncé#
- Écrivez une fonction récursive
void AfficherBinaire(unsigned int n)qui affiche la représentation binaire (suite de 0 et de 1) d'un entier sans utiliser de tableau temporaire. - Implémentez l'algorithme mythique des Tours de Hanoï : une fonction récursive
void ResoudreHanoi(int n, char depart, char auxiliaire, char arrivee)qui affiche la suite minimale des déplacements pour transporter \(n\) disques du piquet A au piquet C sans jamais placer un disque plus grand sur un plus petit.
Solution complète en C#
#include <stdio.h>
/* 1. Affichage récursif de la base 2 */
void AfficherBinaire(unsigned int n)
{
// Cas récursif : afficher les bits supérieurs d'abord
if (n > 1)
{
AfficherBinaire(n / 2);
}
// Cas de base / affichage du bit de poids faible au dépilement
printf("%u", n % 2);
}
/* 2. Résolution des Tours de Hanoï */
void ResoudreHanoi(int n, char depart, char auxiliaire, char arrivee)
{
// Cas de base : déplacer un seul disque
if (n == 1)
{
printf("Deplacer le disque 1 de %c vers %c\n", depart, arrivee);
return;
}
// Étape A : Déplacer n - 1 disques du départ vers l'auxiliaire
ResoudreHanoi(n - 1, depart, arrivee, auxiliaire);
// Étape B : Déplacer le plus grand disque restant
printf("Deplacer le disque %d de %c vers %c\n", n, depart, arrivee);
// Étape C : Déplacer les n - 1 disques de l'auxiliaire vers l'arrivée
ResoudreHanoi(n - 1, auxiliaire, depart, arrivee);
}
int main(void)
{
unsigned int valeur = 43;
printf("--- CONVERSION BINAIRE RECURSIVE ---\n");
printf("Decimal : %u -> Binaire : ", valeur);
AfficherBinaire(valeur);
printf("\n\n");
printf("--- RESOLUTION TOURS DE HANOI (3 DISQUES) ---\n");
ResoudreHanoi(3, 'A', 'B', 'C');
return 0;
}
Problème 3 : Pipeline modulaire de Facturation#
Énoncé#
Dans le cadre d'un système commercial, concevez une application modulaire calculant le montant d'une facture client avec remises commerciales et TVA : - Une fonction pour déterminer le taux de remise selon le montant HT (ex: 0% sous 500 €, 5% entre 500 € et 1 000 €, 10% au-delà). - Une fonction pour calculer la TVA à 20%. - Une procédure pour formater et éditer un reçu clair.
Solution complète en C#
#include <stdio.h>
#define TAUX_TVA 0.20f
/* Prototypes */
float CalculerTauxRemise(float montantBrut);
float CalculerMontantNetHT(float montantBrut, float tauxRemise);
float CalculerMontantTVA(float montantNetHT);
void ImprimerFacture(const char *nomClient, float brut, float remise, float netHT, float tva, float ttc);
int main(void)
{
const char client[] = "Cabinet Alpha Data";
float montantBrut = 1250.00f;
float tauxRemise = CalculerTauxRemise(montantBrut);
float montantRemise = montantBrut * tauxRemise;
float netHT = CalculerMontantNetHT(montantBrut, tauxRemise);
float montantTVA = CalculerMontantTVA(netHT);
float totalTTC = netHT + montantTVA;
ImprimerFacture(client, montantBrut, montantRemise, netHT, montantTVA, totalTTC);
return 0;
}
float CalculerTauxRemise(float montantBrut)
{
if (montantBrut >= 1000.0f) return 0.10f; // 10% de remise
if (montantBrut >= 500.0f) return 0.05f; // 5% de remise
return 0.0f; // Pas de remise
}
float CalculerMontantNetHT(float montantBrut, float tauxRemise)
{
return montantBrut * (1.0f - tauxRemise);
}
float CalculerMontantTVA(float montantNetHT)
{
return montantNetHT * TAUX_TVA;
}
void ImprimerFacture(const char *nomClient, float brut, float remise, float netHT, float tva, float ttc)
{
printf("=========================================\n");
printf(" FACTURE COMMERCIALE \n");
printf("=========================================\n");
printf("Client : %s\n", nomClient);
printf("-----------------------------------------\n");
printf("Montant Brut : %10.2f €\n", brut);
printf("Remise Accordee : -%9.2f €\n", remise);
printf("Montant Net HT : %10.2f €\n", netHT);
printf("TVA (20 %%) : +%9.2f €\n", tva);
printf("-----------------------------------------\n");
printf("TOTAL A PAYER : %10.2f € TTC\n", ttc);
printf("=========================================\n");
}
Vous maîtrisez désormais les fonctions, la récursivité et l'architecture modulaire. Dans la Partie 3, nous allons aborder les structures de données contiguës : les tableaux à une dimension et les matrices.
Commentaires