Problème avec string

Et oui c'est encore moi :lol:

Cette fois si c'est un petit problème avec la bibliothèque string...

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

int dec_bin(int dec) { int a, i; string t = "";   do { a = 0; i = dec; while(i!=1 && i!=0) { i -= 2; a += 1; } t = Convert.ToString(dec-(2*a))+t; dec = a; } while(dec!=0);   return t; }

---

Le compilateur me refuse la ligne t = Convert.ToString(dec-(2*a))+t; qui marche dans mon bouquin ou même dans des tuto que j'ai trouvé sur internet mais pas dans mon compilateur...

Je vous remercie d'avance.

Convert est de quel type?

Citation:

---

Envoyé par Goten

Convert est de quel type?

---

Se n'est pas une variable, c'est une fonction qui convertit le résultat de dec-(2*a))+res en un string dans t.

A moins qu'il existe une autre injonction pour transformer une variable int en string

Alors c'est pas du C++... Je suppose que ce que tu veux faire c'est transformé un nombre en string? Si oui alors faut faire ta propre fonction en utilisant un ostringstream, t'as des exemples dans la faq.

Citation:

---

Envoyé par Goten

Alors c'est pas du C++... Je suppose que ce que tu veux faire c'est transformé un nombre en string? Si oui alors faut faire ta propre fonction en utilisant un ostringstream, t'as des exemples dans la faq.

---

Excusez moi je n'ai pas compris le sens de votre phrase. (HEIN?)

Non se que je souhaite faire c'est convertir un décimal en binaire.
Pour cela, j'ai besoin de la concaténation de string et donc convertir le résultat de la concaténation en question dans un [i]int[/].

Citation:

---

Envoyé par kahn_onjy_bryce

Se n'est pas une variable, c'est une fonction qui convertit le résultat de dec-(2*a))+res en un string dans t.

A moins qu'il existe une autre injonction pour transformer une variable int en string

---

C'est du .NET, la classe Convert. C'est pour ca.

En C, tu ferais (ca marche en C++ mais c'est du C)

Code:

---

char *itoa(int valeur,char *s,int base)

---

qui fait cela, dans la base de ton choix ;) (il faut juste lui passer un tableau de chars de taille suffisante). Donc un

Code:

---

string(itoa(valeur,chaine,base));

---

devrait faire des miracles, par exemple avec base=2... Il te faut alors passer un tableau de 33 char.

En C++, la manière correcte de faire est qqchose comme

Code:

---

1 2 3 4 5 6

string tostring(int i) { ostringstream oss; oss<<i; return oss.str(); }

---

Tu peux utiliser des manipulateurs pour effectuer une conversion vers d'autres bases, je crois...

Francois

http://cpp.developpez.com/faq/cpp/?p...RINGS_numtostr

Voilà la référence de la faq ;)

edit : grillé

En fait, pour traduire en représentation binaire, je ne suis pas certain que la solution de la FAQ (ou une modification triviale de celle ci) fonctionne...

En revanche, les tableaux bitset<> ont une fonction to_string(), qui fait tout le boulot.

Il doit donc falloir quelque chose comme

Code:

---

1 2 3 4 5 6 7 8 9

