std::lexical_cast - est-il une telle chose?

Ne la Norme C++ de la Bibliothèque de définir cette fonction, ou dois-je avoir recours à des Boost?

J'ai cherché sur le web et ne pouvait pas trouver quelque chose, sauf coup de pouce, mais j'ai pensé que je ferais mieux de demander ici.

  • Vous pouvez le "recours" à stringstreams trop 🙂
InformationsquelleAutor smallB | 2011-11-09
  1. 85

    Que partiellement.

    C++11 <string> a std::to_string pour les types intégrés:

    [n3290: 21.5/7]:

    string to_string(int val);
string to_string(unsigned val);
string to_string(long val);
string to_string(unsigned long val);
string to_string(long long val);
string to_string(unsigned long long val);
string to_string(float val);
string to_string(double val);
string to_string(long double val);

    Retourne: Chaque fonction renvoie un string objet la tenue de la
    caractère de la représentation de la valeur de son argument qui serait
    être générée par l'appel de sprintf(buf, fmt, val) avec un format
    spécificateur de "%d", "%u", "%ld", "%lu", "%lld", "%llu",
    "%f", "%f", ou "%Lf", respectivement, où buf désigne
    un caractère interne de la mémoire tampon de taille suffisante.

    Il y a aussi les suivants qui vont dans l'autre sens:

    [n3290: 21.5/1, 21.5/4]:

    int stoi(const string& str, size_t *idx = 0, int base = 10);
long stol(const string& str, size_t *idx = 0, int base = 10);
unsigned long stoul(const string& str, size_t *idx = 0, int base = 10);
long long stoll(const string& str, size_t *idx = 0, int base = 10);
unsigned long long stoull(const string& str, size_t *idx = 0, int base = 10);
float stof(const string& str, size_t *idx = 0);
double stod(const string& str, size_t *idx = 0);
long double stold(const string& str, size_t *idx = 0);

    Cependant, il n'y a rien de générique que vous pouvez utiliser (au moins pas jusqu'à ce que TR2, peut-être!), et rien du tout en C++03.

    • Hum, en fait il y a stoi et les amis 🙂
    • Oh, hé.. donc il est! Merci.
    • Stroustrup dans sa FAQ sur le c++11 utilise stroustrup.com/C++11FAQ.html#constexpr dans la section sur la délégation des constructeurs
    • href="http://www.stroustrup.com/C++11FAQ.html#déléguant-ctor" >stroustrup.com/C++11FAQ.html#déléguant-ctor, puis. Soit il veut dire coup de pouce, ou il l'utilise comme une abstraction arbitraire dans le but de faire un point, ou il se trompe.
    • OK merci @LightnessRacesinOrbit j'ai simplement supposé que la FAQ serait écrit en C++pur style 11 compte tenu de Stroustrup intérêt dans la diffusion des bonnes style de codage pratiques.
    • Nous pouvons tous être intéressés à diffuser la bonne style de codage pratiques, mais qui ne les rend pas moins subjectif!
    • Se souvenir de Stroustrup la dépendance de l'aide gras italique police proportionnelle pour le code, je ne pense pas que l'on puisse parler sérieusement le style de son code. *joke*
    • Je n'ai pas vu plus de rumeurs à propos de ce faire une Spécification Technique. Il l'a fait mourir T. T
    • Si quelque chose que je m'attends à le voir dans la Lib Fondamentaux TS, mais il n'y a aucune preuve de cela. Me semble qu'il est mort, mais je ne suis pas certain.

    InformationsquelleAutor Lightness Races in Orbit
  2. 18

    Non, ce n'est pas le cas, même en C++11, mais c'est proposée pour inscription dans le Rapport Technique 2, le prochain jeu de std bibliothèque d'extensions.

    • Quel est le statut de celle de C++17, par le chemin?
    InformationsquelleAutor CharlesB
  3. 12

    Il n'y a pas de std::lexical_cast, mais vous pouvez toujours faire quelque chose de similaire avec stringstreams:

    template <typename T>
