Question

所以我试图编写一个允许用户输入无限量字符的函数。例如：

char string[100]

将输入限制为100个字符。

我到目前为止的代码是：

#include<stdio.h>

char* uinput(){
    char *string, *current;
    int counter = 0;
    string = (char *) malloc(10 * sizeof(char));
    do{
        realloc(string, counter * sizeof(char));
        current = string + counter;
        *current = getchar();
        counter++;
    }while(*current != '\n');
    return string;
}

int main(){
    char *s;
    s = uinput();
    printf("\nYou entered: %s", *s);
    return 0;
}

我是指针的新手，所以我不确定为什么这不起作用（程序崩溃）。我试图做的是继续读取一个字符并继续重新定位字符串指针，以便字节数不断增加，直到用户按下回车键（＆＃39; \ n＆＃39;）。

由于〜Raf的

Answer 1

好的我认为这是问题

你正在重新分配

realloc(string, counter * sizeof(char));

第一次迭代中字符串的大小是多少？它将是0。

现在，您正在写入一个指定了0个字节的指针，因此会发生段错误。

将其更改为while loop有助于解决问题。您还可以更改计数器的初始值以进行修复

Answer 2

这种方法很明智，但有些细节是错误的。如果您在启用警告的情况下进行编译，则会注意到您遗漏了<stdlib.h>;您也将第一个字符提供给printf，而不是指向缓冲区的指针。

然后有一个明显的错误，你的大小重置为0，而你是casting the return value of malloc，使用char来存储getchar()的结果，这也是错误的，因为你不能检查EOF。你没有保存realloc ed指针;而且你没有正确地终止字符串。在次要细节上，您需要将每个realloc中的缓冲区大小加倍，因为realloc需要可能复制整行，因此随着行长度的增加，它会变得越来越慢

因此我们得到：

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

char* uinput() {
    char *string;
    // number of characters in the buffer
    size_t counter = 0;

    // size of allocated buffer
    size_t allocated = 16;

    int c;
    string = malloc(allocated);  // sizeof(char) is 1
    do {
        c = getchar();
        if (c == EOF) {
            break;
        }
        // if our buffer is too small, double the allocation 
        if (counter + 2 <= allocated) {
            size_t new_size = allocated * 2;
            char *new_buffer = realloc(string, new_size);
            if (! new_buffer) {
                // out of memory? try smaller increment
                new_size = allocated + 16;
                new_buffer = realloc(string, new_size);
                if (! new_buffer) {
                    // really out of memory: free old block
                    free(string);
                    return NULL;
                }
            }
            allocated = new_size;
            string = new_buffer;
        }
        // store the character
        string[counter++] = c;
    } while (c != '\n');

    // terminate the buffer properly
    string[counter] = 0;
    return string;
}

int main() {
    char *s = uinput();
    if (!s) {
        // possibly out of memory in uinput
        perror("Error reading input");
        exit(EXIT_FAILURE);
    }
    printf("\nYou entered: %s", s);
    free(s);
    return EXIT_SUCCESS;
}

Answer 3

您可以尝试以下内容：

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

struct person{
    char *name;
}pers;

void addMem(void);

int main(void){
    addMem();

    printf("\nYour name is:>  %s\n",pers.name);
    free(pers.name);
    pers.name = NULL;
    return 0;
}

void addMem(void){
    unsigned int length = 6;
    size_t newLength = 0;
    unsigned int newSize = 0;
    unsigned int i =0;
    char *name;
    int c;

    name = malloc(length);
    if(name == NULL){
        exit(1);
    }
    newSize = length;

    printf("Enter your name:>  ");

    while ((c = getchar()) != '\n' && c!=EOF){
        name[i++]=(char)c;

        if(i == newSize){
            newSize = i+length;
            name = realloc(name, newSize);
        }
    }

    name[i] = '\0';

    newLength = strlen(name)+1;
    pers.name = malloc(newLength);

    memcpy(pers.name, name, newLength);

    free(name);
    name = NULL;
}

Answer 4

另一种方法是使用fgets()，它从输入流中获取一个大小缓冲区的字符串;如果它有完整的输入，则字符串以\n结尾;如果没有那么它就不会。因此，您可以循环调用fgets，直到最后有一个EOL字符，然后根据您的程序对输入执行的操作，您可以决定是继续重新分配还是一次处理输入。

Answer 5

使用getchar，malloc和realloc来读取无限制的输入字符串

声明字符串类型，也可以使用char *

// String type
typedef char *String;

我编写了此函数，用于在字符串末尾加入char

/**
 * Join the Char into end of String
 *
 * @param string - String
 * @param c - joined char
 */
void String_joinChar(String *string, const char c)
{
  const size_t length = strlen(*string);
  (*string) = (String)realloc((*string), sizeof(char) * (length + 2));
  (*string)[length] = c;
  (*string)[length + 1] = '\0';
}

此函数用于输入字符串，该函数使用getchar从键盘读取字符，并将其连接到当前字符串的末尾。

/**
 * Input String
 *
 * @return Inputed String
 */
String String_input()
{
  String string = (String)malloc(sizeof(char));
  strcpy(string, "");

  char cursor;
  fflush(stdin);
  while ((cursor = getchar()) != '\n' && cursor != EOF)
  {
    String_joinChar(&string, cursor);
  }

  return string;
}

由于使用char *，malloc和realloc，我们必须释放它

/**
 * Destroy String
 *
 * @param string - Destroyed String
 */
void String_destroy(String string)
{
  free(string);
}

现在我们只用它！

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

int main()
{
  String string = String_input();
  printf("\n%s\n", string);
  String_destroy(string);
  return 0;
}

希望对您有用！

在C中获得无限输入？

5 个答案: