I ended up ... using the fgets() function, like so:
fgets(userName, 32, stdin);
Actually I'm a huge fan of sizeof(). So I would have written the code as:
fgets(userName, sizeof(userName), stdin);
Of course this only works if userName is a char array. It does NOT work if userName is a pointer. But where ever I can use sizeof() instead of hard coding a constant, I use it.
I still have a few questions though:
1.) What would be the difference between this and using fgetln() instead? Is it simply that fgetln() reads until a newline character whereas fgets() reads until the given amount of characters or a newline character, whichever comes first? Is there any other difference worth noting here?
Never used fgetln() (didn't even know it existed 🙂 ).
Reading "man fgetln()", you do not get a
nul character terminating the string. Many C string functions depend on that trailing
nul so if you are going to use any of those, you will have to add it yourself.
You must use everything in the returned buffer before calling fgetln() a 2nd time, as it reuses its old buffer. I'm guessing here, but it might point into the Stream buffer as long as the entire line is in the buffer. If the line crosses between one buffer and the next, it most likely malloc()s memory, copies the line from the Stream buffer into the malloc()ed memory. This would explain why there is no terminating
nul as adding a
nul would trash the first character of the next line in the Steam buffer (Steam buffer explained at the end of this post).
On the plus side, you never have to worry about buffer overflow. That alone can be a huge win if you are writing commercial software.
2.) Should I use fgets() for all my input from the command-line, or is it better to use scanf() when I know I'm only going to need to input one word?
I rarely use scanf(), but that is just me. I mostly forget it exists.
Using scanf() means it will read stdin until it fills in all of its argument. If that means consuming multipe input lines, it will do that. This is not always desirable, unless you are doing simple get next blank separated token (scanf("%s",token_string);), and the rest of the code will worry about the structure of the data.
If you do care about one line vs the next, but want the benefits of scanf(), then you read the line, and use
sscanf(). How you want to read the line is up to you, except if you are going to use fgetln(), then you need to add that all important
nul terminator.
size_t len;
char *input_line;
char userName[32];
input_line = fgetln(stdin, &len);
input_line[len-1] = ' '; # replaces newline with nul
sscanf(input_line,"%31s",userName);
Stream Buffer. The Stream I/O calls really read into a Steam buffer which is typically 4096 bytes (sometimes 8192, or larger power of 2). This allows multiple calls to fread(), getc(), fgets(), scanf(), etc... to avoid making a more expensive system call and worse performing a very expensive disk I/O. Of course this only applies to reading files, not reading from the Terminal where the source of input is a user at the other end of a keyboard.
For output, the Stream buffer accumulates up to 4096 bytes (or again maybe 8192 etc...) of output before writing it to disk. Again this is a performance feature, as writing to disk each time someone does a putc() or fputc() gets very expensive very fast. Again if the output is a Terminal screen, the buffering rules are different.
