Como concatenar um std :: string e um int?

Eu pensei que isso seria muito simples, mas está apresentando algumas dificuldades. Se eu tiver

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

Como faço para combiná-los para obter uma única string "John21" ?

Em ordem alfabética:

 std::string name = "John"; int age = 21; std::string result; // 1. with Boost result = name + boost::lexical_cast(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 (requires #include ) 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. é seguro, mas lento; requer Boost (somente header); mais / todas as plataformas
  2. é seguro, requer C ++ 11 ( to_string () já está incluído em #include )
  3. é seguro e rápido; requer FastFormat , que deve ser compilado; mais / todas as plataformas
  4. é seguro e rápido; requer FastFormat , que deve ser compilado; mais / todas as plataformas
  5. é seguro e rápido; requer a biblioteca {fmt} , que pode ser compilada ou usada em um modo somente header; mais / todas as plataformas
  6. seguro, lento e detalhado; requer #include (do padrão C ++)
  7. é frágil (você deve fornecer um buffer grande o suficiente), rápido e detalhado; itoa () é uma extensão não padrão e não é garantida a disponibilidade para todas as plataformas
  8. é frágil (você deve fornecer um buffer grande o suficiente), rápido e detalhado; não requer nada (é padrão C ++); todas as plataformas
  9. é frágil (você deve fornecer um buffer grande o suficiente), provavelmente a conversão mais rápida possível , verbose; requer STLSoft (somente header); mais / todas as plataformas
  10. safe-ish (você não usa mais de uma chamada int_to_string () em uma única instrução), rápido; requer STLSoft (somente header); Somente Windows
  11. é seguro, mas lento; requer Poco C ++ ; mais / todas as plataformas

Em C ++ 11, você pode usar std::to_string , por exemplo:

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

Se você tiver Boost, você pode converter o inteiro em uma string usando boost::lexical_cast(age) .

Outra maneira é usar stringstreams:

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

Uma terceira abordagem seria usar sprintf ou snprintf da biblioteca C.

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

Outros cartazes sugeridos usando itoa . Esta não é uma function padrão, portanto, seu código não será portátil se você usá-lo. Existem compiladores que não suportam isso.

 std::ostringstream o; o < < name << age; std::cout << o.str(); 
 #include  #include  #include  using namespace std; string itos(int i) // convert int to string { stringstream s; s < < i; return s.str(); } 

Roubado sem pudor de http://www.research.att.com/~bs/bs_faq2.html .

Esta é a maneira mais fácil:

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

Parece-me que a resposta mais simples é usar a function sprintf :

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

Se você tiver o C ++ 11, você pode usar std::to_string .

Exemplo:

 std::string name = "John"; int age = 21; name += std::to_string(age); std::cout < < name; 

Saída:

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

Eu não tenho carma suficiente para comentar (muito menos editar), mas o post de Jay (atualmente o mais votado em 27) contém um erro. Este código:

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

Não resolve o problema declarado de criar uma cadeia de caracteres que consiste em uma string e um número inteiro concatenados. Eu acho que Jay quis dizer algo mais assim:

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

A última linha é apenas para imprimir o resultado e mostra como acessar a string final concatenada.

Herb Sutter tem um bom artigo sobre este assunto: “The String Formatters of Manor Farm” . Ele cobre Boost::lexical_cast , std::stringstream , std::strstream (que é obsoleto) e sprintf vs. snprintf .

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

Então seu uso seria algo como isto

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

Pesquisou [e testou: p]

Se você gostaria de usar o + para concatenação de qualquer coisa que tenha um operador de saída, você pode fornecer uma versão de modelo do operator+ :

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

Então você pode escrever suas concatenações de uma maneira direta:

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

Saída:

 the answer is 42 

Essa não é a maneira mais eficiente, mas você não precisa da maneira mais eficiente, a menos que esteja fazendo muita concatenação dentro de um loop.

Se você estiver usando o MFC, poderá usar um CString

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

O C ++ gerenciado também possui um formatador de string .

O std :: ostringstream é um bom método, mas às vezes esse truque adicional pode ser útil transformando a formatação em uma única linha:

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

Agora você pode formatar cadeias como esta:

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

Como uma pergunta relacionada ao Qt foi encerrada em favor desta, aqui está como fazer isso usando o Qt:

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

A variável string agora tem o valor de someIntVariable no lugar de% 1 e o valor de someOtherIntVariable no final.

Você pode concatinar int para string usando o truque simples abaixo, mas observe que isso só funciona quando o inteiro é de um dígito. Caso contrário, adicione dígito por dígito inteiro a essa string.

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

Resposta Comum: itoa ()

Isto é mau. itoa não é padrão, como apontado aqui .

Existem mais opções possíveis para concatenar integer (ou outro object numérico) com string. É Boost.Format

 #include  #include  int main() { using boost::format; int age = 22; std::string str_age = str(format("age is %1%") % age); } 

e Karma do Boost.Spirit (v2)

 #include  #include  #include  int main() { using namespace boost::spirit; int age = 22; std::string str_age("age is "); std::back_insert_iterator sink(str_age); karma::generate(sink, int_, age); return 0; } 

Boost.Spirit Karma afirma ser uma das opções mais rápidas para a conversão de números inteiros para string .

Se você deseja obter um caractere * e usou stringstream conforme o que os respondentes acima descreveram, faça, por exemplo:

 myFuncWhichTakesPtrToChar(ss.str().c_str()); 

Como o stringstream retorna via str () é uma string padrão, você pode chamar c_str () para obter o tipo de saída desejado.

Existe uma function que eu escrevi, que recebe em parâmetros o número int, e converte-a em uma string literal, esta function é dependente de outra function que converte um único dígito em seu equivalente 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 hold 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 combinasion 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; } 

