CONVERTISSEUR "BEAUFORT, KM/H, M/S", ORIENTÉ OBJET, CONSOLE DOS

/*
Yo ! Tout le monde !
Alors, c'est un programme réalisé parce que je fais un stage de catamaran
(du hobit-cat 15 pour être precis) et que j'en ai marre de voir ecris les forces
des vents en toutes les unitées possibles et inimaginables.
Grâce à ce programme ecris en C++ et tres orienté objet, plus de problemes !
On indique la valeur du vent dans l'unité que l'on veut et hop ! La machine
nous sort les autres ! Elle est pas belle la vie ?

Kenji,
progra.... euhh bidouilleur en informatique :D
*/

#include <iostream> //pour les "cout", etc
#include <stdlib.h> 
#include <conio.h> //pour le getch()

using namespace std; //la norme, toujours la norme...

class Vent //classe contenant toutes les fonctions du programme (sauf "main") :D
{
    private :
        float km;
        float ms;
        float beaufort;
        char type;
    
    public :
        
        void kmtoms();
        void mstokm();
        void mstobeaufort();
        void beauforttoms();
        
        void calculer();
        void afficher();
        
        inline void settype(char i){this->type = i;};
        inline void setms(float i) {this->ms = i;};
        inline void setkm(float i) {this->km = i;};
        inline void setbeaufort(float i) {this->beaufort = i;};
        
        inline float gettype() { return this->type; };
};

void Vent::kmtoms()
{
    this->ms = (this->km*1000)/3600; //on multiplie par 1000 et on divise par 3600
}

void Vent::mstokm()
{
    this->km = (this->ms*3600)/1000; // on divise par 1000 et on multiplie par 3600
}

void Vent::mstobeaufort() //fonction utilisant les equivalences beaufort-> m/s
{
    if(this->ms<0.5) // si le vent va a moins de 0.5 m/s
    {
        this->beaufort=0; // il vaut 0 sur l'echelle beaufort
        return; // on quitte la fonction
    }
    if(this->ms<1.5)
    {
        this->beaufort=1;
        return;
    }   
    if(this->ms<3)
    {
        this->beaufort=2;
        return;
    }   
    if(this->ms<4.5)
    {
        this->beaufort=3;
        return;
    }   
    if(this->ms<7)
    {
        this->beaufort=4;
        return;
    }   
    if(this->ms<9)
    {
        this->beaufort=5;
        return;
    }   
    if(this->ms<11)
    {
        this->beaufort=6;
        return;
    }   
    if(this->ms<14)
    {
        this->beaufort=7;
        return;
    }   
    if(this->ms<17)
    {
        this->beaufort=8;
        return;
    }   
    if(this->ms<20)
    {
        this->beaufort=9;
        return;
    }
    if(this->ms<25)
    {
        this->beaufort=10;
        return;
    }       
    if(this->ms<30)
    {
        this->beaufort=11;
        return;
    }
    if(this->ms>=30)
    {
        this->beaufort=12;
        return;
    }
    
    system("cls"); //on efface l'ecran
    cout << "Erreur !!! Vos valeurs ne sont pas correctes !\n"; //on previent l'utilisateur
    system("PAUSE"); // on attend qu'il presse "entrée"
    exit(0); // on quitte le programme ! Bien fait pour lui :D
}

void Vent::beauforttoms() //fonction utilisant les equivalences beaufort-> m/s
{
    if(this->beaufort==0) //si le vent vaut 0 sur l'echelle beaufort :
    {
        this->ms=0.5; //il va environ a 0.5 m/s
        return; // on quitte la fonction
    }
    if(this->beaufort==1)
    {
        this->ms=1.5;
        return;
    }   
    if(this->beaufort==2)
    {
        this->ms=3;
        return;
    }   
    if(this->beaufort==3)
    {
        this->ms=4.5;
        return;
    }   
    if(this->beaufort==4)
    {
        this->ms=7;
        return;
    }   
    if(this->beaufort==5)
    {
        this->ms=9;
        return;
    }   
    if(this->beaufort==6)
    {
        this->ms=11;
        return;
    }   
    if(this->beaufort==7)
    {
        this->ms=14;
        return;
    }   
    if(this->beaufort==8)
    {
        this->ms=17;
        return;
    }   
    if(this->beaufort==9)
    {
        this->ms=20;
        return;
    }
    if(this->beaufort==10)
    {
        this->ms=25;
        return;
    }       
    if(this->beaufort==11)
    {
        this->ms=30;
        return;
    }
    if(this->beaufort==12)
    {
        this->ms=40;
        return;
    }
    
    system("cls"); //on efface l'ecran
    cout << "Erreur !!! Vos valeurs ne sont pas correctes !\n"; //on previent l'utilisateur
    system("PAUSE"); // on attend qu'il presse "entrée"
    exit(0); // on quitte le programme ! Bien fait pour lui :D
}                                                           

