Exercice convertir entier base 10->16 16->10

Version imprimable

Bonjour à la communauté developpez :)
Alors voilà, j'essaie de faire un exercice mais je me retrouve bloqué. Le but étant à partir d'un vecteur et de mes connaissances de base en c++ plutôt médiocre, de faire un programme qui puisse convertir comme un grand un chiffre en base 10 vers une base 16 et l'inverse.
Dans un premier temps, j'ai essayé de produire quelque chose sous la forme d'un algorithme:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
Programme conversionBase1016
  //déclaration des variables du programme
  vecteur[10..15]: caractere
  choix: caractere
  calcule, poids, resultat, k, nb: entier
Debut
   ////on donne au vecteur les valeurs de la base 16 entre 10 et 15
  vecteur<-{"A","B","C","D","E","F"}
  choix<-"c"
  tantque choix <> "Q" et choix <> "q"
    //affichage du menu
    afficher "Conversion base 10 en base 16 (1)"
    afficher "Conversion base 16 en base 10 (2)"
    afficher "Quitter le programme (Q)"
 
    //conversion base 10 en base 16
    si choix = 1 alors
      resultat<-""
      afficher "Renter un nombre entier de base 10"
      saisir nb
      tanque nb <> 0 alors
        resultat<-gauche(str(nb mod 16)+resultat
        nb<-nb div 16
        pour k de 10 à 15
          si resultat = k alors
            resultat<-vecteur[k]
          finsi
        finpour
      fintantque
      afficher "Le nombre en base 16:"+resultat+
      sinon
        si choix = 2 alors
          calcule<-0
          afficher "Rentrer un nombre de base 16:"
          saisir nb
          taille<-taille(nb)
          //tantque nb contient toujours quelque chose
          tantque taille(nb)>0
            poids<-pow (16, taille-1)
            //exemple: si 'A' alors k=10; si 'B' alors k=11
            pour k de 10 à 15
              si extraire(nb,1,1)=vecteur[k] alors
                calcules<-poids*k
              sinon
                //Comme on ne se sert pas de k ici, on utilise val
                calcule<-poids*val(extraire(nb,1,1)
              finsi
            finpour
          fintanque
          afficher"Le nombre en base 10:"+calcule
        finsi
fin

En c++, j'ai quelque chose avec beaucoup d'erreurs et des problèmes aussi pour traduire/passer d'un algorithme à du c++.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
/*programme exo1
 * but: convertir base 10 et 16
 * auteur: Mario
 * Date 24/03/2015
*/
 
//Bibliothèques nécessaires au programme
#include <conio.h> //pour utiliser le 'getch'
#include <stdio.h> //permet d'utiliser 'printf' et 'scanf'
#include <math.h> //permet d'utiliser dans notre cas la fonction mathématique 'pow'
 
using namespace std;
 
int main()
{
	//déclaration des variables du programme
	//on choisis l'interval 10 et 15 par rapport à 'A' étant égale à 10 et 'F' à 15
	//on donne au vecteur les valeurs de la base 16 entre 10 et 15
	string vecteur[10.15] = {"A","B","C","D","E","F"};
 
	char choix;
	int calcule, poids, resultat, k, nb, taille;
 
 
 
 
 
	//on choisit une valeur quelconque qui n'est pas '1','2', ou 'Q'/'q' pour demarrer le programme
	choix = "c";
 
 
	while (choix != "Q" & choix != "q"){
		//affichage du menu du programme
		printf("Conversion base 10 en base 16(1):");
		printf("Conversion base 16 en base 10(2):");
		printf("Quitter le programme (Q):");
 
		//si 1 alors conversion base 10 en base 16
		if(choix = 1){
	          resultat =  ;
	          printf("Rentrer un nombre entier de base 10:");
	          scanf("%d", &nb);
 
	          while(nb != 0){
	             resultat = nb.substr(nb % 16)+resultat;
	             nb = (nb/16);
	             for(k=10 ; k<=15 ; k++){
	        	  if (resultat == k){
	        		 resultat = vecteur[k];
	        	  }
	           }
	      }
	      printf("Le nombre en base 16: %d ", &resultat);
 
	      }else{
		      if(choix = 2){
			calcule = 0;
			printf("Rentrer un nombre base 16:");
			scanf("%d", &nb);
 
			//tantque nb contient toujours quelque chose
			taille = nb.size();
			while (nb.size() > 0){
			      poids = pow(16, taille-1);
		              for(k=10; k<=15; k++){
 
			      //exemple: si 'A' alors k=10. Si 'F' alors k=15
		              if(extracte(nb,1,1)==vecteur[k]){
			        calcule=poids*k;
				  }else{
				          //comme on ne se sert pas de k ici, on utilise la fonction Val
					  calcule=poids*Val(extract(nb,1,1));
 
					 }
				 }
			   }
			   printf("Le nombre en base 10: %d ", &calcule);
			}
 
 
		}
    getch();
    return 0;
	}
 
}

Je suis conscient que ma logique est soit fausse ou très peu optimisée. Qu'il y a des erreurs (même trop) mais je suis ici pour avoir des conseilles et je suis pas la partie débutant :). Bonne journée

La base d'un entier est une question humaine:
dix = dix = dix. C'est à dire 10(décimal) = 012 (octal) = 0x0A (hexadécimal, deux digits majuscules partielles).

que tu comptes en base deux, dix ou 16, ceci:

Citation:

*****

est composé de cinq étoiles.

C'est un problème de notation, qui se résout donc à l'affichage.

Je vais pourrir ton exercice, je le sens.

Conversion 10 vers 16.
Code:

1 2 3 4 5 6 7 8 9 #include <iostream> #include <iomanip> int main() { long nombre; std::cout <<"choisissez un nombre entier:" << std::endl; std::cin >> std::dec >> nombre; std::cout << "sa notation hexadecimal est : " << std::hex << nombre << endl; return 0; }
Attention toutefois, std::dec et std::hex sont "définitifs", ils restent en vigueur jusqu'à ce qu'on en applique un autre.

Si tu tiens à le faire à la main, l'écriture d'un nombre dans une base se fait par division successive, mais à partir de la droite, ce qui est délicat.
L'astuce consiste à faire une liste (std::list) de char, chacun contenant une valeur, puis à convertir cette liste en chaine (std::string).

j'écrirais ainsi:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 char digit(int chiffre, unsigned int base) { assert(chiffre<base); assert(base>=2); if (chiffre<=10) return '0'+chiffre; if (chiffre<=36) return 'A'+chiffre; return '?'; } std::string base(long nombre, unsigned int base) { assert(base>=2); std::list<char> valeur; while (nombre>=base) { valeur.push_front( digit(nombre%base, base) ); nombre/=base; } valeur.push_front( digit(nombre, base) ); return std::string(valeur.begin(), valeur.end()); }

Concernant ton code:
Code:

1 2 3 4 5 /*programme exo1 * but: convertir base 10 et 16 * auteur: Mario * Date 24/03/2015 */
Bonne idée de placer une description en ouverture du fichier.
Code:

1 2 3 4 //Bibliothèques nécessaires au programme #include <conio.h> //pour utiliser le 'getch' #include <stdio.h> //permet d'utiliser 'printf' et 'scanf' #include <math.h> //permet d'utiliser dans notre cas la fonction mathématique 'pow'
en C++, on utilise les en-têtes C++, c'est à dire <cstdio> et <cmath>.
Il y a deux remarques à ce sujet.

Les en-têtes standards du C++ ne portent pas d'extension ".h".
Les en-tête standards commencant par un c signifie qu'ils sont hérités du C.

Il y a souvent une façon plus sure de faire en C++ "pur", par exemple, <iostream> remplace avantageusement <cstdio>.
Mais pas toujours: <cmath> n'a pas de remplaçant.

De plus, évite de mettre des en-têtes propriétaires avant ceux du langage.
En effet, si l'en-tête n'est pas parfaitement écrit, il pourrait polluer les autres.
conio n'est fourni que par windows, pas par le C++.
Code:

1 2 3 using namespace std; int main() {
Bonne signature du main.
Fais attention à ne jamais écrire using namespace std; dans un fichier d'en-tête.
Code:

1 2 3 4 5 //déclaration des variables du programme //on choisis l'interval 10 et 15 par rapport à 'A' étant égale à 10 et 'F' à 15 //on donne au vecteur les valeurs de la base 16 entre 10 et 15 string vecteur[10.15] = {"A","B","C","D","E","F"};
Ca, ca ne marche pas du tout. En C++ (comme en C), les tableaux commencent toujours à l'indice 0.
C'est dans le code qu'il faut faire de la gymnastique.
Par ailleurs, tu aurais intérêt peut-être à utiliser un char[], ou mieux un vector<char>, voire encore mieux, un std::array<char, 6>
Code:

1 2 char choix; int calcule, poids, resultat, k, nb, taille;
Pourquoi déclarer toutes ces variables à l'avance?
Autant les déclarer au bon moment.
L'avantage est que la variable sera déclaré juste au moment de t'en servir, et seulement pour le bloc où elle sert.
Ca fait moins de pollution, et moins de navigation pour savoir quel est le type de ta variable.
Code:

1 2 //on choisit une valeur quelconque qui n'est pas '1','2', ou 'Q'/'q' pour demarrer le programme choix = "c";
Ici, le compilateur doit raler: choix est un char, et "c" une chaine. A priori, il doit se plaindre d'une conversion invalide de pointeur vers entier.
la bonne écriture serait choix = 'c';.
Note comme le caractère utilise des 'simple quote'.
Par contre, c'est un bon commentaire.
Quoique si ton code est malin, tu pourrais ne pas besoin d'initialiser la variable. Sache aussi que tu pourrais utiliser '\0'.

Code:

while (choix != "Q" & choix != "q"){

Bien essayé, mais il faut utiliser l'opérateur logique && plutot que l'opérateur mathématique &.
Plus génant, et le compilateur doit te le dire, choix étant un char, il ne peut pas être comparé correctement avec un const char* (toute chaine entre guillemets).
Code:

1 2 3 4 5 //affichage du menu du programme printf("Conversion base 10 en base 16(1):"); printf("Conversion base 16 en base 10(2):"); printf("Quitter le programme (Q):");
C'est tellement dommage d'utiliser printf en C++, quand on a la solution std::cout qui est probablement plus claire.
Par exemple, ici, tu as oublié les fins de ligne ('\n').
on écrirait en C printf("Conversion base 10 en base 16(1):\n"); et en C++ std::cout << "Conversion base 10 en base 16(1):" << std::endl.

Avec une différence importante, std::endl affiche un retour chariot et force l'affichage immédiat du tampon (buffer en anglais). C'est à dire qu'il fait aussi un std::flush(), équivalent de fflush(stderr);.
Code:

1 2 //si 1 alors conversion base 10 en base 16 if(choix = 1){
Ceci est un grand piège en C++.
= est l'opérateur d'affectation. En tant qu'expression, choix = 1 affecte 1 à choix et vaut la valeur variable choix après ce changement, c'est à dire 1.
Du coup, la valeur testée par le if est 1, qui n'est ni 0, ni faux, ni std::nullptr, donc vraie.
Il faut utiliser l'opérateur de comparaison, if (choix=='1').
Par ailleurs, le caractère '1' ne vaut pas l'entier 1. (il vaut 49=0x31 en ASCII)

Pour le reste, je n'ai pas vu grand chose d'autre.

évite comme la peste getch.
Si tu veux que ta fenetre reste ouverte, demande simplement à ton EDI de laisser la console ouverte après l'exécution du programme.
Ou lance le programme depuis une console que tu as ouverte toi-même :D

N'hésite surtout pas à venir poser ta version corrigée, c'est un bon moyen de progresser.
Et à poser tes questions si tu en as, bien sûr.

25/03/2015, 17h24
ouille123

Merci à toi leternel :) Je vais bien lire tout ce que tu m'as écrit pour voir si j'arrive à m'en dépatouiller.
Bonne soirée à toi.

Salut, alors j'ai étudié ce que tu m'as écrit et je pense en avoir comprit une partie. Ton premier exemple:

Si je le suis correctement, ce sont deux commandes en c++ qui font tout le boulot :) 'std::dec' et 'std::hec'.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
#include <iostream>
#include <iomanip>
int main() {
    long nombre;
    std::cout <<"choisissez un nombre entier:" << std::endl;
    //le nombre rentré est forcement initialisé en décimal avec la commande 'std::dec'
    std::cin >> std::dec >> nombre;
    //'std::hex' permet de passe automatiquement de mon nombre décimal à un hexadécimal (base16) grâce à 'std::hex'
    std::cout << "sa notation hexadecimal est : " << std::hex << nombre << endl;
    system("pause");
    return 0;
}

Donc en suivant ta logique, pour faire l'inverse (base 16 vers 10):

Code:

1
2
3
4
5
6
7
8
9
10
11
12
#include <iostream>
#include <iomanip>
int main() {
    long nombre;
    std::cout <<"choisissez un nombre hexadécimal (base 16):" << std::endl;
    //le nombre rentré est forcement initialisé en hexadécimal avec la commande 'std::hex'
    std::cin >> std::hex >> nombre;
    //'std::dec' permet de passe automatiquement de mon nombre hexadécimal (base 16) à un décimal (base10) grâce à 'std::dex'
    std::cout << "sa notation décimal est : " << std::dec << nombre << endl;
    system("pause");
    return 0;
}

Donc pour mon programme je n'ai plus cas ajouter des itérations:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
/*programme exo1
 * but: convertir base 10 et 16
 * auteur: Mario
 * Date 24/03/2015
*/
#include <iostream>
#include <iomanip>
int main() {
    char choix;
 
    choix = 'c';
 
    while (choix != 'Q' && choix != 'q'){	
          std::cout <<"Conversion base 10 en base 16(1):" << std::endl;
          std::cout <<"Conversion base 16 en base 10(2):" << std::endl;
          std::cout <<"Quitter le programme (Q ou q):" <<std::endl;
          std::cin >> choix;
 
         if (choix == '1'){
            long nombre;
            //ici on rentre un nombre entier
            std::cout <<"choisissez un nombre entier:" << std::endl;
            //ce nombre en enregistré comme tel avec la commande 'std::dec'
            std::cin >> std::dec >> nombre;
            //on passe d'un 'dec' à un hex grâce à 'std::hex' qui convertit la variable 'nombre'
            std::cout << "sa notation hexadecimal est :" << std::hex << nombre << std::endl;
 
         }else{
 
        	    if (choix == '2'){            	    
                   long nombre;
 
                   std::cout <<"choisissez un nombre hexadécimal (base16):" << std::endl;
                   //ce nombre en enregistré comme tel avec la commande 'std::hec'
                   std::cin >> std::hex >> nombre;
                   //passe le nombre hex en décimal
                   std::cout << "sa notation décimal est : " << std::dec << nombre << std::endl;
                }
        	    //commande qui permet de ne pas fermer le programme. Possible d'utiliser system("pause");
        	    std::cin.get();
                return 0;
         }
    }
}

J'ai testé ce code avec 'Eclypse' et il marche. Par contre, je trouve cette technique un peu " trichée" car un idiot comme moi l'a comprise :) J'ai donc essayer de comprendre ta deuxième technique, mais là il y a trop de choses que je ne connais/comprend pas (si tu pouvais détailler?). Et règle importante du jeu "utiliser un vecteur" donc pour moi c'est pas possible. Je l'utiliserais si je ne trouve pas autre chose :( Il faut que je trouve un moyen à mon avis pour dire que s'il y a 11 en entier, il sera remplacer par 'A' en string qui lui sera stocker dans un tableau.

26/03/2015, 18h52
bacelar

Il faut toujours faire au plus simple.
Ce n'est pas tricher, c'est être efficace. cf. la maxime ne Newton sur les géants.

Il faut bien voir que c'est loin d'être trivial car le sens de lecture-écriture de gauche vers la droite impose l'utilisation de structure de stockage comme std::vector (qui est largement la plus simple d'emploi).
27/03/2015, 13h08
ouille123