string int_to_bin(int value) { bitset<numeric_limits<int>::digits + 1> bs(value); string s=bs.to_string(); // elimine les bits à zéros à gauche string::size_type pos(s.find_first_not_of('0')); return (pos==string::npos?"0":s.substr(pos)); }

---

Francois

Ah ça fonctionne parfaitement merci beaucoup. :ccool:

Maintenant dans l'autre sens.
Bon j'ai regardé http://cpp.developpez.com/faq/cpp/?p...RINGS_strtonum se qui donne :

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

int toint(string a) { std::istringstream iss( a ); int b; iss >> b; return b; }   int dec_bin(int dec) { int a, i; string t;   do { a = 0; i = dec; while(i!=1 && i!=0) { i -= 2; a += 1; } t = tostring(dec-(2*a))+t; dec = a; } while(dec!=0); t = toint(t); return t; }

---

Le compilateur me renvoie :
DM1.cpp:42: erreur: cannot convert ‘std::string’ to ‘int’ in return

@fcarton : Ben je vois que c'est bien plus pratique que se que j'ai fait mais je suis déjà en train de digresser sur le sujet car le sujet dit qu'il faut utiliser des tableaux d'entier ou de caractères. J'espère que le professeur sera clément en m'autorisant l'utilisation de string.

C'est tes dernières lignes:

Code:

---

1 2	t = toint(t); return t;

---

Comme t est un string, ca va pas aller... fais juste

return toint(t);

et tout ira bien

PS si tu dois avoir des tableaux de caractères, alors prends itoa()...

Francois

Salut,

La solution la plus simple de toutes, c'est surement celle qui consiste à utiliser la classe qui permet, précisément, de travailler sur un tableau de bit: la classe bitset, disponible dans l'espace de noms std, par inclusion du fichier d'en-tête <bitset>...

En effet, l'ensemble des valeurs que tu peux vouloir manipuler est, naturellement, représenté sous la forme binaire en mémoire, et il est donc "logique" d'envisager d'utiliser une classe qui permet de manipuler des bits lorsque l'on veut pouvoir... les manipuler...

De plus, cette classe dispose d'une fonction membre qui, justement, permet de récupérer ce tableau de bits sous la forme d'une chaine de caractères, pour le cas où tu voudrais pouvoir concaténer cette chaine avec une autre...

Au final, tu pourrais te retrouver avec un code aussi simple que:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

#include <iostream> //pour l'affichage #include <string> //pour les chaines #include <bitset> // pour les bitset int main() { size_t i=255; std::bitset<sizeof(i)> tab(i); std::cout<< tab<<std::endl; std::string str("la valeur en binaire de 255 est "); str+=tab.to_string(); std::cout<<str<<std::endl; return 0; }

---

Salut Koala01,

Deux petites questions/remarques :

Code:

---

1 2	size_t i=255; std::bitset<sizeof(i)> tab(i);

---

Ca va renvoyer un tableau trop court, ca, non? sizeof() renvoie une taille en octetssizeof(i) ca vaut 4 (si i est un size_t, représenté comme un unsigned int), et ca va nous créer un tableau de 4 bits... Faudrait 8*sizeof(i), non? (mais je pense que numeric_limits<size_t>::digits serait plus propre.

Dans ce cas, le bitset<>::to_string() renverra une chaine de 32 caractères, donc dans le cas présent "00000000000000000000000011111111". Je pense qu'il faudrait tronquer les zéros du début.

Francois

Bien vu... j'étais distrait :aie:

Il faut bien multiplier sizeof par le nombre de bits du type envisagé ;)

Et, effectivement, tu risque d'avoir une série de 0 inutiles, mais tu peux alors envisager l'utilisation des fonctions membres substr et find_first_of (ou find_first_not_of) de la classe string pour les tronquer...

cela t'emmenerait à un code proche de

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

int main { size_t i=255; /* transformons cette valeur en binaire, et récupérons la dans   * une chaine de caractères   */ std::bitset<std::numeric_limits<size_t>::digits> tab(i); std::string result=tab.to_string(); /* supprimons les 0 inutiles */ result=result.substr(result.find_first_not_of("0")); /* cela aurait pu prendre la forme de   result=result.substr(result.find_first_of("1"));   */ std::cout<<result<<std::endl; return 0; }

---

hum fait étonnant, ma version de la STL (fourni avec mingw 3.14) ne contient pas la méthode to_string(). Faut que je test sous gcc pour voir.


(je dis ça au cas où tu _le PO_ soit sous mingw, que tu t'arraches pas les cheveux pour rien)

Ouais, je mettrais encore un petit test à la fin pour le cas où le nombre vaut zéro (pour imprimer une chaine "0" et pas la chaine nulle).

Sur numeric_limits<>::digits, je me pose une question...

L'avantage du code qu'on a là est qu'il peut facilement être transformé en un template qui donnerait la représentation binaire de tout type scalaire, tout ce qu'on a dans numeric_limits, en fait.

Mais peut être que sizeof(T)*8 permettrait d'avoir un code fonctionnant pour des types utilisateurs (des POD seulement, j'imagine, mais quand meme). Ca nous donnerait qqchose comme

Code:

---

1 2 3 4 5 6 7 8 9

template<typename T> string tobinary(const T &valeur) { bitset<8*sizeof(T)> bs(valeur); string s=bs.to_string(); int pos=s.find_first_not_of("0") ; if(pos==string::npos) return string("0"); return s.substr(pos); return s }

---

Francois

Citation:

---

Envoyé par Goten

hum fait étonnant, ma version de la STL (fourni avec mingw 3.14) ne contient pas la méthode to_string(). Faut que je test sous gcc pour voir.


(je dis ça au cas où tu _le PO_ soit sous mingw, que tu t'arraches pas les cheveux pour rien)

---

En tout cas, elle est implémentée dans gcc 4.x.x ;) (je te conseillerais d'ailleurs volontiers de passer à la version correspondante de MinGW, ils ont une version stable utilisant 4.3.0 ;))

Sinon, au pire, les opérateurs de flux sont surchargés pour les bitsets...

Ce sera peut être plus long, mais tu peux, au pire, envisager de passer par un stringstream pour récupérer la chaine de caractères ;)

Citation:

---

Envoyé par fcharton

Ouais, je mettrais encore un petit test à la fin pour le cas où le nombre vaut zéro (pour imprimer une chaine "0" et pas la chaine nulle).

Sur numeric_limits<>::digits, je me pose une question...

L'avantage du code qu'on a là est qu'il peut facilement être transformé en un template qui donnerait la représentation binaire de tout type scalaire, tout ce qu'on a dans numeric_limits, en fait.

Mais peut être que sizeof(T)*8 permettrait d'avoir un code fonctionnant pour des types utilisateurs (des POD seulement, j'imagine, mais quand meme). Ca nous donnerait qqchose comme

