Comment concaténer un std :: ssortingng et un int?

Par ordre alphabétique:

 std::ssortingng name = "John"; int age = 21; std::ssortingng result; // 1. with Boost result = name + boost::lexical_cast(age); // 2. with C++11 result = name + std::to_ssortingng(age); // 3. with FastFormat.Format fastformat::fmt(result, "{0}{1}", name, age); // 4. with FastFormat.Write (requires #include ) fastformat::write(result, name, age); // 5. with the {fmt} library result = fmt::format("{}{}", name, age); // 6. with IOStreams std::ssortingngstream 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 seulement); la plupart / toutes les plates-formes
2. est sûr, nécessite C ++ 11 ( to_ssortingng () est déjà inclus dans #include )
3. est sûr et rapide; nécessite FastFormat , qui doit être compilé; la plupart / toutes les plates-formes
4. est sûr et rapide; nécessite FastFormat , qui doit être compilé; la plupart / toutes les plates-formes
5. est sûr et rapide; requirejs la bibliothèque {fmt} , qui peut être compilée ou utilisée dans un mode en-tête uniquement; la plupart / toutes les plates-formes
6. sûr, lent et verbeux; nécessite #include (à partir du standard C ++)
7. est fragile (vous devez fournir un tampon suffisamment grand), rapide et verbeux; itoa () est une extension non standard, et il n'est pas garanti qu'elle soit disponible pour toutes les plates-formes
8. est fragile (vous devez fournir un tampon suffisamment grand), rapide et verbeux; ne nécessite rien (C ++ standard); 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 plates-formes
10. safe-ish (vous n'utilisez pas plus d'un appel int_to_ssortingng () dans une seule déclaration), rapide; nécessite STLSoft (en-tête uniquement); Windows uniquement
11. est sûr, mais lent; nécessite Poco C ++ ; la plupart / toutes les plates-formes

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

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

Si vous avez Boost, vous pouvez convertir l’entier en une chaîne en utilisant boost::lexical_cast(age) .

Une autre méthode consiste à utiliser des chaînes de caractères:

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

Une troisième approche consisterait à utiliser snprintf ou snprintf partir 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 suggèrent d'utiliser itoa . Ceci n'est PAS une fonction standard, donc votre code ne sera pas portable si vous l'utilisez. Il y a des compilateurs qui ne le supportent pas.

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

 #include  #include  #include  using namespace std; ssortingng itos(int i) // convert int to ssortingng { ssortingngstream s; s << i; return s.str(); } 

Volé sans vergogne à http://www.research.att.com/~bs/bs_faq2.html .

C’est le moyen le plus simple:

 ssortingng s = name + std::to_ssortingng(age); 

Il me semble que la réponse la plus simple consiste à utiliser la fonction sprintf :

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

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

Exemple:

 std::ssortingng name = "John"; int age = 21; name += std::to_ssortingng(age); std::cout << name; 

Sortie:

 John21 

 #include  #include  using namespace std; ssortingng concatenate(std::ssortingng const& name, int i) { ssortingngstream s; s << name << i; return s.str(); } 

Je n’ai pas assez de karma pour commenter (encore moins édité), mais le post de Jay (actuellement le plus voté à 27) contient une erreur. Ce code:

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

Ne résout pas le problème déclaré de création d'une chaîne composée d'une chaîne concaténée et d'un entier. Je pense que Jay voulait dire quelque chose comme ça:

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

La dernière ligne est juste pour imprimer le résultat et montre comment accéder à la chaîne concaténée finale.

Herb Sutter a un bon article à ce sujet: “The Ssortingng Formatters of Manor Farm” . Il couvre Boost::lexical_cast , std::ssortingngstream , std::strstream (qui est obsolète) et snprintf vs snprintf .

 #include  template  inline std::ssortingng to_ssortingng (const T& t) { std::ssortingngstream ss; ss << t; return ss.str(); } 

Alors votre utilisation ressemblerait à quelque chose comme ça

  std::ssortingng szName = "John"; int numAge = 23; szName += to_ssortingng(numAge); cout << szName << endl; 

Googled [et testé: p]

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 l’ operator+ :

 template  std::ssortingng operator+(L left, R right) { std::ossortingngstream os; os << left << right; return os.str(); } 

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

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

Sortie:

 the answer is 42 

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

Si vous utilisez MFC, vous pouvez utiliser un CSsortingng

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

C ++ géré a également un formateur de chaîne .

Le std :: ossortingngstream est une bonne méthode, mais parfois cette astuce supplémentaire peut être utile pour transformer la mise en forme en une seule ligne:

 #include  #define MAKE_STRING(tokens) /****************/ \ static_cast( \ std::ossortingngstream().flush() << tokens \ ).str() \ /**/ 

Maintenant, vous pouvez formater des chaînes comme ceci:

 int main() { int i = 123; std::ssortingng 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 procéder en utilisant Qt:

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

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

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

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