Der einfachste Weg, um int in String in C++ zu konvertieren

Nachdem C++ 17 einige Jahre später eine Diskussion mit @ v.oddou aufgenommen hatte, wurde endlich eine Möglichkeit geschaffen, die ursprünglich makro-basierte typunabhängige Lösung (unten erhalten) ohne durch Makro-Hässlichkeit zu führen .

// variadic template
template < typename... Args >
std::string sstr( Args &&... args )
{
    std::ostringstream sstr;
    // fold expression
    ( sstr << std::dec << ... << args );
    return sstr.str();
}

Verwendungszweck:

int i = 42;
std::string s = sstr( "i is: ", i );
puts( sstr( i ).c_str() );

Foo x( 42 );
throw std::runtime_error( sstr( "Foo is '", x, "', i is ", i ) );

Ursprüngliche Antwort:

Da "Konvertieren von ... in Zeichenfolge" ein wiederkehrendes Problem ist, definiere ich das Makro " SSTR () " immer in einem zentralen Header meiner C++ - Quellen:

#include <sstream>

#define SSTR( x ) static_cast< std::ostringstream & >( \
        ( std::ostringstream() << std::dec << x ) ).str()

Die Nutzung ist so einfach wie möglich:

int i = 42;
std::string s = SSTR( "i is: " << i );
puts( SSTR( i ).c_str() );

Foo x( 42 );
throw std::runtime_error( SSTR( "Foo is '" << x << "', i is " << i ) );

Das obige ist C++ 98-kompatibel (wenn Sie C++ 11 std::to_string nicht verwenden können) und benötigt keine Drittanbieter-Includes (wenn Sie Boost lexical_cast<> nicht verwenden können); Diese beiden anderen Lösungen weisen jedoch eine bessere Leistung auf.

Ich verwende normalerweise die folgende Methode:

#include <sstream>

template <typename T>
  std::string NumberToString ( T Number )
  {
     std::ostringstream ss;
     ss << Number;
     return ss.str();
  }

im Detail hier beschrieben.

Der häufigste einfache Weg schließt im Wesentlichen Ihre zweite Wahl in eine Vorlage mit dem Namen lexical_cast ein, z. B. in Boost , so dass Ihr Code so aussieht:

int a = 10;
string s = lexical_cast<string>(a);

Eine gute Sache dabei ist, dass es auch andere Casts unterstützt (z. B. funktioniert die umgekehrte Richtung genauso).

Beachten Sie auch, dass, obwohl Boost lexical_cast anfing, nur in einen Stringstream zu schreiben und dann den Stream wieder aus dem Stream zu extrahieren, es jetzt ein paar Ergänzungen enthält. Zunächst wurden Spezialisierungen für einige Typen hinzugefügt, so dass es für viele gängige Typen wesentlich schneller ist als die Verwendung eines Stringstreams. Zweitens prüft es nun das Ergebnis. Wenn Sie beispielsweise eine Zeichenfolge in eine int konvertieren, kann dies eine Ausnahme auslösen, wenn die Zeichenfolge etwas enthält, das nicht in eine int-Datei umgewandelt werden kann (z. B. würde 1234 erfolgreich sein.) 123abc würde werfen).

Seit C++ 11 ist eine std::to_string-Funktion für Ganzzahltypen überladen, sodass Sie folgenden Code verwenden können:

int a = 20;
std::string s = to_string(a);

Der Standard definiert diese als gleichwertig mit der Konvertierung mit sprintf (unter Verwendung des Konvertierungsspezifizierers, der mit dem bereitgestellten Objekttyp übereinstimmt, z. B. %d für int), in einen Puffer ausreichender Größe, und anschließend einen std::string des Inhalts dieses Puffers erstellt .

Wenn Sie Boost installiert haben (was Sie sollten):

#include <boost/lexical_cast.hpp>

int num = 4;
std::string str = boost::lexical_cast<std::string>(num);

Wäre es nicht einfacher, Stringstreams zu verwenden?

#include <sstream>

int x=42;            //The integer
string str;          //The string
ostringstream temp;  //temp as in temporary
temp<<x;
str=temp.str();      //str is temp as string

Oder machen Sie eine Funktion:

#include <sstream>

string IntToString (int a)
{
    ostringstream temp;
    temp<<a;
    return temp.str();
}

Nicht dass ich wüsste, in reinem C++. Aber eine kleine Änderung von dem, was Sie erwähnt haben

string s = string(itoa(a));

sollte funktionieren, und es ist ziemlich kurz.

sprintf() ist ziemlich gut für die Formatkonvertierung. Sie können den resultierenden C-String dann wie in 1 dem C++ - String zuweisen.

Zuerst gehören:

#include <string>
#include <sstream>

Zweitens fügen Sie die Methode hinzu:

template <typename T>
string NumberToString(T pNumber)
{
 ostringstream oOStrStream;
 oOStrStream << pNumber;
 return oOStrStream.str();
}

