Comment ajouter un int à une chaîne en C++? [dupliquer]

avec C++11, Vous pouvez écrire:

int i = 4;
std::string text = "Player ";
text += std::to_string(i);

Eh bien, si vous utilisez Cut vous pouvez juste écrire l'entier directement à elle, comme dans

std::cout << text << i;

la façon C++ de convertir toutes sortes d'objets en cordes est de string streams . Si vous n'en avez pas à portée de main, il suffit de créer un.

#include <sstream>

std::ostringstream oss;
oss << text << i;
std::cout << oss.str();

Alternativement, vous pouvez simplement convertir l'entier et l'ajouter à la chaîne.

oss << i;
text += oss.str();

enfin, les bibliothèques Boost fournissent boost::lexical_cast , qui s'enroule autour de la conversion stringstream avec une syntaxe comme le type intégré jette.

#include <boost/lexical_cast.hpp>

text += boost::lexical_cast<std::string>(i);

Cela fonctionne aussi dans l'autre sens, c'est à dire analyser les chaînes.

printf("Player %d", i);

(Downvote de ma réponse, tout ce que vous voulez; je les déteste le C++ I/O opérateurs.)

: - P

ceux-ci fonctionnent pour les chaînes générales (dans le cas où vous ne voulez pas sortir vers le fichier/console, mais stocker pour une utilisation ultérieure ou quelque chose).

coup de pouce.lexical_cast

MyStr += boost::lexical_cast<std::string>(MyInt);

Chaîne de flux

//sstream.h
std::stringstream Stream;
Stream.str(MyStr);
Stream << MyInt;
MyStr = Stream.str();

// If you're using a stream (for example, cout), rather than std::string
someStream << MyInt;

pour l'enregistrement, vous pouvez également utiliser un std::stringstream si vous voulez créer la chaîne avant qu'elle ne soit réellement sortie.

cout << text << " " << i << endl;

votre exemple semble indiquer que vous souhaitez afficher la chaîne a suivie d'un entier, auquel cas:

string text = "Player: ";
int i = 4;
cout << text << i << endl;

marcherait très bien.

mais, si vous allez stocker les emplacements de chaîne ou de le passer, et en faisant cela fréquemment, vous pouvez bénéficier de surcharger l'opérateur d'addition. Je le démontre ci-dessous:

#include <sstream>
#include <iostream>
using namespace std;

std::string operator+(std::string const &a, int b) {
  std::ostringstream oss;
  oss << a << b;
  return oss.str();
}

int main() {
  int i = 4;
  string text = "Player: ";
  cout << (text + i) << endl;
}

En fait, vous pouvez utiliser des modèles pour rendre cette approche plus puissant:

template <class T>
std::string operator+(std::string const &a, const T &b){
  std::ostringstream oss;
  oss << a << b;
  return oss.str();
}

maintenant, aussi longtemps que l'objet b a une sortie de flux définie, vous pouvez l'ajouter à votre chaîne (ou, au moins, une copie de celle-ci).

une autre possibilité est Boost.Format :

#include <boost/format.hpp>
#include <iostream>
#include <string>

int main() {
  int i = 4;
  std::string text = "Player";
  std::cout << boost::format("%1% %2%\n") % text % i;
}

voici un petit exemple de conversion/ajout de travail, avec du code dont j'avais besoin avant.

#include <string>
#include <sstream>
#include <iostream>

using namespace std;

int main(){
string str;
int i = 321;
std::stringstream ss;
ss << 123;
str = "/dev/video";
cout << str << endl;
cout << str << 456 << endl;
cout << str << i << endl;
str += ss.str();
cout << str << endl;
}

la sortie sera:

/dev/video
/dev/video456
/dev/video321
/dev/video123

Notez que dans les deux dernières lignes vous enregistrez la chaîne modifiée avant d'être imprimé, et vous pouvez utiliser cela plus tard si nécessaire.

pour le dossier, vous pouvez également utiliser la classe QString de Qt:

#include <QtCore/QString>

int i = 4;
QString qs = QString("Player %1").arg(i);
std::cout << qs.toLocal8bit().constData();  // prints "Player 4"

cout << text << i;

cout << "Player" << i ;

