Як визначити, чи є рядок числом із C ++?

У мене було досить багато проблем, намагаючись написати функцію, яка перевіряє, чи є рядок числом. Для гри, яку я пишу, мені просто потрібно перевірити, чи є рядок із файлу, який я читаю, число чи ні (я буду знати, чи це параметр таким чином). Я написав нижченаведену функцію, яку, на мою думку, працював безперебійно (або випадково відредагував її, щоб зупинити її, або я шизофренічний, або Windows шизофренічний):

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

    return false;
}

Найефективнішим способом було б просто перебрати рядок, поки ви не знайдете нецифровий символ. Якщо є якісь нецифрові символи, ви можете вважати рядок не числом.

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();
}

Або якщо ви хочете зробити це способом 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();
}

Як зазначено в коментарях нижче, це працює лише для натуральних чисел. Якщо вам потрібно виявити негативні цілі чи дроби, вам слід скористатися більш надійним рішенням на основі бібліотеки. Хоча додавання підтримки для від'ємних цілих чисел є досить тривіальним.

Навіщо винаходити колесо? Стандартна бібліотека C (доступна і в C ++) має функцію, яка робить саме це:

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

Якщо ви хочете попрацювати з дробами або науковими позначеннями, перейдіть strtodнатомість (отримаєте doubleрезультат).

Якщо ви хочете дозволити шістнадцяткові та вісімкові константи у стилі C / C ++ ( "0xABC"), то 0замість цього введіть останній параметр .

Тоді ваша функція може бути записана як

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

З компілятором C ++ 11, для невід'ємних цілих чисел я б використав щось подібне (зверніть увагу ::замість std::):

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

http://ideone.com/OjVJWh

Ви можете це зробити C ++ шляхом boost :: lexical_cast. Якщо ви дійсно наполягаєте на тому, щоб не використовувати прискорення, ви можете просто вивчити, що це робить, і зробити це. Це досить просто.

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

Я просто хотів включити цю ідею, яка використовує ітерацію, але якийсь інший код робить цю ітерацію:

#include <string.h>

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

Це не надійно, як це повинно бути під час перевірки знаку десяткової крапки або мінуса, оскільки він може містити більше одного з кожного та в будь-якому місці. Хороша річ, що це один рядок коду і не вимагає сторонніх бібліотек.

Вийміть '.' та "-", якщо дозволені цілі числа - все, що дозволено.

Я б запропонував регулярний підхід. Повне збіг регулярних виразів (наприклад, за допомогою boost :: regex ) з

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

буде показувати, чи є рядок числом чи ні. Сюди входять додатні та від’ємні числа, цілі, а також десяткові.

Інші варіанти:

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

(лише позитивний)

-?[0-9]+

(лише ціле число)

[0-9]+

(лише додатне ціле число)

Ось ще один спосіб зробити це за допомогою <regex>бібліотеки:

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

За допомогою цього рішення ви можете перевірити все від від’ємних до позитивних чисел і навіть плаваючі числа. При зміні типу numна ціле число ви отримаєте помилку, якщо рядок містить крапку.

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

Доведіть: Програма C ++

Я знайшов наступний код найбільш надійним (c ++ 11). Він ловить як цілі числа, так і плаває.

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

Ось рішення для перевірки натуральних чисел:

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

Спробуйте це:

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

Брендан це

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

майже нормально.

припустимо, що будь-який рядок, що починається з 0, є числом, просто додайте чек для цього випадку

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

ofc "123hello" повернеться справжнім, як зазначив Тоні Д.

Найпростіший, що я можу придумати в 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;
}

Зразок робочого коду: https://ideone.com/nRX51Y

Моє рішення з використанням C ++ 11 regex ( #include <regex>), його можна використовувати для більш точної перевірки, наприклад unsigned int, doubleтощо:

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

Ви можете знайти цей код на веб- сайті http://ideone.com/lyDtfi , його можна легко змінити, щоб відповідати вимогам.

Рішення, засноване на коментарі kbjorklu :

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

Як і у відповіді Девіда Ректора, вона не є надійною для рядків з декількома крапками або знаками мінус, але ви можете видалити ці символи, щоб просто перевірити цілі числа.

Однак я частковий до рішення, заснованого на рішенні Бена Фогта , використовуючи strtodв cstdlib для перегляду десяткових значень, науково-інженерних позначень, шістнадцяткових позначень (C ++ 11) або навіть INF / INFINITY / NAN (C ++ 11) є:

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

Ми можемо використовувати клас stringstream .

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

       stream<<str;
       stream>>number;

       return stream.eof();
    }