Aqui está uma implementação de como acrescentar um int a uma string usando as facetas de análise e formatação da biblioteca IOStreams.

 #include  #include  #include  template  struct erasable_facet : Facet { erasable_facet() : Facet(1) { } ~erasable_facet() { } }; void append_int(std::string& s, int n) { erasable_facet>> facet; std::ios str(nullptr); facet.put(std::back_inserter(s), str, str.fill(), static_cast(n)); } int main() { std::string str = "ID: "; int id = 123; append_int(str, id); std::cout < < str; // ID: 123 } 

Outra maneira fácil de fazer isso é:

 name.append(age+""); cout < < name; 

Sem o C ++ 11, para um pequeno intervalo inteiro, descobri que tudo isso é necessário:

declarar / include alguma variante do seguinte em algum lugar:

 const string intToString[10] = {"0","1","2","3","4","5","6","7","8","9"}; 

então:

 string str = intToString[3]+" + "+intToString[4]+" = "+intToString[7]; //str equals "3 + 4 = 7" 

Funciona com enums também.

A resposta detalhada está enterrada em outras respostas, ressurgindo parte dela:

 #include  // cout #include  // string, to_string(some_number_here) using namespace std; int main() { // using constants cout < < "John" + std::to_string(21) << endl; // output is: // John21 // using variables string name = "John"; int age = 21; cout << name + to_string(age) << endl; // output is: // John21 } 

Com a biblioteca {fmt} :

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

Um subconjunto da biblioteca é proposto para padronização como Formatação de Texto P0645 e, se aceito, o acima se tornará:

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

Disclaimer : Eu sou o autor da biblioteca {fmt}.

Esse problema pode ser feito de manys, vou mostrar de duas maneiras:

1) .Converter o número para string usando to_string (i).

2). Usando streams de string.

Código: –

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

// Espero que ajude

  • std :: ostringstream
 #include  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  std::string query("John " + boost::lexical_cast(age)); 

Sugestão de uma solução alternativa para pessoas como eu, que podem não ter access ao C ++ 11 e bibliotecas / headers adicionais, como o boost. Uma simples conversão funciona assim:

Exemplo o número é 4, para converter 3 em ascii podemos simplesmente usar o código:
char a = ‘0’ + 4

Isso armazenará imediatamente 4 como um caractere em a.

A partir daqui, podemos simplesmente concatenar a com o resto da string.

Eu sou um usuário C ++ iniciante e achei isso da maneira mais fácil:

 cout < < name << age; 

Isso irá concatenar com sucesso o nome e a idade, a saída será "John21".

No entanto, tem que haver uma razão pela qual ninguém disse isso; Eu acho que pode haver uma falha nisso, embora eu não tenha experimentado nenhuma até agora.

EDIT: Eu percebi que isso não é necessariamente a resposta certa, no entanto, vou mantê-lo aqui no caso de qualquer iniciantes C ++ gostaria de saber como produzir seqüências de caracteres concatenadas.