Projet de programmation la conversion entre les bases

1
Encadrement : Mr Bendiaf Mokthar. mehdi22mabrouk@gmail.com
La Programmation est un art soyez alors des artistes….
Projet 3ème
Sciences de l’informatique 01…
Année Scolaire
2009/2010
Mahdhi
Mabrouk
Algorithmique
&
Programmation
La conversion entre les bases.
Le projet est réalisé par Mahdhi Mabrouk.

2
Dédicaces
Je dédis ce travail :
A
Ma Famille :
Mon père Nacer, Ma mère Zina, Mes frères et Mes sœurs.
A
Mes Profs :
Mr A. Taher, Mr B. Mokthar, Mr M. Houssam, Mr T. Tawfik, Mr
Ch. Nouredin, Mr Ch. Fathi, Mr M. Imed, Mr M. Riad, Me H.
Houda, Mle D. Warda, Mle E. Fathila et Mle R. Amel.
A
La direction du Lycée. & aux profs : Mr S. Mohamed, Mr J.
Fathi, Mr S. Khalil, Mr Hamza, Mr F. Jamel, Mr A. Jamel, Mr
D. Nouredin et Mr chrih.
A
Mes collègues de classe.
A
Mon ami : Chouat Amor.
A
Mes amis :
Yahya Mohamed, Oussama, Yossri, Yassin, S. Khaled, B. Salah,
H. Imed et Ch. Salah.
A
Mes amies :
H. Raouia, K. Noujoud, M. Souad, G. Olfa, k. Asma et Rim.
**
25.289.559

3
Sommaire
I- Introduction ………………………………………………………………………………………4
II- Les menus : Menu Informations ………………………………………4
Menu Général …………………………………………………5
Menu Conversion ……………………………………………5
Menu Quitter …………………………………………………7
III- Les fonctions :………………………………………………………………………………8
1- FN « conv_bin_et_oct »……………………………………………8
2- FN « conv_hex »…………………………………………………………8
3- FN « convert » ……………………………………………………………9
4- FN « conv_hex_dec »…………………………………………………9
5- FN « conv_bin_oct » …………………………………………………10
6- FN « conv_bin_hex »…………………………………………………10
7- FN « conv_oct_bin » …………………………………………………10
8- FN « conv_hex_bin » …………………………………………………10
9- FN « conv_oct_hex » …………………………………………………11
10- FN « conv_oct_hex » …………………………………………………11
IV- Les procédures :……………………………………………………………………………11
1- Proc « conversions » ……………………………………………………11
2- Proc « menu_secondaire » …………………………………………12
3- Proc « baybay » ……………………………………………………………14
4- Proc « menu_general »…………………………………………………15
5- Proc « informations » …………………………………………………16
6- Procédures de saisie……………………………………………………17
a- Proc « saisir_bin » …………………………………17
b- Proc « saisir_oct » …………………………………17
c- Proc « saisir_dec » …………………………………18
d- Proc « saisir_hex » …………………………………18

4
I- Introduction :
Dans ce projet vous trouverez les algorithmes des fonctions & celles des procédures qui
permettent, chacune avec son rôle, la conversion des entiers entre les bases.
Exemples : (123)10=(1111011)2. (127)8=(57)16. (110111101)2=(1BD)16=(445)10.
En général : Si (base=2) alors
- Conversion vers base 8.
Sinon Si (base=8) alors
Sinon Si (base=10) alors
Sinon
Fin si.
II- Les menus :
1°/ Menu « informations » :
* L’utilisateur tape son Prénom dans la zone A, puis automatiquement le curseur se
déplacera vers la zone B, dont l’utilisateur choisira la langue.
A
B

5
2°/ Menu « Général » (M.G) :
On suppose que le prénom de l’utilisateur est « Noujoud » et la langue est «Français ».
* Dans la zone A, "Noujoud" choisira le numéro équivalant au nombre qu’elle va le convertir
à une autre base.
* Pour la suite, on suppose que "Noujoud" a choisi la base 16 (elle a saisi le numéro 4).
3°/ Menu « conversion » (M.C) :
* Un autre menu se paraît après la dernière saisie. (Menu de conversion).
* "Noujoud" a saisi l’entier 125, dans la base 16, et elle a voulu le convertir vers la base 8
puisqu’elle a choisi 2 comme indique la zone C.
A
B
C

6
* lors de la conversion, un pourcentage virtuel (zone D) se paraît comme indique la figure
suivante :
* L’utilisateur doit attendre jusqu’au pourcentage soit 100%. (Figure suivante).
* En fin, le résultat se paraît au-dessous comme l’indique la figure suivante :
* Dans la zone F, "Noujoud" a trouvé le résultat [(125)16=(445)8].
* Dans la zone G, elle a saisi un caractère quelconque pour retourner au menu général.
D
F
G

