문자열이 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") 에서 16 진 및 8 진 상수를 허용 하려면 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

boost :: lexical_cast를 사용하여 C ++ 방식으로 할 수 있습니다. 부스트를 사용하지 말 것을 정말로 주장한다면 그 기능을 검사하고 수행 할 수 있습니다. 꽤 간단합니다.

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"는 Tony D가 지적한 것처럼 true를 반환합니다.

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) 정규식 (사용하여 내 솔루션은 #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;
}

와 마찬가지로 다윗 목사의 대답 은 여러 점 또는 마이너스 기호 문자열에 강력한 아니라, 단지 정수를 확인하기 위해 당신은 그 문자를 제거 할 수 있습니다.

그러나 나는 cstdlib에서 십진수 값, 과학 / 공학 표기법, 16 진수 표기법 (C ++ 11) 또는 심지어 INF / INFINITY / NAN (C ++ 11)을 사용하여 Ben Voigt의 솔루션을 기반으로 한 솔루션의 일부입니다. strtod입니다 :

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

우리는 문자열 스트림 클래스를 사용할 수 있습니다 .

    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]+))$"));
}

설명서를 좀 더 자세히 살펴본 후에는 내 요구를 지원하는 답변을 찾았지만 다른 사람들에게는 도움이되지 않을 것입니다. 여기에 있습니다 (성가신 반환 true 및 false 문 반환 :-))

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

이 정규 표현식은 거의 모든 경우를 처리해야한다고 생각합니다.

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

(유니 코드 및 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(); 
}

작동 방식 : 문자열 스트림 >> 과부하는 문자열을 다양한 산술 유형으로 변환 할 수 있습니다. 문자열이 부족해질 때까지 문자열 스트림 (이 경우 ss)에서 문자를 순차적으로 읽거나 다음 문자가 저장 기준을 충족하지 않습니다. 대상 변수 유형으로.

예 1 :

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

예 2 :

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

예 3 :

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

"쓰레기"변수 설명 ":

왜 내 double 로의 추출에 유효한 값이 있는지 확인한 다음 true를 반환하지 않습니까?

입력 문자열이 "11ABCD"(숫자가 아님) 인 경우에도 위의 example3은 여전히 ​​숫자 11을 my_number 변수로 읽습니다.

이 경우를 처리하기 위해 문자열 변수 (가비지라는 이름)로 다시 추출하여 double 유형의 변수로 초기 추출 후 문자열 버퍼에 남아있을 수있는 모든 것을 읽을 수 있습니다. 남은 것이 있으면 "쓰레기"로 읽어들입니다. 이는 전달 된 전체 문자열이 숫자가 아님을 의미합니다 (단지 1로 시작 함). 이 경우 우리는 false를 반환하고 싶습니다;

앞에 붙은 "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 :: conversion :: 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

몇 달 전에 문자열이 정수, 16 진수 또는 이중인지 확인하는 방법을 구현했습니다.

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