c++ - parse - stoi was not declared in this scope

c++ parse int de la cadena

Question

Posible duplicado:
Cómo analizar una cadena a un int en C ++?

Investigué un poco y algunas personas dicen usar atio y otros dicen que es malo, y no puedo hacer que funcione de todos modos.

Así que solo quiero preguntar a fondo, cuál es la forma correcta de convertir una cadena a un int.

string s = "10";
int i = s....?

¡Gracias!

Answer 1

Algunas funciones prácticas y rápidas (si no estás usando Boost):

template<typename T>
std::string ToString(const T& v)
{
    std::ostringstream ss;
    ss << v;
    return ss.str();
}

template<typename T>
T FromString(const std::string& str)
{
    std::istringstream ss(str);
    T ret;
    ss >> ret;
    return ret;
}

Ejemplo:

int i = FromString<int>(s);
std::string str = ToString(i);

Funciona para cualquier tipo de transmisible (flotadores, etc.). Necesitarás #include <sstream> y posiblemente también #include <string> .

Answer 2

No hay una "forma correcta". Si quieres una solución universal (pero no óptima), puedes usar un impulso :: elenco léxico.

Una solución común para C ++ es usar el operador std :: ostream y <<. Puede usar un método stringstream y stringstream :: str () para la conversión a cadena.

Si realmente necesita un mecanismo rápido (recuerde la regla 20/80), puede buscar una solución "dedicada" como http://www.partow.net/programming/strtk/index.html

Atentamente,
Marcin

Answer 3

Puedes usar boost::lexical_cast :

#include <iostream>
#include <boost/lexical_cast.hpp>

int main( int argc, char* argv[] ){
std::string s1 = "10";
std::string s2 = "abc";
int i;

   try   {
      i = boost::lexical_cast<int>( s1 );
   }
   catch( boost::bad_lexical_cast & e ){
      std::cout << "Exception caught : " << e.what() << std::endl;
   }

   try   {
      i = boost::lexical_cast<int>( s2 );
   }
   catch( boost::bad_lexical_cast & e ){
      std::cout << "Exception caught : " << e.what() << std::endl;
   }

   return 0;
}

Answer 4

Puedes usar istringstream .

string s = "10";

// create an input stream with your string.
istringstream is(str);

int i;
// use is like an input stream
is >> i;

Answer 5

• En C ++ 11, use std::stoi como:

  std::string s = "10";
  int i = std::stoi(s);

  Tenga en cuenta que std::stoi arrojará excepción de tipo std::invalid_argument si la conversión no se puede realizar, o std::out_of_range si la conversión da como resultado overflow (es decir, cuando el valor de la cadena es demasiado grande para el tipo int ). std::stoi embargo, puede usar std::stoi o std::stoi en caso de que int parezca demasiado pequeño para la cadena de entrada.

• En C ++ 03/98, se puede usar cualquiera de los siguientes:

  std::string s = "10";
  int i;
  
  //approach one
  std::istringstream(s) >> i; //i is 10 after this
  
  //approach two
  sscanf(s.c_str(), "%d", &i); //i is 10 after this

Tenga en cuenta que los dos enfoques anteriores fallarían para la entrada s = "10jh" . Devolverán 10 en lugar de notificar el error. Por lo tanto, el enfoque seguro y robusto es escribir su propia función que analiza la cadena de entrada y verificar que cada carácter verifique si es un dígito o no, y luego trabaje en consecuencia. Aquí hay una implementación robusta (aunque no probada):

int to_int(char const *s)
{
     if ( s == NULL || *s == ''/0'' )
        throw std::invalid_argument("null or empty string argument");

     bool negate = (s[0] == ''-'');
     if ( *s == ''+'' || *s == ''-'' ) 
         ++s;

     if ( *s == ''/0'')
        throw std::invalid_argument("sign character only.");

     int result = 0;
     while(*s)
     {
          if ( *s >= ''0'' && *s <= ''9'' )
          {
              result = result * 10  - (*s - ''0'');  //assume negative number
          }
          else
              throw std::invalid_argument("invalid input string");
          ++s;
     }
     return negate ? result : -result; //-result is positive!
} 

Esta solución es una versión ligeramente modificada de mi otra solución .