determine if input is only digits or q using a returned string and malloc

I want to create my own function in which I enter an input, and then my function will determine if I only entered digits (such as 23412) or if I entered only a single q. Everything else should be counted as invalid input. Note that "242q42", "5435q" or "qq" should be considered invalid input. I believe I managed to create a working function that can decide if I only entered digits, but I am not sure how I should do to get the q thing working. Here is my code(please comment if you see mistakes or inefficient code or other improvements I can make):

char *readLine(int nr) {
   int ch, i=0;
   char *string;
   string = malloc(nr);

   while((ch = getchar()) != '\n') {
       if(i<nr && isdigit(ch)!=0) {
          string[i++]=ch;
       }
       else {
          string=NULL;
          return string;
       }
   }
   string[i]='
char *readLine(int nr) {
int ch, i=0;
char *string;
string = malloc(nr);
while((ch = getchar()) != '\n') {
if(i<nr && isdigit(ch)!=0) {
string[i++]=ch;
}
else {
string=NULL;
return string;
}
}
string[i]='\0';
return string;
} 
int main(void) {
int number;
printf("Enter number: ");
char *p=readLine(100);
if(p==NULL) {
printf("Invalid input!\n");
}
else {
number=atoi(p);
printf("Number as int is %d ", number);
}
free(p);
return 0;
}
';

   return string;
} 


int main(void) {
   int number;

   printf("Enter number: ");
   char *p=readLine(100);

   if(p==NULL) {
      printf("Invalid input!\n");
   }
   else {
      number=atoi(p);
      printf("Number as int is %d ", number);
   }
   free(p);

   return 0;
}

Add another if statement that checks for q as the first character, and add it to string.

You also need to free(string) before assigning NULL, otherwise you have a memory leak.

In the caller, check for q before trying to call atoi().

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

char *readLine(int nr) {
	int ch, i=0, q_entered = 0;
	char *string;
	string = malloc(nr);

	while((ch = getchar()) != '\n') {
		if(i<nr && !q_entered && isdigit(ch)!=0) {
			string[i++]=ch;
		} else if (i == 0 && ch == 'q') {
			string[i++] = ch;
			q_entered = 1;
		} else {
			free(string);
			return NULL;
		}
	}
	string[i]='
#include <stdio.h>
#include <ctype.h>
#include <stdlib.h>
#include <string.h>
char *readLine(int nr) {
int ch, i=0, q_entered = 0;
char *string;
string = malloc(nr);
while((ch = getchar()) != '\n') {
if(i<nr && !q_entered && isdigit(ch)!=0) {
string[i++]=ch;
} else if (i == 0 && ch == 'q') {
string[i++] = ch;
q_entered = 1;
} else {
free(string);
return NULL;
}
}
string[i]='\0';
return string;
}
int main(void) {
int number;
printf("Enter number: ");
char *p=readLine(100);
if(p==NULL) {
printf("Invalid input!\n");
} else if (strcmp(p, "q") == 0) {
printf("Quitting\n");
} else {
number=atoi(p);
printf("Number as int is %d\n", number);
}
free(p);
return 0;
}
';

	return string;
}

int main(void) {
	int number;

	printf("Enter number: ");
	char *p=readLine(100);

	if(p==NULL) {
		printf("Invalid input!\n");
	} else if (strcmp(p, "q") == 0) {
		printf("Quitting\n");
	} else {
		number=atoi(p);
		printf("Number as int is %d\n", number);
	}
	free(p);

	return 0;
}

That said, it's usually better design to separate the input code from the code that parses the input. readLine() should just return the line in any format, and you should have a separate allDigits() function that checks for this.

In your question, you stated that you wanted the input to consist either of

• only digits, or
• only the single character "q".

Otherwise, the input is invalid and should be rejected.

However, in the comments section, you stated that the input string "0" should also be rejected. Instead, you want the input to be in the range of 1 to a certain maximum value.

In that case, it is not meaningful to use the function isdigit to determine whether the input "0" is valid, because it will report that input as valid, although you want that input to be rejected as invalid.

For this reason, I recommend that you first read an entire line using the function fgets, and then inspect the content of that line. If that line consists of the single character q, then you know the input is valid. Otherwise, you can use the function strtol in order to attempt to convert the input to an integer.

If this conversion fails, then you will know that the input is invalid.

However, if the conversion succeeds, you can then perform one further check, to determine whether the converted integer is in the desired range, for example whether it is in the range 1 to 20.