D'un point de vu purement rentabilité c'est tip top oui :) Mais j'ai l'ordre d'utiliser un vecteur :(
27/03/2015, 19h29
bacelar

Encore un exercice complètement débile, ou, plus probablement, encore un élève qui comprend de travers.

Le post de leternel du "25/03/2015" à 16h40, donne une solution avec std::list, d'après toi, il faut combien de modification pour se servir d'un std::vector à la place ? :weird::aie:8O
27/03/2015, 20h25
ouille123

Salut. Je n'ai pas trop envie de te critiquer car tu aide beaucoup ici mais on dirait que tu es énervé ce soir. Et comme je l'ai dit plus haut, j'ai mal comprit le deuxième exemple car il y a des formules que je ne connais pas. Mais je vais m'y remettre et chercher sur internet ce que je ne comprend pas. Bonne soirée

mauvaise réponse :D

Quand on ne comprend pas la syntaxe, on ne dit pas "j'ai pas compris", mais on dit quelle phrase/instruction en particulier.

Mon code comprend deux fonctions. char digit(int chiffre, unsigned int base) qui, comme son nom semble l'indiquer, donne le digit correspondant à un chiffre dans une base donnée, et std::string base(long nombre, unsigned int base) qui transforme un nombre en chaine de caractères.

D'ailleurs j'y avais fait une erreur: 'A' correspondant à 10, il faut aligner chiffre correctement. (je corrigerai aussi mon précédent post)
Code:

1 2 3 4 5 6 7 8 char digit(int chiffre, unsigned int base) { assert(chiffre<base); assert(base>=2); if (chiffre<10) return '0'+chiffre; if (chiffre<36) return 'A'+(chiffre-10); return '?'; }
Vient ensuite une fonction qui transforme un nombre en une chaine de caractère écrite dans la base voulue, par division successive
Code:

1 2 3 4 5 6 7 8 9 10 11 std::string base(long nombre, unsigned int base) { assert(base>=2); std::list<char> valeur; while (nombre>=base) { valeur.push_front( digit(nombre%base, base) ); nombre/=base; } valeur.push_front( digit(nombre, base) ); return std::string(valeur.begin(), valeur.end()); }
Dans les deux cas, j'utilise assert pour expliciter les prérequis de la fonctions.
Observe comment base n'utilise que les fonctions de vector, de string et ma fonction digit