Como converter um número em string e vice-versa em C ++

Como essa pergunta é feita toda semana, essas Perguntas frequentes podem ajudar muitos usuários.

• Como converter um número inteiro em uma seqüência de caracteres em C ++

• como converter uma seqüência de caracteres em um número inteiro em C ++

• como converter um número de ponto flutuante em uma string em C ++

• como converter uma seqüência de caracteres em um número de ponto flutuante em C ++

Atualização para C ++ 11

A partir do C++11padrão, a conversão de string para número e vice-versa são incorporadas à biblioteca padrão. Todas as seguintes funções estão presentes em <string>(conforme o parágrafo 21.5).

string para numérico

float              stof(const string& str, size_t *idx = 0);
double             stod(const string& str, size_t *idx = 0);
long double        stold(const string& str, size_t *idx = 0);
int                stoi(const string& str, size_t *idx = 0, int base = 10);
long               stol(const string& str, size_t *idx = 0, int base = 10);
unsigned long      stoul(const string& str, size_t *idx = 0, int base = 10);
long long          stoll(const string& str, size_t *idx = 0, int base = 10);
unsigned long long stoull(const string& str, size_t *idx = 0, int base = 10);

Cada um deles usa uma string como entrada e tenta convertê-la em um número. Se nenhum número válido puder ser construído, por exemplo, porque não há dados numéricos ou o número está fora do intervalo para o tipo, uma exceção é lançada ( std::invalid_argumentou std::out_of_range).

Se a conversão for bem-sucedida e idxnão for 0, idxconterá o índice do primeiro caractere que não foi usado para decodificação. Este pode ser um índice por trás do último caractere.

Finalmente, os tipos integrais permitem especificar uma base; para dígitos maiores que 9, o alfabeto é assumido ( a=10até z=35). Você pode encontrar mais informações sobre a exata formatação que poderão analisado aqui para números de ponto flutuante , assinado inteiros e inteiros sem sinal .

Finalmente, para cada função, há também uma sobrecarga que aceita a std::wstringcomo primeiro parâmetro.

numérico para string

string to_string(int val);
string to_string(unsigned val);
string to_string(long val);
string to_string(unsigned long val);
string to_string(long long val);
string to_string(unsigned long long val);
string to_string(float val);
string to_string(double val);
string to_string(long double val);

Isso é mais direto: você passa o tipo numérico apropriado e recebe uma string de volta. Para opções de formatação, você deve voltar à opção C ++ 03 stringsream e usar manipuladores de fluxo, conforme explicado em outra resposta aqui.

Conforme observado nos comentários, essas funções retornam a uma precisão mantissa padrão que provavelmente não é a precisão máxima. Se for necessária mais precisão para o seu aplicativo, também é melhor voltar para outros procedimentos de formatação de string.

Também existem funções semelhantes definidas que são nomeadas to_wstring; elas retornarão a std::wstring.

Como converter um número em uma seqüência de caracteres em C ++ 03

1. Não use asfunçõesitoaouitofporque elas não são padrão e, portanto, não são portáteis.
   

2. Use fluxos de sequência
   

    #include <sstream>  //include this to use string streams
    #include <string> 
   
   int main()
   {    
       int number = 1234;
   
       std::ostringstream ostr; //output string stream
       ostr << number; //use the string stream just like cout,
       //except the stream prints not to stdout but to a string.
   
       std::string theNumberString = ostr.str(); //the str() function of the stream 
       //returns the string.
   
       //now  theNumberString is "1234"  
   }

   Observe que você pode usar fluxos de sequência também para converter números de ponto flutuante em sequência e também para formatar a sequência como desejar, assim como com cout

   std::ostringstream ostr;
   float f = 1.2;
   int i = 3;
   ostr << f << " + " i << " = " << f + i;   
   std::string s = ostr.str();
   //now s is "1.2 + 3 = 4.2" 

   Você pode usar manipuladores de fluxo, tais como std::endl, std::hexe funções std::setw(), std::setprecision()etc., com correntes de cordas exatamente da mesma maneira que comcout

   Não confunda std::ostringstream comstd::ostrstream. Este último está obsoleto

3. Usar boost elenco lexical . Se você não está familiarizado com o boost, é uma boa idéia começar com uma pequena biblioteca como esta lexical_cast. Para baixar e instalar o boost e sua documentação, clique aqui . Embora o boost não esteja no padrão C ++, muitas bibliotecas de boost são padronizadas eventualmente e o boost é amplamente considerado uma das melhores bibliotecas C ++.

   O elenco lexical usa fluxos por baixo, então basicamente essa opção é a mesma que a anterior, apenas menos detalhada.

   #include <boost/lexical_cast.hpp>
   #include <string>
   
   int main()
   {
      float f = 1.2;
      int i = 42;
      std::string sf = boost::lexical_cast<std::string>(f); //sf is "1.2"
      std::string si = boost::lexical_cast<std::string>(i); //sf is "42"
   }

