Convertisseur décimal/binaire/hexadécimal

Soyez le premier à donner votre avis sur cette source.

Vue 62 415 fois - Téléchargée 1 517 fois

Description

Le titre résume tout ! C'est simplement un petit convertisseur de décimal/binaire/hexadécimal.
Par contre les classes sont mal organisés, c'était juste histoire de pas avoir des fonctions qui trainaient de partout...

Source / Exemple :


namespace convertion
    {

        /// <summary>
        /// classe regroupant tout ce qui concerne le passage du décimal au binaire ou l'inverse
        /// </summary>
        public class decimal_binaire
        {
            /// <summary>
            /// renvoie le chiffre binaire correspondant a l'entier passé en paramètre
            /// </summary>
            /// <param name="dec">dec est le chiffre décimal (base 10) que l'on veut convertir</param>
            /// <returns>retourne le chiffre binaire</returns>
            public static string convDecBin(int dec)
            {

                string res = "";
                int div;
                int i;

                do
                {

                    div = 0;
                    i = dec;

                    while (i != 1 && i != 0)
                    {
                        i -= 2;
                        div += 1;
                    }

                    res = Convert.ToString(dec - (2 * div)) + res;
                    dec = div;

                }
                while (dec != 0);

                return res;
            }

            /// <summary>
            /// convertit un nombre binaire en décimal
            /// </summary>
            /// <param name="binar">nombre binaire à convertir</param>
            /// <returns>le nombre décimal convertit</returns>
            public static int convBinDec(string binar)
            {
                int taille = binar.Length;
                int puissance = taille - 1;
                int soustotal;
                int total = 0;

                if (binar == "1")
                { total = 1; }
                else
                {
                    if (binar == "0")
                    { total = 0; }
                    else
                    {

                        for (int i = 0; i < taille; i++)
                        {
                            if ((puissance >= 0) && (binar[i] == '1'))
                            {

                                soustotal = maths.puissance(2, puissance);

                                puissance -= 1;
                                total += soustotal;

                            }
                            else
                            {
                                puissance -= 1;
                            }

                        }
                    }

                }
                return total;
            }
        }

            /// <summary>
            /// classe regroupant tout ce qui concerne le passage du binaire à l'hexadécimal ou l'inverse
            /// </summary>
            public class binaire_hexadecimal
            {

                /// <summary>
                /// convertit un nombre binaire en hexadécimal
                /// </summary>
                /// <param name="binar">nombre binaire</param>
                /// <returns>nombre hexadécimal</returns>
                public static string convBinHex(string binar)
                {
                    string hexa = "";
                    int taille=binar.Length;
                    int nb;
                    string bin;
                    int dec;
                    int j =0;
                    int zero = taille % 4;

                    if (zero > 0)
                    {
                        for (int k = 1; k <= (4 - zero); k++)
                        {
                            binar = "0" + binar;
                        }
                    }
                    if (taille > 4) 
                    { nb = (taille / 4)+1; }
                    else
                    { nb = 1; }

                    for (int i = 1; i <= nb; i++)
                    {
                        bin = "";
                        bin += binar.Substring(j,4);
                        j +=4;
                        
                        dec=decimal_binaire.convBinDec(bin);
                        switch (dec)
                        {
                            case 10: hexa += "A";
                                break;

                            case 11: hexa += "B";
                                break;

                            case 12: hexa += "C";
                                break;

                            case 13: hexa += "D";
                                break;

                            case 14: hexa += "E";
                                break;

                            case 15: hexa += "F";
                                break;

                            default: hexa += dec;
                                break;
                        }
                    }
                    
                    return hexa;
                }

                /// <summary>
                /// convertit un nombre Hexadécimal en binaire
                /// </summary>
                /// <param name="Hex">nombre Hexadécimal</param>
                /// <returns>nombre binaire</returns>
                public static string convHexBin(string Hex)
                {
                    string hexa;
                    string bin;
                    string binaire = "";
                    int taille = Hex.Length;

                    for (int i = 0; i < taille; i++)
                    {
                        hexa = Convert.ToString(Hex[i]);

                        bin = "";
                        switch (hexa)
                        {
                            case "A": bin += decimal_binaire.convDecBin(10);
                                break;

                            case "B": bin += decimal_binaire.convDecBin(11);
                                break;

                            case "C": bin += decimal_binaire.convDecBin(12);
                                break;

                            case "D": bin += decimal_binaire.convDecBin(13);
                                break;

                            case "E": bin += decimal_binaire.convDecBin(14);
                                break;

                            case "F": bin += decimal_binaire.convDecBin(15);
                                break;

                            default: bin += decimal_binaire.convDecBin(Convert.ToInt32(hexa));
                                break;
                        }
                        if (bin.Length < 4)
                        {
                            for (int j = bin.Length; j < 4; j++)
                            {
                                bin = "0" + bin;
                            }
                        }
                        bin += " ";
                        binaire += bin;
                    }
                    
                    return binaire;
                }
            }

        /// <summary>
            /// classe regroupant tout ce qui concerne le passage du décimal à l'hexadécimal ou l'inverse
        /// </summary>
        public class decimal_hexadecimal
        {

            /// <summary>
            /// convertit un chiffre décimal en Hexadécimal
            /// </summary>
            /// <param name="dec">décimal à convertir</param>
            /// <returns>nombre Hexadécimal</returns>
            public static string convDecHex(int dec)
            {
                return binaire_hexadecimal.convBinHex(decimal_binaire.convDecBin(dec));
            }

            /// <summary>
            /// convertit un nombre Hexadécimal en décimal
            /// </summary>
            /// <param name="hex">hexadécimal à convertir</param>
            /// <returns>nombre décimal</returns>
            public static int convHexDec(string hex)
            {
                return decimal_binaire.convBinDec(binaire_hexadecimal.convHexBin(hex).Replace(" ",""));
            }

        }
    }

Codes Sources

A voir également

Ajouter un commentaire

Commentaires

Messages postés
3
Date d'inscription
mercredi 14 juin 2006
Statut
Membre
Dernière intervention
12 août 2011

Heu salut sympa ton code il aide vraiment.

Par contre y a juste un truc que j'ai pas compris, c'est au niveau de :
# if (taille > 4)
# { nb = (taille / 4)+1; }

je vois pas pourquoi tu fait le +1. et en faite chez moi si je met ton +1, l'appli plante quand j'essaie de convertir "00000000" en Hexa (c'est pour l'exemple bien sur)
et donc si je met pas le +1 il passe.
par contre sur un décimal a convertir en Hexa du genre "8848613" en hexa donne 3AB9A5, et sans le +1 il manque le 5 à la fin. Je pense que ça viens de ce +1.
Mais j'avoue que je ne vois pas trop la.
Messages postés
8
Date d'inscription
dimanche 20 novembre 2005
Statut
Membre
Dernière intervention
5 octobre 2008

Je savais avant de faire cette appli qu'il existait déjà des fonctions permettants de faire ces conversions, mais j'ai eu envie de le faire histoire de m'amuser pendant les cours...
Messages postés
5487
Date d'inscription
dimanche 4 août 2002
Statut
Modérateur
Dernière intervention
20 juin 2013
49
Conversion de base 10 à N et de N à 10 :
http://www.codyx.org/snippet_transformation-base_69.aspx
Messages postés
2
Date d'inscription
samedi 9 avril 2005
Statut
Membre
Dernière intervention
20 octobre 2006

Bonjour,
La méthode ToString avec le format "X" permet d'écrire n'importe quel type entier en hexadécimal. Par exemple:
int n = 1525;
string hexa = n.ToString("X");

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.