Використання <regex>. Цей код був протестований!

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

Після детальної консультації з документацією я придумав відповідь, яка підтримує мої потреби, але, ймовірно, не буде такою корисною для інших. Ось це (без дратівливого повернення правдивого і повернення помилкових тверджень :-))

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

Я думаю, що цей регулярний вираз повинен обробляти майже всі випадки

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

тож ви можете спробувати наступну функцію, яка може працювати з обома (Unicode та 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>

Для перевірки парних пар:

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;

}

Для перевірки інтів (з негативами)

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;

}

Для перевірки непідписаних інтів

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(); 
}

як це працює: stringstream >> overload може конвертувати рядки в різні арифметичні типи, це робить це, читаючи символи послідовно з stringstream (ss у цьому випадку), поки не закінчиться символів АБО наступний символ не відповідає критеріям, які потрібно зберігати у тип змінної призначення.

example1:

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

example2:

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

example3:

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

пояснення змінної "сміття":

чому б не просто перевірити, чи має видобуток у моєму подвійному дійсне значення, а потім повернути true, якщо він є

Приклад повідомлення3 вище, як і раніше, буде успішно прочитати число 11 у змінній my_number, навіть якщо вхідний рядок є "11ABCD" (що не є числом).

для вирішення цього випадку ми можемо зробити ще одне вилучення в рядкову змінну (яку я назвав сміттям), яка може прочитати все, що, можливо, залишилося в буфері рядків після початкового вилучення в змінну типу double. Якщо щось залишилося, воно буде прочитане у "сміття", що означає, що повний рядок, переданий не був номером (він починається з одиниці). у такому випадку ми хочемо повернути помилкові;

попередньо "0" пояснення ":

спроба вилучення одного символу в подвійний буде невдалою (повернення 0 у наш подвійний), але все-таки буде переміщено позицію буфера рядка до символу. У такому випадку наше сміття, яке буде прочитано, буде порожнім, що призведе до того, що функція неправильно поверне true. щоб обійти це, я заздалегідь передбачив 0 до рядка, так що якщо, наприклад, передана рядок була "a", вона змінюється на "0a", так що 0 буде вилучено в подвійне, а "a" потрапить у сміття.

Попереднє значення 0 не вплине на значення числа, тому число все одно буде правильно виведено в нашу подвійну змінну.

щоб перевірити, чи рядок є цілим числом або плаваючою точкою, або ви можете використовувати:

 #include <sstream>

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

Ще одна відповідь, яка використовує stold(хоча ви також можете використовувати stof/ stodякщо вам не потрібна точність).

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

Як це було виявлено мені у відповіді на моє пов'язане питання, я вважаю, що ви повинні використовувати boost :: convert :: try_lexical_convert

Спробуйте це:

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

Ви можете перевірити, чи перетворюється рядок у ціле число, використовуючи boost :: lexical_cast . Якщо він видає виняток bad_lexical_cast, то рядок не можна перетворити, інакше він може.

Дивіться приклад такої програми тестування нижче:

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

Виконання зразка:

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

Кілька місяців тому я застосував спосіб визначити, чи будь-який рядок є цілим, шістнадцятковим чи подвійним.

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;


}

Тоді у вашій програмі ви зможете легко перетворити число у функцію його типу, якщо виконати наступне,

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

Ви можете зрозуміти, що функція поверне 0, якщо число не було виявлено. 0 може трактуватися як помилковий (як булева).

Я пропоную просту конвенцію:

Якщо перетворення в ASCII дорівнює> 0 або воно починається з 0, то це число. Це не ідеально, але швидко.

Щось на зразок цього:

string token0;

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

Ця функція забезпечує всі можливі випадки:

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....
}

Чи можете ви просто використовувати зворотний код sscanf, щоб визначити, чи це int?

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