So konvertieren Sie eine Zahl in eine Zeichenfolge und umgekehrt in C++

Da diese Frage jede Woche gestellt wird, könnte diese FAQ vielen Benutzern helfen.

• So konvertieren Sie in C++ eine Ganzzahl in einen String

• wie man in C++ einen String in einen Integer umwandelt

• wie man in C++ eine Fließkommazahl in einen String umwandelt

• wie man in C++ einen String in eine Fließkommazahl umwandelt

Update für C++11

Ab dem C++11 Standard, Konvertierung von Zeichenfolgen in Zahlen und umgekehrt sind in die Standardbibliothek integriert. Alle folgenden Funktionen sind in vorhanden <string> (gemäß Absatz 21.5).

Zeichenfolge zu numerisch

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);
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);

Jeder von ihnen nimmt eine Zeichenfolge als Eingabe und versucht, sie in eine Zahl umzuwandeln. Wenn keine gültige Zahl konstruiert werden konnte, weil beispielsweise keine numerischen Daten vorhanden sind oder die Zahl für den Typ außerhalb des zulässigen Bereichs liegt, wird eine Ausnahme ausgelöst (std::invalid_argument oder std::out_of_range).

Wenn die Konvertierung erfolgreich war und idx ist nicht 0, idx enthält den Index des ersten Zeichens, das nicht für die Dekodierung verwendet wurde. Dies könnte ein Index hinter dem letzten Zeichen sein.

Schließlich erlauben die ganzzahligen Typen die Angabe einer Basis, für Ziffern größer als 9 wird das Alphabet angenommen (a=10 noch bis z=35). Weitere Informationen zur genauen Formatierung, die analysiert werden kann, finden Sie hier Gleitkommazahlen, vorzeichenbehaftete ganze Zahlen und vorzeichenlose ganze Zahlen.

Schließlich gibt es für jede Funktion auch eine Überladung, die a akzeptiert std::wstring als erster Parameter.

numerisch zu Zeichenfolge

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);

Diese sind einfacher, Sie übergeben den entsprechenden numerischen Typ und erhalten eine Zeichenfolge zurück. Für Formatierungsoptionen sollten Sie zur C++03-Stringsream-Option zurückkehren und Stream-Manipulatoren verwenden, wie in einer anderen Antwort hier erläutert.

Wie in den Kommentaren erwähnt, greifen diese Funktionen auf eine standardmäßige Mantissengenauigkeit zurück, die wahrscheinlich nicht die maximale Genauigkeit ist. Wenn für Ihre Anwendung mehr Präzision erforderlich ist, greifen Sie am besten auch auf andere Zeichenfolgenformatierungsverfahren zurück.

Es sind auch ähnliche Funktionen definiert, die benannt sind to_wstringdiese geben a zurück std::wstring.

So konvertieren Sie eine Zahl in eine Zeichenfolge in C++03

1. Verwende nicht der itoa oder itof Funktionen, da sie nicht standardisiert und daher nicht portierbar sind.

2. Verwenden Sie String-Streams

    #include <sstream>  //include this to use string streams
    #include <string> 
   
   int main()
   {    
       int number = 1234;
   
       std::ostringstream ostr; //output string stream
       ostr << number; //use the string stream just like cout,
       //except the stream prints not to stdout but to a string.
   
       std::string theNumberString = ostr.str(); //the str() function of the stream 
       //returns the string.
   
       //now  theNumberString is "1234"  
   }
   

   Beachten Sie, dass Sie String-Streams auch verwenden können, um Gleitkommazahlen in Strings umzuwandeln und den String wie gewünscht zu formatieren, genau wie mit cout

   std::ostringstream ostr;
   float f = 1.2;
   int i = 3;
   ostr << f << " + " i << " = " << f + i;   
   std::string s = ostr.str();
   //now s is "1.2 + 3 = 4.2" 
   

   Sie können Stream-Manipulatoren verwenden, z std::endl, std::hex und Funktionen std::setw(), std::setprecision() etc. mit Stringstreams genauso wie mit cout

   Nicht verwechseln std::ostringstream mit std::ostrstream. Letzteres ist veraltet

3. Verwenden lexikalische Besetzung verstärken. Wenn Sie mit Boost nicht vertraut sind, ist es eine gute Idee, mit einer kleinen Bibliothek wie dieser lexical_cast zu beginnen. Zum Herunterladen und Installieren von Boost und seiner Dokumentation Gehe hier hin. Obwohl Boost nicht im C++-Standard enthalten ist, werden viele Boost-Bibliotheken schließlich standardisiert, und Boost wird allgemein als eine der besten C++-Bibliotheken angesehen.

   Lexical Cast verwendet Streams darunter, also ist diese Option im Grunde die gleiche wie die vorherige, nur weniger ausführlich.

   #include <boost/lexical_cast.hpp>
   #include <string>
   
   int main()
   {
      float f = 1.2;
      int i = 42;
      std::string sf = boost::lexical_cast<std::string>(f); //sf is "1.2"
      std::string si = boost::lexical_cast<std::string>(i); //sf is "42"
   }
   

Wie man in C++03 einen String in eine Zahl umwandelt

