Browse Source

Transférer les fichiers vers ''

philouxy-fixme 1 year ago
parent
commit
1a5460c843
5 changed files with 1071 additions and 0 deletions
  1. 462 0
      affichage.c
  2. 52 0
      arithmetique.h
  3. 308 0
      calcul_entier.c
  4. 121 0
      conversion.c
  5. 128 0
      display.h

+ 462 - 0
affichage.c

@@ -0,0 +1,462 @@
+//-----------------------------------------------------------------------------------//
+// Nom du projet 		: Langage_C_fixme
+// Nom du fichier 		: affichage.c
+// Date de création 	: 30.09.2015
+// Date de modification : 23.10.2017
+//
+// Auteur 				: Philou (Ph. Bovey)
+//
+// Description          : fichier comportant différentes fonctions pour permettre des
+//                        effets visuelless
+//
+//
+// Remarques :            lien pour la table ASCII :
+// 						  -> http://www.asciitable.com/
+// 						  lien pour la saisie de clavier avec getc & getchar pour ne pas
+//                        avoir des erreurs d'interprétation
+// 						  -> http://fr.openclassrooms.com/informatique/cours/utiliser-les-bonnes-fonctions-d-entree
+// 						  lien vers différents
+// 						  -> http://fr.wikipedia.org/wiki/String.h
+//----------------------------------------------------------------------------------//
+
+//--- librairie standart ---//
+#include <stdio.h>                  // entrée - sortie
+#include <string.h>
+
+//--- librairie perso ---//
+#include "display.h"
+
+//----------------------------------------------------------------------------------//
+// Nom de la fonction   : Triangle_Etoile_AGB
+// Entrée / Sortie      : nb_etoile / - /
+// Description          : affiche un triangle rectangle selon le choix du user
+// Date modfification   : le 19.11.2015
+// Remarque             : -
+//----------------------------------------------------------------------------------//
+void Triangle_Etoile_AGB(int nb_etoile)
+{
+    //--- déclaration de variable interne ---//
+    int c, l;       // c = colonne || l = ligne
+
+    for(l = 0; l < nb_etoile; l++)
+    {
+        for(c = 0; c <= l ; c++)
+            PRINT_ETOILE;
+
+        PRINT_SAUT_LIGNE;
+    }
+}
+
+//----------------------------------------------------------------------------------//
+// Nom de la fonction   : Triangle_Etoile_ADB
+// Entrée / Sortie      : nb_etoile / - /
+// Description          : affiche un triangle rectangle selon le choix du user
+// Date modfification   : le 19.11.2015
+// Remarque             : -
+//----------------------------------------------------------------------------------//
+void Triangle_Etoile_ADB(int nb_etoile)
+{
+    //--- déclaration de variable interne ---//
+    int c, c_e, l;       // c = colonne || l = ligne || c_e = colonne étoile
+
+    for(l = 0; l < nb_etoile; l++)
+    {
+        for(c = l; c < nb_etoile ; c++)
+        {
+            if (c < (nb_etoile -1))
+                PRINT_ESPACE;
+            else
+            {
+                for(c_e = c; c_e < (nb_etoile + l); c_e++)
+                    PRINT_ETOILE;
+            }
+        }
+        PRINT_SAUT_LIGNE;
+    }
+}
+//for(c_e = c; c_e < (val_user + c); c_e++)
+
+
+//----------------------------------------------------------------------------------//
+// Nom de la fonction   : Triangle_Etoile_AGH
+// Entrée / Sortie      : nb_etoile / - /
+// Description          : affiche un triangle rectangle selon le choix du user
+// Date modfification   : le 19.11.2015
+// Remarque             : -
+//----------------------------------------------------------------------------------//
+void Triangle_Etoile_AGH(int nb_etoile)
+{
+    //--- déclaration de variable interne ---//
+    int c, l;       // c = colonne || l = ligne
+
+    for(l = 0; l < nb_etoile; l++)
+    {
+        for(c = l; c < nb_etoile ; c++)
+            PRINT_ETOILE;
+
+        PRINT_SAUT_LIGNE;
+    }
+}
+
+//----------------------------------------------------------------------------------//
+// Nom de la fonction   : Triangle_Etoile_AGH
+// Entrée / Sortie      : nb_etoile / - /
+// Description          : affiche un triangle rectangle selon le choix du user
+// Date modfification   : le 11.11.2015
+// Remarque             : en commentaire une deuxième variente
+//----------------------------------------------------------------------------------//
+void Triangle_Etoile_ADH(int nb_etoile)
+{
+    //--- déclaration de variable interne ---//
+    int c, c_e, l;       // c = colonne || l = ligne || c_e = colonne étoile
+
+    for(l = 0; l < nb_etoile; l++)
+    {
+        for(c = l; c >= 0 ; c--)
+        {
+            if(c < 1)
+            {
+                for(c_e = l; c_e < nb_etoile; c_e++)
+                    PRINT_ETOILE;
+            }
+            else
+                PRINT_ESPACE;
+        }
+        PRINT_SAUT_LIGNE;
+    }
+}
+
+/* ----------------------------------------------------------------------------------
+--- autre solution pour la boucle interne ---
+for(c = l, c_e = val_user; c_e > 0  ; c_e--){
+    if(c < 1)
+        PRINT_ETOILE;
+    else{
+        PRINT_ESPACE;
+        c--;
+    }
+}
+PRINT_SAUT_LIGNE;
+---------------------------------------------------------------------------------- */
+
+// for(c = l, c_e = (val_user - c); c_e > 0 ; c_e--, c--)
+
+//----------------------------------------------------------------------------------//
+// Nom de la fonction   : Choix_Emplacement_Triangle
+// Entrée / Sortie      : choix_HB, choix_GD / - /
+// Description          : permet de choisir quel triangle on veut afficher en
+//                        fonction du choix utilisateur
+// Date modfification   : le 23.10.2017
+// Remarque             :
+//----------------------------------------------------------------------------------//
+void Choix_Emplacement_Triangle(char choix_HB, char choix_GD)
+{
+    //--- déclaration de variable ---//
+    int choix_val;
+
+    choix_val = Select_Var_Entier(LIMITE_ETOILE_MAX, LIMITE_ETOILE_MIN);
+
+    if(choix_HB == CHOIX_HAUT)
+    {
+        if(choix_GD == CHOIX_GAUCHE)
+            Triangle_Etoile_AGH(choix_val);
+        else
+            Triangle_Etoile_ADH(choix_val);
+    }
+    else
+    {
+        if(choix_GD == CHOIX_DROITE)
+            Triangle_Etoile_ADB(choix_val);
+        else
+            Triangle_Etoile_AGB(choix_val);
+    }
+}
+
+//----------------------------------------------------------------------------------//
+// Nom de la fonction   : Carre
+// Entrée / Sortie      : val_user / - /
+// Description          : affiche un carré plein d'étoiles
+// Date modfification   : le 10.11.2015
+// Remarque             : -
+//----------------------------------------------------------------------------------//
+void Carre(int val_user)
+{
+    //--- déclaration de variable ---//
+    int c, l;
+
+    //--- boucle pour afficher chaque ligne ---//
+    for(l = 0; l < val_user; l++)
+    {
+        //--- boucle pour afficher chaque colonne ---//
+        for(c = 0; c < val_user; c++)
+            PRINT_ETOILE;
+
+        PRINT_SAUT_LIGNE;
+    }
+}
+
+//----------------------------------------------------------------------------------//
+// Nom de la fonction   : Parallelogramme_AG
+// Entrée / Sortie      : val_user / - /
+// Description          : affiche un parallelogramme avec l'angle a gauche
+// Date modfification   : le 11.11.2015
+// Remarque             : on lieu de la boucle de deux boucle for imbriquée =>
+//                        utilisation d'une boucle while (externe) et de la boucle
+//                        do ..while pour la boucle (interne)
+//----------------------------------------------------------------------------------//
+void Parallelogramme_AG(int val_user)
+{
+    //--- déclaration de variable interne ---//
+    int c, c_e, l;       // c = colonne || l = ligne || c_e = colonne étoile
+
+    //--- initialisation de variable ---//
+    l = 0;
+
+    //--- gestion du traitement des lignes ---//
+    while(l < val_user)
+    {
+        //--- initialisation de variables pour la 2ème boucle ---//
+        c = l;
+        c_e = (val_user + l);
+
+        //--- gestion des colonnes ---//
+        do
+        {
+           if(c < 1)
+            {
+                PRINT_ETOILE;
+            }
+            else
+            {
+                PRINT_ESPACE;
+                c--;
+            }
+            c_e--;
+        }while(c_e > 0);
+
+        PRINT_SAUT_LIGNE;
+        //--- incrémentation de la ligne ---//
+        l++;
+    }
+}
+
+/* ----------------------------------------------------------------------------------
+--- autre solution mais cette fois avec des boucles for imbriquée ---
+for(l = 0; l < val_user; l++){
+    for(c = l, c_e = (val_user + l); c_e > 0  ; c_e--){
+        if(c < 1)
+            PRINT_ETOILE;
+        else{
+            PRINT_ESPACE;
+            c--;
+        }
+    }
+    PRINT_SAUT_LIGNE;
+}
+---------------------------------------------------------------------------------- */
+
+// for(c = l, c_e = (val_user - c); c_e > 0 ; c_e--, c--)
+
+
+//----------------------------------------------------------------------------------//
+// Nom de la fonction   : Parallelogramme_AD
+// Entrée / Sortie      : val_user / - /
+// Description          : affiche un parallelogramme avec l'angle a droite
+// Date modfification   : le 06.01.2016
+// Remarque             : on lieu de la boucle de deux boucle for imbriquée =>
+//                        utilisation d'une boucle while (externe) et de la boucle
+//                        do ..while pour la boucle (interne)
+//----------------------------------------------------------------------------------//
+void Parallelogramme_AD(int val_user)
+{
+    //--- déclaration de variable interne ---//
+    int c, c_e, l;       // c = colonne || l = ligne || c_e = colonne étoile
+
+    //--- initialisation de variable ---//
+    l = 0;
+
+    //--- gestion du traitement des lignes ---//
+    while(l < val_user)
+    {
+        //--- initialisation de variables pour la 2ème boucle ---//
+        c = l;
+        c_e = val_user;
+
+        //--- gestion des colonnes ---//
+        do
+        {
+            PRINT_ESPACE;
+            c++;
+        }while(c < val_user);
+
+        for(c_e = 0; c_e < val_user ; c_e++)
+            PRINT_ETOILE;
+
+        PRINT_SAUT_LIGNE;
+        //--- incrémentation de la ligne ---//
+        l++;
+    }
+}
+
+//----------------------------------------------------------------------------------//
+// Nom de la fonction   : Selection_Sens_Paralelogramme
+// Entrée / Sortie      : choix_user / - /
+// Description          : permet de choisir entre la direction de l'angle d'un
+//                        parallelogramme
+// Date modfification   : le 23.10.2017
+// Remarque             :
+//----------------------------------------------------------------------------------//
+void Selection_Sens_Paralelogramme(char choix_user)
+{
+    //--- déclaration de variables ---//
+    int val_user;
+
+    //--- choix du nb d'étoile à afficher dans le parallélogramme ---//
+    val_user = Select_Var_Entier(LIMITE_ETOILE_MAX, LIMITE_ETOILE_MIN);
+
+
+    if(choix_user == CHOIX_GAUCHE)
+        Parallelogramme_AG(val_user);
+    else
+        Parallelogramme_AD(val_user);
+}
+
+
+
+//----------------------------------------------------------------------------------//
+// Nom de la fonction   : Losange_Vide
+// Entrée / Sortie      : - / - /
+// Description          : permet d'afficher un "losange" vide
+// Date modfification   : le 23.10.2017
+// Remarque             :
+//----------------------------------------------------------------------------------//
+void Losange_Vide(void)
+{
+    //--- déclaration de variable interne ---//
+    int c_e, c_v, l;       // c_e = colonne etoile || c_v = colonne vide || l = ligne
+    int nb_etoile;
+
+    nb_etoile = Select_Var_Entier(LIMITE_ETOILE_MAX, LIMITE_ETOILE_MIN);
+
+    //--- Partie supérieur du losange
+    for(l = 0; l < nb_etoile; l++)
+    {
+        //--- premiere partie - ETOILE ---//
+        for(c_e = l; c_e < nb_etoile ; c_e++)
+            PRINT_ETOILE;
+
+        //--- deuxième partie - ESPACE ---//
+        for(c_v = 2 * (nb_etoile - (nb_etoile - l)); c_v > 0; c_v--)
+            PRINT_ESPACE;
+
+         //--- troisième partie - ETOILE ---//
+        for(c_e = (nb_etoile - l); c_e > 0 ; c_e--)
+            PRINT_ETOILE;
+
+        PRINT_SAUT_LIGNE;
+    }
+
+    //--- partie inférieur du losange
+    for(l = 0; l < nb_etoile; l++)
+    {
+        //--- premiere partie - ETOILE ---//
+        for(c_e = 0; c_e <= l ; c_e++)
+            PRINT_ETOILE;
+
+        //--- deuxième partie - ESPACE ---//
+        for(c_v = 2 * (nb_etoile - (l + 1)); c_v > 0; c_v--)
+            PRINT_ESPACE;
+
+        //--- troisième partie - ETOILE ---//
+        for(c_e = nb_etoile - (nb_etoile - l); c_e >= 0; c_e--)
+            PRINT_ETOILE;
+
+        PRINT_SAUT_LIGNE;
+    }
+}
+
+//----------------------------------------------------------------------------------//
+// Nom de la fonction   : Losange_Plein
+// Entrée / Sortie      : - / - /
+// Description          : permet d'afficher un "losange" plein
+// Date modfification   : le 29.12.2015
+// Remarque             :
+//----------------------------------------------------------------------------------//
+void Losange_Plein(void)
+{
+    //--- déclaration de variable interne ---//
+    int c_e, c_v, l;       // c_e = colonne etoile || c_v = colonne vide || l = ligne
+    int nb_etoile;
+
+    nb_etoile = Select_Var_Entier(LIMITE_ETOILE_MAX, LIMITE_ETOILE_MIN);
+
+    //--- Partie supérieur du losange
+    for(l = 0; l < nb_etoile; l++)
+    {
+        //--- premiere partie - ETOILE ---//
+        for(c_e = l; c_e < nb_etoile ; c_e++)
+            PRINT_ESPACE;
+
+        //--- deuxième partie - ESPACE ---//
+        for(c_v = 2 * (nb_etoile - (nb_etoile - l)); c_v > 0; c_v--)
+            PRINT_ETOILE;
+
+         //--- troisième partie - ETOILE ---//
+        for(c_e = (nb_etoile - l); c_e > 0 ; c_e--)
+            PRINT_ESPACE;
+
+        PRINT_SAUT_LIGNE;
+    }
+
+    //--- partie inférieur du losange
+    for(l = 0; l < nb_etoile; l++)
+    {
+        //--- premiere partie - ETOILE ---//
+        for(c_e = 0; c_e <= l ; c_e++)
+            PRINT_ESPACE;
+
+        //--- deuxième partie - ESPACE ---//
+        for(c_v = 2 * (nb_etoile - (l + 1)); c_v > 0; c_v--)
+            PRINT_ETOILE;
+
+        //--- troisième partie - ETOILE ---//
+        for(c_e = nb_etoile - (nb_etoile - l); c_e >= 0; c_e--)
+            PRINT_ESPACE;
+
+        PRINT_SAUT_LIGNE;
+    }
+}
+
+//----------------------------------------------------------------------------------//
+// Nom de la fonction   : Selection_Losange
+// Entrée / Sortie      : choix_user / - /
+// Description          : permet d'appeler soit la fonction "losange vide" soit la
+//                        fonction "losange plein"
+// Date modfification   : le 05.01.2016
+// Remarque             :
+//----------------------------------------------------------------------------------//
+void Selection_Losange (char choix_user)
+{
+    if(choix_user == CHOIX_PLEINS)
+        Losange_Plein();
+    else
+        Losange_Vide();
+}
+
+/*
+//----------------------------------------------------------------------------------//
+// Nom de la fonction   : Simul_led
+// Entrée / Sortie      : choix_user / - /
+// Description          : permet d'appeler soit la fonction "losange vide" soit la
+//                        fonction "losange plein"
+// Date modfification   : le 05.01.2016
+// Remarque             :
+//----------------------------------------------------------------------------------//
+Simul_led()
+{
+    for(int l)
+    {
+        for()
+    }
+}
+*/

