How to check if input is numeric(float) or it is some character?

Question

I was asked to write a program to find sum of two inputs in my college so I should first check whether the input is valid.

For example, if I input 2534.11s35 the program should detect that it is not a valid input for this program because of s in the input.

Answer 1

to check input is numeric(float)

1) Take input as a string char buf[Big_Enough]. I'd expect 160 digits will handle all but the most arcane "float" strings¹.

#define N 160
char buf[N];
if (fgets, buf, sizeof buf, stdin) {

2) Apply float strtof() for float, (strtod() for double, strtold() for long double).

  char *endptr;  
  errno = 0;
  float d = strtof(buf, &endptr);
  // endptr now points to the end of the conversion, if any.

3) Check results.

    if (buf == endptr) return "No_Conversion";
    // Recommend to tolerate trailing white-space.
    //   as leading white-spaces are already allowed by `strtof()`
    while (isspace((unsigned char)*endptr) {
      endptr++;
    }
    if (*endptr) return "TrailingJunkFound";
    return "Success";

4) Tests for extremes, if desired.

At this point, the input is numeric. The question remains if the "finite string" an be well represented by a finite float: if a the |result| is in range of 0 or [FLT_TRUE_MIN...FLT_MAX].

This involves looking at errno.

The conversion "succeed" yet finite string values outside the float range become HUGE_VALF which may be infinity or FLT_MAX.

Wee |values| close to 0.0, but not 0.0 become something in the range [0.0 ... INT_MIN].

Since the goal is to detect is a conversion succeeded (it did), I'll leave these details for a question that wants to get into the gory bits of what value.

---

An alternative is to use fscanf() to directly read and convert, yet the error handling there has its troubles too and hard to portably control.

---

¹ Typical float range is +/- 10³⁸. So allowing for 40 or so characters makes sense. An exact print of FLT_TRUE_MIN can take ~150 characters. To distinguish a arbitrarily "float" string from FLT_TRUE_MIN from the next larger one needs about that many digits.

If "float" strings are not arbitrary, but only come from the output of a printed float, then far few digits are needed - about 40.

Of course it is wise to allow for extra leading/trailing spaces and zeros.

Answer 2

You need to take the input as a string and then, make use of strtod() to parse the input.

Regarding the return values, from the man page:

double strtod(const char *nptr, char **endptr);

These functions return the converted value, if any.

If endptr is not NULL, a pointer to the character after the last character used in the conversion is stored in the location referenced by endptr.

If no conversion is performed, zero is returned and the value of nptr is stored in the location referenced by endptr.

Getting to the point of detection of errors, couple of points:

• Ensure the errno is set to 0 before the call and it still is 0 after the call.
• The return value is not HUGE_VAL.
• The content pointed to by *endptr is not null and not equal to nptr (i.e., no conversation has been preformed).

The above checks, combined together will ensure a successful conversion.

In your case, the last point is essential, as if there is an invalid character present in the input, the *endptr would not be pointing to a null, instead it would hold the address of that (first) invalid character in the input.

Answer 3

#include<stdio.h>
#include<stdlib.h>
void main(){
char num1[15];
float number1;
int dot_check1=0,check=0,i;
printf("enter the numbers :\n");
gets(num1);
i=0;
while(num1[i]){
    if(num1[i]>'/' && num1[i]<':')
        ;
    else { if(dot_check1==0){
            if(num1[i]=='.')
                dot_check1=1;
            else {
                check=1;
                break;
                }
            }
            else  {
                check=1;
                break;
                }
        }
    i++;
}
if(check){
    printf("please check the number you have entered");
}
else{
    number1=atof(num1);
    printf("you entered number is %f",number1);
}
}

Answer 4

Here is untested code to check whether a string meets the requested specification.

#include <ctype.h>


/*  IsFloatNumeral returns true (1) if the string pointed to by p contains a
    valid numeral and false (0) otherwise.  A valid numeral:

        Starts with optional white space.
        Has an optional hyphen as a minus sign.
        Contains either digits, a period followed by digits, or both.
        Ends with optional white space.

    Notes:

        It is unusual not to accept "3." for a float literal, but this was
        specified in a comment, so the code here is written for that.

        The question does not state that leading or trailing white space
        should be accepted (and ignored), but that is included here.  To
        exclude such white space, simply delete the relevant lines.
*/
_Bool IsFloatNumeral(const char *p)
{
    _Bool ThereAreInitialDigits = 0;
    _Bool ThereIsAPeriod = 0;

    //  Skip initial spaces.  (Not specified in question; removed if undesired.)
    while (isspace(*p))
        ++p;

    //  Allow an initial hyphen as a minus sign.
    if (*p == '-')
        ++p;

    //  Allow initial digits.
    if (isdigit(*p))
    {
        ThereAreInitialDigits = 1;
        do
            ++p;
        while (isdigit(*p));
    }

    //  Allow a period followed by digits.  Require at least one digit to follow the period.
    if (*p == '.')
    {
        ++p;
        if (!isdigit(*p))
            return 0;
        ThereIsAPeriod = 1;
        do
            ++p;
        while (isdigit(*p));
    }

    /*  If we did not see either digits or a period followed by digits,
        reject the string (return 0).
    */
    if (!ThereAreInitialDigits && !ThereIsAPeriod)
        return 0;

    //  Skip trailing spaces.  (Not specified in question; removed if undesired.)
    while (isspace(*p))
        ++p;

    /*  If we are now at the end of the string (the null terminating
        character), accept the string (return 1).  Otherwise, reject it (return
        0).
    */
    return *p == 0;
}