c++ titel Wie verkette ich eine std:: string und eine int?




title tag länge 2018 (23)

Gemeinsame Antwort: itoa()

Das ist schlecht. itoa ist nicht Standard, wie here .

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 einzige Saite "John21" ?


Eine alternative Lösung für Leute wie mich vorschlagen, die möglicherweise keinen Zugriff auf C ++ 11 und zusätzliche Bibliotheken / Header wie Boost haben. Eine einfache Umwandlung funktioniert folgendermaßen:

Beispiel die Zahl ist 4, um 3 in ASCII umzuwandeln können wir einfach den Code verwenden:
char a = '0' + 4

Dies speichert sofort 4 als Zeichen in einem.

Von hier aus können wir einfach a mit dem Rest der Zeichenkette verketten.


Es scheint mir, dass die einfachste Antwort die Verwendung der sprintf Funktion ist:

sprintf(outString,"%s%d",name,age);

Ich habe nicht genug Karma, um etwas zu kommentieren (geschweige denn zu editieren), aber Jay's Post (derzeit der mit der besten Wahl bei 27) enthält einen Fehler. Dieser Code:

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

Löst das angegebene Problem des Erstellens einer Zeichenfolge, die aus einer verketteten Zeichenfolge und Ganzzahl besteht, nicht. Ich glaube Jay meinte etwas mehr so:

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

Die letzte Zeile dient nur zum Drucken des Ergebnisses und zeigt, wie auf die letzte verkettete Zeichenfolge zugegriffen wird.


Eine weitere einfache Möglichkeit ist es:

name.append(age+"");
cout << name;

Ich bin ein Anfänger C ++ Benutzer und fand dies am einfachsten:

cout << name << age; 

Dies wird erfolgreich Namen und Alter verketten, die Ausgabe wird "John21" sein.

Aber es muss einen Grund geben, dass das niemand gesagt hat; Ich denke, dass es einen Fehler geben kann, obwohl ich bisher noch keinen erlebt habe.

EDIT: Ich habe festgestellt, dass dies nicht unbedingt die richtige Antwort ist, aber ich werde es hier für den Fall behalten, dass jeder C ++ Anfänger gerne wissen würde, wie man verkettete Strings ausgeben kann.


Die detaillierte Antwort ist unten in anderen Antworten vergraben, wobei ein Teil davon wieder aufgetaucht ist:

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

std::ostringstream o;
o << name << age;
std::cout << o.str();

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

Beispiel:

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

name += std::to_string(age);

std::cout << name;

Ausgabe:

John21

Im Folgenden finden Sie eine Implementierung zum Anfügen eines Int an eine Zeichenfolge mithilfe der Facetten zum Analysieren und Formatieren aus der IOStreams-Bibliothek.

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

#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 Verwendung in etwa so aussehen

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

Googled [und getestet: p]


Wenn Sie char * abfragen möchten und stringstream verwendet haben, wie es die obigen Antwortenden beschrieben haben, dann tun Sie zB:

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

Da der Stringstream über str () eine Standardzeichenfolge zurückgibt, können Sie dann c_str () aufrufen, um den gewünschten Ausgabetyp zu erhalten.


Ohne C ++ 11, für einen kleinen ganzzahligen Bereich, fand ich, das ist alles was ich brauchte:

eine Variante des folgenden irgendwo erklären / einschließen:

const string intToString[10] = {"0","1","2","3","4","5","6","7","8","9"};

dann:

string str = intToString[3]+" + "+intToString[4]+" = "+intToString[7]; //str equals "3 + 4 = 7"

Funktioniert auch mit Enums.


In C ++ 11 können Sie std::to_string , zB:

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

Sie können int mit dem unten angegebenen einfachen Trick in eine Zeichenkette überführen, beachten Sie jedoch, dass dies nur funktioniert, wenn die ganze Zahl aus einer einzelnen Ziffer besteht, andernfalls addieren Sie die ganze Zahl Ziffer um Zahl zu dieser Zeichenkette.

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

Output:-  John5

Mit der Bibliothek {fmt} :

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

Eine Untergruppe der Bibliothek wird für die Standardisierung als P0645-Textformatierung vorgeschlagen. Wenn dies akzeptiert wird, wird das obige:

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

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


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


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 .


Es gibt eine Funktion, die ich geschrieben habe, die Parameter die int-Zahl aufnimmt und in ein String-Literal umwandelt. Diese Funktion hängt von einer anderen Funktion ab, die eine einzelne Ziffer in ihr entsprechendes Zeichen konvertiert:

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

Dies ist der einfachste Weg:

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

Als eine Qt-bezogene Frage zugunsten dieser Frage geschlossen wurde, hier ist, wie es mit Qt zu tun ist:

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

Die String-Variable hat jetzt den Wert von someIntVariable anstelle von% 1 und den Wert von someOtherIntVariable am Ende.


Wenn Sie Boost haben, können Sie die ganze Zahl mit boost::lexical_cast<std::string>(age) in eine Zeichenkette boost::lexical_cast<std::string>(age) .

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 schlugen vor, itoa . Dies ist KEINE Standardfunktion, daher ist Ihr Code nicht übertragbar, wenn Sie ihn verwenden. Es gibt Compiler, die es nicht unterstützen.


Wenn Sie + für die Verkettung von allem, das einen Ausgabeoperator verwendet, 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 einfach 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 brauchen nicht den effizientesten Weg, es sei denn, Sie machen viele Verkettungen innerhalb einer Schleife.





stdstring