Je programme en Visual C++ 6 et j'ai un problème (normal sinon j'écrirai
pas...). En fait il y a plusieurs mois j'ai écris un petit programme et il
marchait très bien (en débug et en exe). Seulement depuis un petit moment
l'exe bugue sur une erreur dans msvcrtd.dll et le debug m'indique que
l'erreur se situe sur les lignes
char* heuref;
itoa(12,heuref,10);
je tiens à préciser que je n'ai fait aucune modification de code (de toute
façon ces lignes devraient fonctionner) alors comment puis-je faire pour
résoudre mon problème ? La dll est bien présente, faut-il que je la mette à
jour ? Peut-être un programme me l'a remplacé par une version compatible ?
Le problème vient-il bien de ce fichier ?
Pour faire ce que voulais le posteur initial: std::ostringstream oss; oss << 12; std::string heuref = oss.str();
qd ça commence à devenir un besoin fréquent, on peut en faire une fonction (qui remplacera avantageusement les strtod, atoi, etc.., du C) :
#include <sstream> #include <typeinfo> // pour bad_cast
// un mini boost::lexical_cast template<class T> T val_from_string(std::string const& s) { std::stringstream converter(s); T ret; converter >> ret >> std::ws; // eat white-space if(!converter) // conversion impossible throw std::bad_cast; if(! converter.eof()) // s n'a pas été entierement converti throw std::bad_cast; return ret; }
ça s'utilise comme ça : double d = val_from_string<double> ("3.124e05");
il faudrait une classe d'exception plus précise que bad_cast, par exemple copier celle de boost::lexical_cast ..
et si boost est dispo, il suffit simplement d'utiliser boost::lexical_cast. double d = boost::lexical_cast<double, std::string> ("3.123e05") ;
Le seul bémol, c'est que c'est cette façon de convertir est évidemment bcp plus lente (je verrai bien un facteur 10. peut être 100 ..) que le très basique atoi. Et donc si on a besoin de convertir en masse des nombres, il sera surement nécessaire d'utiliser une fonction spécialisée. (pas forcément atoi, on peut garder plus de polyvalence en modifiant val_from_string pour passer en parametre le stream de conversion à utiliser, pour en prendre un custom et le garder d'un appel au suivant en vidant juste le buffer - ça devient je pense d'une vitesse acceptable. genre 60% de atoi, ou du genre..)
-- Sam
le Thursday 15 January 2004 09:36, tib.motuelle@laposte.net écrivit :
Pour faire ce que voulais le posteur initial:
std::ostringstream oss;
oss << 12;
std::string heuref = oss.str();
qd ça commence à devenir un besoin fréquent, on peut en faire une fonction
(qui remplacera avantageusement les strtod, atoi, etc.., du C) :
#include <sstream>
#include <typeinfo> // pour bad_cast
// un mini boost::lexical_cast
template<class T>
T val_from_string(std::string const& s) {
std::stringstream converter(s);
T ret;
converter >> ret >> std::ws; // eat white-space
if(!converter) // conversion impossible
throw std::bad_cast;
if(! converter.eof()) // s n'a pas été entierement converti
throw std::bad_cast;
return ret;
}
ça s'utilise comme ça :
double d = val_from_string<double> ("3.124e05");
il faudrait une classe d'exception plus précise que bad_cast, par exemple
copier celle de boost::lexical_cast ..
et si boost est dispo, il suffit simplement d'utiliser boost::lexical_cast.
double d = boost::lexical_cast<double, std::string> ("3.123e05") ;
Le seul bémol, c'est que c'est cette façon de convertir est évidemment bcp
plus lente (je verrai bien un facteur 10. peut être 100 ..) que le très
basique atoi.
Et donc si on a besoin de convertir en masse des nombres, il sera surement
nécessaire d'utiliser une fonction spécialisée.
(pas forcément atoi, on peut garder plus de polyvalence en modifiant
val_from_string pour passer en parametre le stream de conversion à
utiliser, pour en prendre un custom et le garder d'un appel au suivant en
vidant juste le buffer - ça devient je pense d'une vitesse acceptable.
genre 60% de atoi, ou du genre..)
Pour faire ce que voulais le posteur initial: std::ostringstream oss; oss << 12; std::string heuref = oss.str();
qd ça commence à devenir un besoin fréquent, on peut en faire une fonction (qui remplacera avantageusement les strtod, atoi, etc.., du C) :
#include <sstream> #include <typeinfo> // pour bad_cast
// un mini boost::lexical_cast template<class T> T val_from_string(std::string const& s) { std::stringstream converter(s); T ret; converter >> ret >> std::ws; // eat white-space if(!converter) // conversion impossible throw std::bad_cast; if(! converter.eof()) // s n'a pas été entierement converti throw std::bad_cast; return ret; }
ça s'utilise comme ça : double d = val_from_string<double> ("3.124e05");
il faudrait une classe d'exception plus précise que bad_cast, par exemple copier celle de boost::lexical_cast ..
et si boost est dispo, il suffit simplement d'utiliser boost::lexical_cast. double d = boost::lexical_cast<double, std::string> ("3.123e05") ;
Le seul bémol, c'est que c'est cette façon de convertir est évidemment bcp plus lente (je verrai bien un facteur 10. peut être 100 ..) que le très basique atoi. Et donc si on a besoin de convertir en masse des nombres, il sera surement nécessaire d'utiliser une fonction spécialisée. (pas forcément atoi, on peut garder plus de polyvalence en modifiant val_from_string pour passer en parametre le stream de conversion à utiliser, pour en prendre un custom et le garder d'un appel au suivant en vidant juste le buffer - ça devient je pense d'une vitesse acceptable. genre 60% de atoi, ou du genre..)
