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

Was ist der einfachste Weg, um in C ++ von inteinem Äquivalent zu konvertieren? stringMir sind zwei Methoden bekannt. Gibt es einen einfacheren Weg?

(1)

int a = 10;
char *intStr = itoa(a);
string str = string(intStr);

(2)

int a = 10;
stringstream ss;
ss << a;
string str = ss.str();

C ++ 11 führt std::stoi(und Varianten für jeden numerischen Typ) und std::to_stringdie Gegenstücke des C ein atoiund wird itoajedoch in Term ausgedrückt std::string.

#include <string> 

std::string s = std::to_string(42);

ist daher der kürzeste Weg, den ich mir vorstellen kann. Sie können sogar die Benennung des Typs mit dem autoSchlüsselwort weglassen :

auto s = std::to_string(42);

Hinweis: siehe [string.conversions] ( 21,5 in n3242 )

C ++ 17 hat einige Jahre später eine Diskussion mit @ v.oddou aufgenommen und bietet nun endlich die Möglichkeit, die ursprünglich makrobasierte typunabhängige Lösung ( siehe unten) zu erstellen, ohne die Makro-Hässlichkeit zu durchlaufen.

// 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 ... 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 Verwendung 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 oben genannte ist C ++ 98-kompatibel (wenn Sie C ++ 11 nicht verwenden können std::to_string) und benötigt keine Includes von Drittanbietern (wenn Sie Boost nicht verwenden können lexical_cast<>). Diese beiden anderen Lösungen weisen jedoch eine bessere Leistung auf.

Normalerweise verwende ich die folgende Methode:

#include <sstream>

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

Es wird im Detail beschrieben hier .

Die wohl häufigste einfache Art und Weise wickelt im Wesentlichen Ihre zweite Wahl in eine Vorlage mit dem Namen lexical_cast, wie die in - Boost , so dass Ihr Code sieht wie folgt aus :

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

Eine Besonderheit davon ist, dass es auch andere Casts unterstützt (z. B. funktioniert die entgegengesetzte Richtung genauso gut).

Beachten Sie auch, dass Boost lexical_cast zwar zunächst nur in einen Stringstream schrieb und dann wieder aus dem Stream extrahierte, jetzt aber einige Ergänzungen enthält. Zunächst wurden Spezialisierungen für einige Typen hinzugefügt, sodass diese für viele gängige Typen wesentlich schneller sind als die Verwendung eines Stringstreams. Zweitens wird jetzt das Ergebnis überprüft. Wenn Sie also beispielsweise von einer Zeichenfolge in eine konvertieren int, kann eine Ausnahme ausgelöst werden, wenn die Zeichenfolge etwas enthält, das nicht in eine konvertiert werden konnte int(z. B. 1234wäre erfolgreich, 123abcwürde aber werfen). .

Ab C ++ 11 ist eine std::to_stringFunktion für Ganzzahltypen überladen, sodass Sie Code wie folgt verwenden können:

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

Der Standard definiert diese als äquivalent zur Konvertierung mit sprintf(unter Verwendung des Konvertierungsspezifizierers, der dem angegebenen Objekttyp entspricht, z. B. %dfür int) in einen Puffer mit ausreichender Größe und anschließendem Erstellen eines std::stringInhalts dieses Puffers.

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

Es wäre 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 das ich wüsste, in reinem C ++. Aber eine kleine Modifikation von dem, was Sie erwähnt haben

string s = string(itoa(a));

sollte funktionieren, und es ist ziemlich kurz.

Sie können std::to_stringverfügbar in C ++ 11 verwenden, wie von Matthieu M vorgeschlagen :

std::to_string(42);

Wenn die Leistung kritisch ist (z. B. wenn Sie viele Konvertierungen durchführen), können Sie fmt::format_intaus der {fmt} -Bibliothek eine Ganzzahl konvertieren in std::string:

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

Oder eine C-Zeichenfolge:

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

