Come si aggiunge un int a una stringa in C ++?

Con C++ 11 puoi scrivere:

#include <string>     // to use std::string, std::to_string() and "+" operator acting on strings 

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

Bene, se usi cout puoi semplicemente scrivere il numero intero direttamente ad esso, come in

std::cout << text << i;

Il modo C++ per convertire tutti i tipi di oggetti in stringhe è attraverso string stream . Se non ne hai uno a portata di mano, creane uno.

#include <sstream>

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

In alternativa, puoi semplicemente convertire il numero intero e aggiungerlo alla stringa.

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

Infine, le librerie Boost forniscono boost::lexical_cast , che avvolge la conversione stringstream con una sintassi come i cast di tipo built-in.

#include <boost/lexical_cast.hpp>

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

Ciò funziona anche al contrario, ovvero per analizzare le stringhe.

printf("Player %d", i);

(Svuota la mia risposta tutto ciò che ti piace, odio ancora gli operatori di I/O C++.)

:-P

Questi funzionano per le stringhe generali (nel caso in cui non si desideri eseguire l'output su file/console, ma archiviare per un utilizzo futuro o qualcosa del genere).

boost.lexical_cast

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

Stream di stringhe

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

Per la cronaca, puoi anche usare un std::stringstream se vuoi creare la stringa prima che sia effettivamente emessa.

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

Il tuo esempio sembra indicare che ti piacerebbe visualizzare una stringa seguita da un intero, nel qual caso:

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

funzionerebbe benissimo.

Ma, se stai memorizzando i posti delle stringhe o passandoli intorno, e facendo così frequentemente, potresti trarre vantaggio da un sovraccarico dell'operatore addizione. Lo dimostro di seguito:

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

In effetti, puoi usare i modelli per rendere questo approccio più potente:

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

Ora, finché l'oggetto b ha un output di flusso definito, è possibile aggiungerlo alla stringa (o, almeno, una sua copia).

Un'altra possibilità è 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;
}

Ecco un piccolo esempio di conversione/aggiunta di lavoro, con un codice che avevo bisogno prima.

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

l'output sarà:

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

Notare che nelle ultime due righe si salva la stringa modificata prima che sia effettivamente stampata, e si potrebbe usare in seguito, se necessario.

Per la cronaca, puoi anche usare la classe QString di Qt:

#include <QtCore/QString>

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

cout << "Player" << i ;

cout << text << i;

Un metodo qui sta direttamente stampando l'output se richiesto nel tuo problema.

cout << text << i;

Altrimenti, uno dei metodi più sicuri è quello di utilizzare

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

E quindi copiarlo nella stringa "testo".

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

Quindi, hai la stringa di output richiesta

Per maggiori informazioni su sprintf, seguire: http://www.cplusplus.com/reference/cstdio/sprintf

cout << text << i;

L'operatore << per ostream restituisce un riferimento all'ostream, quindi puoi continuare a concatenare le operazioni <<. Cioè, quanto sopra è fondamentalmente lo stesso di:

cout << text;
cout << i;

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

Prova anche a concatenare il numero del giocatore con std::string::Push_back:

Esempio con il tuo codice:

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

Vedrai in console:

Giocatore 4

Il modo più semplice per scoprirlo è il seguente ..
Funzionerà come stringa singola e stringa array. Sto considerando un array di stringhe, in quanto è complicato (un po 'lo stesso verrà seguito con una stringa). Creo una serie di nomi e append qualche intero e char con esso per mostrare quanto sia facile aggiungere alcuni int e chars alla stringa, spero che sia d'aiuto. la lunghezza è solo per misurare la dimensione della matrice. Se hai familiarità con la programmazione allora size_t è un unsigned 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;
        }


}