Comment concaténer une std::string et un int?

Dans l'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 il est lent; nécessite Boost (tête seulement); la plupart/toutes les plates-formes
2. est sûr, exige de C++11 (to_string() est déjà inclus dans #include <string>)
3. est sûr et rapide, ne nécessite FastFormat, qui doivent être compilés; la plupart/toutes les plates-formes
4. est sûr et rapide, ne nécessite FastFormat, qui doivent être compilés; la plupart/toutes les plates-formes
5. est sûr et rapide, ne nécessite le {fmt} bibliothèque, qui peut être compilé ou utilisé dans un en-tête de la mode; la plupart/toutes les plates-formes
6. coffre-fort, lent et bavard; nécessite #include <sstream> (à partir de la norme C++)
7. est fragile (vous devez fournir un tampon assez grand), rapide et détaillé; itoa() est un non-standard de l'extension, et de ne pas être disponible pour toutes les plates-formes
8. est fragile (vous devez fournir un tampon assez grand), rapide et détaillé; il ne faut rien (est-ce que la norme C++); toutes les plates-formes
9. est fragile (vous devez fournir un tampon assez grand), probablement la plus rapide possible de la conversion, verbose; nécessite STLSoft (tête seulement); la plupart/toutes les plates-formes
10. coffre-ish (vous n'utilisez pas plus d'un int_to_string() dans un même énoncé), rapide, ne nécessite STLSoft (en-tête uniquement); Windows uniquement
11. est sûr, mais il est lent; nécessite Poco C++ ; la plupart/toutes les plates-formes

Si vous avez le coup de pouce, vous pouvez convertir un entier en une chaîne de caractères à l'aide de boost::lexical_cast<std::string>(age).

Une autre façon est d'utiliser des stringstreams:

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

Une troisième approche serait d'utiliser sprintf ou snprintf 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, de sorte que votre code ne sera pas portable si vous l'utilisez. Il existe des compilateurs qui ne le supportent pas.

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

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

Exemple:

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

name += std::to_string(age);

std::cout << name;

De sortie:

John21

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

Si vous souhaitez utiliser + pour la concaténation de tout ce qui a un opérateur de sortie, vous pouvez fournir une version du 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 votre concaténations d'une façon simple:

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

De sortie:

the answer is 42

Ce n'est pas le moyen le plus efficace, mais vous n'avez pas besoin de la manière la plus efficace, sauf si vous faites beaucoup de concaténation à l'intérieur d'une boucle.

Si vous êtes à l'aide de MFC, vous pouvez utiliser une CString

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

Managed C++ dispose également d'un
chaîne de formatage.

Comme Qt question a été fermé en faveur de celui-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 de chaîne a maintenant someIntVariable de la valeur à la place de %1 et someOtherIntVariable de la valeur à la fin.

Réponse Commune: itoa()

Ce qui est mauvais. itoa est non standard, comme l'a souligné ici.

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

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

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

Output:  John5