¿Cómo determinar si una cadena es un número con C ++?

He tenido problemas para escribir una función que verifique si una cadena es un número. Para un juego que estoy escribiendo, solo necesito verificar si una línea del archivo que estoy leyendo es un número o no (sabré si es un parámetro de esta manera). Escribí la siguiente función que creo que estaba funcionando sin problemas (o la edité accidentalmente para detenerla o soy esquizofrénico o Windows es esquizofrénico):

bool isParam (string line)
{
    if (isdigit(atoi(line.c_str())))
        return true;

    return false;
}

La forma más eficiente sería simplemente iterar sobre la cadena hasta que encuentre un carácter que no sea un dígito. Si hay caracteres que no sean dígitos, puede considerar que la cadena no es un número.

bool is_number(const std::string& s)
{
    std::string::const_iterator it = s.begin();
    while (it != s.end() && std::isdigit(*it)) ++it;
    return !s.empty() && it == s.end();
}

O si quieres hacerlo de la manera C ++ 11:

bool is_number(const std::string& s)
{
    return !s.empty() && std::find_if(s.begin(), 
        s.end(), [](unsigned char c) { return !std::isdigit(c); }) == s.end();
}

Como se señala en los comentarios a continuación, esto solo funciona para enteros positivos. Si necesita detectar enteros negativos o fracciones, debe optar por una solución más sólida basada en la biblioteca. Sin embargo, agregar soporte para enteros negativos es bastante trivial.

¿Por qué reinventar la rueda? La biblioteca estándar de C (disponible también en C ++) tiene una función que hace exactamente esto:

char* p;
long converted = strtol(s, &p, 10);
if (*p) {
    // conversion failed because the input wasn't a number
}
else {
    // use converted
}

Si desea manejar fracciones o notación científica, elija en su strtodlugar (obtendrá un doubleresultado).

Si desea permitir constantes hexadecimales y octales en estilo C / C ++ ( "0xABC"), haga el último parámetro en su 0lugar.

Su función entonces puede escribirse como

bool isParam(string line)
{
    char* p;
    strtol(line.c_str(), &p, 10);
    return *p == 0;
}

Con el compilador C ++ 11, para enteros no negativos, usaría algo como esto (tenga ::en cuenta el en lugar de std::):

bool is_number(const std::string &s) {
  return !s.empty() && std::all_of(s.begin(), s.end(), ::isdigit);
}

http://ideone.com/OjVJWh

Puede hacerlo de la manera C ++ con boost :: lexical_cast. Si realmente insiste en no usar el impulso, simplemente puede examinar lo que hace y hacerlo. Es muy simple

try 
{
  double x = boost::lexical_cast<double>(str); // double could be anything with >> operator.
}
catch(...) { oops, not a number }

Solo quería incluir esta idea que usa iteración, pero algún otro código hace esa iteración:

#include <string.h>

bool is_number(const std::string& s)
{
    return( strspn( s.c_str(), "-.0123456789" ) == s.size() );
}

No es robusto como debería ser cuando se busca un punto decimal o un signo menos, ya que permite que haya más de uno de cada uno y en cualquier ubicación. Lo bueno es que es una sola línea de código y no requiere una biblioteca de terceros.

Saca '.' y '-' si los enteros positivos son todo lo que está permitido.

Sugeriría un enfoque regex. Una coincidencia completa de expresiones regulares (por ejemplo, usando boost :: regex ) con

-?[0-9]+([\.][0-9]+)?

mostraría si la cadena es un número o no. Esto incluye números positivos y negativos, enteros y decimales.

Otras variaciones

[0-9]+([\.][0-9]+)?

(solo positivo)

-?[0-9]+

(solo entero)

[0-9]+

(solo entero positivo)

Aquí hay otra forma de hacerlo usando la <regex>biblioteca:

bool is_integer(const std::string & s){
    return std::regex_match(s, std::regex("[(-|+)|][0-9]+"));
}

