it-swarm.com.de

Wie verkettet man einen std :: string und einen int?

Ich dachte, das wäre wirklich einfach, aber es bringt einige Schwierigkeiten mit sich. Wenn ich habe

std::string name = "John";
int age = 21;

Wie kombiniere ich sie, um eine einzelne Zeichenfolge "John21" zu erhalten?

624
Obediah Stane

In alphabetischer Reihenfolge:

std::string name = "John";
int age = 21;
std::string result;

// 1. with Boost
result = name + boost::lexical_cast<std::string>(age);

// 2. with C++11
result = name + std::to_string(age);

// 3. with FastFormat.Format
fastformat::fmt(result, "{0}{1}", name, age);

// 4. with FastFormat.Write
fastformat::write(result, name, age);

// 5. with the {fmt} library
result = fmt::format("{}{}", name, age);

// 6. with IOStreams
std::stringstream sstm;
sstm << name << age;
result = sstm.str();

// 7. with itoa
char numstr[21]; // enough to hold all numbers up to 64-bits
result = name + itoa(age, numstr, 10);

// 8. with sprintf
char numstr[21]; // enough to hold all numbers up to 64-bits
sprintf(numstr, "%d", age);
result = name + numstr;

// 9. with STLSoft's integer_to_string
char numstr[21]; // enough to hold all numbers up to 64-bits
result = name + stlsoft::integer_to_string(numstr, 21, age);

// 10. with STLSoft's winstl::int_to_string()
result = name + winstl::int_to_string(age);