void Vent::calculer() //pour tout calculer
{
    
    if(this->km!=0 || this->type=='k') //si on a une valeur en km/h
    {
        this->kmtoms(); //on calcule en m/s
        this->mstobeaufort(); // on calcule en beaufort
        return; // on quitte la fonction
    }
    
    if(this->ms!=0 || this->type=='m') // si on a une valeur en m/s
    {
        this->mstokm(); // on calcule en km/h
        this->mstobeaufort(); // on calcule en beaufort
        return; // on quitte la fonction
    }
    
    if(this->beaufort!=0 || this->type=='b') // si on a une valeur en   beaufort
    {
        this->beauforttoms(); // on calcule en m/s
        this->mstokm(); // on calcule en km/h
        return; // on quitte la fonction
    }
    
    //si on a rien de tout ca :
        exit(0);
                        
} 

void Vent::afficher()
{
    system("cls");
    cout << "Resultat :\n\n";
    cout << "Force du vent en m/s :" << this->ms << endl;
    cout << "Force du vent en km/h :" << this->km << endl;
    cout << "Equivalence beaufort :" << this->beaufort << endl << endl;
}

int main(int argc, char *argv[])
{
Vent * vent = new Vent(); //creation d'un objet dynamique de type "vent"
    
while(1) //boucle principale
{
system("cls"); //effacement de l'ecran
cout << "___________________________" << endl; //"image" de presentation
cout << "|                           |" << endl;
cout << "|       BIENVENUE !!!         |" << endl;
cout << "|                           |" << endl;
cout << "|__________________________|"<< endl << endl << endl;
    
char o; //creation d'une variable locale nécessaire au "getch()"
    
cout << "Quelle est l'unite du vent que vous allez donner ?\n";
cout << "k --> Km/H \n";
cout << "m --> m/s \n";
cout << "b --> beaufort \n";
cout << "q --> quitter\n\n";
    
o = getch(); //attendre que l'utilisateur presse une touche et l'enregistrer dans "o"
    //cin o; //si probleme avec la librairie conio.h
    
if(o=='q') exit(0); //si la touche pressée est un "q", on quitte le programme
    
vent->settype(o); //on indique au programme l'unité qui va etre utilisée
    
float u; //creation d'une variable locale nécessaire au "cin"
cout << "Donnez maintenant, la valeur de ce vent :\n" ;
cin >> u; //attente d'une saisie utilisateur
    
switch(o) //si l'unité utilisée est le :
{
case 'k' :vent->setkm(u);break; // -km/h, on modifie la variable km de l'objet "vent"
case 'm' :vent->setms(u);break; // -m/s, on modifie la variable ms de l'objet "vent"
case 'b' :vent->setbeaufort(u);break;// -beaufort, on modifie...
        
default : cout << "Erreur"; continue; //si le type n'est pas valide, on reviens a la boucle
}   
    
vent->calculer(); //on calcule les autres unitées à partir de la premiere
vent->afficher(); //on affiche les resultats
    
vent->settype(0); //on remet tout à 0
vent->setkm(0);
vent->setms(0);
vent->setbeaufort(0);
    
system("PAUSE"); //on attend que l'utilisateur presse la touche "entrée"
}
    
delete vent; //on detruit le pointeur "vent" et on libere la memoire
    
return 0; //on quitte le programme
}