T lexical_cast(const std::string& str)
{
    T var;
    std::istringstream iss;
    iss.str(str);
    iss >> var;
    //deal with any error bits that may have been set on the stream
    return var;
}
    • merci, mais ce serait encore plus lent que boost::lexical_cast
    • Un flux en fonction de la solution ne va pas être aussi rapide que quelque chose comme snprintf, mais vous n'avez pas mentionné la problématique de la performance dans votre question.
    • Je plaisante maintenant, mais lorsque nous parlons de C++ solutions n'est pas des problèmes de rendement donné ;)? De toute façon boost utilise aussi les flux, mais ils ne se spécialisent également que c'est pourquoi il est très difficile de les battre.
    • notez que boost::lexical_cast dégénère à cette version quand les types sont inconnus. Aussi, vous ne devez pas seulement affaire avec les bits d'erreur, mais aussi de vérifier que le tampon a été vidé.
    • La Performance est toujours une source de préoccupation, mais il n'est jamais la seule préoccupation. La simplicité, la clarté, l'exactitude et la facilité de maintenance sont également très importants. Je ne voudrais pas utiliser le code ci-dessus dans une boucle serrée, mais il pourrait être très bien pour d'autres situations. Une question commune en ce qui concerne les performances sur, si vous avez profilé votre code, et a constaté que le sacrifice d'autres préoccupations sont à la peine 🙂
    • Si vous vous retrouvez à l'aide de lexical_cast<string>(string) cela ne sera de retour que le premier mot, pas ce que vous transmettez. (Vous pouvez l'utiliser dans une basée sur des modèles de fonction ou de quelque chose, du moins pas directement.) Quelque chose à regarder dehors pour.
    • Cette version peut être accéléré beaucoup en faisant iss statique
    • peut-être, mais alors vous avez de la réinitialiser l'ISS du tampon à chaque fois, et il ne serait pas thread-safe. C'était un simple exemple. Faisant preuve fool est un exercice pour le lecteur/bibliothèque Boost 😉
    • Si l'idée est correcte, cette réponse a l'envers. La déclaration de la fonction doit être " template <typename T> const std::string lexical_cast(const T& val) { ... }

    InformationsquelleAutor luke
  4. 5

    Non, c'est une pure Boost chose seulement.

    InformationsquelleAutor Some programmer dude
  5. 4

    Si vous ne voulez pas boost puis un léger bibliothèque appelée fmt met en œuvre les suivantes:

    //Works with all the C++11 features and AFAIK faster then boost or standard c++11
std::string string_num = fmt::format_int(123456789).str(); //or .c_str()

    Plus d'exemples de la page officielle.

    Accès à des arguments par la poste:

    format("{0}, {1}, {2}", 'a', 'b', 'c');
//Result: "a, b, c"
format("{}, {}, {}", 'a', 'b', 'c');
//Result: "a, b, c"
format("{2}, {1}, {0}", 'a', 'b', 'c');
//Result: "c, b, a"
format("{0}{1}{0}", "abra", "cad");  //arguments' indices can be repeated
//Result: "abracadabra"

    En alignant le texte et en spécifiant une largeur:

    format("{:<30}", "left aligned");
//Result: "left aligned                  "
format("{:>30}", "right aligned");
//Result: "                 right aligned"
format("{:^30}", "centered");
//Result: "           centered           "
format("{:*^30}", "centered");  //use '*' as a fill char
//Result: "***********centered***********"

    Remplacement d' %+f, %-f et % f et en spécifiant un signe:

    format("{:+f}; {:+f}", 3.14, -3.14);  //show it always
//Result: "+3.140000; -3.140000"
format("{: f}; {: f}", 3.14, -3.14);  //show a space for positive numbers
//Result: " 3.140000; -3.140000"
format("{:-f}; {:-f}", 3.14, -3.14);  //show only the minus -- same as '{:f}; {:f}'
//Result: "3.140000; -3.140000"

    Remplacement d' %x et %o et la conversion de la valeur de bases différentes:

    format("int: {0:d};  hex: {0:x};  oct: {0:o}; bin: {0:b}", 42);
//Result: "int: 42;  hex: 2a;  oct: 52; bin: 101010"
//with 0x or 0 or 0b as prefix:
format("int: {0:d};  hex: {0:#x};  oct: {0:#o};  bin: {0:#b}", 42);
//Result: "int: 42;  hex: 0x2a;  oct: 052;  bin: 0b101010"
    • J'aime vraiment le fmt bibliothèque et aime voir son utilisation promu. fmt, cependant, ne fera que le string de conversion. (Maintenant, il le fait mieux que tout les autres de la bibliothèque C++ que j'ai vu.) fmt ne pas faire de de la chaîne conversion effectuée par lexical_cast ou std::stoxyz fonctions.
    InformationsquelleAutor Sandu Liviu Catalin