Con esta solución, puede verificar todo, desde números negativos a positivos e incluso números flotantes. Cuando cambia el tipo de numentero, obtendrá un error si la cadena contiene un punto.

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


int main()
{
      string s;

      cin >> s;

      stringstream ss;
      ss << s;

      float num = 0;

      ss >> num;

      if(ss.good()) {
          cerr << "No Valid Number" << endl;
      }
      else if(num == 0 && s[0] != '0') {
          cerr << "No Valid Number" << endl;
      }
      else {
          cout << num<< endl;
      }             
}

Probar: Programa C ++

He encontrado que el siguiente código es el más robusto (c ++ 11). Atrapa tanto enteros como flotadores.

#include <regex>
bool isNumber( std::string token )
{
    return std::regex_match( token, std::regex( ( "((\\+|-)?[[:digit:]]+)(\\.(([[:digit:]]+)?))?" ) ) );
}

Aquí hay una solución para verificar enteros positivos:

bool isPositiveInteger(const std::string& s)
{
    return !s.empty() && 
           (std::count_if(s.begin(), s.end(), std::isdigit) == s.size());
}

Prueba esto:

isNumber(const std::string &str) {    
  return !str.empty() && str.find_first_not_of("0123456789") == string::npos;
}

Brendan esto

bool isNumber(string line) 
{
    return (atoi(line.c_str())); 
}

está casi bien

suponiendo que cualquier cadena que comience con 0 es un número, simplemente agregue un cheque para este caso

bool isNumber(const string &line) 
{
 if (line[0] == '0') return true;
 return (atoi(line.c_str()));
}

ofc "123hello" volverá verdadero como Tony D señaló.

Lo más simple que se me ocurre en c ++

bool isNumber(string s) {
    if(s.size()==0) return false;
    for(int i=0;i<s.size();i++) {
        if((s[i]>='0' && s[i]<='9')==false) {
            return false;
        }
    }
    return true;
}

Ejemplo de código de trabajo: https://ideone.com/nRX51Y

Mi solución usando C ++ 11 regex ( #include <regex>), se puede usar para una verificación más precisa, como unsigned int, doubleetc.

static const std::regex INT_TYPE("[+-]?[0-9]+");
static const std::regex UNSIGNED_INT_TYPE("[+]?[0-9]+");
static const std::regex DOUBLE_TYPE("[+-]?[0-9]+[.]?[0-9]+");
static const std::regex UNSIGNED_DOUBLE_TYPE("[+]?[0-9]+[.]?[0-9]+");

bool isIntegerType(const std::string& str_)
{
  return std::regex_match(str_, INT_TYPE);
}

bool isUnsignedIntegerType(const std::string& str_)
{
  return std::regex_match(str_, UNSIGNED_INT_TYPE);
}

bool isDoubleType(const std::string& str_)
{
  return std::regex_match(str_, DOUBLE_TYPE);
}

bool isUnsignedDoubleType(const std::string& str_)
{
  return std::regex_match(str_, UNSIGNED_DOUBLE_TYPE);
}

Puede encontrar este código en http://ideone.com/lyDtfi , que puede modificarse fácilmente para cumplir con los requisitos.

Una solución basada en un comentario de kbjorklu es:

bool isNumber(const std::string& s)
{
   return !s.empty() && s.find_first_not_of("-.0123456789") == std::string::npos;
}

Al igual que con la respuesta de David Rector, no es robusto para las cadenas con múltiples puntos o signos menos, pero puede eliminar esos caracteres para verificar los enteros.

Sin embargo, soy parcial a una solución, basada en la solución de Ben Voigt , que usa strtoden cstdlib para buscar valores decimales, notación científica / de ingeniería, notación hexadecimal (C ++ 11), o incluso INF / INFINITY / NAN (C ++ 11) es:

bool isNumberC(const std::string& s)
{
    char* p;
    strtod(s.c_str(), &p);
    return *p == 0;
}

Podemos usar una clase stringstream .

    bool isNumeric(string str)
    {
       stringstream stream;                   
       double number;

       stream<<str;
       stream>>number;

       return stream.eof();
    }

Utilizando <regex>. Este código fue probado!

bool isNumber(const std::string &token)
{
    return std::regex_match(token, std::regex("(\\+|-)?[0-9]*(\\.?([0-9]+))$"));
}

Después de consultar un poco más la documentación, se me ocurrió una respuesta que respalda mis necesidades, pero que probablemente no será tan útil para otros. Aquí está (sin el molesto return true y return false declaraciones :-))