+ 52 - 0
arithmetique.h

@@ -0,0 +1,52 @@
+//-----------------------------------------------------------------------------------//
+// Nom du projet 		: Langage_C_fixme
+// Nom du fichier 		: arithmetique.h
+// Date de création 	: 09.04.2015
+// Date de modification : 23.10.2017
+//
+// Auteur 				: Philou (Ph. Bovey)
+//
+// Description : fichier de type header file pour toutes les fonctions
+//               liées aux calculs
+//
+// Remarques :            lien pour la table ASCII :
+// 						  -> http://www.asciitable.com/
+// 						  lien pour la saisie de clavier avec getc & getchar pour ne pas
+//                        avoir des erreurs d'interprétation
+// 						  -> http://fr.openclassrooms.com/informatique/cours/utiliser-les-bonnes-fonctions-d-entree
+// 						  lien vers différents
+// 						  -> http://fr.wikipedia.org/wiki/String.h
+//----------------------------------------------------------------------------------//
+#ifndef ARITHMETIQUE_H_INCLUDED
+#define ARITHMETIQUE_H_INCLUDED
+
+#define _CRT_NONSTDC_NO_WARNINGS
+
+//--- constante ou définition ---//
+#define CHAR_RETOUR_CHARIOT     '\n'      // caractère spécial représentant un retour de ligne
+#define DEBUT_CHAR              65        // correspond a la lettre 'A'
+#define DEBUT_NUM               48        // correspond au caractère '0'
+#define LIMITE_AXE_X_MAX		100		  // abscisse max 	
+#define LIMITE_AXE_X_MIN		-100	  // abscisse min  	
+#define LIMITE_AXE_Y_MAX		50		  // ordonnee max 
+#define LIMITE_AXE_Y_MIN		-50		  // ordonnee min 
+#define NB_ALPHABETE            24        // nombre de caractère dans l'alphabet
+#define SAUT_MAJ_MIN            32        // différence entre les caractères majuscule et minuscule -><-
+
+//--- déclaration de prototype ---//
+//--- fonctions liées au fichier : calcul_entier.c ---//
+void Astuce_Calcul(void);                   //-> affiche des exemples d'incrémentation
+void Addition(void);                        //-> affiche une addition pour le user (entier ou flottant)
+void Soustraction(void);                    //-> affiche la soustraction de deux nombre choisi par l'utilisateur
+void Multiplication(void);                  //-> affiche la multiplication de deux nombre choisi par l'utilisateur
+void Division(void);                        //-> affiche la division de deux nombre choisi par l'utilisateur
+
+int pemier_calcul(int val_x);
+
+//--- fonctions liées au fichier : conversions.c ---//
+void Conv_Char_Num(char var_char);          //-> converti un caractère en valeur numérique
+void Conv_Num_Char(int var_int);            //-> converti un nombre en caractère
+void Conv_Num_Oct_Hex(int var_int);         //-> converti un nombre en octal et en hexa
+void Astuce_ASCII(void);                    //-> montre toutes les valeurs des caractères
+
+#endif // ARITHMETIQUE_H_INCLUDED

+ 308 - 0
calcul_entier.c

@@ -0,0 +1,308 @@
+//-----------------------------------------------------------------------------------//
+// Nom du projet 		: Langage_C_fixme
+// Nom du fichier 		: calcul_entier.c
+// Date de création 	: 09.04.2015
+// Date de modification : 23.10.2017
+//
+// Auteur 				: Philou (Ph. Bovey)
+//
+// Description          : fichier comportant différentes fonctions arithmetiques avec des
+//                        éléments entiers
+//
+// Remarques :            lien pour la table ASCII :
+// 						  -> http://www.asciitable.com/
+// 						  lien pour la saisie de clavier avec getc & getchar pour ne pas
+//                        avoir des erreurs d'interprétation
+// 						  -> http://fr.openclassrooms.com/informatique/cours/utiliser-les-bonnes-fonctions-d-entree
+// 						  lien vers différents
+// 						  -> http://fr.wikipedia.org/wiki/String.h
+//----------------------------------------------------------------------------------//
+//--- librairie standart ---//
+#include <stdio.h>                  // entrée - sortie
+#include <string.h>
+#include <stdint.h>					// type normalisé
+
+//--- librairie perso ---//
+#include "arithmetique.h"
+#include "display.h"
+
+
+//----------------------------------------------------------------------------------//
+// Nom de la fonction   : Astuce_Calcul
+// Entrée / Sortie      : - / - / -
+// Description          : montre différent mode d'affichage avec le mode d
+//                        incrémentation et decrementation
+// modification         : le 19.06.2014
+// Remarque             : -
+//----------------------------------------------------------------------------------//
+void Astuce_Calcul(void)
+{
+    //--- déclaration de variable interne ---//
+    char val_exemple;
+
+    //--- récuperation de la valeur ---//
+    val_exemple = Selection_Menus('V');
+
+    //--- incrémentation ---//
+    PRINT_SAUT_LIGNE;
+    PRINT_SAUT_LIGNE;
+    printf("-> NB = %d ", val_exemple);
+    PRINT_SAUT_LIGNE;
+    printf("-> NB++ = %d ", val_exemple++);
+    printf(" la valeur ne change pas !!!");
+    PRINT_SAUT_LIGNE;
+    printf("-> Rappel NB = %d ", val_exemple);
+    printf(" la valeur a change cette fois, on parle de post incrementation !!!");
+    PRINT_SAUT_LIGNE;
+    printf("-> NB-- = %d ", val_exemple--);
+    printf(" la valeur ne change pas !!!");
+    PRINT_SAUT_LIGNE;
+    printf("-> Rappel NB = %d ", val_exemple);
+    printf(" la valeur a change cette fois, on parle de post decrementation !!!");
+    PRINT_SAUT_LIGNE;
+    PRINT_SAUT_LIGNE;
+    printf("-> NB = %d", val_exemple);
+    PRINT_SAUT_LIGNE;
+    printf("-> ++NB = %d ", ++val_exemple);
+    printf(" la valeur change directement, on parle de pre incrementation !!!");
+    PRINT_SAUT_LIGNE;
+    printf("-> --NB = %d ", --val_exemple);
+    printf(" la valeur change directement, on parle de pre decrementation !!!");
+    PRINT_SAUT_LIGNE;
+    PRINT_SAUT_LIGNE;
+    printf("Valeur Initialee = %d", val_exemple);
+}
+
+//----------------------------------------------------------------------------------//
+// Nom de la fonction   : Addition
+// Entrée / Sortie      : - / - / -
+// Description          : Addition de deux variables + affichage en mode entier en
+//                        flottant
+// modification         : le 09.09.2015
+// Remarque             : -
+//----------------------------------------------------------------------------------//
+void Addition(void)
+{
+    //--- déclaration de variables ---//
+    int     var_i_1, var_i_2;
+    float   var_f_1, var_f_2;
+
+    var_f_1 = Select_Var_Flottant();
+    var_f_2 = Select_Var_Flottant();
+    var_i_1 = (int)var_f_1;             //caster une valeur de flottante en valeur entière
+    var_i_2 = (int)var_f_2;             //caster une valeur de flottante en valeur entière
+    PRINT_SAUT_LIGNE;
+    PRINT_SAUT_LIGNE;
+    printf("adition mode affichage entier :        X + Y  = %d + %d = %d",var_i_1, var_i_2, (var_i_1 + var_i_2));
+    PRINT_SAUT_LIGNE;
+    printf("meme addition - ecriture differente :  X += Y ou X = X + Y: %d",var_i_1 += var_i_2);
+    PRINT_SAUT_LIGNE;
+    printf("adition mode affichage flottant :      X + Y  = %f + %f = %f",var_f_1, var_f_2, (var_f_1 + var_f_2));
+    PRINT_SAUT_LIGNE;
+    printf("meme addition - ecriture differente :  X += Y ou X = X + Y: %f",var_f_1 += var_f_2);
+    //--- réinitialiser la valeur de X ---//
+    var_f_1 -= var_f_2;
+    PRINT_SAUT_LIGNE;
+    printf("adition notation scientifique :        X + Y  = %4.1e + %4.1e = %4.1e",var_f_1, var_f_2, (var_f_1 + var_f_2));
+}
+
+//----------------------------------------------------------------------------------//
+// Nom de la fonction   : Soustraction
+// Entrée / Sortie      : choix_option / - / -
+// Description          : Soustraction de deux variable + affichage en mode entier en
+//                        flottant
+// modification         : le 09.09.2015
+// Remarque             : -
+//----------------------------------------------------------------------------------//
+void Soustraction(void)
+{
+    //--- déclaration de variables ---//
+    int   var_i_1, var_i_2;
+    float var_f_1, var_f_2;
+
+    var_f_1 = Select_Var_Flottant();
+    var_f_2 = Select_Var_Flottant();
+    var_i_1 = (int)var_f_1;             //caster une valeur de flottante en valeur entière
+    var_i_2 = (int)var_f_2;             //caster une valeur de flottante en valeur entière
+    PRINT_SAUT_LIGNE;
+    PRINT_SAUT_LIGNE;
+    printf("soustraction mode affichage entier :      X - Y  = %d - %d = %d",var_i_1, var_i_2, (var_i_1 - var_i_2));
+    PRINT_SAUT_LIGNE;
+    printf("meme soustraction - ecriture differente : X -= Y ou X = X - Y: %d",var_i_1 -= var_i_2);
+    PRINT_SAUT_LIGNE;
+    printf("soustraction mode affichage flottant :    X - Y  = %f - %f = %f",var_f_1, var_f_2, (var_f_1 - var_f_2));
+    PRINT_SAUT_LIGNE;
+    printf("meme soustraction - ecriture differente : X -= Y ou X = X - Y: %f",var_f_1 -= var_f_2);
+    //--- réinitialiser la valeur de X ---//
+    var_f_1 += var_f_2;
+    PRINT_SAUT_LIGNE;
+    printf("sosutraction notation scientifique :      X - Y  = %4.1e - %4.1e = %4.1e",var_f_1, var_f_2, (var_f_1 - var_f_2));
+}
+
+//----------------------------------------------------------------------------------//
+// Nom de la fonction   : Multiplication
+// Entrée / Sortie      : choix_option / - / -
+// Description          : Multiplication de deux variables + affichage en mode entier en
+//                        flottant
+// modification         : le 09.09.2015
+// Remarque             : -
+//----------------------------------------------------------------------------------//
+void Multiplication(void)
+{
+    //--- déclaration de variables ---//
+    int   var_i_1, var_i_2;
+    float var_f_1, var_f_2;
+
+    var_f_1 = Select_Var_Flottant();
+    var_f_2 = Select_Var_Flottant();
+    var_i_1 = (int)var_f_1;             //caster une valeur de flottante en valeur entière
+    var_i_2 = (int)var_f_2;             //caster une valeur de flottante en valeur entière
+    PRINT_SAUT_LIGNE;
+    PRINT_SAUT_LIGNE;
+    printf("multiplication mode affichage emtier :      X * Y  = %d * %d = %d",var_i_1, var_i_2, (var_i_1 * var_i_2));
+    PRINT_SAUT_LIGNE;
+    printf("meme multiplication - ecriture differente : X *= Y ou X = X * Y: %d",var_i_1 *= var_i_2);
+    PRINT_SAUT_LIGNE;
+    printf("multiplication en mode affichage flottant : X * Y  = %f * %f = %f",var_f_1, var_f_2, (var_f_1 * var_f_2));
+    PRINT_SAUT_LIGNE;
+    printf("meme multiplication - ecriture differente : X *= Y ou X = X * Y: %f",var_f_1 *= var_f_2);
+    //--- réinitialiser la valeur de X ---//
+    var_f_1 /= var_f_2;
+    PRINT_SAUT_LIGNE;
+    printf("multiplication notation scientifique :      X * Y  = %4.1e * %4.1e = %4.1e",var_f_1, var_f_2, (var_f_1 * var_f_2));
+}
+
+//----------------------------------------------------------------------------------//
+// Nom de la fonction   : Division
+// Entrée / Sortie      : choix_option / - / -
+// Description          : Division de deux variables + affichage en mode entier en
+//                        flottant
+// modification         : le 09.09.2015
+// Remarque             : -
+//----------------------------------------------------------------------------------//
+void Division(void)
+{
+    //--- déclaration de variables ---//
+    int     var_i_1, var_i_2;
+    float   var_f_1, var_f_2;
+
+    var_f_1 = Select_Var_Flottant();
+    var_f_2 = Select_Var_Flottant();
+    var_i_1 = (int)var_f_1;             //caster une valeur de flottante en valeur entière
+    var_i_2 = (int)var_f_2;             //caster une valeur de flottante en valeur entière
+    PRINT_SAUT_LIGNE;
+    PRINT_SAUT_LIGNE;
+    printf("division mode affichage entier :          X / Y  = %d / %d = %d",var_i_1, var_i_2, (var_i_1 / var_i_2));
+    PRINT_SAUT_LIGNE;
+    printf("meme soustraction - ecriture differente : X /= Y ou X = X / Y: %d",var_i_1 /= var_i_2);
+    PRINT_SAUT_LIGNE;
+    printf("divsion mode affichage flottant :         X / Y  = %f / %f = %f",var_f_1, var_f_2, (var_f_1 / var_f_2));
+    PRINT_SAUT_LIGNE;
+    printf("meme soustraction - ecriture differente : X /= Y ou X = X / Y: %f",var_f_1 /= var_f_2);
+    //--- réinitialiser la valeur de X ---//
+    var_f_1 *= var_f_2;
+    PRINT_SAUT_LIGNE;
+    printf("division notation scientifique :          X / Y  = %4.1e / %4.1e = %4.1e",var_f_1, var_f_2, (var_f_1 / var_f_2));
+}
+
+
+//----------------------------------------------------------------------------------//
+// Nom de la fonction   : pemier_calcul
+// Entrée / Sortie      : val_x / val_y
+// Description          : calculs simple de plusieurs expressions mathématiques
+//                        addition / soustraction / mulptiplication entre deux
+//                        variables externes ou internes
+// modification         : le 09.04.2014
+// Remarque             : -
+//----------------------------------------------------------------------------------//
+int pemier_calcul(int val_x)
+{
+    //--- constantes ---//
+    const int VAL_CONST = 5;
+
+    //--- variables ---//
+    int var_int_x = 1;
+    int var_int_y = 3;
+    int res_int;
+
+    //--- afficher plusieurs opération arithmétique simple en mode raccoucis ---//
+    printf("\n\naddition entre x et y      : %d",var_int_x += var_int_y);         // afficher 4
+    printf("\naddition entre x et -y       : %d",var_int_x += -var_int_y);        // afficher 1
+    printf("\nsoustraction entre x et y    : %d",var_int_x -= var_int_y);         // afficher -2
+    printf("\nsoustraction entre x et -y   : %d",var_int_x -= -var_int_y);        // afficher 1
+    printf("\nmultiplication entre x et y  : %d",var_int_x *= var_int_y);         // afficher 3
+    printf("\nmultiplication entre x et -y : %d",var_int_x *= -var_int_y);        // afficher -9
+
+    //--- tests sur la priorité des opérateurs ---//
+    var_int_x = 3;                                        // nouvelle affectation
+    var_int_y = 6;
+
+    res_int = var_int_x * var_int_y == 18;                // le résultat sera binaire
+    printf("\n\nEst-ce que : %d * %d vaut 18 ", var_int_x, var_int_y);
+    if (res_int != 1)
+        printf("\n\nPas de correspondance !!! \n ");
+    else
+        printf("\nEquivalent !!! \n ");
+
+    //--- calcul simple avec retour de la valeur---//
+    return(val_x * VAL_CONST);
+}
+
+
+//----------------------------------------------------------------------------------//
+// Nom de la fonction   : Calculs_Segment 
+// Entrée / Sortie      : 
+// Description          : permet de calculer la longueur d'un segment (point A(x,y) 
+//						  à un point B(x,y)) + le milieu du segment en coordonnée X 
+//                        et Y + ainsi que la pente dans un système d'axes à deux 
+//						  dimension 
+// modification         : le 23.10.2017
+// Remarque             : -
+//----------------------------------------------------------------------------------//
+void Calculs_Segment(void)
+{
+	//-- déclaration de variable locale --//
+	double distanceSegmentA_B;
+	float milieuSegment_X, milieuSegment_Y;
+	float pente;
+
+	int8_t pointA_X, pointA_Y;		// définissant le point A  
+	int8_t pointB_X, pointB_Y;		// définissant le point B 
+
+	//-- message utilisateur --//
+	//-- definition du point A (X, Y)
+	PRINT_SAUT_LIGNE; 
+	PRINT_SELECTION_ABSCISSE; 
+	PRINT_SAUT_LIGNE;
+	pointA_X = Select_Var_Entier(LIMITE_AXE_X_MAX, LIMITE_AXE_X_MIN); 
+	PRINT_SELECTION_ORDONNEE; 
+	PRINT_SAUT_LIGNE;
+	pointA_Y = Select_Var_Entier(LIMITE_AXE_Y_MAX, LIMITE_AXE_Y_MIN);
+	
+	//-- definition du point B (X, Y)
+	PRINT_SAUT_LIGNE;
+	PRINT_SELECTION_ABSCISSE;
+	PRINT_SAUT_LIGNE;
+	pointB_X = Select_Var_Entier(LIMITE_AXE_X_MAX, LIMITE_AXE_X_MIN);
+	PRINT_SELECTION_ORDONNEE;
+	PRINT_SAUT_LIGNE;
+	pointB_Y = Select_Var_Entier(LIMITE_AXE_Y_MAX, LIMITE_AXE_Y_MIN);
+
+	//-- partie calcul --//
+	//-- calcul de la distance : d = sqrt (Xb - Xa)^2 + (Yb - Ya)^2
+	distanceSegmentA_B = sqrt(pow((pointB_X - pointA_X), 2) + pow((pointB_Y - pointA_Y), 2));
+	//distanceSegmentA_B = sqrt(((pointB_axeX - pointA_axeX)*(pointB_axeX - pointA_axeX)) + ((pointB_axeY - pointA_axeY)*(pointB_axeY - pointA_axeY)));
+
+	//-- calcul coordonéé milieu d'un segment: M_X = (Xa + Xb)/2 et M_Y = (Ya + Yb)/2
+	milieuSegment_X = (pointA_X + pointB_X) / 2.0;
+	milieuSegment_Y = (pointA_Y + pointB_Y) / 2.0;
+
+	//-- calcul de la pente : m = (Yb - Ya) / (Xb - Xa)
+	pente = (float)(pointB_Y - pointA_Y) / (float)(pointB_X - pointA_X);
+
+	//-- affichage des différents calculs --// 
+	printf("la distance du segment A - B est de : %f \n", distanceSegmentA_B);
+	printf("le milieu du segment A - B est pour l'abssice de : %f \n", milieuSegment_X);
+	printf("le milieu du segment A - B est pour l'ordonnee : %f \n", milieuSegment_Y);
+	printf("la pente vaut : %f", pente);
+}

