Einlesen von char durch char mit realloc in C

Question

Ich möchte Eingabe char von Char lesen und speichern Sie es als ein Wort in Char * Array. Ich weiß nicht, wie lange die Eingabe sein wird, also möchte ich das Memory dynamisch zuweisen. Das Programm endet, wenn das Zeichen Leerzeichen ist. Wie kann ich dies mit Realloc tun? Es ist mein Code:

#include <stdio.h> 
int main(void) { 
    char *word=malloc(1*sizeof(char)); 
    char c; 
    int numOfChars=0; 
    c=getchar(); 
    word[0]=c; 
    numOfChars++; 
    while((c=getchar())!=' '){ 
     numOfChars++; 
     realloc(word,numOfChars); 
     word[numofChars-1]=c; 
    } 
    printf("%s", word); 

    return 0; 
} 

Beispiel Eingabe: Word Beispiel Ausgabe: Word

Answer 1

Das Programm kann auf folgende Weise aussehen. Beachten Sie, dass die Eingabe gepuffert und gefüllt wird, bis ein neues Zeilenzeichen eingegeben wird, das ebenfalls ein Leerzeichen ist. Und das Ergebniswort muss null-terminiert sein, wenn Sie den Formatbezeichner %s verwenden wollen, um es auszugeben.

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

int main(void) 
{ 
    int c; 
    size_t n; 
    char *word; 
    char *tmp; 

    n = 0; 
    word = malloc(n + 1); 
    word[n++] = '\0'; 

    printf("Enter a word: "); 

    while ((c = getchar()) != EOF && !isspace(c) && (tmp = realloc(word, n + 1)) != NULL) 
    { 
     word = tmp; 
     word[n-1] = c; 
     word[n++] = '\0'; 
    } 

    printf("You've entered \"%s\"\n", word); 

    free(word); 
}   

Das Programm Ausgabe wie

Enter a word: Hello 
You've entered "Hello" 

Answer 2

Dies wird

#include <stdio.h> 
#include <stdlib.h> 
int main(void) { 
    char *ptr; 
    char *word=malloc(1*sizeof *word); 
    char c; 
    int numofChars=0; 
    printf("Enter string terminated by a space :"); 
    c=getchar(); 
    word[0]=c; 
    numofChars++; 

    while((c=getchar())!=' '){ 
    numofChars++; 
    ptr=realloc(word,numofChars*sizeof *ptr); 
    if(ptr!=NULL) 
    { 
     word=ptr; 
     word[numofChars-1]=c; 
    } 
    } 
    /* You need to append a null character to make it a valid string */ 
    numofChars++; 
    ptr=realloc(word,numofChars*sizeof *ptr); 
    if(ptr!=NULL) 
    { 
    word=ptr; 
    word[numofChars-1]='\0'; 
    } 

    printf("Word : %s\n", word); 

    free(word); // Freeing word/ 

    return 0; 
} 

Nun tun, können Sie eine Funktion schreiben

numofChars++; 
     ptr=realloc(word,numofChars*sizeof *ptr); 
     if(ptr!=NULL) 
     { 
     word=ptr; 
     word[numofChars-1]='\0'; 
     } 

ersetzen

Hinweis: Es wird nicht empfohlen, dass Sie

tun

word=realloc(word,numOfChars*sizeof(char)); 

weil im Falle realloc ausfällt, Sie Speicherverlust haben. Also habe ich ptr hier verwendet.

Answer 3

Um zu erklären, was ich im Sinn hatte, habe ich schnell dieses kleine Programm einrichten zu erklären, wie ein exponentielles Wachstum zu nutzen:

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

#define INITIAL_CAPACITY 100 
#define GROW_FACTOR 1.5 

struct string_buffer { 
    size_t capacity; 
    size_t length; 
    char *buffer; 
}; 

typedef struct string_buffer string_buffer_t; 

string_buffer_t *sb_init(void); 
static void sb_grow(string_buffer_t *sb); 
void sb_shrink(string_buffer_t *sb); 
char *sb_release(string_buffer_t *sb); 

void sb_append_char(string_buffer_t *sb, char c); 
char *sb_peek_string(string_buffer_t *sb); 

int main(void) 
{ 
    string_buffer_t *sb=sb_init(); 
    int c; 

    while ((c=getchar())!=' ' && c!='\n' && c!=EOF) 
    sb_append_char(sb, c); 

    char *string=sb_release(sb); 
    printf("string : \"%s\"\nlength : %zu\n", string, strlen(string)); 
    free(string); 
    return 0; 
} 

string_buffer_t *sb_init(void) 
{ 
    string_buffer_t *new=malloc(sizeof *new); 
    if (new==NULL) exit(EXIT_FAILURE); 

    new->capacity=INITIAL_CAPACITY; 
    new->length=1; 
    new->buffer=malloc(INITIAL_CAPACITY); 
    if (new->buffer==NULL) exit(EXIT_FAILURE); 
    new->buffer[0]=0; 

    return new; 
} 

static void sb_grow(string_buffer_t *sb) 
{ 
    char *new=realloc(sb->buffer, (size_t) (GROW_FACTOR*sb->capacity)); 
    if (new==NULL) exit(EXIT_FAILURE); 
    sb->capacity=(size_t) (GROW_FACTOR*sb->capacity); 
    sb->buffer=new; 
} 

void sb_shrink(string_buffer_t *sb) 
{ 
    char *new=realloc(sb->buffer, sb->length); 
    if (new==NULL) exit(EXIT_FAILURE); 
    sb->buffer=new; 
} 

char *sb_release(string_buffer_t *sb) 
{ 
    sb_shrink(sb); 
    char *string=sb->buffer; 
    free(sb); 
    return string; 
} 

void sb_append_char(string_buffer_t *sb, char c) 
{ 
    if (sb->capacity==sb->length) sb_grow(sb); 
    sb->buffer[sb->length-1]=c; 
    sb->buffer[sb->length]=0; 
    sb->length=sb->length+1; 
}