Como converter uma seqüência de caracteres em um número em C ++ 03

1. A opção mais leve, herdada de C, são as funções atoi(para números inteiros (em ordem alfabética para número inteiro)) e atof(para valores de ponto flutuante (em ordem alfabética para flutuar)). Essas funções aceitam uma string no estilo C como argumento ( const char *) e, portanto, seu uso pode ser considerado uma prática não exatamente boa do C ++. O cplusplus.com possui uma documentação fácil de entender, tanto no atoi quanto no atof, incluindo como eles se comportam em caso de insatisfação . No entanto, o link contém um erro, de acordo com o padrão, se o número de entrada for muito grande para caber no tipo de destino, o comportamento será indefinido.

   #include <cstdlib> //the standard C library header
   #include <string>
   int main()
   {
       std::string si = "12";
       std::string sf = "1.2";
       int i = atoi(si.c_str()); //the c_str() function "converts" 
       double f = atof(sf.c_str()); //std::string to const char*
   }

2. Use fluxos de cadeia (desta vez insira fluxo de cadeia istringstream). Novamente, o istringstream é usado da mesma maneira cin. Mais uma vez, não confunda istringstreamcom istrstream. O último está obsoleto.

   #include <sstream>
   #include <string>
   int main()
   {
      std::string inputString = "1234 12.3 44";
      std::istringstream istr(inputString);
      int i1, i2;
      float f;
      istr >> i1 >> f >> i2;
      //i1 is 1234, f is 12.3, i2 is 44  
   }

3. Usar elenco lexical de reforço .

   #include <boost/lexical_cast.hpp>
   #include <string>
   
   int main()
   {
      std::string sf = "42.2"; 
      std::string si = "42";
      float f = boost::lexical_cast<float>(sf); //f is 42.2
      int i = boost::lexical_cast<int>(si);  //i is 42
   }       

   No caso de uma entrada incorreta, lexical_castlança uma exceção do tipoboost::bad_lexical_cast

No C ++ 17, novas funções std :: to_chars e std :: from_chars são introduzidas no cabeçalho charconv .

std :: to_chars é independente da localidade, não está alocando e não está jogando.

Somente um pequeno subconjunto de políticas de formatação usado por outras bibliotecas (como std :: sprintf) é fornecido.

De std :: to_chars , o mesmo para std :: from_chars .

A garantia de que std :: from_chars pode recuperar todos os valores de ponto flutuante formatados por to_chars exatamente é fornecida apenas se as duas funções forem da mesma implementação

 // See en.cppreference.com for more information, including format control.
#include <cstdio>
#include <cstddef>
#include <cstdlib>
#include <cassert>
#include <charconv>

using Type =  /* Any fundamental type */ ;
std::size_t buffer_size = /* ... */ ;

[[noreturn]] void report_and_exit(int ret, const char *output) noexcept 
{
    std::printf("%s\n", output);
    std::exit(ret);
}
void check(const std::errc &ec) noexcept
{
    if (ec ==  std::errc::value_too_large)
        report_and_exit(1, "Failed");
}
int main() {
    char buffer[buffer_size];        
    Type val_to_be_converted, result_of_converted_back;

    auto result1 = std::to_chars(buffer, buffer + buffer_size,  val_to_be_converted);
    check(result1.ec);
    *result1.ptr = '\0';

    auto result2 = std::from_chars(buffer, result1.ptr, result_of_converted_back);
    check(result2.ec);

    assert(val_to_be_converted == result_of_converted_back);
    report_and_exit(0, buffer);
}

Embora não seja totalmente implementado pelos compiladores, definitivamente será implementado.

Eu roubei essa classe conveniente de algum lugar aqui no StackOverflow para converter qualquer coisa streamable em uma string:

// make_string
class make_string {
public:
  template <typename T>
  make_string& operator<<( T const & val ) {
    buffer_ << val;
    return *this;
  }
  operator std::string() const {
    return buffer_.str();
  }
private:
  std::ostringstream buffer_;
};

E então você o usa como;

string str = make_string() << 6 << 8 << "hello";

Bastante bacana!

Também uso essa função para converter seqüências de caracteres para qualquer coisa que possa ser estriada, apesar de não ser muito seguro se você tentar analisar uma sequência que não contém um número; (e não é tão inteligente quanto o último)

// parse_string
template <typename RETURN_TYPE, typename STRING_TYPE>
RETURN_TYPE parse_string(const STRING_TYPE& str) {
  std::stringstream buf;
  buf << str;
  RETURN_TYPE val;
  buf >> val;
  return val;
}

Use como:

int x = parse_string<int>("78");

Você também pode querer versões para wstrings.