+ 121 - 0
conversion.c

@@ -0,0 +1,121 @@
+//-----------------------------------------------------------------------------------//
+// Nom du projet 		: Langage_C_fixme
+// Nom du fichier 		: conversion.c
+// Date de création 	: 19.06.2015
+// Date de modification : 19.08.2015
+//
+// Auteur 				: Philou (Ph. Bovey)
+//
+// Description          : fichier comportant différentes fonctions de conversions
+//
+//
+// Remarques :            lien pour la table ASCII :
+// 						  -> http://www.asciitable.com/
+// 						  lien pour la saisie de clavier avec getc & getchar pour ne pas
+//                        avoir des erreurs d'interprétation
+// 						  -> http://fr.openclassrooms.com/informatique/cours/utiliser-les-bonnes-fonctions-d-entree
+// 						  lien vers différents
+// 						  -> http://fr.wikipedia.org/wiki/String.h
+//----------------------------------------------------------------------------------//
+//--- librairie standart ---//
+#include <stdio.h>                  // entrée - sortie
+#include <string.h>
+
+//--- librairie perso ---//
+#include "arithmetique.h"
+#include "display.h"
+
+
+//----------------------------------------------------------------------------------//
+// Nom de la fonction   : Conv_Char_Num
+// Entrée / Sortie      : var_char / - / -
+// Description          : avec le choix de l'utilisateur sélectionnant un caractètre
+//                        la fonction affiche sa valeur decimale et hexa
+// modification         : le 29.07.2015
+// Remarque             : -
+//----------------------------------------------------------------------------------//
+void Conv_Char_Num(char var_char)
+{
+    if(var_char < DEBUT_NUM)
+        printf("le caractere selectionne est sepacial");
+    else
+        printf("le caractere selectionne est '%c'", var_char);
+
+    PRINT_SAUT_LIGNE;
+    printf("conv en hexa : 0X%x", var_char);
+    PRINT_SAUT_LIGNE;
+    printf("conv en decimal :  %d", var_char);
+    PRINT_SAUT_LIGNE;
+}
+
+
+//----------------------------------------------------------------------------------//
+// Nom de la fonction   : Conv_Num_Char
+// Entrée / Sortie      : var_int / - / -
+// Description          : avec le choix de l'utilisateur sélectionnant un nombre
+//                        la fonction affiche la valeur en caractère
+// modification         : le 23.06.2014
+// Remarque             : -
+//----------------------------------------------------------------------------------//
+void Conv_Num_Char(int var_int)
+{
+    printf("la valeur selectionnee est '%d'", var_int);
+    PRINT_SAUT_LIGNE;
+    printf("conv en caractere : %c", var_int);
+    PRINT_SAUT_LIGNE;
+}
+
+//----------------------------------------------------------------------------------//
+// Nom de la fonction   : Conv_Num_Oct_Hex
+// Entrée / Sortie      : var_int / - / -
+// Description          : avec le choix de l'utilisateur sélectionnant un nombre
+//                        la fonction affiche la valeur en octal et en hexa
+// modification         : le 19.08.2015
+// Remarque             : -
+//----------------------------------------------------------------------------------//
+void Conv_Num_Oct_Hex(int var_int)
+{
+    printf("la valeur selectionnee est '%d'", var_int);
+    PRINT_SAUT_LIGNE;
+    printf("conv en octal: %o || conv en hexa : %x", var_int, var_int);
+    PRINT_SAUT_LIGNE;
+}
+
+//----------------------------------------------------------------------------------//
+// Nom de la fonction   : Astuce_ASCII
+// Entrée / Sortie      : - / - / -
+// Description          : affiche la correspondance entre un caractère et sa valeur
+//                        en numérique (dec + hexa)
+// modification         : le 08.07.2015
+// Remarque             : -
+//----------------------------------------------------------------------------------//
+void Astuce_ASCII(void)
+{
+    //--- déclaration de variable ---//
+    char i;                         // utiliser pour l'incrémentation
+    char fin_num = 57;              // correspond au caractère '9'
+
+    //--- affiche les valeurs correspondant aux chiffres 0 à 9 ---//
+    for(i = DEBUT_NUM; i < fin_num + 1; i++)
+    {
+        Conv_Char_Num(i);
+        PRINT_SAUT_LIGNE;
+    }
+
+    //--- affichage des valeurs correspondants au caractère de l'alpahabet en majuscule et minuscule ---//
+    for(i = DEBUT_CHAR; i < DEBUT_CHAR + NB_ALPHABETE; i++)
+    {
+        //--- Partie Majuscule ---//
+        Conv_Char_Num(i);
+        PRINT_SAUT_LIGNE;
+
+        //--- Partie Minsucle ---//
+        Conv_Char_Num(i + SAUT_MAJ_MIN);
+        PRINT_SAUT_LIGNE;
+    }
+
+    //--- affichage de valeur de certains caractère spéciaux ---//
+    Conv_Char_Num(CHAR_RETOUR_CHARIOT);     // retiour chariot
+    PRINT_SAUT_LIGNE;
+}
+