Verwenden Sie die Methode wie folgt:

NumberToString(69);

oder

int x = 69;
string vStr = NumberToString(x) + " Hello Word!."

Sie können std::to_string in C++ 11 als vorgeschlagen von Matthieu M. verwenden:

std::to_string(42);

Wenn die Leistung von entscheidender Bedeutung ist (wenn Sie beispielsweise viele Konvertierungen durchführen), können Sie fmt::FormatInt aus der Bibliothek C++ Format verwenden, um eine Ganzzahl in std::string zu konvertieren:

fmt::FormatInt(42).str();

Oder eine C-Saite:

fmt::FormatInt f(42);
f.c_str();

Letzteres führt keine dynamischen Speicherzuweisungen durch und ist mehr als zehnmal schneller als std::to_string bei Boost-Karma-Benchmarks. Weitere Informationen finden Sie unter SCHNELLE GANZZAHL-ZU-ZEICHENFOLGE-KONVERTIERUNG IN C++.

Im Gegensatz zu std::to_string benötigt fmt::FormatInt kein C++ 11 und kann mit jedem C++ - Compiler verwendet werden.

Haftungsausschluss: Ich bin der Autor der C++ - Formatbibliothek.

Die Verwendung von Stringstream zur Zahlenumrechnung ist gefährlich!

Siehe http://www.cplusplus.com/reference/ostream/ostream/operator%3C%3C/ wo angegeben wird, dass operator<< formatierte Ausgaben einfügt.

Je nach aktuellem Gebietsschema kann eine ganze Zahl mit mehr als 3 Ziffern in eine aus 4 Ziffern bestehende Zeichenfolge konvertiert werden, wodurch ein zusätzliches Tausendertrennzeichen hinzugefügt wird.

Zum Beispiel könnte int = 1000 in einen String 1.001 umgewandelt werden. Dies kann dazu führen, dass Vergleichsoperationen überhaupt nicht funktionieren.

Daher würde ich dringend die Verwendung des std::to_string-Weges empfehlen. Es ist einfacher und macht, was Sie erwarten.

Für C++ 98 gibt es einige Optionen:

boost/lexical_cast

Boost ist nicht Teil der C++ - Bibliothek, enthält jedoch viele nützliche Bibliothekserweiterungen.

Die Funktionsvorlage lexical_cast bietet ein bequemes und konsistentes Formular zur Unterstützung gängiger Konvertierungen in und aus beliebigen Typen, wenn diese als Text dargestellt werden. 
- Boost-Dokumentation

#include "boost/lexical_cast.hpp"
#include <string>

int main() {
    int x = 5;
    std::string x_str = boost::lexical_cast<std::string>(x);
    return 0;
}

Was die Laufzeit angeht, dauert der lexical_cast-Vorgang bei der ersten Konvertierung etwa 80 Mikrosekunden (auf meiner Maschine) und beschleunigt sich danach beträchtlich, wenn er redundant ausgeführt wird.

itoa

Diese Funktion ist nicht in ANSI-C definiert und gehört nicht zu C++, wird jedoch von einigen Compilern unterstützt. 
- cplusplus.com

Dies bedeutet, dass gccg++ Code nicht mit itoa kompilieren kann.

#include <stdlib.h>

int main() {
    int x = 5;
    char * x_str = new char[2];
    x_str = itoa(x, x_str, 10); // base 10
    return 0;
}

Keine Laufzeit zum Melden Ich habe kein Visual Studio installiert, das angeblich in der Lage ist, itoa zu kompilieren.

sprintf

sprintf ist eine C-Standard-Bibliotheksfunktion, die mit C-Strings arbeitet und eine absolut gültige Alternative ist.

Erstellt eine Zeichenfolge mit demselben Text, die gedruckt würde, wenn das Format für printf verwendet wurde. Der Inhalt wird jedoch nicht gedruckt, sondern als C-Zeichenfolge im Puffer gespeichert, auf den str zeigt. 
- cplusplus.com

#include <stdio.h>

int main() {
    int x = 5;
    char * x_str = new char[2];
    int chars_written = sprintf(x_str, "%d", x);
    return 0;
}

Der stdio.h-Header ist möglicherweise nicht erforderlich. Was die Laufzeit angeht, dauert die sprintf-Operation bei der ersten Konvertierung etwa 40 Mikrosekunden (auf meinem Computer) und beschleunigt sich danach beträchtlich, wenn sie redundant ausgeführt wird.

stringstream

Dies ist die Hauptmethode der C++ - Bibliothek, Ganzzahlen in Strings umzuwandeln und umgekehrt. Es gibt ähnliche Schwesterfunktionen wie stringstream, die die beabsichtigte Verwendung des Streams weiter einschränken, beispielsweise ostringstream. Durch die Verwendung von ostringstream wird der Leser insbesondere über Ihren Code informiert, dass Sie im Wesentlichen nur den Operator << verwenden möchten. Diese Funktion ist alles, was besonders notwendig ist, um eine Ganzzahl in einen String zu konvertieren. Siehe diese Frage für eine ausführlichere Diskussion.

