Read a line from console in C

Question

Is crazy enough but there is seems to be very very difficult to read a simple line of chars from the console in C... gets, fgets, getline, scanf.... any of these functions does not seem to achieve such a simple thing, read a simple line, without the new line char...

What is that language? I follow these answers, but I don't understand how a language that is so complex to just read a string from console can exist?

Please, could someone guide me how, having a char* str, to just read in a console text...

Answer 1

The following will read a line from stdin, then remove the newline:

char buffer[260];
...
fgets(buffer, sizeof(buffer), stdin);
buffer[strcspn(buffer, "\n")] = 0;  

The C library function char *fgets(char *str, int n, FILE *stream) reads a line from the specified stream and stores it into the string pointed to by str. It stops when either (n-1) characters are read, the newline character is read, or the end-of-file is reached, whichever comes first.

To collect larger amounts of input, this construct can be called within a loop. Note that how to accumulate each successive buffer is another topic.

More on fgets()

Answer 2

@ryker provided a good answer that explains the most of it. Here is a pretty safe implementation that is 100% portable and allows you to not bother about neither the newline, buffer overflow or allocation. But it returns a pointer that you need to free.

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

char *gline() {
    char *buffer;

    const size_t step = 10;
    size_t size = step;

    if(!(buffer = malloc(size))) goto CLEANUP;

    char *s = buffer;

    // step-1 is not strictly necessary, but some implementations of fgets
    // are buggy. That's why it's step-1 instead of just step
    while(fgets(s, step-1, stdin)) {
        if(strchr(s, '\n')) break;
        size += step;
        if(!(buffer = realloc(buffer, size))) goto CLEANUP;
        s = &buffer[strlen(buffer)];
    }

    buffer[strcspn(buffer, "\n")] = 0;
    return buffer;

CLEANUP:
    free(buffer);
    return NULL;
}

int main(void) {
    char *s = gline();
    if(!s)
        puts("Error reading line");
    else
        puts(s);
    free(s);
}

I have not finetuned it, so it's possible that it allocates a little bit more memory than necessary. It's not very efficient either, because it runs strlen in every iteration. But as long as the allocations does not fail, it's safe and easy to use.

Answer 3

The built in functions like scanf will do it but the problem I have with them is that you need to know ahead of time how much input you will receive. What if it's 1 character? What if it's 10000? So I prefer to dynamically allocate memory using malloc and realloc and build the string as the input is received. This is what I use when I need to read from stdin or a file. It is simple enough, probably far from perfect, it simply gets a character from stream and if it isn't the newline or EOF it adds it to the string. If the reallocation fails it frees the entire string as I need to have an "all or nothing" approach to building the string. It returns a pointer to the string or NULL or any failure.

char* get_str(FILE* stream)
{
    char *s;
    int ix = 0, sz = 1, rf = 0, ch;

    if(stream == NULL) {
        s = NULL;
    } else {
        s = (char*)malloc(sizeof(char) * sz);
        if(s != NULL) {
            s[ix] = '\0';
            ch = fgetc(stream);
            while(ch != '\n' && ch != EOF && rf == 0) {
                sz++;
                s = (char*)realloc(s, sizeof(char) * sz);
                if(s != NULL) {
                    s[ix] = ch;
                    ix++;
                    s[ix] = '\0';
                    ch = fgetc(stream);
                } else {
                    rf = 1;
                    free(s);
                    s = NULL;
                }
            }
        }
    }

    return s;
}

And then you call it like this:

int main()
{
    char *s = get_str(stdin); /* or a file you opened with fopen, etc */

    printf("%s\n", s);

    free(s);

    return 0;
}

Just remember that memory allocated with either malloc, calloc, or realloc needs to be freed.