How can we check if an input string is a valid double? - c

Question

If I'm reading numbers of type double from stdin, how can I check if the numbers being read are in fact valid (that the numbers are in fact a double)?

Answer 1

You can use strtod. Check if the result is zero and subsequently if endptr == nptr, according to the man page:
If no conversion is performed, zero is returned and the value of nptr is stored in the location referenced by endptr.
Something like this:
char input[50];
char * end;
double result = 0;
fgets(input, sizeof input, stdin);
errno = 0;
result = strtod(input, &end);
if(result == 0 && (errno != 0 || end == input)){
fprintf(stderr, "Error: input is not a valid double\n");
exit(EXIT_FAILURE);
}
EDIT there seems to be a bit of a discrepancy between the standard and the man page. The man page says that endptr == nptr when no conversion is performed, while the standard seems to imply this isn't necessarily the case. Worse still it says that in case of no conversion errno may be set to EINVAL. Edited the example code to check errno as well.
Alternatively, sscanf could be used (preferred over scanf), in conjunction with fgets:
/* just fgetsed input */
if(sscanf(input, "%lf", &result) != 1){
fprintf(stderr, "Error: input is not a valid double\n");
exit(EXIT_FAILURE);
}
Also, don't forget to check the return value of fgets for NULL, in case it failed!

Answer 2

Neither simple strtod nor sscanf are enough to distinguish cases such as 1,5 or 1blah from desired 1.0 - All of these will result in 1.0. The reason is that
The strtod(), strtof(), and strtold() functions convert the initial portion of the string pointed to by nptr to double, float, and long double representation, respectively.
To ensure that the entire string was a valid double literal, use strtod like this:
#include <stdlib.h>
#include <errno.h>
#include <stdio.h>
...
char *endptr;
errno = 0;
double result = strtod(input, &endptr);
if (errno != 0 || *endptr != '\0') {
fprintf(stderr, "the value could not be represented as a double exactly\n");
}
The errno will be set if the value cannot be represented (ERANGE). Additionally, end will be pointing to the first character not converted. If the locale has not been set, when parsing 1,5 or 1blah, endptr will point to the second character. Iff the entire string was successfully parsed as a double constant, *endptr will point to the terminating '\0'.
Note that the errno must be set to zero prior to calling the function, otherwise it will retain the value from a previous failed function call.

Answer 3

How can we check if an input string is a valid double?
Start with
strtod() for double,
strtof() for float and
strtold() for long double.
double strtod(const char * restrict nptr, char ** restrict endptr);
The strtod, ... functions convert the initial portion of the string pointed to by nptr to double ....
A pointer to the final string is stored in the object pointed to by endptr, provided that endptr is not a null pointer.
C11dr §7.22.1.3 2&5
Simplified code to check loosely for validity. Does not complain about over/underflow nor extra text.
// Return true on valid
bool valid_string_to_double(const char *s) {
char *end;
strtod(s, &end);
return s != end;
}
Challenges of using strto*() include: errno == RANGE on arithmetic overflow and maybe underflow. The return value on overflow is only specified in default rounding mode. That value is HUGE_VAL which may be an infinity or a great number. The return value on underflow is implementation defined. errno has been known to be set to other non-zero values on conditions not specified by the C spec. Leading white-space is allowed, trailing white-space is not considered.
Sample function that looks for 1) conversion, 2) extra space, 3) over/underflow. It not only returns a valid indication, it also addresses the value of the conversion and the state of errno afterward.
// Return 0 on success
// Return non-0 on error, adjust these values as needed - maybe as an `enum`?
int convert_string_to_double(double *y, const char *s) {
char *end;
errno = 0;
*y = strtod(s, &end);
if (s == end) {
return 1; // Failed: No conversion, *y will be 0
}
// This may/may not constitute an error - adjust per coding goals
// Too great or too small (yet not exactly 0.0)
if (errno == ERANGE) {
if (fabs(*y) > 1.0) {
return 2; // Overflow
}
// In the case of too small, errno _may_ be set. See §7.22.1.3 10.
// For high consistency, return 0.0 and/or clear errno and/or return success.
// *y = 0.0; errno = 0;
}
// What to do if the remainder of the string is not \0?
// Since leading whitespace is allowed,
// let code be generous and tolerate trailing whitespace too.
while (isspace((unsigned char) *end)) {
end++;
}
if (*end) {
return 3; // Failed: Extra non-white-space junk at the end.
}
return 0; // success
}
If the result underflows (7.12.1), the functions return a value whose magnitude is no greater than the smallest normalized positive number in the return type; whether errno acquires the value ERANGE is implementation-defined. C11dr §7.22.1.3 10
A consideration includes the value of errno after this function is done. The C spec only species errno == ERANGE for strtod(), yet various implementations have been known to set errno to other values for other reasons including "no conversion". Code could clear errno except when ERANGE for high consistency.

Answer 4

You could use the standard atof function. It returns 0 on fail - and you could test if the string was 0 beforehand.
http://www.cplusplus.com/reference/cstdlib/atof/