#include <sstream>
#include <string>

int main() {
    int x = 5;
    std::ostringstream stream;
    stream << x;
    std::string x_str = stream.str();
    return 0;
}

Was die Laufzeit angeht, dauert die ostringstream-Operation ungefähr 71 Mikrosekunden (auf meiner Maschine) und beschleunigt sich danach beträchtlich, wenn sie redundant ausgeführt wird, jedoch _/nicht so sehr wie die vorherigen Funktionen.

Natürlich gibt es auch andere Optionen, und Sie können sogar eine davon in Ihre eigene Funktion einbinden, aber dies bietet einen analytischen Blick auf einige der beliebtesten.

Es ist ziemlich einfach, etwas syntaktischen Zucker hinzuzufügen, der es erlaubt, Strings on-the-fly in einer Stream-artigen Weise zusammenzusetzen

#include <string>
#include <sstream>

struct strmake {
    std::stringstream s;
    template <typename T> strmake& operator << (const T& x) {
        s << x; return *this;
    }   
    operator std::string() {return s.str();}
};

Jetzt können Sie an alles, was Sie möchten (sofern ein Operator << (std::ostream& ..) für ihn definiert ist) an strmake() anhängen und ihn anstelle eines std::string verwenden.

Beispiel:

#include <iostream>

int main() {
    std::string x =
      strmake() << "Current time is " << 5+5 << ":" << 5*5 << " GST";
    std::cout << x << std::endl;
}

Benutzen:

#define convertToString(x) #x

int main()
{
    convertToString(42); // Returns const char* equivalent of 42
}

C++ 17 bietet std :: to_chars als eine von der Locale unabhängige Alternative.

Ich benutze:

int myint = 0;
long double myLD = 0.0;

string myint_str = static_cast<ostringstream*>( &(ostringstream() << myint) )->str();
string myLD_str = static_cast<ostringstream*>( &(ostringstream() << myLD) )->str();

Es funktioniert auf meinen Windows- und Linux g ++ - Compilern. 

Es hat bei mir geklappt das mein Code:

#include <iostream>
using namespace std;

int main()
{
    int n=32;
    string s=to_string(n);
    cout << "string: " + s  << endl;
    return 0;
}

namespace std
{
    inline string to_string(int _Val)
    {   // convert long long to string
        char _Buf[2 * _MAX_INT_Dig];
        snprintf(_Buf, "%d", _Val);
        return (string(_Buf));
    }
}

sie können jetzt to_string(5) verwenden.

#include "stdafx.h"
#include<iostream>
#include<string>
#include<string.h>


std::string intToString(int num);

int main()
{

    int integer = 4782151;

    std::string integerAsStr = intToString(integer);

    std::cout << "integer = " << integer << std::endl;
    std::cout << "integerAsStr = " << integerAsStr << std::endl;


    return 0;
}

std::string intToString(int num)
{
    std::string numAsStr;

    while (num)
    {
        char toInsert = (num % 10) + 48;
        numAsStr.insert(0, 1, toInsert);

        num /= 10;
    }

    return numAsStr;
}

Hier ist ein weiterer einfacher Weg 

char str[100] ; 
sprintf(str , "%d" , 101 ) ;  
string s = str; 

sprintf ist allgemein bekannt, um beliebige Daten in einen String des erforderlichen Formats einzufügen.

Sie können char * array in string konvertieren, wie in der dritten Zeile gezeigt.

string number_to_string(int x){
    if(!x) return "0";
        string s,s2;
        while(x){
            s.Push_back(x%10 + '0');
            x/=10;
        }
    reverse(s.begin(),s.end());
    return s;
}

char * bufSecs = new char[32];
char * bufMs = new char[32];
sprintf(bufSecs,"%d",timeStart.elapsed()/1000);
sprintf(bufMs,"%d",timeStart.elapsed()%1000);

Warum kannst du es nicht einfach tun?

int a = 10;
string str = a + '0';

CString verwenden:

int a = 10;
CString strA;
strA.Format("%d", a);

Ich denke, das Verwenden von Stringstream ist ziemlich einfach.

 string toString(int n)
 {
   stringstream ss(n);
   ss << n;
   return ss.str();
 }

 int main()
 {
    int n;
    cin>>n;
    cout<<toString(n)<<endl;
    return 0;
 }

Verwenden von "reinem" C++ (kein C++ 11 usw.):

#include <bits/stdc++.h>

using namespace std;

string to_str(int x) {
    ostringstream ss;
    ss << x;
    return ss.str();
}

int main()
{
    int number = 10;
    string s = to_str(number);
    cout << s << endl;
    return 0;
}