+ 128 - 0
display.h

@@ -0,0 +1,128 @@
+//-----------------------------------------------------------------------------------//
+// Nom du projet 		    : Langage_C_fixme
+// Nom du fichier 		    : display.h
+// Date de création 	    : 25.02.2015
+// Date de modification     : 23.10.2017
+//
+// Auteur 				    : Philou (Ph. Bovey)
+//
+// Description              : fichier de type header file pour toutes les fonctions
+//                            liées à l'afficahge
+//
+//
+// Remarques 			    : lien pour la table ASCII :
+// 						    -> http://www.asciitable.com/
+// 						     lien pour la saisie de clavier avec getc & getchar pour ne pas
+//                           avoir des erreurs d'interprétation
+// 						    -> http://fr.openclassrooms.com/informatique/cours/utiliser-les-bonnes-fonctions-d-entree
+// 						     lien vers différents
+// 						    -> http://fr.wikipedia.org/wiki/String.h
+//----------------------------------------------------------------------------------//
+#ifndef DISPLAY_H_INCLUDED
+#define DISPLAY_H_INCLUDED
+//--- librairie associée ---//
+#define _CRT_NONSTDC_NO_WARNINGS
+
+//--- constante ou définition ---//
+#define CHOIX_BAS               66          // représente B en caractère
+#define CHOIX_DROITE            68          // représente D en caractère
+#define CHOIX_ENTIER            73          // représente I en caractère
+#define CHOIX_EXIT              69          // représente E en caractère
+#define CHOIX_FLOTTANT          70          // représente F en caractère
+#define CHOIX_GAUCHE            71          // représente G en caractère
+#define CHOIX_HAUT              72          // représente H en caractère
+#define CHOIX_MENU              77          // représente M en caractère
+#define CHOIX_MENU_PRINCIPAL    80          // représente P en caractère
+#define CHOIX_PLEINS            80          // représente P en caractère
+#define CHOIX_VIDE              86          // représente V en caractère
+#define LIMITE_ETOILE_MIN		1			// nb d'étoile min que l'on peut afficher
+#define LIMITE_ETOILE_MAX		15			// nb d'étoile min que l'on peut afficher
+#define LIMITE_NB_MAX			10			// limite d'un nombre entier 
+#define LIMITE_NB_MIN			-10			// limite d'un nombre entier 
+#define MAX_CARA                80          // largeur d'une fenêtre DOS
+
+#define PRINT_SAUT_LIGNE			printf("\n")
+#define PRINT_ESPACE				printf(" ")
+#define PRINT_ETOILE				printf("*");
+#define PRINT_M_MENU				printf("MENU : ")
+#define PRINT_SELECTION_ABSCISSE	printf("Entrer Valeur entiere entre %d et %d", LIMITE_AXE_X_MIN, LIMITE_AXE_X_MAX)
+#define PRINT_SELECTION_CHAR		printf("Veuillez taper un caractere :")
+#define PRINT_SELECTION_CHOIX		printf("Veuillez Selectionner votre choix : ")
+#define PRINT_SELECTION_FLOAT		printf("Voulez-vous travailler en flottant - taper 'F' ")
+#define PRINT_SELECTION_GD			printf("Veuillez choisir entre Gauche[G] et Droite[D] : ")
+#define PRINT_SELECTION_HB			printf("Veuillez choisir entre Haut[H] et Bas[B] : ")
+#define PRINT_SELECTION_INT			printf("Voulez-vous travailler en entier   - taper 'I' ")
+#define PRINT_SELECTION_MENU		printf("Veuillez Selectionner votre Menu : ")
+#define PRINT_SELECTION_NB			printf("Indiquer un nombre : ")
+#define PRINT_SELECTION_ORDONNEE	printf("Entrer Valeur entiere entre %d et %d", LIMITE_AXE_Y_MIN, LIMITE_AXE_Y_MAX)
+#define PRINT_SELECTION_PV			printf("Veuillez choisir entre Plein [P] et Vide [V] : ")
+
+#define NAME_M_ADITION                  "ADITION"
+#define NAME_M_AFFICHAGE                "AFFICHAGE"
+#define NAME_M_ARITHEMTIQUE             "ARITHMETIQUE"
+#define NAME_M_ASTUCE_PRINTF            "ASTUCE PRINTF"
+#define NAME_M_ASTUCE_INCR              "ASTUCE INCREMENTATION & DECREMENTATION"
+#define NAME_M_ASTUCE_CONV_CHAR_NUM     "ASTUCE CONVERSION CARACTERE NUMERIQUE - TABLE"
+#define NAME_M_ASTUCE_LOOP              "ASTUCE BOUCLE"
+#define NAME_M_CALCUL_SEG_AB			"CALCUL SEGMENT POINT_A(x,y) - POINT_B(x,y)"
+#define NAME_M_CONV                     "CONVERSIONS"
+#define NAME_M_CONV_CHAR_NUM            "CONVERSION CARACTERE EN NUM (DEC - HEXA)"
+#define NAME_M_CONV_NUM_CHAR            "CONVERSION NUMERIQUE EN CARACTERE"
+#define NAME_M_CONV_NUM_OCT_HEX         "CONVERSION NUMERIQUE EN OCTAL - HEXA"
+#define NAME_M_DIVISION                 "DIVISION"
+#define NAME_M_DISP_CARRE               "AFFICHAGE DE CARRE"
+#define NAME_M_DISP_LOSANGE             "AFFICHAGE DE LOSANGE"
+#define NAME_M_DISP_PARALLELOGRAMME     "AFFICHAGE DE PARALLELOGRAMME"
+#define NAME_M_DISP_TRIANGLE            "AFFICHAGE DE TRIANGLE"
+#define NAME_M_MULTIPLICATION           "MULTIPLICATION"
+#define NAME_M_OP_SIMPLE                "OPERATION SIMPLE"
+#define NAME_M_PRINICIPAL               "PRINCIPAL"
+#define NAME_M_SOUSTRACTION             "SOUSTRACTION"
+
+//--- déclaration de variable global ---//
+extern char var_retour;
+
+//--- déclaration de prototype ---//
+//--- liée au fichier template_menu.c ---//
+void Template_Menu_Ligne(void);                         //-> affiche un trait d'*
+void Template_Display_Menu(char choix_menu);            //-> affiche le titre dans lequel se trouve le user et sélectionne le menu choisi
+void Template_Choix_Menu_Principal(void);               //-> affiche le menu principal pour le user
+
+//--- liée au fichier template_menu_arithm.c ---//
+void Template_Display_Menu_Arithm(char choix_menu);     //-> affiche le titre dans lequel se trouve le user et sélectionne le menu choisi
+void Template_Choix_Menu_Arithmetique(void);            //-> affiche le menu arithmetique
+void Template_Choix_Menu_OP_Simple(void);               //-> affiche le menu opération simple
+void Template_Choix_Menu_Conversion(void);              //-> affiche le menu Conversion
+void Template_Display_Menu_OP_Simple(char choix_menu);  //-> affiche le menu concernant les oérations simples
+void Template_Display_Menu_Conversion(char choix_menu); //-> affiche le menu concernant différentes conversions
+
+//--- liée au fichier template_menu_display.c ---//
+void Template_Choix_Menu_Display(void);                 //-> affichage de différents theme du menu display
+void Template_Display_Menu_Display(char choix_menu);    //-> affiche le titre dans lequel se trouve le user et sélectionne le menu choisi
+
+//--- liée au fichier selection_user.c ---//
+char Selection_Menus(char choix_selection_msg);         //-> permet de récuprer une valeur entrer par l'utilisateur
+char Select_Var_Cara(void);                             //-> récupère un caractère fournis par un utilisateur
+char Select_Option(void);                               //-> permet à l'utilisteur de choisir entre deux options
+float Select_Var_Flottant(void);                        //-> récupère une chaine de caractère et la transforme en floattant
+int Select_Var_Entier(int limiteMax, int limiteMin);    //-> récupère une châine de chaîne de caractère et le transforme en entier avec controle de limite 
+
+//--- lié au fichier help.c ---//
+void Help_Printf(void);                                 //-> affiche une aide sur le printf
+void Help_Loop(void);                                   //-> effect visuel avec des boucles itératives
+
+//--- liée au fichier affichage.c ---//
+void Triangle_Etoile_AGB(int nb_etoile);                            // permet d'afficher un triangle selon les datas du user
+void Triangle_Etoile_AGH(int nb_etoile);
+void Triangle_Etoile_ADB(int nb_etoile);
+void Triangle_Etoile_ADH(int nb_etoile);
+void Carre(int val_user);                                           // afficher un carré plein d'étoiles
+void Parallelogramme_AG(int val_user);                              // affiche un parallelogramme avec l'angle a gauche
+void Parallelogramme_AD(int val_user);                              // affiche un parallelogramme avec l'angle a droite
+void Choix_Emplacement_Triangle(char choix_HB, char choix_GD);      // definit quel dessin de traingle afficher selon le user
+void Losange_Vide(void);                                            // affiche un losange entouré d'étoile
+void Losange_Plein(void);                                           // affiche un losange remplit d'étoile
+void Selection_Losange (char choix_user);                           // selectionne un losange vide ou plein
+void Selection_Sens_Paralelogramme(char choix_user);                // choix pour l'affichage d'un parallelogramme (angle droite ou gauche)
+
+#endif // DISPLAY_H_INCLUDED