Letzterer führt keine dynamischen Speicherzuweisungen durch und ist mehr als zehnmal schneller als std::to_stringbei Boost Karma-Benchmarks. Weitere Informationen finden Sie unter Schnelle Konvertierung von Ganzzahlen in Zeichenfolgen in C ++ .

Beachten Sie, dass beide threadsicher sind.

Im Gegensatz zu std::to_string, fmt::format_interfordert nicht C ++ 11 und funktioniert mit jedem C ++ Compiler.

Haftungsausschluss: Ich bin der Autor der {fmt} -Bibliothek.

sprintf()ist ziemlich gut für die Formatkonvertierung. Sie können dann die resultierende C-Zeichenfolge der C ++ - Zeichenfolge wie in 1 zuweisen.

Zuerst umfassen:

#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!."

Die Verwendung von Stringstream zur Nummernkonvertierung ist gefährlich!

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

Abhängig von Ihrem aktuellen Gebietsschema kann eine Ganzzahl mit mehr als 3 Ziffern in eine Zeichenfolge mit 4 Ziffern konvertiert werden, wobei ein zusätzliches Tausendertrennzeichen hinzugefügt wird.

Könnte int = 1000beispielsweise in einen String konvertiert werden 1.001. Dies könnte dazu führen, dass Vergleichsoperationen überhaupt nicht funktionieren.

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

Aktualisiert (siehe Kommentare unten) :

C ++ 17 bietet std::to_charseine leistungsstärkere, vom Gebietsschema unabhängige Alternative

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

boost/lexical_cast

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

Die lexical_castFunktionsvorlage bietet eine bequeme und konsistente Form zur Unterstützung gängiger Konvertierungen von und zu beliebigen Typen, wenn diese als Text dargestellt werden.
- Boosts 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 betrifft, lexical_castdauert der Vorgang bei der ersten Konvertierung etwa 80 Mikrosekunden (auf meinem Computer) und wird anschließend erheblich beschleunigt, wenn er redundant ausgeführt wird.

itoa

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

Dies bedeutet, dass gcc/ g++Code nicht mit kompiliert werden kann itoa.

#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 zu melden. Ich habe Visual Studio nicht installiert, das Berichten zufolge kompiliert werden kann itoa.

sprintf

sprintf ist eine C-Standardbibliotheksfunktion, die mit C-Strings funktioniert und eine absolut gültige Alternative darstellt.

Erstellt eine Zeichenfolge mit demselben Text, der gedruckt würde, wenn das Format für printf verwendet würde. Statt gedruckt zu werden, wird der Inhalt als C-Zeichenfolge in dem 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.hHeader ist möglicherweise nicht erforderlich. Was die Laufzeit betrifft, sprintfdauert der Vorgang bei der ersten Konvertierung etwa 40 Mikrosekunden (auf meinem Computer) und wird anschließend erheblich beschleunigt, wenn er redundant ausgeführt wird.

stringstream

Dies ist die Hauptmethode der C ++ - Bibliothek zum Konvertieren von Ganzzahlen in Zeichenfolgen und umgekehrt. Es gibt ähnliche Schwesterfunktionen stringstream, die die beabsichtigte Verwendung des Streams weiter einschränken, wie z ostringstream. Die Verwendung ostringstreamteilt dem Leser Ihres Codes ausdrücklich mit, dass Sie im <<Wesentlichen nur den Operator verwenden möchten. Diese Funktion ist alles, was besonders notwendig ist, um eine Ganzzahl in eine Zeichenfolge umzuwandeln. In dieser Frage finden Sie 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 betrifft, ostringstreamdauert der Vorgang ungefähr 71 Mikrosekunden (auf meinem Computer) und beschleunigt sich danach erheblich, wenn er redundant ausgeführt wird, jedoch nicht so stark 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.

C ++ 17 bietet std :: to_chars als leistungsstärkere, vom Gebietsschema unabhängige Alternative.

Es ist ziemlich einfach, etwas syntaktischen Zucker hinzuzufügen, der es einem ermöglicht, Strings im laufenden Betrieb stromartig zu komponieren