// 11. With Poco NumberFormatter
result = name + Poco::NumberFormatter().format(age);
  1. ist sicher, aber langsam; erfordert Boost (nur Header); die meisten/alle Plattformen
  2. ist sicher, erfordert C++ 11 ( to_string () ist bereits in #include <string> enthalten)
  3. ist sicher und schnell; erfordert FastFormat , das kompiliert werden muss; die meisten/alle Plattformen
  4. ( dito )
  5. ist sicher und schnell; erfordert die {fmt} -Bibliothek , die entweder kompiliert oder nur im Header-Modus verwendet werden kann; die meisten/alle Plattformen
  6. sicher, langsam und wortreich; benötigt #include <sstream> (von Standard C++)
  7. ist spröde (Sie müssen einen ausreichend großen Puffer bereitstellen), schnell und ausführlich; itoa () ist keine Standarderweiterung und steht nicht für alle Plattformen zur Verfügung
  8. ist spröde (Sie müssen einen ausreichend großen Puffer bereitstellen), schnell und ausführlich; erfordert nichts (ist Standard C++); alle Plattformen
  9. ist spröde (Sie müssen einen ausreichend großen Puffer bereitstellen), wahrscheinlich die schnellstmögliche Konvertierung , wortreich; erfordert STLSoft (nur Header); die meisten/alle Plattformen
  10. safe-ish (Sie verwenden nicht mehr als einen int_to_string () Aufruf in einer einzigen Anweisung), fast; erfordert STLSoft (nur Header); Nur für Windows
  11. ist sicher, aber langsam; erfordert Poco C++ ; die meisten/alle Plattformen
1057
DannyT

In C++ 11 können Sie std::to_string verwenden, z.

auto result = name + std::to_string( age );
250
Jeremy

Wenn Sie Boost haben, können Sie die Ganzzahl mit boost::lexical_cast<std::string>(age) in eine Zeichenfolge konvertieren.

Eine andere Möglichkeit ist die Verwendung von Stringstreams:

std::stringstream ss;
ss << age;
std::cout << name << ss.str() << std::endl;

Ein dritter Ansatz wäre, sprintf oder snprintf aus der C-Bibliothek zu verwenden.

char buffer[128];
snprintf(buffer, sizeof(buffer), "%s%d", name.c_str(), age);
std::cout << buffer << std::endl;

Andere Poster, die mit itoa vorgeschlagen wurden. Dies ist KEINE Standardfunktion, sodass Ihr Code nicht portierbar ist, wenn Sie ihn verwenden. Es gibt Compiler, die das nicht unterstützen.

82
Jay Conrod
#include <iostream>
#include <sstream>

std::ostringstream o;
o << name << age;
std::cout << o.str();
75
Ben Hoffstein
#include <iostream>
#include <string>
#include <sstream>
using namespace std;
string itos(int i) // convert int to string
{
    stringstream s;
    s << i;
    return s.str();
}

Schamlos gestohlen von http://www.research.att.com/~bs/bs_faq2.html .

50
tloach

Dies ist der einfachste Weg:

string s = name + std::to_string(age);
29
Kevin

Wenn Sie C++ 11 haben, können Sie std::to_string verwenden.

Beispiel:

std::string name = "John";
int age = 21;

name += std::to_string(age);

std::cout << name;

Ausgabe:

John21
22
0x499602D2

Mir scheint, dass die einfachste Antwort darin besteht, die Funktion sprintf zu verwenden:

sprintf(outString,"%s%d",name,age);
18
user12576
#include <string>
#include <sstream>
using namespace std;
string concatenate(std::string const& name, int i)
{
    stringstream s;
    s << name << i;
    return s.str();
}
15
Seb Rose

Herb Sutter hat einen guten Artikel zu diesem Thema: "The String Formatters of Manor Farm" . Er behandelt Boost::lexical_cast, std::stringstream, std::strstream (was veraltet ist) und sprintf vs. snprintf.

12
Fred Larson
#include <sstream>

template <class T>
inline std::string to_string (const T& t)
{
   std::stringstream ss;
   ss << t;
   return ss.str();
}

Dann würde Ihre Nutzung ungefähr so ​​aussehen

   std::string szName = "John";
   int numAge = 23;
   szName += to_string<int>(numAge);
   cout << szName << endl;

gegoogelt [und getestet: p]

11
Zing-

Dieses Problem kann auf viele Arten gelöst werden. Ich werde es auf zwei Arten zeigen:

  1. Konvertieren Sie die Zahl mit to_string(i) in einen String.

  2. String-Streams verwenden.

    Code:

    #include <string>
    #include <sstream>
    #include <bits/stdc++.h>
    #include <iostream>
    using namespace std;
    
    int main() {
        string name = "John";
        int age = 21;
    
        string answer1 = "";
        // Method 1). string s1 = to_string(age).
    
        string s1=to_string(age); // Know the integer get converted into string
        // where as we know that concatenation can easily be done using '+' in C++
    
        answer1 = name + s1;
    
        cout << answer1 << endl;
    
        // Method 2). Using string streams
    
        ostringstream s2;
    
        s2 << age;
    
        string s3 = s2.str(); // The str() function will convert a number into a string
    
        string answer2 = "";  // For concatenation of strings.
    
        answer2 = name + s3;
    
        cout << answer2 << endl;
    
        return 0;
    }
    
8
lohith99

Wenn Sie + für die Verkettung von Objekten mit einem Ausgabeoperator verwenden möchten, können Sie eine Vorlagenversion von operator+ bereitstellen:

template <typename L, typename R> std::string operator+(L left, R right) {
  std::ostringstream os;
  os << left << right;
  return os.str();
}

Dann können Sie Ihre Verkettungen auf einfache Weise schreiben:

std::string foo("the answer is ");
int i = 42;
std::string bar(foo + i);    
std::cout << bar << std::endl;

Ausgabe:

the answer is 42

Dies ist nicht der effizienteste Weg, aber Sie benötigen nicht den effizientesten Weg, es sei denn, Sie führen eine große Verkettung innerhalb einer Schleife durch.

7
uckelman

Wenn Sie MFC verwenden, können Sie einen CString verwenden

CString nameAge = "";
nameAge.Format("%s%d", "John", 21);

Managed C++ hat auch ein Zeichenkettenformatierer .

5
bsruth

Der std :: ostringstream ist eine gute Methode, aber manchmal kann dieser zusätzliche Trick nützlich sein, um die Formatierung in einen Einzeiler umzuwandeln:

#include <sstream>
#define MAKE_STRING(tokens) /****************/ \
    static_cast<std::ostringstream&>(          \
        std::ostringstream().flush() << tokens \
    ).str()                                    \
    /**/

Jetzt können Sie Zeichenfolgen wie folgt formatieren:

int main() {
    int i = 123;
    std::string message = MAKE_STRING("i = " << i);
    std::cout << message << std::endl; // prints: "i = 123"
}
4
Pyry Jahkola

Da eine Qt-bezogene Frage zugunsten dieser Frage geschlossen wurde, erfahren Sie hier, wie Sie dies mit Qt tun können:

QString string = QString("Some string %1 with an int somewhere").arg(someIntVariable);
string.append(someOtherIntVariable);

Die Zeichenfolgenvariable hat jetzt den Wert von someIntVariable anstelle von% 1 und den Wert von someOtherIntVariable am Ende.

4
leinir

Häufige Antwort: itoa ()

Das ist schlecht. itoa ist nicht Standard, wie bereits erwähnt hier .

3
Tom Ritter

Es gibt mehrere Optionen, mit denen Sie eine Ganzzahl (oder ein anderes numerisches Objekt) mit einer Zeichenfolge verketten können. Es ist Boost.Format

#include <boost/format.hpp>
#include <string>
int main()
{
    using boost::format;

    int age = 22;
    std::string str_age = str(format("age is %1%") % age);
}

und Karma von Boost.Spirit (v2)

#include <boost/spirit/include/karma.hpp>
#include <iterator>
#include <string>
int main()
{
    using namespace boost::spirit;

    int age = 22;
    std::string str_age("age is ");
    std::back_insert_iterator<std::string> sink(str_age);
    karma::generate(sink, int_, age);

    return 0;
}

Boost.Spirit Karma behauptet, eine der schnellste Option für Ganzzahl in String Konvertierungen zu sein.

3
mloskot

Wenn Sie ein char * ausgeben möchten und Stringstream gemäß den obigen Angaben der Befragten verwendet haben, tun Sie Folgendes:

myFuncWhichTakesPtrToChar(ss.str().c_str());

Da das, was der Stringstream über str () zurückgibt, ein Standard-String ist, können Sie daraufhin c_str () aufrufen, um den gewünschten Ausgabetyp zu erhalten.

3
Engineer

Sie können int mit dem folgenden einfachen Trick mit string verknüpfen. Beachten Sie jedoch, dass dies nur funktioniert, wenn integer eine einstellige Zahl ist. Andernfalls fügen Sie dieser Zeichenfolge eine ganze Zahl ziffernweise hinzu.

string name = "John";
int age = 5;
char temp = 5 + '0';
name = name + temp;
cout << name << endl;

Output:  John5
2
Sukhbir

Hier ist eine Implementierung, wie ein Int an einen String angehängt wird, indem die Parsing- und Formatierungsfacetten aus der IOStreams-Bibliothek verwendet werden.

#include <iostream>
#include <locale>
#include <string>

template <class Facet>
struct erasable_facet : Facet
{
    erasable_facet() : Facet(1) { }
    ~erasable_facet() { }
};

void append_int(std::string& s, int n)
{
    erasable_facet<std::num_put<char,
                                std::back_insert_iterator<std::string>>> facet;
    std::ios str(nullptr);

    facet.put(std::back_inserter(s), str,
                                     str.fill(), static_cast<unsigned long>(n));
}

int main()
{
    std::string str = "ID: ";
    int id = 123;

    append_int(str, id);

    std::cout << str; // ID: 123
}
2
0x499602D2

Es gibt eine von mir geschriebene Funktion, die die int-Zahl als Parameter verwendet und in ein String-Literal konvertiert. Diese Funktion ist von einer anderen Funktion abhängig, die eine einzelne Ziffer in ihr Zeichenäquivalent umwandelt:

char intToChar(int num)
{
    if (num < 10 && num >= 0)
    {
        return num + 48;
        //48 is the number that we add to an integer number to have its character equivalent (see the unsigned ASCII table)
    }
    else
    {
        return '*';
    }
}

string intToString(int num)
{
    int digits = 0, process, single;
    string numString;
    process = num;

    // The following process the number of digits in num
    while (process != 0)
    {
        single  = process % 10; // 'single' now holds the rightmost portion of the int
        process = (process - single)/10;
        // Take out the rightmost number of the int (it's a zero in this portion of the int), then divide it by 10
        // The above combination eliminates the rightmost portion of the int
        digits ++;
    }

    process = num;

    // Fill the numString with '*' times digits
    for (int i = 0; i < digits; i++)
    {
        numString += '*';
    }


    for (int i = digits-1; i >= 0; i--)
    {
        single = process % 10;
        numString[i] = intToChar ( single);
        process = (process - single) / 10;
    }

    return numString;
}
2
Reda Lahdili
  • std :: ostringstream
#include <sstream>

std::ostringstream s;
s << "John " << age;
std::string query(s.str());
  • std :: to_string (C++ 11)
std::string query("John " + std::to_string(age));
  • boost :: lexical_cast
#include <boost/lexical_cast.hpp>

std::string query("John " + boost::lexical_cast<std::string>(age));
2

Mit der {fmt} Bibliothek :

auto result = fmt::format("{}{}", name, age);

Eine Teilmenge der Bibliothek wird zur Standardisierung vorgeschlagen als P0645 Textformatierung und wenn akzeptiert, wird das oben Genannte:

auto result = std::format("{}{}", name, age);

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

1
vitaut

Die detaillierte Antwort ist unter anderen Antworten vergraben und taucht teilweise wieder auf:

#include <iostream> // cout
#include <string> // string, to_string(some_number_here)

using namespace std;

int main() {
    // using constants
    cout << "John" + std::to_string(21) << endl;
    // output is:
    //    John21

    // using variables
    string name = "John";
    int age = 21;
    cout << name + to_string(age) << endl;
    // output is:
    //    John21
}