Programme 5 : Calcul de la distance de freinage (version 2)
Programme 5 .cpp
— 14.0 KB
Contenu du fichier
/**
\file calcul_distance_de_freinage-modules-bis.cpp
\brief Ce programme calcule la distance de freinage d'une voiture. Cette version utilise des modules.
\author Benoit Fraikin
\date 21 septembre 2007
\version 1.0 :21 septembre 2007, création, Benoît Fraikin
\b Entrees:
\li (\c cin) Vitesse \c vitesse_initiale initiale (\c float )
\li (\c cin) Acceleration \c acceleration_initiale initiale (\c float )
\li (\c cin) Vitesse \c vitesse_a_atteindre a atteindre (\c float )
\b Sorties:
\li (\c cout) Distance \c distance_ralentissement_en_metre de ralentissement en metre (\c float )
\li (\c cout) La composante \c composante_en_milles_de_la_distance_ralentissement en mille entier de la distance de ralentissement en systeme imperial (\c int )
\li (\c cout) La composante \c composante_en_verges_de_la_distance_ralentissement en verge entière de la distance de ralentissement en systeme imperial (\c int )
\li (\c cout) La composante \c composante_en_pieds_de_la_distance_ralentissement en pied entier de la distance de ralentissement en systeme imperial (\c int )
\li (\c cout) La composante \c composante_en_pouces_de_la_distance_ralentissement en pouce entier de la distance de ralentissement en systeme imperial (\c int )
Ce programme calcule a partir de la vitesse initiale d'un vehicule
et de l'acceleration initiale a laquelle il est soumis, la distance
necessaire pour atteindre une vitesse choisie par l'utilisateur.
La distance de reaction correspond au temps mis avant d'applique l'acceleration.
La distance de freinage est la distance necessaire a partir du moment ou
l'acceleration rentre en jeu. La distance de ralentissement est la somme des
deux. \n
On estime ici que le temps de reaction est constant et correspond a une seconde. \n
Quatre distances sont affichees : la distance de reaction, celle de freinage
et celles de ralentissement en metre et en systeme imperial
(mille, verge, pied, pouce).
La distance de ralentissement en systeme imperial est representee par
quatre valeurs, chacune entiere. On perd donc avec la mesure en systeme
imperial la precision en dessous du pouces. On peut cependant estimer que
ceci est legitime puisque de toute facon, les erreurs de mesures et les
approximations ne permettent pas d'etre plus precis.
*/
#include <cmath>
#include <iostream>
using namespace std;
// Definition des constantes globales
/// NBRE_PIEDS_DANS_VERGE est une constante universelle
const int NBRE_PIEDS_DANS_VERGE = 3 ;
/// NBRE_POUCES_DANS_PIED est une constante universelle
const int NBRE_POUCES_DANS_PIED = 12 ;
/// NBRE_PIEDS_DANS_MILLE est une constante universelle
const int NBRE_PIEDS_DANS_MILLE = 5280 ;
/// NBRE_METRES_DANS_VERGE est une constante universelle
const float NBRE_METRES_DANS_VERGE = 0.914 ;
// Note : il serait possible de declarer toutes les autres constantes ici:
//+ elles sont toutes universelles. Cependant, pour des raisons
//+ d'illustrations, nous allons ne déclarer en constantes globales
//+ uniquement les constantes qui sont définies de manière explicite.
//+ Les autres seront définies dans les modules utilisés.
/**
\brief Ce programme calcule la distance de freinage d'une voiture.
*/
int main ()
{
// Declaration des fonctions
float calculer_une_distance_de_ralentissement_en_metre ( float une_vitesse_initiale,
float une_vitesse_a_atteindre,
float une_acceleration_initiale );
int obtenir_composante_en_mille_entier (int une_distance_exprimee_en_pouce);
int obtenir_composante_en_verge_entiere (int une_distance_exprimee_en_pouce);
int obtenir_composante_en_pied_entier (int une_distance_exprimee_en_pouce);
int obtenir_composante_en_pouce_entier (int une_distance_exprimee_en_pouce);
int convertir_des_metres_en_pouces (float distance_en_metres);
// Declaration des constantes
// Declaration des variables
// Entrees
float vitesse_initiale, acceleration_initiale, vitesse_a_atteindre ;
// Sorties
float distance_ralentissement_en_metre ;
int distance_totale_en_pouces;
int composante_en_mille_de_la_distance_ralentissement;
int composante_en_verge_de_la_distance_ralentissement;
int composante_en_pied_de_la_distance_ralentissement;
int composante_en_pouce_de_la_distance_ralentissement;
// 1 Lire les entrées
// 1.1 lire la vitesse initiale
cout << "Quel est la vitesse initiale ?" << endl;
cin >> vitesse_initiale ;
// 1.2 lire l'accéleration de freinage
cout << "Quel est l'acceleration de freinage initiale ?" << endl;
cin >> acceleration_initiale ;
// 1.3 lire la vitesse à atteindre
cout << "Quel est la vitesse a atteindre ?" << endl;
cin >> vitesse_a_atteindre ;
// 2 Calculer la distance de ralentissement en metre
distance_ralentissement_en_metre = calculer_une_distance_de_ralentissement_en_metre (vitesse_initiale, vitesse_a_atteindre, acceleration_initiale);
// 3 Calculer la distance de ralentissement en mesure impériale
// 3.1 calculer la distance totale en pouces
distance_totale_en_pouces = convertir_des_metres_en_pouces(distance_ralentissement_en_metre);
// 3.2 calculer la distance en mille entier
composante_en_mille_de_la_distance_ralentissement = obtenir_composante_en_mille_entier(distance_totale_en_pouces) ;
// 3.3 calculer la distance en verge entière
composante_en_verge_de_la_distance_ralentissement = obtenir_composante_en_verge_entiere(distance_totale_en_pouces) ;
// 3.4 calculer la distance en pieds entiers
composante_en_pied_de_la_distance_ralentissement = obtenir_composante_en_pied_entier(distance_totale_en_pouces) ;
// 3.5 calculer la distance en pouce entier
composante_en_pouce_de_la_distance_ralentissement = obtenir_composante_en_pouce_entier(distance_totale_en_pouces) ;
// 4 Afficher les résultats
// 4.1 afficher la distance totale de ralentissement en metre
cout << "D = " << distance_ralentissement_en_metre << endl;
// 4.2 afficher la distance totale de ralentissement dans le système impérial
cout << "Distance en mesure imperiale : " << endl;
// 4.2.1 afficher la distance totale de ralentissement en mille entier
cout << composante_en_mille_de_la_distance_ralentissement << " milles," << endl ;
// 4.2.2 afficher la distance totale de ralentissement en verge entière
cout << composante_en_verge_de_la_distance_ralentissement << " verges," << endl ;
// 4.2.3 afficher la distance totale de ralentissement en pied entier
cout << composante_en_pied_de_la_distance_ralentissement << " pieds," << endl ;
// 4.2.4 afficher la distance totale de ralentissement en pouce entier
cout << composante_en_pouce_de_la_distance_ralentissement << " pouces." << endl ;
// Fin du programme
return 0;
}
/**
\brief permet d'obtenir la composante en mille d'une distance exprimee en pouce
*/
int obtenir_composante_en_mille_entier (int distance_exprimee_en_pouce)
{
// declaration des constantes
const int NBRE_POUCES_DANS_MILLE = NBRE_POUCES_DANS_PIED * NBRE_PIEDS_DANS_MILLE ;
// declaration des variables
// --> valeur de retour
int composante_en_mille_entier;
composante_en_mille_entier = distance_exprimee_en_pouce / NBRE_POUCES_DANS_MILLE ;
return composante_en_mille_entier;
}
/**
\brief permet d'obtenir la composante en verge d'une distance exprimee en pouce
*/
int obtenir_composante_en_verge_entiere (int distance_exprimee_en_pouce)
{
// declaration des constantes
const int NBRE_POUCES_DANS_MILLE = NBRE_POUCES_DANS_PIED * NBRE_PIEDS_DANS_MILLE ;
const int NBRE_POUCES_DANS_VERGE = NBRE_POUCES_DANS_PIED * NBRE_PIEDS_DANS_VERGE ;
// declaration des variables
// --> valeur de retour
int composante_en_verge_entiere;
// 1. calculer le reste de pouces restant apres soustraction des milles entiers
// 2. calculer la composante en verges entieres
// REMARQUE :
//+ L'exemple suivant montre que deux points d'une conception peuvent etre implementes
//+ en une seule instruction complexe : l'ordre de la conception est bien respectee
//+ a l'aide du parenthesage, c'est-a-dire calcul du reste puis de la composante.
composante_en_verge_entiere = ( (distance_exprimee_en_pouce % NBRE_POUCES_DANS_MILLE)
/ NBRE_POUCES_DANS_VERGE ) ;
return composante_en_verge_entiere;
}
/**
\brief permet d'obtenir la composante en pied d'une distance exprimee en pouce
*/
int obtenir_composante_en_pied_entier (int distance_exprimee_en_pouce)
{
// declaration des constantes
const int NBRE_POUCES_DANS_MILLE = NBRE_POUCES_DANS_PIED * NBRE_PIEDS_DANS_MILLE ;
const int NBRE_POUCES_DANS_VERGE = NBRE_POUCES_DANS_PIED * NBRE_PIEDS_DANS_VERGE ;
// la constante NBRE_POUCES_DANS_PIED est definie globalement
// declaration des variables
// --> valeur de retour
int composante_en_pied_entier;
// --> variable intermediaire
int reste_en_pouces ; // sert pour representer reste_milles et reste_verges de la conception
// 1. calculer le reste de pouces restant apres soustraction des milles entiers
reste_en_pouces = distance_exprimee_en_pouce % NBRE_POUCES_DANS_MILLE ;
// 2. calculer le reste de pouces restant apres soustraction des verges entieres
reste_en_pouces = reste_en_pouces % NBRE_POUCES_DANS_VERGE;
// 3. calculer la composante en pieds entiers
composante_en_pied_entier = reste_en_pouces / NBRE_POUCES_DANS_PIED ;
return composante_en_pied_entier;
}
/**
\brief permet d'obtenir la composante en pouce d'une distance exprimee en pouce
*/
int obtenir_composante_en_pouce_entier (int distance_exprimee_en_pouce)
{
// declaration des constantes
const int NBRE_POUCES_DANS_MILLE = NBRE_POUCES_DANS_PIED * NBRE_PIEDS_DANS_MILLE ;
const int NBRE_POUCES_DANS_VERGE = NBRE_POUCES_DANS_PIED * NBRE_PIEDS_DANS_VERGE ;
// la constante NBRE_POUCES_DANS_PIED est definie globalement
// declaration des variables
// --> variable intermediaire et valeur de retour
int reste_en_pouces ; // sert pour representer reste_milles, reste_verges et reste_pieds de la conception
// 1. calculer le reste de pouces restant apres soustraction des milles entiers
reste_en_pouces = distance_exprimee_en_pouce % NBRE_POUCES_DANS_MILLE ;
// 2. calculer le reste de pouces restant apres soustraction des verges entieres
reste_en_pouces = reste_en_pouces % NBRE_POUCES_DANS_VERGE;
// 3. calculer le reste de pouces restant apres soustraction des pieds entiers
reste_en_pouces = reste_en_pouces % NBRE_POUCES_DANS_PIED ;
// 4. calculer la composante en pouces entiers
// ce qui correspond a la derniere valeur de reste_en_pouces. On se passe d'une ligne
//+ composante_en_pouce_entier = reste_en_pouces
return reste_en_pouces;
}
/**
\brief
*/
float calculer_une_distance_de_ralentissement_en_metre ( float vitesse_initiale,
float vitesse_a_atteindre,
float acceleration_initiale )
{
// declaration des fonctions
float calculer_une_distance_de_reaction (float une_vitesse_initiale, float un_temps_de_reaction);
float calculer_une_distance_de_freinage ( float une_vitesse_initiale,
float une_vitesse_a_atteindre,
float une_acceleration_initiale );
// declaration des constantes
const int TEMPS_REACTION = 1 ; // temps de reaction en seconde
// declaration des variables
// --> valeur de retour
int distance_de_ralentissement_en_metre;
// --> variables intermediaires
float distance_reaction ;
float distance_freinage ;
// 1 calculer la distance de réaction
distance_reaction = calculer_une_distance_de_reaction(vitesse_initiale, TEMPS_REACTION) ;
// 2 calculer la distance de freinage
distance_freinage = calculer_une_distance_de_freinage ( vitesse_initiale,
vitesse_a_atteindre,
acceleration_initiale );
// 3 calculer la distance de ralentissement
distance_de_ralentissement_en_metre = distance_reaction + distance_freinage ;
return distance_de_ralentissement_en_metre;
}
/**
\brief
*/
float calculer_une_distance_de_reaction (float vitesse_initiale, float temps_de_reaction)
{
// declaration des variables
float distance_de_reaction;
distance_de_reaction = vitesse_initiale * temps_de_reaction ;
return distance_de_reaction;
}
/**
\brief
*/
float calculer_une_distance_de_freinage ( float vitesse_initiale,
float vitesse_a_atteindre,
float acceleration_initiale )
{
// declaration des variables
// --> valeur de retour
float distance_de_freinage;
// --> variabel intermediaire
float difference_de_vitesse ;
// 1. Calculer la difference de vitesse
difference_de_vitesse = vitesse_initiale - vitesse_a_atteindre ;
// 2. Calculer la distance de freinage
distance_de_freinage = ( pow(difference_de_vitesse, 2) -
2 * vitesse_initiale * difference_de_vitesse )
/ (2 * acceleration_initiale) ;
return distance_de_freinage;
}
/**
\brief effectue une conversion de metre en pouce
\param distance_en_metres une distance exprimee en metre
*/
int convertir_des_metres_en_pouces ( float distance_en_metres )
{
// declaration des constantes
const int NBRE_POUCES_DANS_VERGE = NBRE_POUCES_DANS_PIED * NBRE_PIEDS_DANS_VERGE ;
const float NBRE_POUCES_DANS_METRE = NBRE_POUCES_DANS_VERGE / NBRE_METRES_DANS_VERGE ;
return int(floor(distance_en_metres * NBRE_POUCES_DANS_METRE));
}