7
4°/ Menu « Quitter » (M.Q) :
* Au M.G encor une fois, l’utilisateur peut réutiliser le programme pour une autre
conversion avec une nouvelle base et un autre entier.
* Ainsi qu’il peut quitter l’application tout en choisir le numéro 5. Comme suivant :
* Alors le programme finit l’application tout en affichant successivement :
Fin application
Fin application.
Fin application..
Fin application…
Comme suivant :

8
III- Les Fonctions :
1°/ Fonction « conv-bin-et-oct » :
(* Fonction conv_bin_et_oct (permet la conversion de Décimal ---> binaire ou la conversion
de Décimal ---> octal *)
2°/ Fonction « conv_hex» :
(* Fonction conv_hex (Décimal ---> hexadécimal) *)
a- Spécification :
Résultat : conv_bin_et_oct ch.
Traitements :
[ch1, ch ""]=Répéter
R d mod base
convch(r,ch1)
ch ch1+ch
d d div base
Jusqu’à (d=0)
[d,e]= valeur(nb,d,e). T.D.O.L
Objet Type
R, e Entier.
d Entier Long.
Ch, ch1 Chaîne.
b- Algorithme :
0) fonction conv_bin_et_oct(nb: chaîne;
base :entier):chaîne;
1) valeur (nb, d, e)
2) ch ''"
3) Répéter
R d mod base
convch(r,ch1)
ch ch1+ch
d d div base
Jusqu’à (d=0)
4) conv_bin_et_oct ch
5) fin conv_bin_et_oct.
a- Spécification :
Résultat : conv_hex ch.
Traitements :
[ch ""]=Répéter
Si (d mod 16 dans [1..9]) alors
Ch chr(d mod 16 +48)+ch
Si non Ch chr(d mod 16 +55)+ch
Fin Si.
d d div base
Jusqu’à (d=0)
[d,e]= valeur(nb,d,e).
T.D.O.L
Objet Type
R, e Entier.
d Entier Long.
Ch Chaîne.
b- Algorithme :
0) fonction conv_hex (nb: chaîne):chaîne
1) valeur (nb, d, e)
2) ch ''"
3) Répéter
Si (d mod 16 dans [1..9]) alors
Si non
Fin Si.
d d div base
Jusqu’à (d=0)
4) conv_hex ch
5) fin conv_hex.

9
3°/ Fonction « convert» :
(* Fonction convert (permet la conversion de binaire --> décimal ou la conversion de
Octal --> décimal *)
4°/ Fonction « conv_hex_dec» :
(* Fonction conv_hex_dec (permet la conversion de hexadécimal --> décimal *)
a- Spécification :
Résultat : convert ch1.
Traitements : convch(nb,ch1)
[nb 0, a 1]=
Pour i de long(ch) à 1 (pas -1) faire
valeur(ch[i],d,e)
nb nb+d*a
a a*base
Fin Pour.
T.D.O.L
Objet Type
d, e ,i Entier.
Nb, a Entier Long.
ch1 Chaîne.
b- Algorithme :
0) fonction convert(base:entier; ch: chaîne)
:chaîne;
1) nb 0 ; a 1
2) Pour i de long(ch) à 1 (pas -1) faire
valeur(ch[i],d,e)
nb nb+d*a
a a*base
Fin Pour.
4) convert ch1
5) fin convert.
a- Spécification :
Résultat : convert ch1.
Traitements : convch(nb,ch)
[nb 0, a 1]=
Pour i de long(ch) à 1 (pas -1) faire
Si (ch[i] dans ["A".."F"]) alors
Nb nb+(ord(ch[i])-55)*a
a a*16
Si non valeur(ch[i],d,e)
Nb nb+d*a
A a*16
Fin si
Fin Pour.
T.D.O.L
Objet Type
i, e Entier.
d, nb, a Entier Long.
b- Algorithme :
0) fonction conv_hex_dec(ch:chaîne):chaîne
1) nb 0; a 1
2) Pour i de long(ch) à 1 (pas-1) faire
Si (ch[i] dans ["A".."F"]) alors
Nb nb+(ord(ch[i])-55)*a
a a*16
Si non valeur(ch[i],d,e)
Nb nb+d*a
A a*16
Fin si
Fin Pour.
3) convch(nb,ch)
4) conv_hex_dec ch
5) Fin conv_hex_dec.