#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 anhängen, was Sie möchten (vorausgesetzt, ein Operator << (std::ostream& ..)ist dafür definiert), strmake()und es anstelle von verwenden std::string.

Beispiel:

#include <iostream>

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

BEARBEITET. Wenn Sie eine schnelle Konvertierung einer Ganzzahl mit einer festen Anzahl von Ziffern in ein mit * 0 links aufgefülltes Zeichen * benötigen , ist dies das Beispiel für Little-Endian-Architekturen (alle x86, x86_64 und andere):

Wenn Sie eine zweistellige Zahl konvertieren:

int32_t s = 0x3030 | (n/10) | (n%10) << 8;

Wenn Sie eine dreistellige Zahl konvertieren:

int32_t s = 0x303030 | (n/100) | (n/10%10) << 8 | (n%10) << 16;

Wenn Sie eine vierstellige Zahl konvertieren:

int64_t s = 0x30303030 | (n/1000) | (n/100%10)<<8 | (n/10%10)<<16 | (n%10)<<24;

Und so weiter bis zu siebenstellige Zahlen. In diesem Beispiel nist eine bestimmte Ganzzahl. Nach der Konvertierung kann auf die Zeichenfolgendarstellung zugegriffen werden als (char*)&s:

std::cout << (char*)&s << std::endl;

HINWEIS: Wenn Sie es in Big-Endian-Bytereihenfolge benötigen, obwohl ich es nicht getestet habe, aber hier ein Beispiel: Für dreistellige Zahlen ist es int32_t s = 0x00303030 | (n/100)<< 24 | (n/10%10)<<16 | (n%10)<<8;für vierstellige Zahlen (64-Bit-Bogen): int64_t s = 0x0000000030303030 | (n/1000)<<56 | (n/100%10)<<48 | (n/10%10)<<40 | (n%10)<<32;Ich denke, es sollte funktionieren.

Verwenden:

#define convertToString(x) #x

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

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.

Hier ist eine weitere einfache Möglichkeit

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

sprintf ist bekannt dafür, Daten in eine Zeichenfolge des erforderlichen Formats einzufügen.

Sie können ein char *Array wie in der dritten Zeile gezeigt in eine Zeichenfolge konvertieren .

Das hat bei mir funktioniert -

Mein Code:

#include <iostream>
using namespace std;

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

C ++ 11 std::to_string()für numerische Typen eingeführt:

int n = 123; // Input, signed/unsigned short/int/long/long long/float/double
std::string str = std::to_string(n); // Output, std::string

Verwenden:

#include<iostream>
#include<string>

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

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

Wenn Sie MFC verwenden , können Sie Folgendes verwenden CString:

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

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

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 verwenden to_string(5).

Ich denke, die Verwendung stringstreamist 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;
 }

Sie verwenden einen Zählertyp-Algorithmus, um ihn in eine Zeichenfolge zu konvertieren. Ich habe diese Technik durch Programmieren von Commodore 64- Computern erhalten. Es ist auch gut für die Spielprogrammierung.

• Sie nehmen die ganze Zahl und nehmen jede Ziffer, die mit Zehnerpotenzen gewichtet ist. Nehmen wir also an, die ganze Zahl ist 950.

  • Wenn die Ganzzahl gleich oder größer als 100.000 ist, subtrahieren Sie 100.000 und erhöhen Sie den Zähler in der Zeichenfolge bei ["000000"];
    Mach so weiter, bis keine Zahlen mehr auf Position 100.000 sind. Lass eine weitere Zehnerpotenz fallen.

  • Wenn die Ganzzahl gleich oder größer als 10.000 ist, subtrahieren Sie 10.000 und erhöhen Sie den Zähler in der Zeichenfolge an der Position ["000000"] + 1;
    mach so weiter, bis keine Zahlen mehr auf Position 10.000 sind.

• Lass eine weitere Zehnerpotenz fallen

• Wiederholen Sie das Muster

Ich weiß, dass 950 zu klein ist, um als Beispiel zu dienen, aber ich hoffe, Sie haben die Idee.