Is there a way to get numbers as characters in C and validate them?

Question

I want to get a string of numbers up to 50(i.e. the limit on characters is 50) and validate them. For example - 123456789 is valid but 123sadfd456789 is not.

I could only figure out a way to get integer numbers through char.

Here's the code:

#include<stdio.h>
#include<stdlib.h>

int conToInteger(int n){
    char ch[50];
    printf("Enter a string: ");
    gets(ch);
    n=atoi(ch);
    printf("Answer is: %d",n);
}

int main(){
  int n;
  conToInteger(n);
  return 0; 
}

Can anybody help me out?? Thanks.

Answer 1

If all you care about is validating that an arbitrarily long sequence of characters contains only decimal digits, then chux's answer is the right one.

However, based on your code, it looks like you don't just want to validate the string, you want to convert it to the corresponding integer value and save it. If that's the case, 50 digits is way beyond what you can store in any of the standard integer types¹; you'd have to use a multi-precision library like GMP. The best you can do with native types is unsigned long long, which on my platform can support values with up to 20 decimal digits (ULLONG_MAX == 18446744073709551615).

Instead of using atoi, you can use something from the strto* family of functions. The neat thing about these functions is you can pass a pointer argument that will point to the first character in the string that wasn't converted - if that character isn't whitespace or the 0 terminator, then you know the input string isn't valid.

In this case we'll use strtoll, which converts strings to long long:

#define LLONG_DIGITS 19 // set this for whatever your platform supports;
                        // mine supports up to 19 for long long

char buf[LLONG_DIGITS+3] = {0}; // digits plus sign, newline, and terminator
long long val = 0;

if ( fgets( buf, sizeof buf, stdin ) )
{
  /**
   * Step 1.  Check for a newline character.  If one isn't present,
   *          then the input was too long for the buffer.  Reject
   *          the input and clear out the input stream.
   */
  char *newline = strchr( buf, '\n' );
  if ( !newline )
  {
    fputs( "Input too long, rejecting\n", stderr );
    while ( getchar() != '\n' )
      ; // empty loop
  }
  else
  {
    /**
     * Step 2. Replace newline with terminator
     */
    *newline = 0;
    char *check;

    /**
     * Step 3.  Use strtoll to convert the string to a long long.
     * check will point to the first character in the string
     * that was *not* converted - if this character isn't
     * whitespace or the string terminator, then the input
     * was not a valid integer string
     */
    long long tmp = strtoll( buf, &check, 10 );
    if ( check > buf && !isspace( *check ) && *check != 0 )
      fputs( "Input value is empty or contains non-numeric characters!\n", stderr );
    else
      val = tmp;
  }
}
else
{
  fputs( "Error on input\n", stderr );
}

Now, when I say a type can support decimal values up to N digits, that doesn't mean it can support all N-digit values. An 8 bit byte can represent 256 distinct values, so it can represent some 3-digit decimals, but it can't represent things like 999. LLONG_MAX is 9223372036854775807, so if you input a value higher than that you will have signed integer overflow, which invokes undefined behavior.

---

1. 50 decimal digits corresponds to at least 160 bits; I'm not aware of any system with a native integer type that large. An int is only guaranteed to store values in the range [-32767..32767], which is at most 5 digits. Most platforms use 32-bit int which can store values in the range [-2147483648..2147483647] which is 10 digits. A 64-bit `unsigned long long` can store a value up to 18446744073709551615 which is 21 digits. No native type, not even long double, is going to be able to handle 50 digits.

Answer 2

Read the line of user input as a string with fgets(). Use an ample sized buffer. Suggest 2x expected input size.

#define LENGTH_GOOD_MAX 50
#define BUF_N (LENGTH_GOOD_MAX * 2 + 2)  // + 2 for the \n \0
char buf[BUF_N];
if (fgets(buf, sizeof buf, stdin)) {

Then test the characters with isdigit() from <ctype.h>.

  unsigned char *s = buf;  // Change to unsigned type for correct `isdigit()` usage.
  while (isdigit(*s)) {
    s++;
  }

  if (s == buf || s-buf > LENGTH_GOOD_MAX) puts("Too short or too long");
  else if (*s != '\0' && *s != '\n') puts("Not numeric");
  else puts("Just right!");
}

Answer 3

You could use getchar() in a loop, but check @chux answer for best practices.

#include <stdio.h>
#include <ctype.h>

int main() {

    char s[50] = { 0 };

    for(int i = 0, c; i < 49 && isdigit(c = getchar()); s[i++] = c);

    printf("%s", s);

    return 0;
}