c - मैं अज्ञात लंबाई की इनपुट स्ट्रिंग कैसे पढ़ सकता हूं?




scanf (6)

अगर मैं एक सुरक्षित दृष्टिकोण का सुझाव दे सकता हूं:

स्ट्रिंग को पकड़ने के लिए पर्याप्त बफर घोषित करें:

char user_input[255];

उपयोगकर्ता इनपुट को सुरक्षित तरीके से प्राप्त करें:

fgets(user_input, 255, stdin);

इनपुट प्राप्त करने का एक सुरक्षित तरीका, पहला तर्क एक बफर के लिए सूचक होता है जहां इनपुट संग्रहीत किया जाएगा, दूसरा अधिकतम इनपुट फ़ंक्शन को पढ़ना चाहिए और तीसरा मानक इनपुट के लिए सूचक है - यानी उपयोगकर्ता इनपुट कहां आता है से।

विशेष रूप से सुरक्षा दूसरे तर्क से आती है कि कितना पढ़ा जाएगा जो बफर ओवररन्स को रोकता है। इसके अलावा, fgets संसाधित स्ट्रिंग को शून्य समाप्त करने का ख्याल रखता है।

उस समारोह पर अधिक जानकारी here

संपादित करें: यदि आपको कोई स्वरूपण करने की आवश्यकता है (उदाहरण के लिए एक स्ट्रिंग को किसी संख्या में परिवर्तित करें), तो आपके पास इनपुट होने के बाद atoi उपयोग कर सकते हैं।

अगर मुझे नहीं पता कि शब्द कितना समय है, तो मैं char m[6]; नहीं लिख सकता 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 के साथ एक स्ट्रिंग इनपुट करें
नमस्ते
यह स्ट्रिंग है: हैलो


आज के कंप्यूटरों के साथ, आप कंप्यूटर के रैम उपयोग में शायद ही कभी दांत बनाते समय बहुत बड़े तारों (सैकड़ों हजारों पात्र) आवंटित करने से दूर हो सकते हैं। तो मैं बहुत ज्यादा चिंता नहीं करता।

हालांकि, पुराने दिनों में, जब स्मृति प्रीमियम पर थी, आम अभ्यास भाग में तारों को पढ़ना था। 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 के वापसी मूल्य को सत्यापित करके ठीक है।

यह भी ध्यान रखें कि अंत में यदि रीडिनपूट दिनचर्या, कोई बाइट बर्बाद नहीं होता है; स्ट्रिंग में सटीक मेमोरी आकार होता है जिसकी आवश्यकता होती है।


मुझे पता है कि मैं 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

मेरे पास मानक इनपुट और आउटपुट के साथ समाधान भी है

#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);
}

सुरक्षित और तेज (दोगुनी क्षमता) संस्करण:

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);
}

fgets() साथ आवंटित स्थान में सीधे पढ़ें।

एक सफल पढ़ने, अंत-फ़ाइल, इनपुट त्रुटि और स्मृति के बाहर की विशेष देखभाल करने की आवश्यकता है। ईओएफ पर उचित स्मृति प्रबंधन की आवश्यकता है।

यह विधि एक पंक्ति के '\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;
}




scanf