Thread: fgets

That code should work fine, apart from the missing ';' which I guess is just a typo.
Post some more of your code if you still have trouble.

[edit]
when input is skipped over it is usually because there is a newline lurking around in the input buffer. This is why you have read that scanf is bad.
Try adding this before you call fgets() :

Code:

while( getchar() != '\n' );

This will remove unwanted characters from the input buffer up to the first newline.
[/edit]

>>else while( getchar() != 0xa );
Just to be picky, how do you know that 0xa is a newline character? And no, the answer isn't "because the ASCII chart says so".

To be portable, you should use \n

>If it didn't, there's garbage left
Be careful, that 'garbage' may be valid input that was one of those cases where the string was longer than the buffer. If you throw it away then the rest of the program could break.

>To be portable, you should use \n
But 0xA looks more computery. We can't have non-programmers being able to figure out our code now, can we? And you're not being picky, portability is very important, if the standard gives us something that can go from ASCII to EBCDIC to whatever without change then by all means we should use it.

[edit]
To be more portable, you should take files into consideration:

Code:

while ( ( ch = fgetc ( filep ) ) != EOF && ch != '\n' );

[/edit]

-Prelude

>>while ( ( ch = fgetc ( filep ) ) != EOF && ch != '\n' );

...except that EOF is no longer reliable since file formats these days are littered with the signature EOF value -1. The most reliable way is to use the while(!feof(file_pointer)) construct with files since it relies on the information the operating system places in the FILE structure. fgets() works too since it returns NULL when the end of file condition is reached.

Originally posted by Sebastiani
>>while ( ( ch = fgetc ( filep ) ) != EOF && ch != '\n' );

...except that EOF is no longer reliable since file formats these days are littered with the signature EOF value -1. The most reliable way is to use the while(!feof(file_pointer)) construct with files since it relies on the information the operating system places in the FILE structure. fgets() works too since it returns NULL when the end of file condition is reached.

Seb, you're way off base here.

EOF is an int, not a char. fgetc() will return EOF at the end of the file (or upon error) which will equate to a -1 int, not a -1 char. There's a big difference.

Here's some code to prove it, with comments at the end to show the results.

Code:

#include <stdio.h>

int main(void)
{
    FILE *fp;
    int c;
    
    if ((fp = fopen("file.bin", "rb")) == NULL)
        return 1;
    
    while ((c = fgetc(fp)) != EOF)
        printf ("c is %x\n", c);
    printf ("\nEOF: %x", c);
    fclose(fp);
    return(0);
}

/*
The input file is one byte long, and that byte has value 0xff.
The output from this program is:
c is ff   <- This is "real data"

EOF: ffffffff   <-- This is the value of c now it has been assigned EOF

>while(!feof(file_pointer))
Definately not the way to go. This can lead to double reads at the end of the file.

Some compilers don't set the EOF flag in the file stream until they have performed a read and the OS has replied with EOF instead of data.

Other compilers will work differently, and will set EOF when doing the final read that gets data. In this case, the feof() loop would work correctly.

>>fgets() works too since it returns NULL when the end of file condition is reached.
Agreed.

i thought EOF could be defined by the standard library as any int value which cannot fit into a single char, not nessecarily -1?

i thought EOF could be defined by the standard library as any int value which cannot fit into a single char, not nessecarily -1?

Yes, you are correct, but it is typically -1, hence I used it in my example. The same principles still apply.

[EDIT] From one of the standards docs:

EOF is traditionally -1, but may be any negative integer, and hence distinguishable from any valid character code.

I always use something like this (may not work):

Code:

#include <stdio.h>

...

int getstuffed(char *cpntr, int maxlen)
{
 fgets(cpntr, maxlen, stdin);   // whoops,  corrected.
 for(int i = 0;cpntr[i];i++)
  if(cpntr[i] == '\n') cpntr[i] == '\0';
 return 0;
}

int main(void)
{
 char coolstring[256];
 getstuffed(coolstring,256);
 printf("%s",coolstring);
 return 0;
}

>>>I always use something like this (may not work):
You can't use that, the function name is way too funny

Besides, there's a library function that'll do it for you:

Code:

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

int main(void)
{
    char c[] = "This is a line\n";
    printf (">%s<\n", c);
    c[strcspn(c, "\n")] = '\0';
    printf (">%s<\n", c);
    return(0);
}

Originally posted by Brian


I haven't been here for a while. But isn't this addressed in the FAQ?

Probably, but they're top secret, and no-one is allowed to read them.