如何读取未知长度的输入字符串？

Question

如果我不知道这个词有多长，我就不能写char m[6];，
这个词的长度可能是十或二十个长。 如何使用scanf从键盘获取输入？

#include <stdio.h>
int main(void)
{
    char  m[6];
    printf("please input a string with length=5\n");
    scanf("%s",&m);
    printf("this is the string: %s\n", m);
    return 0;
}

请输入lenght = 5的字符串 你好
这是字符串：hello

Answer 1

在动态保护区域时输入

E.G。

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

char *inputString(FILE* fp, size_t size){
//The size is extended by the input with the value of the provisional
    char *str;
    int ch;
    size_t len = 0;
    str = realloc(NULL, sizeof(char)*size);//size is start size
    if(!str)return str;
    while(EOF!=(ch=fgetc(fp)) && ch != '\n'){
        str[len++]=ch;
        if(len==size){
            str = realloc(str, sizeof(char)*(size+=16));
            if(!str)return str;
        }
    }
    str[len++]='\0';

    return realloc(str, sizeof(char)*len);
}

int main(void){
    char *m;

    printf("input string : ");
    m = inputString(stdin, 10);
    printf("%s\n", m);

    free(m);
    return 0;
}

Answer 2

使用今天的计算机，您可以放弃分配非常大的字符串（数十万个字符），同时几乎不会削弱计算机的RAM使用率。所以我不会太担心。

然而，在过去，当内存非常宝贵时，通常的做法是以块的形式读取字符串。 fgets从输入中读取最大数量的字符，但保留输入缓冲区的其余部分，因此您可以随意读取其余部分。

在这个例子中，我读了200个字符的块，但你可以使用你想要的任何块大小。

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

char* readinput()
{
#define CHUNK 200
   char* input = NULL;
   char tempbuf[CHUNK];
   size_t inputlen = 0, templen = 0;
   do {
       fgets(tempbuf, CHUNK, stdin);
       templen = strlen(tempbuf);
       inputlen += templen;
       input = realloc(input, inputlen+1);
       strcat(input, tempbuf);
    } while (templen==CHUNK-1 && tempbuf[CHUNK-2]!='\n');
    return input;
}

int main()
{
    char* result = readinput();
    printf("And the result is [%s]\n", result);
    free(result);
    return 0;
}

请注意，这是一个简单的示例，没有错误检查;在现实生活中，你必须通过验证fgets的返回值来确保输入正常。

另请注意，最后如果是readinput例程，则不会浪费任何字节;字符串具有它需要的确切内存大小。

Answer 3

我只看过一种简单的方式来读取任意长的字符串，但我从未使用它。我认为它是这样的：

char *m = NULL;
printf("please input a string\n");
scanf("%ms",&m);
if (m == NULL)
    fprintf(stderr, "That string was too long!\n");
else
{
    printf("this is the string %s\n",m);
    /* ... any other use of m */
    free(m);
}

m和%之间的s告诉scanf()测量字符串并为其分配内存并将字符串复制到该字符串中，并存储该字符串的地址在相应的参数中分配内存。完成后，您必须free()。

但scanf()的每个实现都不支持此功能。

正如其他人所指出的，最简单的解决方案是设置输入长度的限制。如果您仍想使用scanf()，那么您可以这样做：

char m[100];
scanf("%99s",&m);

请注意，m[]的大小必须至少比%和s之间的数字大一个字节。

如果输入的字符串长于99，则其余字符将等待另一个调用或传递给scanf()的其余格式字符串读取。

通常不建议scanf()来处理用户输入。它最适用于由其他应用程序创建的基本结构化文本文件。即使这样，您也必须意识到输入可能没有按照您的预期进行格式化，因为有人可能会干扰它以试图破坏您的程序。

Answer 4

如果我建议采用更安全的方法：

声明一个足以容纳字符串的缓冲区：

char user_input[255];

以安全方式获取用户输入：

fgets(user_input, 255, stdin);

获取输入的安全方法，第一个参数是指向将存储输入的缓冲区的指针，第二个参数是函数应该读取的最大输入，第三个是指向标准输入的指针 - 即用户输入来自。

安全性尤其来自第二个参数，它限制了将要读取多少以防止缓冲区溢出。此外，fgets负责处理null终止已处理的字符串。

有关该功能的更多信息here。

编辑：如果您需要进行任何格式化（例如将字符串转换为数字），您可以在输入后使用atoi。