1. Die einfachste Option, die von C geerbt wurde, sind die Funktionen atoi (für ganze Zahlen (alphabetisch zu ganzen Zahlen)) und atof (für Fließkommawerte (alphabetisch nach Float)). Diese Funktionen nehmen eine Zeichenfolge im C-Stil als Argument (const char *) und damit ihre Verwendung dürfen als nicht gerade gute C++-Praxis angesehen werden. cplusplus.com hat eine leicht verständliche Dokumentation zu beiden atoi und atof einschließlich, wie sie sich im Falle einer schlechten Eingabe verhalten. Der Link enthält jedoch den Fehler, dass laut Standard das Verhalten undefiniert ist, wenn die Eingabenummer zu groß ist, um in den Zieltyp zu passen.

   #include <cstdlib> //the standard C library header
   #include <string>
   int main()
   {
       std::string si = "12";
       std::string sf = "1.2";
       int i = atoi(si.c_str()); //the c_str() function "converts" 
       double f = atof(sf.c_str()); //std::string to const char*
   }
   

2. Verwenden Sie String-Streams (diesmal geben Sie String-Stream ein, istringstream). Auch hier wird istringstream wie verwendet cin. Auch hier nicht verwechseln istringstream mit istrstream. Letzteres ist veraltet.

   #include <sstream>
   #include <string>
   int main()
   {
      std::string inputString = "1234 12.3 44";
      std::istringstream istr(inputString);
      int i1, i2;
      float f;
      istr >> i1 >> f >> i2;
      //i1 is 1234, f is 12.3, i2 is 44  
   }
   

3. Verwenden lexikalische Besetzung verstärken.

   #include <boost/lexical_cast.hpp>
   #include <string>
   
   int main()
   {
      std::string sf = "42.2"; 
      std::string si = "42";
      float f = boost::lexical_cast<float>(sf); //f is 42.2
      int i = boost::lexical_cast<int>(si);  //i is 42
   }       
   

   Im Falle einer schlechten Eingabe, lexical_cast löst eine Ausnahme vom Typ aus boost::bad_lexical_cast

In C++17 neue Funktionen std::to_chars und std::from_chars werden in der Kopfzeile eingeführt charconv.

std::to_chars ist gebietsschemaunabhängig, nicht zuweisend und nicht werfend.

Es wird nur eine kleine Teilmenge von Formatierungsrichtlinien bereitgestellt, die von anderen Bibliotheken (z. B. std::sprintf) verwendet werden.

Von std::to_charsdas gleiche für std::from_chars.

Die Garantie, dass std::from_chars jeden von to_chars formatierten Fließkommawert exakt wiederherstellen kann, ist nur gegeben, wenn beide Funktionen aus derselben Implementierung stammen

 // See en.cppreference.com for more information, including format control.
#include <cstdio>
#include <cstddef>
#include <cstdlib>
#include <cassert>
#include <charconv>

using Type =  /* Any fundamental type */ ;
std::size_t buffer_size = /* ... */ ;

[[noreturn]] void report_and_exit(int ret, const char *output) noexcept 
{
    std::printf("%s\n", output);
    std::exit(ret);
}
void check(const std::errc &ec) noexcept
{
    if (ec ==  std::errc::value_too_large)
        report_and_exit(1, "Failed");
}
int main() {
    char buffer[buffer_size];        
    Type val_to_be_converted, result_of_converted_back;

    auto result1 = std::to_chars(buffer, buffer + buffer_size,  val_to_be_converted);
    check(result1.ec);
    *result1.ptr="\0";

    auto result2 = std::from_chars(buffer, result1.ptr, result_of_converted_back);
    check(result2.ec);

    assert(val_to_be_converted == result_of_converted_back);
    report_and_exit(0, buffer);
}

Obwohl es von Compilern noch nicht vollständig implementiert ist, wird es definitiv implementiert werden.

Ich habe diese praktische Klasse irgendwo hier bei StackOverflow gestohlen, um alles, was streambar ist, in einen String zu konvertieren:

// make_string
class make_string {
public:
  template <typename T>
  make_string& operator<<( T const & val ) {
    buffer_ << val;
    return *this;
  }
  operator std::string() const {
    return buffer_.str();
  }
private:
  std::ostringstream buffer_;
};

Und dann verwenden Sie es als;

string str = make_string() << 6 << 8 << "hello";

Ziemlich raffiniert!

Außerdem verwende ich diese Funktion, um Zeichenfolgen in alles zu konvertieren, was streambar ist, obwohl es nicht sehr sicher ist, wenn Sie versuchen, eine Zeichenfolge zu analysieren, die keine Zahl enthält.
(und es ist auch nicht so schlau wie das letzte)

// parse_string
template <typename RETURN_TYPE, typename STRING_TYPE>
RETURN_TYPE parse_string(const STRING_TYPE& str) {
  std::stringstream buf;
  buf << str;
  RETURN_TYPE val;
  buf >> val;
  return val;
}

Benutzen als:

int x = parse_string<int>("78");

Möglicherweise möchten Sie auch Versionen für wstrings.

#include <iostream>
#include <string.h>
using namespace std;
int main() {
   string s="000101";
   cout<<s<<"\n";
   int a = stoi(s);
   cout<<a<<"\n";
   s=to_string(a);
   s+='1';
   cout<<s;
   return 0;
}

Ausgabe:

• 000101
• 101
• 1011