bool isNumber(string line) 
{
    return (atoi(line.c_str())); 
}

Creo que esta expresión regular debería manejar casi todos los casos

"^(\\-|\\+)?[0-9]*(\\.[0-9]+)?"

para que pueda probar la siguiente función que puede funcionar con ambos (Unicode y ANSI)

bool IsNumber(CString Cs){
Cs.Trim();

#ifdef _UNICODE
std::wstring sr = (LPCWSTR)Cs.GetBuffer(Cs.GetLength());
return std::regex_match(sr, std::wregex(_T("^(\\-|\\+)?[0-9]*(\\.[0-9]+)?")));

#else
    std::string s = (LPCSTR)Cs.GetBuffer();
return std::regex_match(s, std::regex("^(\\-|\\+)?[0-9]*(\\.[0-9]+)?"));
#endif
}

include <string>

Para validar dobles:

bool validateDouble(const std::string & input) {
int decimals = std::count(input.begin(), input.end(), '.'); // The number of decimals in the string
int negativeSigns = std::count(input.begin(), input.end(), '-'); // The number of negative signs in the string

if (input.size() == decimals + negativeSigns) // Consists of only decimals and negatives or is empty
    return false;
else if (1 < decimals || 1 < negativeSigns) // More than 1 decimal or negative sign
    return false;
else if (1 == negativeSigns && input[0] != '-') // The negative sign (if there is one) is not the first character
    return false;
else if (strspn(input.c_str(), "-.0123456789") != input.size()) // The string contains a character that isn't in "-.0123456789"
    return false;
return true;

}

Para validar Ints (con negativos)

bool validateInt(const std::string & input) {
int negativeSigns = std::count(input.begin(), input.end(), '-'); // The number of negative signs in the string

if (input.size() == negativeSigns) // Consists of only negatives or is empty
    return false;
else if (1 < negativeSigns) // More than 1 negative sign
    return false;
else if (1 == negativeSigns && input[0] != '-') // The negative sign (if there is one) is not the first character
    return false;
else if (strspn(input.c_str(), "-0123456789") != input.size()) // The string contains a character that isn't in "-0123456789"
    return false;
return true;

}

Para validar Ints sin firmar

bool validateUnsignedInt(const std::string & input) {
return (input.size() != 0 && strspn(input.c_str(), "0123456789") == input.size()); // The string is not empty and contains characters only in "0123456789"

}

bool isNumeric(string s){
    if ( !s.empty() && s[0] != '-' )
        s = "0" + s; //prepend 0

    string garbage;

    stringstream ss(s); 
    ss >> *(auto_ptr<double>(new double)) >> garbage;
/*
//the line above extracts the number into an anonymous variable. it could also be done like this:
double x;
ss >> x >> garbage;
*/
    //if there is no garbage return true or else return false
    return garbage.empty(); 
}

cómo funciona: la sobrecarga de secuencia de cadena >> puede convertir cadenas a varios tipos aritméticos, lo hace leyendo caracteres secuencialmente de la secuencia de secuencia (ss en este caso) hasta que se queda sin caracteres O el siguiente carácter no cumple los criterios para ser almacenado en el tipo de variable de destino.

Ejemplo 1:

stringstream ss("11");
double my_number;
ss >> my_number; //my number = 11

