Comment concaténer une chaîne std :: et un int?

Je pensais que ce serait vraiment simple, mais cela présente des difficultés. Si j'ai

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

Comment les combiner pour obtenir une seule chaîne "John21"?

Par ordre alphabétique:

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. est sûr, mais lent; nécessite Boost (en-tête uniquement); la plupart / toutes les plateformes
2. est sûr, nécessite C ++ 11 ( to_string () est déjà inclus dans #include <string>)
3. est sûr et rapide; requiert FastFormat , qui doit être compilé; la plupart / toutes les plateformes
4. ( idem )
5. est sûr et rapide; nécessite la bibliothèque {fmt} , qui peut être compilée ou utilisée dans un mode en-tête uniquement; la plupart / toutes les plateformes
6. sûr, lent et verbeux; nécessite #include <sstream>(du standard C ++)
7. est fragile (vous devez fournir un tampon suffisamment grand), rapide et verbeux; itoa () est une extension non standard et n'est pas garantie d'être disponible pour toutes les plateformes
8. est fragile (vous devez fournir un tampon suffisamment grand), rapide et verbeux; ne nécessite rien (est standard C ++); toutes les plateformes
9. est fragile (vous devez fournir un tampon suffisamment grand), probablement la conversion la plus rapide possible , verbeuse; nécessite STLSoft (en-tête uniquement); la plupart / toutes les plateformes
10. safe-ish (vous n'utilisez pas plus d'un appel int_to_string () dans une seule instruction), fast; nécessite STLSoft (en-tête uniquement); Windows seulement
11. est sûr, mais lent; nécessite Poco C ++ ; la plupart / toutes les plateformes

En C ++ 11, vous pouvez utiliser std::to_string, par exemple:

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

Si vous avez Boost, vous pouvez convertir l'entier en chaîne à l'aide de boost::lexical_cast<std::string>(age).

Une autre façon est d'utiliser des chaînes de caractères:

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

Une troisième approche consisterait à utiliser sprintfou à snprintfpartir de la bibliothèque C.

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

D'autres affiches ont suggéré d'utiliser itoa. Ce n'est PAS une fonction standard, donc votre code ne sera pas portable si vous l'utilisez. Il existe des compilateurs qui ne le prennent pas en charge.

#include <iostream>
#include <sstream>

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

#include <iostream>
#include <string>
#include <sstream>
using namespace std;
string itos(int i) // convert int to string
{
    stringstream s;
    s << i;
    return s.str();
}

Sans vergogne volé à http://www.research.att.com/~bs/bs_faq2.html .

C'est le moyen le plus simple:

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

Si vous avez C ++ 11, vous pouvez utiliser std::to_string.

Exemple:

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

name += std::to_string(age);

std::cout << name;

Production:

John21

Il me semble que la réponse la plus simple est d'utiliser la sprintffonction:

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

#include <string>
#include <sstream>
using namespace std;
string concatenate(std::string const& name, int i)
{
    stringstream s;
    s << name << i;
    return s.str();
}

#include <sstream>

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

Votre utilisation ressemblerait alors à ceci

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

Googlé [et testé: p]

Ce problème peut se faire de plusieurs manières. Je vais le montrer de deux manières:

1. Convertissez le nombre en chaîne à l'aide de to_string(i).

2. Utilisation de flux de chaînes.

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

Si vous souhaitez utiliser +pour la concaténation de tout ce qui a un opérateur de sortie, vous pouvez fournir une version modèle de operator+:

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

Ensuite, vous pouvez écrire vos concaténations de manière simple:

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

Production:

the answer is 42

Ce n'est pas le moyen le plus efficace, mais vous n'avez pas besoin du moyen le plus efficace, sauf si vous faites beaucoup de concaténation dans une boucle.

Si vous utilisez MFC, vous pouvez utiliser un CString

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

Managed C ++ possède également un formateur de chaînes .

Le std :: ostringstream est une bonne méthode, mais parfois cette astuce supplémentaire peut être utile pour transformer le formatage en une ligne:

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

Vous pouvez maintenant formater des chaînes comme ceci:

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

Comme une question liée à Qt a été fermée en faveur de celle-ci, voici comment le faire en utilisant Qt:

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

La variable chaîne a maintenant la valeur de someIntVariable à la place de% 1 et la valeur de someOtherIntVariable à la fin.

Il existe d'autres options possibles pour concaténer un entier (ou un autre objet numérique) avec une chaîne. C'est 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);
}

et Karma de 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 prétend être l'une des options les plus rapides pour la conversion d' entiers en chaînes .

Réponse commune: itoa ()

C'est mauvais. itoaest non standard, comme indiqué ici .

Vous pouvez concaténer int en chaîne en utilisant l'astuce simple donnée ci-dessous, mais notez que cela ne fonctionne que lorsque l'entier est à un seul chiffre. Sinon, ajoutez un nombre entier chiffre par chiffre à cette chaîne.

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

Output:  John5

Voici une implémentation de la façon d'ajouter un int à une chaîne à l'aide des facettes d'analyse et de formatage de la bibliothèque IOStreams.

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

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

Il y a une fonction que j'ai écrite, qui prend le nombre entier comme paramètre et le convertit en chaîne littérale. Cette fonction dépend d'une autre fonction qui convertit un seul chiffre en son équivalent char:

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

Avec la bibliothèque {fmt} :

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

Un sous-ensemble de la bibliothèque est proposé pour la normalisation en tant que formatage de texte P0645 et, s'il est accepté, ce qui précède deviendra:

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

Avertissement : je suis l'auteur de la bibliothèque {fmt}.

En tant que doublure: name += std::to_string(age);