10
5°/ Fonction « conv_bin_oct» :
(* Fonction conv_bin_oct (permet la conversion de binaire --> Octal *)
6°/ Fonction « conv_bin_hex» :
(* Fonction conv_bin_hex (permet la conversion de binaire --> Hexadécimal *)
7°/ Fonction « conv_oct_bin» :
(* Fonction conv_oct_bin (permet la conversion de Octal --> binaire) *)
8°/ Fonction « conv_hex_bin» :
(* Fonction conv_hex_bin (permet la conversion de Hexadécimal --> binaire) *)
9°/ Fonction « conv_oct_hex» :
(* Fonction conv_oct_hex (permet la conversion de Octal --> Hexadécimal) *)
a- Spécification :
Résultat :
conv_bin_oct FN conv_bin_et_oct(ch,8)
Traitements :
[ch]= ch FN convert(2,ch)
b- Algorithme :
0) fonction conv_bin_oct(ch:chaîne):chaîne
1) ch FN convert(2,ch)
2) conv_bin_oct FN conv_bin_et_oct(ch,8)
3) Fin conv_bin_oct.
a- Spécification :
Résultat :
conv_bin_hex FN conv_hex(ch)
Traitements :
b- Algorithme :
0) fonction conv_bin_hex(ch:chaîne):chaîne
2) conv_bin_hex FN conv_hex(ch)
3) conv_bin_hex.
a- Spécification :
Résultat :
conv_oct_bin FN conv_bin_et_oct(ch,2)
Traitements :
b- Algorithme :
0) fonction conv_oct_bin(ch:chaîne):chaîne
2) conv_oct_bin FN conv_bin_et_oct(ch,2)
3) conv_oct_bin.
a- Spécification :
Résultat :
conv_hex_bin FN conv_bin_et_oct(FN
conv_hex_dec(ch),2)
b- Algorithme :
0) fonction conv_hex_bin (ch:chaîne):chaîne
1) conv_hex_bin FN conv_bin_et_oct(FN
conv_hex_dec(ch),2)
2) conv_hex_bin.

11
10°/ Fonction « conv_oct_hex» :
(* Fonction conv_hex_oct (permet la conversion de Hexadécimal --> Octal) *)
IV- Les Procédures :
[Pour les procédures on va donner seulement les algorithmes (en pascal)
puisqu’elles sont un peut longs].
1°/ Procédure « conversions » :
(*procedure forme *)
procedure forme(lg:char);
begin
clrscr; writeln; writeln;
case lg of
'F':begin
writeln(' Saisir votre nombre en base :');
writeln(' ********************************************************');
writeln(' * Menu de conversion de la base vers les autres bases *');
writeln(' *---------------------------------------------------------------------------------------*');
writeln(' * *');
writeln(' * 1) Conversion vers base . *');
writeln(' * *');
writeln(' *---------------------------------------------------------------------------------------*');
writeln(' *---------------------------------------------------------------------------------------*');
writeln(' * *');
writeln(' * Donner votre choix : *');
a- Spécification :
Résultat :
conv_oct_hex FN conv_hex(FN
convert(8,ch))
b- Algorithme :
0) fonction conv_oct_hex(ch:chaîne):chaîne
1) conv_oct_hex FN conv_hex(FN
convert(8,ch))
2) conv_oct_hex.
a- Spécification :
Résultat :
conv_hex_oct FN conv_bin_et_oct(FN
conv_hex_dec(ch1),8)
b- Algorithme :
0) fonction conv_oct_hex(ch:chaîne):chaîne
1) conv_hex_oct FN conv_bin_et_oct(FN
conv_hex_dec(ch1),8)
2) conv_oct_hex.

12
writeln(' * *');
writeln(' **********************************************************');
end;
'A':begin
writeln(' Enter your nombre in ( ) :');
writeln(' ********************************************************');
writeln(' * Menu of conversion from ( ) to other bases .. *');
writeln(' *----------------------------------------------------------------------------------------*');
writeln(' * *');
writeln(' * 1) Conversion to base. *');
writeln(' * *');
writeln(' *----------------------------------------------------------------------------------------*');
writeln(' *----------------------------------------------------------------------------------------*');
writeln(' * *');
writeln(' * Enter your choice : *');
writeln(' * *');
writeln(' *********************************************************');
end;
end;
end;
2°/ Procédure « menu_secondaire » :
(* procedure menu_secondaire (permet d'afficher les menus secondaires et faire les
conversions) *)
procedure menu_secondaire(base:integer; lg:char);
var i,m,j,ch_sec,ch_g:integer; car:char;
begin
forme(lg);
gotoxy(43,3);write(base);
gotoxy(43,5);write(base);
case base of
2:begin
gotoxy(47,8);write('8');
saisir_bin(nb);
end;
8:begin

