De texte à autre chose, et inversement

Certaines questions reviennent constamment, dans presque tous les langages de programmation : comment convertir du texte en autre chose (p. ex. : en entier) et inversement?

Dans chaque langage de programmation, on trouve des outils et des stratégies pour faire ce genre d'opération. Nous en présenterons ici quelques unes, soit des stratégies propres :

• Au langage C
• Au langage C++
• Aux langages .NET, comme C# ou VB.NET, et
• Au langage Java

La liste n'est évidemment pas exhaustive, les techniques proposées pour chaque langage ne le sont pas non plus – l'imagination des informaticiennes et des informaticiens ne connaît, avouons-le, que peu de limites – et la liste n'est présentée dans aucun ordre particulier.

Considérations générales

Convertir un nombre en texte est une opération relativement simple dans la mesure où l'espace fourni pour représenter le texte en question est suffisamment grand pour y écrire ce texte. Par exemple, pour écrire "3.14159" sous forme ASCIIZ, il importe habituellement d'avoir à sa disposition un espace d'au moins huit caractères, soit un par caractère et un pour le délimiteur marquant la fin du texte.

#include <iostream>
int main() {
   using namespace std;
   if (17 == 021 && 17 == 0x11)
      cout << "OUI" << endl;
   else
      cout << "Ceci ne devrait pas se produire" << endl;
}

Je vous invite à consulter ce document sur la structure interne des nombres pour en savoir plus. Évidemment, si on vise à représenter un nombre sous forme de texte, il faudra choisir un système de numération pour l'écriture résultante. La plupart des outils standards utiliseront une écriture décimale par défaut, mais certains (comme itoa(), par exemple, décrit dans la section portant sur le langage C) permettront de choisir la base dans laquelle se fera l'écriture.