Here is an example:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <errno.h>

#define MIN_INPUT_NUMBER 1
#define MAX_INPUT_NUMBER 20

void get_line_from_user( const char prompt[], char buffer[], int buffer_size );

int main( void )
{
    char line[200], *p;
    long num;

    //read exactly one line of input from the user
    get_line_from_user(
        "Please enter a number: ",
        line, sizeof line
    );

    //determine whether the user entered `"q"` as input
    if ( line[0] == 'q' && line[1] == '
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <errno.h>
#define MIN_INPUT_NUMBER 1
#define MAX_INPUT_NUMBER 20
void get_line_from_user( const char prompt[], char buffer[], int buffer_size );
int main( void )
{
char line[200], *p;
long num;
//read exactly one line of input from the user
get_line_from_user(
"Please enter a number: ",
line, sizeof line
);
//determine whether the user entered `"q"` as input
if ( line[0] == 'q' && line[1] == '\0' )
{
printf( "Input is valid, user entered \"q\".\n" );
exit( EXIT_SUCCESS );
}
//attempt to convert input to a number
errno = 0;
num = strtol( line, &p, 10 );
//verify that at least one character was converted
if ( p == line )
{
printf( "Error: Unable to convert input to integer!\n" );
exit( EXIT_FAILURE );
}
//verify that input is not too small or too large to be
//representable as a `long int`
if ( errno == ERANGE )
{
printf( "Error: Input is outside the range of a long int!\n" );
exit( EXIT_FAILURE );
}
//verify that either all characters were converted or that all
//remaining characters are whitespace characters, so that input
//such as "242q42" gets rejected
for ( ; *p != '\0'; p++ )
{
if ( !isspace( (unsigned char)*p ) )
{
printf( "Error: Not all non-whitespace characters were converted!\n" );
exit( EXIT_FAILURE );
}
}
//verify that the converted integer is in the desired range
if ( num < MIN_INPUT_NUMBER || num > MAX_INPUT_NUMBER )
{
printf(
"Error: Input must be in the range %d to %d.\n",
MIN_INPUT_NUMBER, MAX_INPUT_NUMBER
);
exit( EXIT_FAILURE );
}
//everything went ok, so print the result
printf( "Input was valid! User entered %ld.\n", num );
return EXIT_SUCCESS;
}
//This function will read exactly one line of input from the
//user. It will remove the newline character, if it exists. If
//the line is too long to fit in the buffer, then the function
//will automatically reprompt the user for input. On failure,
//the function will never return, but will print an error
//message and call "exit" instead.
void get_line_from_user( const char prompt[], char buffer[], int buffer_size )
{
for (;;) //infinite loop, equivalent to while(1)
{
char *p;
//prompt user for input
fputs( prompt, stdout );
//attempt to read one line of input
if ( fgets( buffer, buffer_size, stdin ) == NULL )
{
printf( "Error reading from input!\n" );
exit( EXIT_FAILURE );
}
//attempt to find newline character
p = strchr( buffer, '\n' );
//make sure that entire line was read in (i.e. that
//the buffer was not too small to store the entire line)
if ( p == NULL )
{
int c;
//a missing newline character is ok if the next
//character is a newline character or if we have
//reached end-of-file (for example if the input is
//being piped from a file or if the user enters
//end-of-file in the terminal itself)
if ( (c=getchar()) != '\n' && !feof(stdin) )
{
if ( c == EOF )
{
printf( "Error reading from input!\n" );
exit( EXIT_FAILURE );
}
printf( "Input was too long to fit in buffer!\n" );
//discard remainder of line
do
{
c = getchar();
if ( c == EOF )
{
//this error message will be printed if either
//a stream error or an unexpected end-of-file
//is encountered
printf( "Error reading from input!\n" );
exit( EXIT_FAILURE );
}
} while ( c != '\n' );
//reprompt user for input by restarting loop
continue;
}
}
else
{
//remove newline character by overwriting it with
//null character
*p = '\0';
}
//input was ok, so break out of loop
break;
}
}
' )
    {
        printf( "Input is valid, user entered \"q\".\n" );
        exit( EXIT_SUCCESS );
    }

    //attempt to convert input to a number
    errno = 0;
    num = strtol( line, &p, 10 );

    //verify that at least one character was converted
    if ( p == line )
    {
        printf( "Error: Unable to convert input to integer!\n" );
        exit( EXIT_FAILURE );
    }

    //verify that input is not too small or too large to be
    //representable as a `long int`
    if ( errno == ERANGE )
    {
        printf( "Error: Input is outside the range of a long int!\n" );
        exit( EXIT_FAILURE );
    }

    //verify that either all characters were converted or that all
    //remaining characters are whitespace characters, so that input
    //such as "242q42" gets rejected
    for ( ; *p != '
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <errno.h>
#define MIN_INPUT_NUMBER 1
#define MAX_INPUT_NUMBER 20
void get_line_from_user( const char prompt[], char buffer[], int buffer_size );
int main( void )
{
char line[200], *p;
long num;
//read exactly one line of input from the user
get_line_from_user(
"Please enter a number: ",
line, sizeof line
);
//determine whether the user entered `"q"` as input
if ( line[0] == 'q' && line[1] == '\0' )
{
printf( "Input is valid, user entered \"q\".\n" );
exit( EXIT_SUCCESS );
}
//attempt to convert input to a number
errno = 0;
num = strtol( line, &p, 10 );
//verify that at least one character was converted
if ( p == line )
{
printf( "Error: Unable to convert input to integer!\n" );
exit( EXIT_FAILURE );
}
//verify that input is not too small or too large to be
//representable as a `long int`
if ( errno == ERANGE )
{
printf( "Error: Input is outside the range of a long int!\n" );
exit( EXIT_FAILURE );
}
//verify that either all characters were converted or that all
//remaining characters are whitespace characters, so that input
//such as "242q42" gets rejected
for ( ; *p != '\0'; p++ )
{
if ( !isspace( (unsigned char)*p ) )
{
printf( "Error: Not all non-whitespace characters were converted!\n" );
exit( EXIT_FAILURE );
}
}
//verify that the converted integer is in the desired range
if ( num < MIN_INPUT_NUMBER || num > MAX_INPUT_NUMBER )
{
printf(
"Error: Input must be in the range %d to %d.\n",
MIN_INPUT_NUMBER, MAX_INPUT_NUMBER
);
exit( EXIT_FAILURE );
}
//everything went ok, so print the result
printf( "Input was valid! User entered %ld.\n", num );
return EXIT_SUCCESS;
}
//This function will read exactly one line of input from the
//user. It will remove the newline character, if it exists. If
//the line is too long to fit in the buffer, then the function
//will automatically reprompt the user for input. On failure,
//the function will never return, but will print an error
//message and call "exit" instead.
void get_line_from_user( const char prompt[], char buffer[], int buffer_size )
{
for (;;) //infinite loop, equivalent to while(1)
{
char *p;
//prompt user for input
fputs( prompt, stdout );
//attempt to read one line of input
if ( fgets( buffer, buffer_size, stdin ) == NULL )
{
printf( "Error reading from input!\n" );
exit( EXIT_FAILURE );
}
//attempt to find newline character
p = strchr( buffer, '\n' );
//make sure that entire line was read in (i.e. that
//the buffer was not too small to store the entire line)
if ( p == NULL )
{
int c;
//a missing newline character is ok if the next
//character is a newline character or if we have
//reached end-of-file (for example if the input is
//being piped from a file or if the user enters
//end-of-file in the terminal itself)
if ( (c=getchar()) != '\n' && !feof(stdin) )
{
if ( c == EOF )
{
printf( "Error reading from input!\n" );
exit( EXIT_FAILURE );
}
printf( "Input was too long to fit in buffer!\n" );
//discard remainder of line
do
{
c = getchar();
if ( c == EOF )
{
//this error message will be printed if either
//a stream error or an unexpected end-of-file
//is encountered
printf( "Error reading from input!\n" );
exit( EXIT_FAILURE );
}
} while ( c != '\n' );
//reprompt user for input by restarting loop
continue;
}
}
else
{
//remove newline character by overwriting it with
//null character
*p = '\0';
}
//input was ok, so break out of loop
break;
}
}
'; p++ )
    {
        if ( !isspace( (unsigned char)*p ) )
        {
            printf( "Error: Not all non-whitespace characters were converted!\n" );
            exit( EXIT_FAILURE );
        }
    }

    //verify that the converted integer is in the desired range
    if ( num < MIN_INPUT_NUMBER || num > MAX_INPUT_NUMBER )
    {
        printf(
            "Error: Input must be in the range %d to %d.\n",
            MIN_INPUT_NUMBER, MAX_INPUT_NUMBER
        );
        exit( EXIT_FAILURE );
    }

    //everything went ok, so print the result
    printf( "Input was valid! User entered %ld.\n", num );

    return EXIT_SUCCESS;
}

//This function will read exactly one line of input from the
//user. It will remove the newline character, if it exists. If
//the line is too long to fit in the buffer, then the function
//will automatically reprompt the user for input. On failure,
//the function will never return, but will print an error
//message and call "exit" instead.
void get_line_from_user( const char prompt[], char buffer[], int buffer_size )
{
    for (;;) //infinite loop, equivalent to while(1)
    {
        char *p;

        //prompt user for input
        fputs( prompt, stdout );

        //attempt to read one line of input
        if ( fgets( buffer, buffer_size, stdin ) == NULL )
        {
            printf( "Error reading from input!\n" );
            exit( EXIT_FAILURE );
        }

        //attempt to find newline character
        p = strchr( buffer, '\n' );

        //make sure that entire line was read in (i.e. that
        //the buffer was not too small to store the entire line)
        if ( p == NULL )
        {
            int c;

            //a missing newline character is ok if the next
            //character is a newline character or if we have
            //reached end-of-file (for example if the input is
            //being piped from a file or if the user enters
            //end-of-file in the terminal itself)
            if ( (c=getchar()) != '\n' && !feof(stdin) )
            {
                if ( c == EOF )
                {
                    printf( "Error reading from input!\n" );
                    exit( EXIT_FAILURE );
                }

                printf( "Input was too long to fit in buffer!\n" );

                //discard remainder of line
                do
                {
                    c = getchar();

                    if ( c == EOF )
                    {
                        //this error message will be printed if either
                        //a stream error or an unexpected end-of-file
                        //is encountered
                        printf( "Error reading from input!\n" );
                        exit( EXIT_FAILURE );
                    }

                } while ( c != '\n' );

                //reprompt user for input by restarting loop
                continue;
            }
        }
        else
        {
            //remove newline character by overwriting it with
            //null character
            *p = '
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <errno.h>
#define MIN_INPUT_NUMBER 1
#define MAX_INPUT_NUMBER 20
void get_line_from_user( const char prompt[], char buffer[], int buffer_size );
int main( void )
{
char line[200], *p;
long num;
//read exactly one line of input from the user
get_line_from_user(
"Please enter a number: ",
line, sizeof line
);
//determine whether the user entered `"q"` as input
if ( line[0] == 'q' && line[1] == '\0' )
{
printf( "Input is valid, user entered \"q\".\n" );
exit( EXIT_SUCCESS );
}
//attempt to convert input to a number
errno = 0;
num = strtol( line, &p, 10 );
//verify that at least one character was converted
if ( p == line )
{
printf( "Error: Unable to convert input to integer!\n" );
exit( EXIT_FAILURE );
}
//verify that input is not too small or too large to be
//representable as a `long int`
if ( errno == ERANGE )
{
printf( "Error: Input is outside the range of a long int!\n" );
exit( EXIT_FAILURE );
}
//verify that either all characters were converted or that all
//remaining characters are whitespace characters, so that input
//such as "242q42" gets rejected
for ( ; *p != '\0'; p++ )
{
if ( !isspace( (unsigned char)*p ) )
{
printf( "Error: Not all non-whitespace characters were converted!\n" );
exit( EXIT_FAILURE );
}
}
//verify that the converted integer is in the desired range
if ( num < MIN_INPUT_NUMBER || num > MAX_INPUT_NUMBER )
{
printf(
"Error: Input must be in the range %d to %d.\n",
MIN_INPUT_NUMBER, MAX_INPUT_NUMBER
);
exit( EXIT_FAILURE );
}
//everything went ok, so print the result
printf( "Input was valid! User entered %ld.\n", num );
return EXIT_SUCCESS;
}
//This function will read exactly one line of input from the
//user. It will remove the newline character, if it exists. If
//the line is too long to fit in the buffer, then the function
//will automatically reprompt the user for input. On failure,
//the function will never return, but will print an error
//message and call "exit" instead.
void get_line_from_user( const char prompt[], char buffer[], int buffer_size )
{
for (;;) //infinite loop, equivalent to while(1)
{
char *p;
//prompt user for input
fputs( prompt, stdout );
//attempt to read one line of input
if ( fgets( buffer, buffer_size, stdin ) == NULL )
{
printf( "Error reading from input!\n" );
exit( EXIT_FAILURE );
}
//attempt to find newline character
p = strchr( buffer, '\n' );
//make sure that entire line was read in (i.e. that
//the buffer was not too small to store the entire line)
if ( p == NULL )
{
int c;
//a missing newline character is ok if the next
//character is a newline character or if we have
//reached end-of-file (for example if the input is
//being piped from a file or if the user enters
//end-of-file in the terminal itself)
if ( (c=getchar()) != '\n' && !feof(stdin) )
{
if ( c == EOF )
{
printf( "Error reading from input!\n" );
exit( EXIT_FAILURE );
}
printf( "Input was too long to fit in buffer!\n" );
//discard remainder of line
do
{
c = getchar();
if ( c == EOF )
{
//this error message will be printed if either
//a stream error or an unexpected end-of-file
//is encountered
printf( "Error reading from input!\n" );
exit( EXIT_FAILURE );
}
} while ( c != '\n' );
//reprompt user for input by restarting loop
continue;
}
}
else
{
//remove newline character by overwriting it with
//null character
*p = '\0';
}
//input was ok, so break out of loop
break;
}
}
';
        }

        //input was ok, so break out of loop
        break;
    }
}

This program has the following behavior:

Please enter a number: 242q42
Error: Not all non-whitespace characters were converted!

Please enter a number: 5435q
Error: Not all non-whitespace characters were converted!

Please enter a number: qq
Error: Unable to convert input to integer!

Please enter a number: q
Input is valid, user entered "q".

Please enter a number: 50000000000000000000000000
Error: Input is outside the range of a long int!

Please enter a number: -23
Error: Input must be in the range 1 to 20.

Please enter a number: 0
Error: Input must be in the range 1 to 20.

Please enter a number: 22
Error: Input must be in the range 1 to 20.

Please enter a number: 17
Input was valid! User entered 17.

In order to change the permissible range, you can change the lines

#define MIN_INPUT_NUMBER 1
#define MAX_INPUT_NUMBER 20

in the program.

Checking also for 'q' your code would look like this:

char *readLine(int nr) {
   int ch, i=0;
   char *string;
   string = malloc(nr);

   while((ch = getchar()) != '\n') {
       if(i<nr && isdigit(ch)!=0) {
          string[i++]=ch;
       }       
       else if (ch=='q' && i==0 && getchar()=='\n')
       {
        string[i++]=ch;
        return string;
       }                      
       else {
          string=NULL;
          return string;
       }
   }
   string[i]='
char *readLine(int nr) {
int ch, i=0;
char *string;
string = malloc(nr);
while((ch = getchar()) != '\n') {
if(i<nr && isdigit(ch)!=0) {
string[i++]=ch;
}       
else if (ch=='q' && i==0 && getchar()=='\n')
{
string[i++]=ch;
return string;
}                      
else {
string=NULL;
return string;
}
}
string[i]='\0';
return string;
} 
int main(void) {
int number;
printf("Enter a number or q: ");
char *p=readLine(100);
if(p==NULL) {
printf("Invalid input!\n");
}
else if (p[0]=='q' && p[1]=='\0')   
{
printf("You entered q\n");
}
else {
number=atoi(p);
printf("Number as int is %d ", number);
}
free(p);
return 0;
}
';
   return string;
} 


int main(void) {
   int number;

   printf("Enter a number or q: ");
   char *p=readLine(100);

   if(p==NULL) {
      printf("Invalid input!\n");
   }
   else if (p[0]=='q' && p[1]=='
char *readLine(int nr) {
int ch, i=0;
char *string;
string = malloc(nr);
while((ch = getchar()) != '\n') {
if(i<nr && isdigit(ch)!=0) {
string[i++]=ch;
}       
else if (ch=='q' && i==0 && getchar()=='\n')
{
string[i++]=ch;
return string;
}                      
else {
string=NULL;
return string;
}
}
string[i]='\0';
return string;
} 
int main(void) {
int number;
printf("Enter a number or q: ");
char *p=readLine(100);
if(p==NULL) {
printf("Invalid input!\n");
}
else if (p[0]=='q' && p[1]=='\0')   
{
printf("You entered q\n");
}
else {
number=atoi(p);
printf("Number as int is %d ", number);
}
free(p);
return 0;
}
')   
   {
      printf("You entered q\n");
   }
   
   else {
      number=atoi(p);
      printf("Number as int is %d ", number);
   }
   free(p);

   return 0;
}