13
gotoxy(50,3);saisir_oct(nb);
end;
10:begin
gotoxy(50,3);saisir_dec(nb);
end;
16:begin
gotoxy(50,3);saisir_hex(nb);
end;
end;
repeat
gotoxy(49,15);write(' ');
gotoxy(49,15);readln(ch_sec);
until(ch_sec in [1..3]);
conversions(lg);
case lg of
'F':begin
gotoxy(1,18);writeln(' ***************************************************');
gotoxy(1,19);writeln(' * Le résultat est : *');
gotoxy(1,20);writeln(' *-------------------------------------------------------------------------------*');
gotoxy(1,21);writeln(' * Taper un autre caractère pour retourner au M.G : *');
gotoxy(1,22);writeln(' ***************************************************');
end;
'A':begin
gotoxy(1,18);writeln(' ***************************************************');
gotoxy(1,19);writeln(' * The result is : *');
gotoxy(1,20);writeln(' *------------------------------------------------------------------------------*');
gotoxy(1,21);writeln(' * Enter an other char in order to return : *');
gotoxy(1,22);writeln(' ***************************************************');
end;
end;

14
case base of
2:begin
case ch_sec of
1:begin
gotoxy(37,19);write(conv_bin_oct(nb));
end;
2:begin
gotoxy(37,19);write(convert(2,nb));
end;
3:begin
gotoxy(37,19);write(conv_bin_hex(nb));
end;
end;
end;
8:begin
case ch_sec of
1:begin
gotoxy(37,19);write(conv_oct_bin(nb));
end;
2:begin
gotoxy(37,19);write(convert(8,nb));
end;
3:begin
gotoxy(37,19);write(conv_oct_hex(nb));
end;
end;
end;
10:begin
case ch_sec of
1:begin
gotoxy(37,19);write(conv_bin_et_oct(nb,2));
end;
2:begin
gotoxy(37,19);write(conv_bin_et_oct(nb,8));
end;
3:begin
gotoxy(37,19);write(conv_hex(nb));
end;
end ;
end ;
16:begin
case ch_sec of
1:begin
gotoxy(37,19);write(conv_hex_bin(nb));
end;
2:begin
gotoxy(37,19);write(conv_hex_oct(nb));
end;
3:begin
gotoxy(37,19);write(conv_hex_dec(nb));
end;
end;
end;
end;
gotoxy(62,21);readln(car);
end;
3°/ Procédure « baybay» :
(* Procedure baybay *)
procedure baybay;
var k:integer; p:longint;
begin
clrscr;
gotoxy(30,15);write('Fin application');
k:=0;
repeat
p:=0;
repeat
p:=p+1;
until (p=199999999);
gotoxy(45+k,15);write('.');
k:=k+1;
until(k=3);
end;

15
4°/ Procédure « Menu_general» :
(*Procedure Menu_general : Permet d'afficher le menu général et de retourner la base à
convertir *)
Procedure Menu_general(var ch_g,base:integer; lg:char;prenom:string);
var nb:string; car:char;
begin
Clrscr;
case lg of
'F':begin
writeln;
writeln(' ******************************************************');
writeln(' * Bienvenu *');
writeln(' A *******************************************************');
writeln(' N * *');
writeln(' N * 1) Saisir un nombre dans la base 10. *');
writeln(' E * 2) Saisir un nombre dans la base 2. *');
writeln(' E * 3) Saisir un nombre dans la base 8. *');
writeln(' * 4) Saisir un nombre dans la base 16. *');
writeln(' S * 5) Quitter... *');
writeln(' C * *');
writeln(' O *-------------------------------------------------------------------------------------*');
writeln(' L *-------------------------------------------------------------------------------------*');
writeln(' A * *');
writeln(' I * Donner votre choix : *');
writeln(' R * *');
writeln(' E * *');
writeln(' *******************************************************');
writeln(' 2');
writeln(' 0 *******************************************************');
writeln(' 1 * Ce programme est réalisé par Mahdhi Mabrouk . *');
writeln(' 0 *******************************************************');
end;
'A':begin
writeln;
writeln(' *******************************************************');
writeln(' * Wellcome *');
writeln(' *******************************************************');
writeln(' S * *');
writeln(' C * 1) Enter your nomber in "10" base. *');
writeln(' H * 2) Enter your nomber in "2" base. *');
writeln(' O * 3) Enter your nomber in "8" base. *');