En retour, il faut habituellement être prudent pour traduire du texte en nombre, car plusieurs écritures textuelles ne représentent pas des nombres pour la plupart des langages (p. ex. : le texte "Bonjour" se traduit très mal en entier, à moins bien entendu qu'on ait en tête un code un peu spécial). Il n'est pas non plus toujours clair qu'un texte donné puisse se représenter dans le type de données souhaité par le programme (ex: traduire "3.14159" en entier).

Enfin, les questions de bornes (traduire "1000000" en entier codé sur 16 bits, par exemple) doivent être prises en considération.

Langage C

Le langage C utilise des chaînes de caractères ASCIIZ brutes avec des caractères habituellement encodés sur un byte (type char) ou sur un type de 16 bytes ou plus, soit le type wchar_t.

Fonction sprintf()

#include <stdio.h> /* en C++: <cstdio> */
int main() {
   char tampon[256]; /* espérons que ce soit suffisant */
   int i = 3;
   float f = 3.14159f;
   sprintf(
      tampon,
      "Exemple (conversion de nombre en texte): %d %lf\n",
      i,  /* %d, pour « decimal », est utilisé pour les int */
      f   /* %lf sert pour les float */
   );
   /*
     affiche « Exemple (conversion de nombre en texte): 3 3.141590 »
   */
   printf(Tampon);
}

#include <stdio.h> /* ou <cstdio> en C++ */
int main() {
   char tampon[128];
   sprintf(tampon, "%d %d", 3); /* il manque un paramètre entier... BOUM! */
}

Fonction sscanf()

#include <stdio.h> /* en C++: <cstdio> */
int main() {
   char *s = "3 3.14159"; /* texte d'où extraire les nombres */
   int i;
   float f;
   sscanf(
      s,
      "%d %lf\n",
      &i,  /* %d, pour « decimal », est utilisé pour les int */
      &f   /* %lf sert pour les float */
   );
   /* affiche « 3.141590 3 » */
   printf("%lf %d", f, i);
}

#include <stdio.h> /* ou <cstdio> en C++ */
int main() {
   char *s = "allo";
   int i;
   sscanf(s, "%d", &i); /* les types ne correspondent pas... BOUM! */
}

Fonction itoa()

Sous Microsoft Windows, on peut traduire un nombre entier en texte en utilisant la fonction itoa(), comme par exemple :

#include <stdio.h> /* en C++: <cstdio> */
#include <stdlib.h> /* en C++: <cstdlib> */
int main() {
   int i = 17;
   /* on espère que cela suffise pour contenir le texte résultant */
   char tampon[32];
   /* on peut choisir une base (ici: décimale) */
   int base_voulue = 10;
   itoa(i, tampon, base_voulue);
   /* affiche 17 */
   printf(Tampon);
   base_voulue = 2;
   itoa(i, tampon, base_voulue);
   /* affiche 10001 */
   printf(tampon);
   base_voulue = 16;
   itoa(i, tampon, base_voulue);
   /* affiche 11 */
   printf(tampon);
}

Cette fonction prend en paramètre, dans l'ordre :

• L'entier à traduire
• Un tableau de caractères suffisamment grand pour contenir le texte résultant – prudence, d'ailleurs, car le choix de la base influencera le nombre de caractères requis pour le résulat, et
• Un entier pour indiquer la base dans laquelle devra être écrit le nombre (voir ce document pour plus de détails)

Fonction atoi()

Sous Microsoft Windows, on peut traduire du texte en nombre entier en utilisant la fonction atoi(), comme par exemple :

#include <stdio.h> /* en C++: <cstdio> */
#include <stdlib.h> /* en C++: <cstdlib> */
int main() {
   char *s = "17";
   int i = atoi(s);
   /* affiche 17 */
   printf("%d", i);
}

Cette fonction prend en paramètre le texte dont il faut extraire un entier, présumé écrit sous sa forme décimale, et retourne l'entier correspondant.

Langage C++

Le langage C++ permet d'exploiter les outils du langage C, mais offre un paradigme plus intéressant, plus souple et surtout moins dangereux pour arriver au même résultat. On peut ainsi écrire nos propres outils standards de conversion à partir de la paire d'abstractions fort élégante constituée des flux d'entrée/ sortie et des opérateurs d'insertion sur un flux ou d'extraction d'un flux.

Pourquoi préférer std::string à des tableaux de caractères bruts

On voudra presque toujours préférer une std::string à un tableau de caractères bruts, du fait que la std::string peut croître au besoin. Ceci lui confère une souplesse et une élégance qui sont des atouts non négligeables. De manière générale, du fait qu'elle encapsule sa propre gestion de mémoire et qu'elle est consciente de sa propre lonmgueur et de sa propre capacité, il est plus simple de manipuler (copier, passer en paramètre par valeur ou par référence, retourner d'une fonction, concaténer, etc.) une std::string que des blocs de caractères bruts.

Ce qu'est un std::stringstream

Les programmeurs C++ ont un avantage marqué sur les programmeurs C en ce sens que les outils d'entrée/ sortie sur des flux de C++ sont aussi rapides mais plus sécuritaires que ceux de C. En effet, les opérateurs d'insertion dans un flux (<<) et d'extraction d'un flux (>>) de C++ sont des opérateurs binaires (à deux opérandes), dont l'opérande de gauche est un flux et dont l'opérande de droite est – et c'est là quelque chose de merveilleux – une donnée d'un type connu à la compilation.

Impacts de ce constat :

• Un compilateur efficace pourra générer du code plus rapide en C++ qu'en C pour les entrées/ sorties sur un type primitif car, en C++, aucune analyse n'est requise à l'exécution pour savoir les types de données impliqués, alors qu'en langage C il faut que les fonctions responsables des entrées/ sorties décodent une chaîne contenant des indications de formatage pour savoir comment procéder
• Les risques d'erreurs lors d'entrées/ sorties sont de beaucoup réduits en C++ par rapport au langage C puisque le compilateur est conscient de tous les types impliqués et évite ainsi de subir des erreurs comme celles se produisant en C lorsque les paramètres passés à une fonction d'entrée/ sortie standard ne correspondent pas aux spécifications de formatage données dans la chaîne utilisée pour guider le traitement

Sachant cela, on comprendra qu'il serait très agréable de pouvoir exploiter un outil de la souplesse et de la puissance des flux d'entrée/ sortie standard pour y insérer ou en extraire des données d'un type arbitraire (mais susceptible d'être écrites sur un flux ou extraites d'un flux).

Et nous avons un tel outil: le std::stringstream, disponible en incluant le fichier <sstream> et pouvant être décliné sous des versions en entrée seule (std::istringstream) ou en sortie seule (std::ostringstream), de manière analogue à tous les flux d'entrée/ sortie standards (incluant les instances de std::istream et de std::ostream que sont respectivement std::cin et std::cout). Le fait que le flux soit représenté sous la forme d'une chaîne de caractères (et n'implique en conséquence aucun accès au système de fichiers) le rend très rapide sans que cela n'entraîne une dégradation du point de vue souplesse.

Les exemples qui suivent montrent comment on peut tirer profit de ce simple mais puissant outil.

Écrire itos()

En C++, la manière la plus simple de traduire un entier en texte est d'écrire l'entier en question sur un flux puis d'extraire le texte contenu dans ce flux, comme on le voit dans l'exemple ci-dessous :

#include <string>
#include <sstream>
using namespace std;
// ...
string itos(int i) {
   stringstream sstr;
   sstr << i;
   return sstr.str();
}
int main() {
   cout << "Entrez un entier: ";
   if (int i; cin >> i) {
      string s = itos(i);
      cout << "Sous forme de texte, cela donne " << s << endl;
   }
}

Écrire stoi()

En C++, la manière la plus simple de traduire du texte en un entier est d'écrire le texte en question sur un flux puis d'extraire l'entier contenu dans ce flux, comme on le voit dans l'exemple ci-dessous :

#include <string>
#include <sstream>
using namespace std;
// ...
int stoi(const string &s) {
   stringstream sstr;
   sstr << s;
   int i;
   sstr >> i; // on suppose absence d'erreur, par souci de simplicité
   return i;
}
int main() {
   cout << "Entrez un entier: ";
   if (string s; cin >> s) {
      int i = stoi(s);
      cout << "J'ai compris " << i << endl;
   }
}

Généraliser (ttos(), stot())

On comprendra rapidement que la stratégie s'applique de manière élégante à tout type pouvant être inscrit sur un flux et extrait d'un flux. Conséquemment, on pourra généraliser itos() et stoi() à tout type T à l'aide de templates :

#include <sstream>
using namespace std;
// ...
template <class T>
   string ttos(const T &val) {
      stringstream sstr;
      sstr << val;
      return sstr.str();
   }
template <class T>
   T stot(const string &s) {
      stringstream sstr;
      sstr << s;
      T val;
      sstr >> val; // on suppose absence d'erreur, par souci de simplicité
      return val;
   }
int main() {
   cout << "Entrez un entier: ";
   if (string s; cin >> s) {
      int i = stot<int>(s);
      cout << "J'ai compris " << i << endl;
      string str = ttos<int>(i);
      cout << "Je confirme " << str <<endl;
   }
}

Parenthèse – gérer les erreurs de conversion

Merci à François Boileau pour avoir suggéré ce raffinement.

Si l'objectif est de produire du code de conversion sécuritaire, il faut tenir compte des erreurs de conversion et de leur signalement (par exemple, tenter de traduire "allo" en int est un cas d'exception qui doit être rapporté au sous-programme appelant).

Le problème se résout à peu de frais. En effet, une tentative d'extraction d'une donnée à partir d'un flux, si elle échoue, met le flux dans un état d'erreur qui peut être vérifié en testant ce flux, tout simplement. Ainsi, pour mettre en place une stratégie plus complète de conversion, il suffit d'ajouter un test sur l'état du flux suite à l'extraction et de lever une exception si nécessaire.

#include <sstream>
// ... using et autres trucs ...
class ErreurConversion {};
template <class T>
   string ttos(const T &val) {
      stringstream sstr;
      sstr << val;
      return sstr.str();
   }
template <class T>
   T stot(const string &s) {
      stringstream sstr;
      sstr << s;
      if (T val; !(sstr >> val))
         throw ErreurConversion{};
      else
         return val;
   }
int main() {
   cout << "Entrez un entier: ";
   if (string s; cin >> s)
      try {
         int i = stot<int>(s);
         cout << "J'ai compris " << i << endl;
         string str = ttos<int>(i);
         cout << "Je confirme " << str << endl;
      } catch (ErreurConversion&) {
         cerr << "Incapable de convertir " << s << " en entier" << endl;
      }
}

Notez cependant que l'ajout d'un test supplémentaire ralentit le code. Sachant cela, si votre code utilise des données préalablement garanties, en particulier si votre programme est soumis à des contraintes de temps drastiques, vous voudrez peut-être privilégier une approche plus brute.

Avec C++ 11

Depuis C++ 11, certaines fonctionnalités de conversion ont été ajoutées à std::string. Certaines d'entre elles entrâinent d'ailleurs un conflit de nom potentiel avec les exemples de cet article (il existe par exemple maintenant un std::stoi() qui peut être appelée exactement comme l'est la fonction stoi() proposée ici). Pour en savoir plus, voir http://en.cppreference.com/w/cpp/string/basic_string/stol qui en présente une et propose des liens documentant les autres.

Depuis C++ 17

Depuis C++ 17, un nouveau groupe de fonctions de très bas niveau, mais extrêmement rapides, sont fournies pour convertir de texte à entiers (ou à flottants) et inversement :

//
// exemple inspiré directement de cppreference
//
#include <iostream>
#include <charconv>
#include <system_error>
#include <string_view>
#include <array>
int main() {
   using namespace std;
   array<char, 10> str; 
   if(auto [p, ec] = to_chars(str.data(), str.data() + str.size(), 3.14159);
      ec == std::errc())
       cout << string_view(str.data(), p - str.data()) << endl; // 3.14159
}

//
// exemple inspiré directement de cppreference
//
#include <iostream>
#include <charconv>
#include <array> 
int main() {
   using namespace std;
   array<char, 10> str{"3.14159"};
   double resultat;
   from_chars(str.data(), str.data()+str.size(), resultat);
   cout << resultat << endl;
}

Ces fonctions sont archi-rapides du fait qu'elles n'allouent pas de mémoire, et ne tiennent pas non plus compte de la culture ou de l'internationalisation, donc qu'elles vont (en quelque sorte) à l'essentiel.

Langages .NET (p. ex. : C#, VB.NET)

Dans les langages .NET, la manière privilégiée de traduire une donnée d.un type primitif .NET à un autre type primitif .NET est de passer par System.Convert et d'appeler la méthode de conversion appropriée.

#include "stdafx.h"
#using <mscorlib.dll>
int _tmain()
{
   System::String *s0 = "3";
   int i = System::Convert::ToInt32(s0);
   System::String *s1 = System::Convert::ToString(i);
   System::Console::WriteLine("Chaine {0}: entier {1}", s0, s1);
}

Module ModuleTest
    Sub Main()
        Dim s0 As String = "3"
        Dim i As Integer = System.Convert.ToInt32(s0)
        Dim s1 As String = System.Convert.ToString(i)
        System.Console.WriteLine("Chaine {0}: entier {1}", s0, s1)
    End Sub
End Module

namespace Test
{
   public class ClasseTest
   {
      public static void Main()
      {
         string s0 = "3";
         int i = System.Convert.ToInt32(s0);
         string s1 = System.Convert.ToString(i);
         System.Console.WriteLine($"Chaine {s0}: entier {s1}");
         // autre possibilité
         i = int.Parse(s1);
      }
   }
}

Langage Java

Le langage Java a ceci de particulier que, bien qu'il se vante d'être plus objet que la compétition, il offre un type String qui a de particulier d'être à la fois un objet et un type au support proche de celui offert aux types primitifs du langage (incluant un support spécifique pour l'opérateur + dans le but de faciliter la concaténation).

public class Z {
   public static void main(String [] args) {
      int i = 3;
      String s = new Integer(i).toString();
      int j = Integer.parseInt(s);
   }
}

Il est immédiatement visible que les avantages et les inconvénients de Java et de C# sont à peu près les mêmes : il existe des fonctions de conversion pour les types standards du langage, mais peu de possibilités élégantes d'extension générique de ce modèle.

Lectures complémentaires

Quelques liens pour enrichir le propos.

• Pour une autre point de vue sur les chaînes de caractères en C++, voir ce texte de John D. Cook : http://www.johndcook.com/cplusplus_strings.html
• Conversions entre nombres et chaînes de caractères :
  • Petit tutoriel : https://thispointer.com/c-convert-double-to-string-and-manage-precision-scientific-notation/
  • En 2013, Victor Zverovich mesure la vitesse de conversion en entre nombres et chaînes de caractères selon plusieurs approches : http://www.zverovich.net/2013/09/07/integer-to-string-conversion-in-cplusplus.html
  • Texte de 2014 par Marcellus Bancilla pour des détails sur les conversions entre nombres et chaînes de caractères en C++ 11 : http://codexpert.ro/blog/2014/04/14/standard-way-of-converting-between-numbers-and-strings-in-cpp11/
  • Convertir divers types en string, par Jonathan Boccara en 2017 : http://www.fluentcpp.com/2017/06/06/using-tostring-custom-types-cpp/
  • Textes de « jft » sur le site de Jonathan Boccara, en 2018, portant sur la conversion en C++ de string à int :
    • https://www.fluentcpp.com/2018/07/24/how-to-convert-a-string-to-an-int-in-c/
    • https://www.fluentcpp.com/2018/07/27/how-to-efficiently-convert-a-string-to-an-int-in-c/
  • Les fonctions to_chars() et from_chars() de C++ 17 :
    • https://en.cppreference.com/w/cpp/utility/to_chars
    • https://en.cppreference.com/w/cpp/utility/from_chars
  • Texte de 2020 par Arthur O'Dwyer sur les méthodes data() et c_str() de std::string (et, en partie, de std::string_view), incluant des conseils quant aux occasions de préférer l'une ou l'autre : https://quuxplusone.github.io/blog/2020/03/20/c-str-correctness/
• Quelques exemples de conversion dans des langages .NET, pris directement de la documentation officielle de cette plateforme (ou de sites qui s'en rapprochent), voir :
  • http://msdn.microsoft.com/en-us/library/1k20k614.aspx
  • http://www.dotnetperls.com/int-parse
• Interfacer avec les systèmes d'exploitation :
  • Utiliser les std::string de C++ pour interfacer avec les fonctions de Microsoft Windows, texte de Giovanni Dicanio en 2015 : https://docs.microsoft.com/en-us/archive/msdn-magazine/2015/july/c-using-stl-strings-at-win32-api-boundaries
  • Convertir un résultat retourné par une fonction de Microsoft Windows en une std::string ou en une std::wstring, selon Larry Osterman en 2015 : https://blogs.msdn.microsoft.com/larryosterman/2015/11/24/converting-win32-api-results-to-stdwstring-or-stdstring/
  • Dans ce texte de 2016, Raymond Chen explique ce qu'est un HSTRING dans Microsoft Windows : https://devblogs.microsoft.com/oldnewthing/?p=93675
  • Les chaînes de caractères de WinRT, par Kenny Kerr en 2018 : https://kennykerr.ca/2018/02/28/cppwinrt-strings/
• Quelques exemples de conversion en Java, pris directement de la documentation officielle de ce langage, voir : http://docs.oracle.com/javase/tutorial/java/data/converting.html