Answer 5

更安全，更快（加倍容量）版本：

char *readline(char *prompt) {
  size_t size = 80;
  char *str = malloc(sizeof(char) * size);
  int c;
  size_t len = 0;
  printf("%s", prompt);
  while (EOF != (c = getchar()) && c != '\r' && c != '\n') {
    str[len++] = c;
    if(len == size) str = realloc(str, sizeof(char) * (size *= 2));
  }
  str[len++]='\0';
  return realloc(str, sizeof(char) * len);
}

Answer 6

C标准中有一个新功能，用于获取行而不指定其大小。 getline函数自动分配具有所需大小的字符串，因此无需猜测字符串的大小。以下代码演示用法：

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


int main(void)
{
    char *line = NULL;
    size_t len = 0;
    ssize_t read;

    while ((read = getline(&line, &len, stdin)) != -1) {
        printf("Retrieved line of length %zu :\n", read);
        printf("%s", line);
    }

    if (ferror(stdin)) {
        /* handle error */
    }

    free(line);
    return 0;
}

Answer 7

获取存储所需字符串的字符指针。如果您对字符串的可能大小有所了解，请使用函数

char *fgets (char *str, int size, FILE* file);`

否则你也可以使用动态提供所需内存的 malloc（） 函数在运行时分配内存。

Answer 8

使用fgets()直接读入已分配的空间。

需要特别注意区分成功的读取，文件结束，输入错误和内存不足。 EOF需要适当的内存管理。

此方法会保留一行'\n'。

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

#define FGETS_ALLOC_N 128

char* fgets_alloc(FILE *istream) {
  char* buf = NULL;
  size_t size = 0;
  size_t used = 0;
  do {
    size += FGETS_ALLOC_N;
    char *buf_new = realloc(buf, size);
    if (buf_new == NULL) {
      // Out-of-memory
      free(buf);
      return NULL;
    }
    buf = buf_new;
    if (fgets(&buf[used], (int) (size - used), istream) == NULL) {
      // feof or ferror
      if (used == 0 || ferror(istream)) {
        free(buf);
        buf = NULL;
      }
      return buf;
    }
    size_t length = strlen(&buf[used]);
    if (length + 1 != size - used) break;
    used += length;
  } while (buf[used - 1] != '\n');
  return buf;
}

样本用法

int main(void) {
  FILE *istream = stdin;
  char *s;
  while ((s = fgets_alloc(istream)) != NULL) {
    printf("'%s'", s);
    free(s);
    fflush(stdout);
  }
  if (ferror(istream)) {
    puts("Input error");
  } else if (feof(istream)) {
    puts("End of file");
  } else {
    puts("Out of memory");
  }
  return 0;
}

Answer 9

我知道我已经4年后来到了，但为时已晚，但我认为我有另一种方式可以使用。我曾经使用getchar()这样的函数： -

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

//I had putten the main Function Bellow this function.
//d for asking string,f is pointer to the string pointer
void GetStr(char *d,char **f)
{
    printf("%s",d);

    for(int i =0;1;i++)
    {    
        if(i)//I.e if i!=0
            *f = (char*)realloc((*f),i+1);
        else
            *f = (char*)malloc(i+1);
        (*f)[i]=getchar();
        if((*f)[i] == '\n')
        {
            (*f)[i]= '\0';
            break;
        }
    }   
}

int main()
{
    char *s =NULL;
    GetStr("Enter the String:- ",&s);
    printf("Your String:- %s \nAnd It's length:- %lu\n",s,(strlen(s)));
    free(s);
}

这是该程序的示例运行： -

Enter the String:- I am Using Linux Mint XFCE 18.2 , eclispe CDT and GCC7.2 compiler!!
Your String:- I am Using Linux Mint XFCE 18.2 , eclispe CDT and GCC7.2 compiler!! 
And It's length:- 67

Answer 10

我还有一个标准输入和输出的解决方案

#include<stdio.h>
#include<malloc.h>
int main()
{
    char *str,ch;
    int size=10,len=0;
    str=realloc(NULL,sizeof(char)*size);
    if(!str)return str;
    while(EOF!=scanf("%c",&ch) && ch!="\n")
    {
        str[len++]=ch;
        if(len==size)
        {
            str = realloc(str,sizeof(char)*(size+=10));
            if(!str)return str;
        }
    }
    str[len++]='\0';
    printf("%s\n",str);
    free(str);
}