16
writeln(' O * 4) Enter your nomber in "16" base. *');
writeln(' L * 5) Exit... *');
writeln(' S * *');
writeln(' *----------------------------------------------------------------------------------------*');
writeln(' Y *----------------------------------------------------------------------------------------*');
writeln(' E * *');
writeln(' A * Enter your choice : *');
writeln(' R * *');
writeln(' * *');
writeln(' 2 *********************************************************');
writeln(' 0');
writeln(' 1 *********************************************************');
writeln(' 0 * This program made by Mahdhi Mabrouk. *');
writeln(' *********************************************************');
end;
end;
gotoxy(32,3);write(prenom);
repeat
gotoxy(43,15);read(ch_g);
until (ch_g>=1)and(ch_g<=5);
case ch_g of
1:menu_secondaire(10,lg);
5:begin
baybay;
donewincrt;
end;
end;
Menu_general(ch_g,base,lg,prenom);
end;
5°/ Procédure « informations» :
procedure informations(var prenom:string; var langue:char);
var c:integer;
begin
clrscr;
writeln;
writeln;
writeln(' A propos l"utilisatreur ....');
writeln(' ********************************************************');
writeln(' * Saisir votre Prénom S.V.P [<=15] : *');
writeln(' *----------------------------------------------------------------------------------------*');
writeln(' * *');
writeln(' * Saisir le numéro équivalant à votre langue : *');

17
writeln(' * *');
writeln(' * 1) Français. *');
writeln(' * 2) Anglais. *');
writeln(' * *');
writeln(' *------------------------------------------------------------------------------------------*');
writeln(' *------------------------------------------------------------------------------------------*');
writeln(' * Donner votre choix : *');
writeln(' * *');
writeln(' **********************************************************');
6°/ les Procédures de saisie :
a- Procédure « saisir_bin » :
(* procedure saisir_bin (permet Saisir un nbre binaire ) *)
Procedure saisir_bin(var nb:string);
var i:integer; test:boolean;
begin
repeat
gotoxy(50,3);readln(nb);
i:=0;
repeat
i:=i+1;
test:=nb[i]in['1','0'];
until (not test) or (i=length(nb));
until(test);
end;
b- Procédure « saisir_oct » :
(* procedure saisir_oct (permet Saisir un nbre Octal ) *)
Procedure saisir_oct(var nb:string);
begin
repeat
i:=0;
repeat
i:=i+1;
test:=nb[i]in['0'..'7'];
until(test);
end;

Encadrement
c- Procédure «
(* procédure saisir_dec (permet Saisir un nombre décimal ) *)
Procedure saisir_dec(var nb:string);
var d,e:integer;
begin
repeat
val(nb,d,e);
until(d>0);
end;
d- Procédure «
(* procedure saisir_hex (permet Saisir un nombre Hexadécimal ) *)
Procedure saisir_hex (var nb:string);
begin
repeat
i:=0;
repeat
i:=i+1;
test:=upcase(nb[i])in['0'..'9','A'..'F'];
until (not test) or
until(test);
for i:=1 to length(nb) do
nb[i]:=upcase(nb[i]);
end;
Encadrement : Mr Bendiaf Mokthar. mehd
Procédure « saisir_dec » :
(* procédure saisir_dec (permet Saisir un nombre décimal ) *)
Procedure saisir_dec(var nb:string);
var d,e:integer;
val(nb,d,e);
Procédure « saisir_hex » :
Procedure saisir_hex (var nb:string);
test:=upcase(nb[i])in['0'..'9','A'..'F'];
for i:=1 to length(nb) do
nb[i]:=upcase(nb[i]);
18
mehdi22mabrouk@gmail.com

Encadrement
V- Remarques du prof
0) Début remarques_prof
1) Proc aff_forme
2) Ecrire("Saisir vos remarques S.V.P Mr
3) Ecrire("Merci mon meilleur Prof…")
4) Fin remarques_prof.
T.D.O.G
Objet
remarques
* Lors de l’exécution
Encadrement : Mr Bendiaf Mokthar. mehd
Remarques du prof :
Début remarques_prof
Proc aff_forme
Ecrire("Saisir vos remarques S.V.P Mr :") ;lire(remarques)
Ecrire("Merci mon meilleur Prof…")
Fin remarques_prof.
Type
Mots d’or.
* Lors de l’exécution :
19
mehdi22mabrouk@gmail.com

20

Projet de programmation la conversion entre les bases

Contenu connexe

Tendances

En vedette

Similaire à Projet de programmation la conversion entre les bases

Plus de Tunisie collège

Projet de programmation la conversion entre les bases