How to read a line from the console in C?

问题:

What is the simplest way to read a full line in a C console program The text entered might have a variable length and we can\'t make any assumption about its content.

回答1:

You need dynamic memory management, and use the fgets function to read your line. However, there seems to be no way to see how many characters it read. So you use fgetc:

char * getline(void) {
    char * line = malloc(100), * linep = line;
    size_t lenmax = 100, len = lenmax;
    int c;

    if(line == NULL)
        return NULL;

    for(;;) {
        c = fgetc(stdin);
        if(c == EOF)
            break;

        if(--len == 0) {
            len = lenmax;
            char * linen = realloc(linep, lenmax *= 2);

            if(linen == NULL) {
                free(linep);
                return NULL;
            }
            line = linen + (line - linep);
            linep = linen;
        }

        if((*line++ = c) == \'\\n\')
            break;
    }
    *line = \'\\0\';
    return linep;
}

Note: Never use gets ! It does not do bounds checking and can overflow your buffer

回答2:

If you are using the GNU C library or another POSIX-compliant library, you can use getline() and pass stdin to it for the file stream.

回答3:

A very simple but unsafe implementation to read line for static allocation:

char line[1024];

scanf(\"%[^\\n]\", line);

A safer implementation, without the possibility of buffer overflow, but with the possibility of not reading the whole line, is:

char line[1024];

scanf(\"%1023[^\\n]\", line);

Not the \'difference by one\' between the length specified declaring the variable and the length specified in the format string. It is a historical artefact.

回答4:

You might need to use a character by character (getc()) loop to ensure you have no buffer overflows and don\'t truncate the input.

回答5:

So, if you were looking for command arguments, take a look at Tim\'s answer. If you just want to read a line from console:

#include <stdio.h>

int main()
{
  char string [256];
  printf (\"Insert your full address: \");
  gets (string);
  printf (\"Your address is: %s\\n\",string);
  return 0;
}

Yes, it is not secure, you can do buffer overrun, it does not check for end of file, it does not support encodings and a lot of other stuff. Actually I didn\'t even think whether it did ANY of this stuff. I agree I kinda screwed up :) But...when I see a question like \"How to read a line from the console in C?\", I assume a person needs something simple, like gets() and not 100 lines of code like above. Actually, I think, if you try to write those 100 lines of code in reality, you would do many more mistakes, than you would have done had you chosen gets ;)

回答6:

getline runnable example

Mentioned on this answer but here is an example.

It is POSIX 7, allocates memory for us, and reuses the allocated buffer on a loop nicely.

Pointer newbs, read this: Why is the first argument of getline a pointer to pointer "char**" instead of "char*"?

#define _XOPEN_SOURCE 700

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

int main(void) {
    char *line = NULL;
    size_t len = 0;
    ssize_t read = 0;
    while (read != -1) {
        puts(\"enter a line\");
        read = getline(&line, &len, stdin);
        printf(\"line = %s\", line);
        printf(\"line length = %zu\\n\", read);
        puts(\"\");
    }
    free(line);
    return 0;
}

glibc implementation

No POSIX? Maybe you want to look at the glibc 2.23 implementation.

It resolves to getdelim, which is a simple POSIX superset of getline with an arbitrary line terminator.

It doubles the allocated memory whenever increase is needed, and looks thread-safe.

It requires some macro expansion, but you\'re unlikely to do much better.

回答7:

As suggested, you can use getchar() to read from the console until an end-of-line or an EOF is returned, building your own buffer. Growing buffer dynamically can occur if you are unable to set a reasonable maximum line size.

You can use also use fgets as a safe way to obtain a line as a C null-terminated string:

#include <stdio.h>

char line[1024];  /* Generously large value for most situations */

char *eof;

line[0] = \'\\0\'; /* Ensure empty line if no input delivered */
line[sizeof(line)-1] = ~\'\\0\';  /* Ensure no false-null at end of buffer */

eof = fgets(line, sizeof(line), stdin);

If you have exhausted the console input or if the operation failed for some reason, eof == NULL is returned and the line buffer might be unchanged (which is why setting the first char to \'\\0\' is handy).

fgets will not overfill line[] and it will ensure that there is a null after the last-accepted character on a successful return.

If end-of-line was reached, the character preceding the terminating \'\\0\' will be a \'\\n\'.

If there is no terminating \'\\n\' before the ending \'\\0\' it may be that there is more data or that the next request will report end-of-file. You\'ll have to do another fgets to determine which is which. (In this regard, looping with getchar() is easier.)

In the (updated) example code above, if line[sizeof(line)-1] == \'\\0\' after successful fgets, you know that the buffer was filled completely. If that position is proceeded by a \'\\n\' you know you were lucky. Otherwise, there is either more data or an end-of-file up ahead in stdin. (When the buffer is not filled completely, you could still be at an end-of-file and there also might not be a \'\\n\' at the end of the current line. Since you have to scan the string to find and/or eliminate any \'\\n\' before the end of the string (the first \'\\0\' in the buffer), I am inclined to prefer using getchar() in the first place.)

Do what you need to do to deal with there still being more line than the amount you read as the first chunk. The examples of dynamically-growing a buffer can be made to work with either getchar or fgets. There are some tricky edge cases to watch out for (like remembering to have the next input start storing at the position of the \'\\0\' that ended the previous input before the buffer was extended).

回答8:

Many people, like me, come to this post with the title matching what is searched for, though the description is saying about variable length. For most cases, we know the length beforehand.

If you do know length before hand, try below:

char str1[1001] = { 0 };
fgets(str1, 1001, stdin); // 1000 chars may be read

source: https://www.tutorialspoint.com/c_standard_library/c_function_fgets.htm

回答9:

How to read a line from the console in C?

• Building your own function, is one of the way that would help you to achieve reading a line from console in C.

• I\'m using dynamic memory allocation to allocate just the sufficient amount of memory required to hold all the characters of a line along with the \'\\0\' character.

• And here I\'m using a loop to scan each character of the string one by one using the getchar() function untill the user enters \'\\n\' or EOF character

  //the function to read lines of variable length
  
  char* scan_line(char *line)
  {
      int ch; //as getchar() returns `int`
  
      if( (line = malloc(sizeof(char))) == NULL) //allocating memory
      {
          //checking if allocation was successful or not
          printf(\"unsuccessful allocation\");
          exit(1);
      }
  
      line[0]=\'\\0\';
  
      for(int index = 0; ( (ch = getchar())!=\'\\n\' ) && (ch != EOF) ; index++)
      {
          if( (line = realloc(line, (index + 2)*sizeof(char))) == NULL )
          {
              //checking if reallocation was successful or not
              printf(\"unsuccessful reallocation\");
              exit(1);
          }
  
          line[index] = (char) ch; //type casting `int` to `char`
          line[index + 1] = \'\\0\'; //inserting null character at the end
      }
  
      return line;
  }  
  

• Now you could read a full line this way :

  char *line = NULL;
  line = scan_line(line);
  

---

Here\'s an example program using the scan_line() function :

#include <stdio.h>
#include <stdlib.h> //for dynamic allocation functions

char* scan_line(char *line)
{
    ..........
}

int main(void)
{
    char *a = NULL;

    a = scan_line(a); //function call to scan the line

    printf(\"%s\\n\",a); //printing the scanned line

    free(a); //don\'t forget to free the malloc\'d pointer
}

sample input :

Twinkle Twinkle little star.... in the sky!

sample output :

Twinkle Twinkle little star.... in the sky!

回答10:

I came across the same problem some time ago, this was my solutuion, hope it helps.

/*
 * Initial size of the read buffer
 */
#define DEFAULT_BUFFER 1024

/*
 * Standard boolean type definition
 */
typedef enum{ false = 0, true = 1 }bool;

/*
 * Flags errors in pointer returning functions
 */
bool has_err = false;

/*
 * Reads the next line of text from file and returns it.
 * The line must be free()d afterwards.
 *
 * This function will segfault on binary data.
 */
char *readLine(FILE *file){
    char *buffer   = NULL;
    char *tmp_buf  = NULL;
    bool line_read = false;
    int  iteration = 0;
    int  offset    = 0;

    if(file == NULL){
        fprintf(stderr, \"readLine: NULL file pointer passed!\\n\");
        has_err = true;

        return NULL;
    }

    while(!line_read){
        if((tmp_buf = malloc(DEFAULT_BUFFER)) == NULL){
            fprintf(stderr, \"readLine: Unable to allocate temporary buffer!\\n\");
            if(buffer != NULL)
                free(buffer);
            has_err = true;

            return NULL;
        }

        if(fgets(tmp_buf, DEFAULT_BUFFER, file) == NULL){
            free(tmp_buf);

            break;
        }

        if(tmp_buf[strlen(tmp_buf) - 1] == \'\\n\') /* we have an end of line */
            line_read = true;

        offset = DEFAULT_BUFFER * (iteration + 1);

        if((buffer = realloc(buffer, offset)) == NULL){
            fprintf(stderr, \"readLine: Unable to reallocate buffer!\\n\");
            free(tmp_buf);
            has_err = true;

            return NULL;
        }

        offset = DEFAULT_BUFFER * iteration - iteration;

        if(memcpy(buffer + offset, tmp_buf, DEFAULT_BUFFER) == NULL){
            fprintf(stderr, \"readLine: Cannot copy to buffer\\n\");
            free(tmp_buf);
            if(buffer != NULL)
                free(buffer);
            has_err = true;

            return NULL;
        }

        free(tmp_buf);
        iteration++;
    }

    return buffer;
}

回答11:

On BSD systems and Android you can also use fgetln:

#include <stdio.h>

char *
fgetln(FILE *stream, size_t *len);

Like so:

size_t line_len;
const char *line = fgetln(stdin, &line_len);

The line is not null terminated and contains \\n (or whatever your platform is using) in the end. It becomes invalid after the next I/O operation on stream.

回答12:

Something like this:

unsigned int getConsoleInput(char **pStrBfr) //pass in pointer to char pointer, returns size of buffer
{
    char * strbfr;
    int c;
    unsigned int i;
    i = 0;
    strbfr = (char*)malloc(sizeof(char));
    if(strbfr==NULL) goto error;
    while( (c = getchar()) != \'\\n\' && c != EOF )
    {
        strbfr[i] = (char)c;
        i++;
        strbfr = (void*)realloc((void*)strbfr,sizeof(char)*(i+1));
        //on realloc error, NULL is returned but original buffer is unchanged
        //NOTE: the buffer WILL NOT be NULL terminated since last
        //chracter came from console
        if(strbfr==NULL) goto error;
    }
    strbfr[i] = \'\\0\';
    *pStrBfr = strbfr; //successfully returns pointer to NULL terminated buffer
    return i + 1; 
    error:
    *pStrBfr = strbfr;
    return i + 1;
}

回答13:

This function should do what you want:

char* readLine( FILE* file )
 {
 char buffer[1024];
 char* result = 0;
 int length = 0;

 while( !feof(file) )
  {
  fgets( buffer, sizeof(buffer), file );
  int len = strlen(buffer);
  buffer[len] = 0;

  length += len;
  char* tmp = (char*)malloc(length+1);
  tmp[0] = 0;

  if( result )
   {
   strcpy( tmp, result );
   free( result );
   result = tmp;
   }

  strcat( result, buffer );

  if( strstr( buffer, \"\\n\" ) break;
  }

 return result;
 }

char* line = readLine( stdin );
/* Use it */
free( line );

I hope this helps.