une méthode ici est l'impression directe de la sortie si elle est requise dans votre problème.

cout << text << i;

autrement, l'une des méthodes les plus sûres est d'utiliser

sprintf(count, "%d", i);

et copiez-le dans votre chaîne de caractères" text".

for(k = 0; *(count + k); k++)
{ 
  text += count[k]; 
} 

ainsi, vous avez votre chaîne de sortie requise

pour plus d'informations sur sprintf , suivez: http://www.cplusplus.com/reference/cstdio/sprintf

le moyen le plus simple que j'ai pu trouver est le suivant..

Il fonctionnera comme un chaîne et tableau de chaîne . Je considère un tableau string, car il est compliqué (un peu le même sera suivi avec string). Je crée un tableau de noms et ajoute un certain nombre entier et de char avec elle pour montrer comment il est facile d'ajouter quelques int et chars à corde, espérons qu'il aide. la longueur est juste pour mesurer la taille d'un tableau. Si vous êtes familier avec la programmation alors size_t est un non signé int

#include<iostream>
    #include<string>
    using namespace std;
    int main() {

        string names[] = { "amz","Waq","Mon","Sam","Has","Shak","GBy" }; //simple array
        int length = sizeof(names) / sizeof(names[0]); //give you size of array
        int id;
        string append[7];    //as length is 7 just for sake of storing and printing output 
        for (size_t i = 0; i < length; i++) {
            id = rand() % 20000 + 2;
            append[i] = names[i] + to_string(id);
        }
        for (size_t i = 0; i < length; i++) {
            cout << append[i] << endl;
        }


}

cout << text << i;

l'opérateur << renvoie une référence à l'osstream, de sorte que vous pouvez continuer à enchaîner les opérations << . Autrement dit, ce qui précède est essentiellement le même que:

cout << text;
cout << i;

cout << text << " " << i << endl;

il y a quelques options, et celle que vous voulez dépend du contexte.

la manière la plus simple est

std::cout << text << i;

ou si vous voulez cela sur une seule ligne

std::cout << text << i << endl;

si vous écrivez un seul programme threadé et si vous n'appelez pas ce code beaucoup (où" beaucoup " est des milliers de fois par seconde) alors vous êtes fait.

si vous écrivez un programme multi-threadé et plus d'un thread d'écriture de cout, alors ce code simple peut vous causer des ennuis. Supposons que la bibliothèque qui est venue avec votre compilateur a rendu le thread de routage assez sûr que n'importe quel appel à lui ne sera pas interrompu. Maintenant, disons qu'un thread utilise ce code pour écrire "Player 1" et un autre pour écrire "Player 2". Si vous êtes chanceux, vous obtiendrez ce qui suit:

Player 1
Player 2

Si vous êtes malchanceux, vous pourriez obtenir quelque chose comme

Player Player 2
1

Le problème est que std::cout << texte << i << endl; se transforme en 3 appels de fonction. Le code est l'équivalent du suivant:

std::cout << text;
std::cout << i;
std::cout << endl;

si au lieu de cela vous avez utilisé le C-style printf, et encore une fois votre compilateur a fourni une bibliothèque d'exécution avec une sécurité de thread raisonnable (chaque appel de fonction est atomique) alors le code suivant fonctionnerait mieux:

printf("Player %d\n", i);

être capable de faire quelque chose dans un appel de fonction unique permet à la bibliothèque io de fournir synchronisation sous les couvertures, et maintenant toute votre ligne de texte sera atomiquement écrite.

Pour des programmes simples, std::cout est grande. Jetez multithreading ou d'autres complications et le printf moins élégant commence à regarder plus attrayant.

vous essayez aussi le numéro du joueur de concaténate avec std::string::push_back :

exemple avec votre code:

int i = 4;
string text = "Player ";
text.push_back(i + '0');
cout << text;

vous verrez en console:

Joueur 4

vous pouvez utiliser ce qui suit""

int i = 4;
string text = "Player ";
text+=(i+'0');
cout << (text);

si vous utilisez Windows / MFC, et avez besoin de la chaîne pour plus que la sortie immédiate essayer:

int i = 4;
CString strOutput;
strOutput.Format("Player %d", i);