Excess buffer using fgets

Hi to all... I checked the FAQ and some tutorials over the net regarding not use
scanf or gets just use fgets to control buffer. I created this code for a test but it seems
like the excess buffer is not removed but the other fgets received it and it won't allow
me to input another value.

Code:

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


int main()
{
    char name[ 22 ];
    char age[ 4 ];
    int length;
    char *newlineName;
    char *newlineAge;

    fputs( "Enter name: (20 maximum characters) ", stdout );

    if( fgets( name, 22, stdin ) )
    {
        newlineName = strchr( name, '\n' );
        if( newlineName )
          *newlineName = '\0';
    }

    fputs( "Enter age: ", stdout );
    if( fgets( age, 2, stdin ) )
    {
        newlineAge = strchr( age, '\n' );
        if( newlineAge )
          *newlineAge = '\0';
    }

    fputs( "Your name is: " , stdout );
    fputs( name, stdout );

    fputs( "\nYour age is: ", stdout );
    fputs( age, stdout );

    return 0;
}

I can't think of any resolution to this problem. Thanks for the help in advance..

Works fine for me:

Code:

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

char* get( char* buffer, size_t size, FILE* in )
{	
	char *newline, *result = fgets( buffer, size, in );
	if( result )
	{
		newline = strchr( buffer, '\n' );
		if( newline )
			*newline = 0;
	}
	return result;
}

int main()
{
    const int size = 22;	
    char name[ size ];
    char age[ size ];
    int length;
    char *newlineName;
    char *newlineAge;

    fputs( "Enter name: (21 maximum characters) ", stdout );
    get( name, size, stdin );
    fputs( "Enter age: ", stdout );
    get( age, size, stdin );
    fprintf( stdout, "Your name is: %s\n" , name );
    fprintf( stdout, "Your age is: %s\n" , age );
    return 0;
}

I'm not sure what's the issue here but the second fgets() is a few characters short of the array size

Code:

char age[ 4 ];
...
if( fgets( age, 2, stdin ) ) /* perhaps the 2 should really be a 4? */

It worked properly except for it's not printing the age properly. I think what you're trying to do is hitting enter after the "Enter name: (20 maximum characters)" line.

>> I'm not sure what's the issue here but the second fgets() is a few characters short of the array size

Right. fgets makes sure there is room for the null terminator, so it really isn't necessary to pass it a smaller size than the buffer.

Originally Posted by Sebastiani

Right. fgets makes sure there is room for the null terminator, so it really isn't necessary to pass it a smaller size than the buffer.

Yep! in this case it'll read just one char and null-terminate age[], so it's biased towards kiddos

> if( fgets( age, 2, stdin ) )
Don't you mean 4 (the size of the array)?

Since one of these two is reserved for the \0, that leaves just ONE character for your input AND a \n (that doesn't fit).

Originally Posted by BEN10

It worked properly except for it's not printing the age properly. I think what you're trying to do is hitting enter after the "Enter name: (20 maximum characters)" line.

Yes.. I modified the code and applied sebastiani's code:

Code:

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

char *getString( char *buffer, size_t size, FILE* input );

int main()
{
    const int size = 22;

    char name[ size ];
    char age[ size ];

    fputs( "Enter name: ", stdout );
    getString( name, size, stdin );

    fputs( "Enter age: ", stdout );
    getString( age, size, stdin );

    fprintf( stdout, "Name is: %s\n",name );
    fprintf( stdout, "Age  is: %s\n", age );

    return 0;
}

char *getString( char *buffer, size_t size, FILE *input )
{
    char *newLine, *stringResult = fgets( buffer, size, input );

    if( stringResult )
    {
        newLine = strchr( stringResult, '\n' );
        if( newLine )
          *newLine = '\0';
    }

    return stringResult;
}

The size of the string is 22, if I entered more than 22 the age input will accept the excess buffer that was from the first input. So I can't input for the age at all and the age will print out the excess from the first input.

here's the output of the program:

Code:

Enter name: Maria Theresa Acosta D
Enter age: Name is: Maria Theresa Acosta
Age  is: D

Process returned 0 (0x0)   execution time : 42.703 s
Press any key to continue.

As you can see the 22nd character is D and it's directly retrieved by age...

Originally Posted by Salem

> if( fgets( age, 2, stdin ) )
Don't you mean 4 (the size of the array)?

Since one of these two is reserved for the \0, that leaves just ONE character for your input AND a \n (that doesn't fit).

Yes I'm sorry, I forgot to change the code to it's original state for I was playing with it earlier.

>> The size of the string is 22, if I entered more than 22 the age input will accept the excess buffer that was from the first input.

I see. Well, I don't know how portable this is, but you could try:

Code:

char *getString( char *buffer, size_t size, FILE *input )
{
    char *newLine, *stringResult = fgets( buffer, size, input );

    if( stringResult )
    {
        newLine = strchr( stringResult, '\n' );
        if( newLine )
          *newLine = '\0';
    }
    fflush( input );
    return stringResult;
}

EDIT:

OK, so it's actually not recommended (read: undefined behavior). So apparently you'll need an OS-specific solution...

Originally Posted by Sebastiani

I don't know how portable this is

It is not portable because fflush() is not defined for input streams or update streams for which the last operation was a read operation. I suggest:

Code:

char *getString( char *buffer, size_t size, FILE *input )
{
    int c;

    char *stringResult = fgets( buffer, size, input );
    if( stringResult )
    {
        char *newLine = strchr( stringResult, '\n' );
        if( newLine )
            *newLine = '\0';
    }

    while( ( c = fgetc( input ) ) != '\n' && c != EOF );

    return stringResult;
}

>> while( ( c = fgetc( input ) ) != '\n' && c != EOF );

The problem with that, though, is that tries to read from the input even if there's none available.

What about this:

Code:

void flush_input_stream( FILE* in )
{
	while( fseek( in, 1, SEEK_CUR ) == 0 )
		continue;
} 

char *getString( char *buffer, size_t size, FILE *input )
{
    char *newLine, *stringResult = fgets( buffer, size, input );

    if( stringResult )
    {
        newLine = strchr( stringResult, '\n' );
        if( newLine )
          *newLine = '\0';
    }
    flush_input_stream( input );
    return stringResult;
}

EDIT:
OK, so what I've found is that while it is in fact portable (standard-compliant), it isn't necessarily implemented correctly on all systems. But it should work on most. Also, you could probably compress it into a single fseek by specifying SEEK_END (and 0 for the offset, of course).

I learned from a thread one thing that returning strings might result in a pointer which might be pointing to the string which is not present there. So, wouldn't this declaration be more safe than yours.

Code:

static char *stringResult = fgets( buffer, size, input );

Originally Posted by Sebastiani

The problem with that, though, is that tries to read from the input even if there's none available.

I think that that would result in EOF being read. But I see what you mean: if this was keyboard input, there would be a problem, but we should be able to cater for keyboard input... I'll post later if this has not been addressed by the time I get back.

Originally Posted by BEN10

I learned from a thread one thing that returning strings might result in a pointer which might be pointing to the string which is not present there. So, wouldn't this declaration be more safe than yours.
Code:

The function returns a pointer that was passed to it, so if the pointer points to something that exists in the caller, the caller will receive a pointer to something that exists. There is no problem.

>> I learned from a thread one thing that returning strings might result in a pointer which might be pointing to the string which is not present there. So, wouldn't this declaration be more safe than yours.

It depends on the function, but fgets, specifically, is guaranteed to return a pointer to the buffer, unless an error occurs, in which case it returns NULL.