ejemplo2:

stringstream ss("011");
double my_number;
ss >> my_number; //my number = 11

ejemplo3:

stringstream ss("11ABCD");
double my_number;
ss >> my_number; //my number = 11 (even though there are letters after the 11)

la explicación variable "basura":

¿por qué no simplemente verificar si la extracción en mi doble tiene un valor válido y luego devolver verdadero si lo tiene?

observe que el ejemplo 3 anterior aún leerá con éxito el número 11 en la variable my_number incluso si la cadena de entrada es "11ABCD" (que no es un número).

Para manejar este caso, podemos hacer otra extracción en una variable de cadena (que denominé basura) que puede leer cualquier cosa que pueda haber quedado en el búfer de cadena después de la extracción inicial en la variable de tipo double. Si queda algo, se leerá en "basura", lo que significa que la cadena completa que se pasó no era un número (solo comienza con uno). en este caso, nos gustaría devolver falso;

la explicación "0" antepuesta:

intentar extraer un solo carácter en un doble fallará (devolver 0 en nuestro doble) pero aún moverá la posición del búfer de cadena a después del carácter. En este caso, nuestra lectura de basura estará vacía, lo que provocaría que la función devuelva incorrectamente verdadero. para evitar esto, agregué un 0 a la cadena de modo que si, por ejemplo, la cadena que se ingresó fuera "a", se cambia a "0a" para que el 0 se extraiga en el doble y "a" se extraiga en la basura.

anteponer un 0 no afectará el valor del número, por lo que el número aún se extraerá correctamente en nuestra variable doble.

para verificar si una cadena es un número entero o un punto flotante o podría usar:

 #include <sstream>

    bool isNumber(string str) {
    double d;
    istringstream is(str);
    is >> d;
    return !is.fail() && is.eof();
}

Otra respuesta más, que usa stold(aunque también podría usar stof/ stodsi no requiere la precisión).

bool isNumeric(const std::string& string)
{
    std::size_t pos;
    long double value = 0.0;

    try
    {
        value = std::stold(string, &pos);
    }
    catch(std::invalid_argument&)
    {
        return false;
    }
    catch(std::out_of_range&)
    {
        return false;
    }

    return pos == string.size() && !std::isnan(value);
}

Como se me reveló en una respuesta a mi pregunta relacionada, creo que debería usar boost :: conversion :: try_lexical_convert

Prueba esto:

bool checkDigit(string str)
{  
   int n=str.length();

   for(int i=0;    i   < n ;   i++)
   {
     if(str[i]<'0' || str[i]>'9')
       return false;
   }

   return true;
}

Puede probar si una cadena es convertible a entero utilizando boost :: lexical_cast . Si arroja una excepción bad_lexical_cast, entonces la cadena no se podría convertir, de lo contrario, puede.

Vea el ejemplo de dicho programa de prueba a continuación:

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

int main(int, char** argv)
{
        try
        {
                int x = boost::lexical_cast<int>(argv[1]);
                std::cout << x << " YES\n";
        }
        catch (boost::bad_lexical_cast const &)
        {
                std:: cout << "NO\n";
        }
        return 0;
}

Ejecución de muestra:

# ./a.out 12
12 YES
# ./a.out 12/3
NO

Hace unos meses, implementé una forma de determinar si alguna cadena es entera, hexadecimal o doble.

enum{
        STRING_IS_INVALID_NUMBER=0,
        STRING_IS_HEXA,
        STRING_IS_INT,
        STRING_IS_DOUBLE
};

bool isDigit(char c){
    return (('0' <= c) && (c<='9'));
}

bool isHexaDigit(char c){
    return ((('0' <= c) && (c<='9')) || ((tolower(c)<='a')&&(tolower(c)<='f')));
}


char *ADVANCE_DIGITS(char *aux_p){

    while(CString::isDigit(*aux_p)) aux_p++;
    return aux_p;
}