Code:

---

1 2 3 4 5 6 7 8 9

template<typename T> string tobinary(const T &valeur) { bitset<8*sizeof(T)> bs(valeur); string s=bs.to_string(); int pos=s.find_first_not_of("0") ; if(pos==string::npos) return string("0"); return s.substr(pos); return s }

---

Francois

---

Oui, mais non...

Je ne suis personnellement pas partisan du fait de permettre de tronquer la chaine résultant de la conversion d'un type POD...

Pour les scalaires, cela peut encore se comprendre (quoi que, cela peut poser des problèmes au niveau des réels), mais, pour les types POD non scalaires, tu risque, si les premières valeurs sont nulles, de perdre toute information te permettant de déterminer lesquelles le sont...

Imagine un type POD proche de

Code:

---

1 2 3 4 5

struct POD { char c[8]; int i[5]; };

---

qui serait converti en binaire (pas de problème là dessus), et tronqué...

Si c[0], c[1] et c[2] sont nuls, tu va "jouir" pour arriver à t'en rendre compte :P;)

Citation:

---

Envoyé par fcharton

Mais peut être que sizeof(T)*8 permettrait d'avoir un code fonctionnant pour des types utilisateurs (des POD seulement, j'imagine, mais quand meme). Ca nous donnerait qqchose comme

---

Tant qu'à faire, ne vaudrait-il pas mieux écrire sizeof(T) * CHAR_BIT

Citation:

---

Envoyé par gl

Tant qu'à faire, ne vaudrait-il pas mieux écrire sizeof(T) * CHAR_BIT

---

Ce serait encore le mieux, afin de s'éviter les problèmes relatifs à la taille même des char ;)

Le tout, modulo la remarque que j'ai faite plus haut, bien sur ;)

@gl CHAR_BIT, bien vu!

@ koala01 Tu as raison, si on veut un système qui marche sur les POD, il ne faut mieux pas tronquer les zéros de début de représentation. Ou peut être ne le faire que sur les types entiers, par spécialisation du template...

Ceci dit, même avec troncature, je ne crois pas qu'on perde de l'information au point de ne pouvoir reconstituer la forme originale. Ce sont toujours les premiers zéros qui sont tronqués, et on connait la taille (via sizeof(POD)*CHAR_BITS), on peut donc facilement déduire le nombre de bits à zéro qu'on a éliminé...

Mais ca reste une mauvaise idée de les éliminer.

Francois

Citation:

---

Envoyé par fcharton

Ceci dit, même avec troncature, je ne crois pas qu'on souffrirair beaucoup : ce sont toujours les premiers zéros qui sont tronqués, et on connait la taille (via sizeof()*CHAR_BITS), on peut donc savoir exactement combien de bits à zéro on doit avoir au début.

---

Ce n'est pas forcément aussi simple que ça, il faut aussi inclure les problèmes d'interprétation du au padding dans la structure qui pourrait rendre la suppression des 0 initiaux quasiment invisible.

Ceci étant, la présence même de ce padding me laisse dubitatif quant à l'intérêt de cette conversion dans la plupart des cas sur des types utilisateurs

Citation:

---

Envoyé par gl

Ce n'est pas forcément aussi simple que ça, il faut aussi inclure les problèmes d'interprétation du au padding dans la structure qui pourrait rendre la suppression des 0 initiaux quasiment invisible.

---

Ce problème se posera même si tu ne tronques pas, non? Du fait des alignements de données, la position des membres d'un POD peut varier, et la chaine binaire (tronquée ou pas) ne te permet pas de conclure.

Je n'arrive pas à imaginer un cas où la version tronquée et le sizeof() apportent moins d'info que la version complète (puisque la complète, c'est par définition le tronqué avec un nombre de zéros au début qui dépend du sizeof()...)

Citation:

---

Envoyé par gl

Ceci étant, la présence même de ce padding me laisse dubitatif quant à l'intérêt de cette conversion dans la plupart des cas sur des types utilisateurs

---

A la base, représenter une représentation binaire par une chaine de caractères, c'est un peu étrange. Dans un éditeur, ou un outil de contrôle, peut être?

Francois