char *ADVANCE_HEXADIGITS(char *aux_p){

    while(CString::isHexaDigit(*aux_p)) aux_p++;
    return aux_p;
}


int isNumber(const string & test_str_number){
    bool isHexa=false;
    char *str = (char *)test_str_number.c_str();

    switch(*str){
    case '-': str++; // is negative number ...
               break;
    case '0': 
              if(tolower(*str+1)=='x')  {
                  isHexa = true;
                  str+=2;
              }
              break;
    default:
            break;
    };

    char *start_str = str; // saves start position...
    if(isHexa) { // candidate to hexa ...
        str = ADVANCE_HEXADIGITS(str);
        if(str == start_str)
            return STRING_IS_INVALID_NUMBER;

        if(*str == ' ' || *str == 0) 
            return STRING_IS_HEXA;

    }else{ // test if integer or float
        str = ADVANCE_DIGITS(str);
        if(*str=='.') { // is candidate to double
            str++;
            str = ADVANCE_DIGITS(str);
            if(*str == ' ' || *str == 0)
                return STRING_IS_DOUBLE;

            return STRING_IS_INVALID_NUMBER;
        }

        if(*str == ' ' || *str == 0)
            return STRING_IS_INT;

    }

    return STRING_IS_INVALID_NUMBER;


}

Luego, en su programa, puede convertir fácilmente el número en función de su tipo si hace lo siguiente,

string val; // the string to check if number...

switch(isNumber(val)){
   case STRING_IS_HEXA: 
   // use strtol(val.c_str(), NULL, 16); to convert it into conventional hexadecimal
   break;
   case STRING_IS_INT: 
   // use (int)strtol(val.c_str(), NULL, 10); to convert it into conventional integer
   break;
   case STRING_IS_DOUBLE:
   // use atof(val.c_str()); to convert it into conventional float/double
   break;
}

Puede darse cuenta de que la función devolverá un 0 si no se detectó el número. El 0 se puede tratar como falso (como booleano).

Propongo una convención simple:

Si la conversión a ASCII es> 0 o comienza con 0, entonces es un número. No es perfecto sino rápido.

Algo como esto:

string token0;

if (atoi(token0.c_str())>0 || isdigit(token0.c_str()[0]) ) { //this is a value
    // do what you need to do...
}

Esta función se ocupa de todos los casos posibles:

bool AppUtilities::checkStringIsNumber(std::string s){
    //Eliminate obvious irritants that could spoil the party
    //Handle special cases here, e.g. return true for "+", "-", "" if they are acceptable as numbers to you
    if (s == "" || s == "." || s == "+" || s == "-" || s == "+." || s == "-.") return false;

    //Remove leading / trailing spaces **IF** they are acceptable to you
    while (s.size() > 0 && s[0] == ' ') s = s.substr(1, s.size() - 1);
    while (s.size() > 0 && s[s.size() - 1] == ' ') s = s.substr(0, s.size() - 1);


    //Remove any leading + or - sign
    if (s[0] == '+' || s[0] == '-')
        s = s.substr(1, s.size() - 1);

    //Remove decimal points
    long prevLength = s.size();

    size_t start_pos = 0;
    while((start_pos = s.find(".", start_pos)) != std::string::npos) 
        s.replace(start_pos, 1, "");

    //If the string had more than 2 decimal points, return false.
    if (prevLength > s.size() + 1) return false;

    //Check that you are left with numbers only!!
    //Courtesy selected answer by Charles Salvia above
    std::string::const_iterator it = s.begin();
    while (it != s.end() && std::isdigit(*it)) ++it;
    return !s.empty() && it == s.end();

    //Tada....
}

¿Podría simplemente usar el código de retorno de sscanf para determinar si es un int?

bool is_number(const std::string& s)
{
    int value;
    int result = sscanf(valueStr.c_str(), "%d", &value);
    return (result != EOF && readResult != 0);
}