केवल एक वर्ण को पढ़ने के लिए getchar () के साथ Enter दबाने से कैसे बचें?

Question 1

अगले कोड में:

#include <stdio.h>

int main(void) {   
  int c;   
  while ((c=getchar())!= EOF)      
    putchar(c); 
  return 0;
}

मुझे उन Enterसभी पत्रों को प्रिंट करने के लिए प्रेस करना होगा जिन्हें मैंने दर्ज किया था getchar, लेकिन मैं ऐसा नहीं करना चाहता, जो मैं करना चाहता हूं वह पत्र को प्रेस करना है और तुरंत उस पत्र को देखना है जिसे मैंने बिना दबाए दोहराया Enter। उदाहरण के लिए, यदि मैं 'a' अक्षर को दबाता हूं, तो मैं उसके बगल में एक 'a' देखना चाहता हूं, और इसी तरह:

aabbccddeeff.....

लेकिन जब मैं 'a' प्रेस करता हूं तो कुछ नहीं होता है, मैं अन्य पत्र लिख सकता हूं और कॉपी तभी दिखाई देती है जब मैं प्रेस करता हूं Enter:

abcdef
abcdef

मैं यह कैसे कर सकता हूँ?

मैं cc -o example example.cसंकलन के लिए Ubuntu के तहत कमांड का उपयोग कर रहा हूं ।

Question 2

एक लिनक्स सिस्टम पर, आप sttyकमांड का उपयोग करके टर्मिनल व्यवहार को संशोधित कर सकते हैं । डिफ़ॉल्ट रूप से, टर्मिनल सभी सूचनाओं को तब तक Enterदबाए रखेगा, जब तक कि उसे C प्रोग्राम में भेजने से पहले।

प्रोग्राम के भीतर से ही व्यवहार को बदलने के लिए एक त्वरित, गंदा और विशेष रूप से पोर्टेबल उदाहरण:

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

int main(void){
  int c;
  /* use system call to make terminal send all keystrokes directly to stdin */
  system ("/bin/stty raw");
  while((c=getchar())!= '.') {
    /* type a period to break out of the loop, since CTRL-D won't work raw */
    putchar(c);
  }
  /* use system call to set terminal behaviour to more normal behaviour */
  system ("/bin/stty cooked");
  return 0;
}

कृपया ध्यान दें कि यह वास्तव में इष्टतम नहीं है, क्योंकि यह मान लेता है कि stty cookedयह वही व्यवहार है जो आप चाहते हैं कि कार्यक्रम से बाहर निकलते समय, मूल टर्मिनल सेटिंग्स क्या थीं, यह जाँचने के बजाय। इसके अलावा, चूंकि सभी विशेष प्रसंस्करण कच्चे मोड में छोड़ दिए जाते हैं, इसलिए कई महत्वपूर्ण अनुक्रम (जैसे कि CTRL-C या CTRL-D ) वास्तव में काम नहीं करेंगे क्योंकि आप उन्हें कार्यक्रम में स्पष्ट रूप से संसाधित किए बिना उम्मीद करते हैं।

आप man sttyटर्मिनल व्यवहार पर अधिक नियंत्रण के लिए, वास्तव में आप क्या हासिल करना चाहते हैं पर निर्भर करता है।

Question 3

यह आपके OS पर निर्भर करता है, यदि आप UNIX में हैं जैसे वातावरण ICANON ध्वज डिफ़ॉल्ट रूप से सक्षम है, इसलिए इनपुट अगले '\n'या जब तक बफ़र्ड है EOF। विहित मोड को अक्षम करने से आपको वर्ण तुरंत मिलेंगे। यह अन्य प्लेटफार्मों पर भी संभव है, लेकिन सीधे आगे क्रॉस-प्लेटफॉर्म समाधान नहीं है।

संपादित करें: मैं आपको निर्दिष्ट करता हूं कि आप उबंटू का उपयोग करते हैं। मैंने कल ही कुछ ऐसा ही पोस्ट किया था, लेकिन ध्यान रहे कि यह आपके टर्मिनल के कई डिफ़ॉल्ट व्यवहारों को निष्क्रिय कर देगा।

#include<stdio.h>
#include <termios.h>            //termios, TCSANOW, ECHO, ICANON
#include <unistd.h>     //STDIN_FILENO


int main(void){   
    int c;   
    static struct termios oldt, newt;

    /*tcgetattr gets the parameters of the current terminal
    STDIN_FILENO will tell tcgetattr that it should write the settings
    of stdin to oldt*/
    tcgetattr( STDIN_FILENO, &oldt);
    /*now the settings will be copied*/
    newt = oldt;

    /*ICANON normally takes care that one line at a time will be processed
    that means it will return if it sees a "\n" or an EOF or an EOL*/
    newt.c_lflag &= ~(ICANON);          

    /*Those new settings will be set to STDIN
    TCSANOW tells tcsetattr to change attributes immediately. */
    tcsetattr( STDIN_FILENO, TCSANOW, &newt);

    /*This is your part:
    I choose 'e' to end input. Notice that EOF is also turned off
    in the non-canonical mode*/
    while((c=getchar())!= 'e')      
        putchar(c);                 

    /*restore the old settings*/
    tcsetattr( STDIN_FILENO, TCSANOW, &oldt);


    return 0;
}

आप देखेंगे, कि हर चरित्र दो बार दिखाई देता है। इसका कारण यह है कि इनपुट तुरंत टर्मिनल पर वापस गूँज जाता है और फिर आपका प्रोग्राम इसे putchar()भी वापस रख देता है। यदि आप आउटपुट से इनपुट को अलग करना चाहते हैं, तो आपको ईसीएचओ का झंडा भी बदलना होगा। आप इसे केवल उपयुक्त पंक्ति को बदलकर ऐसा कर सकते हैं:

newt.c_lflag &= ~(ICANON | ECHO);

Question 4

getchar () एक मानक फ़ंक्शन है जो कई प्लेटफार्मों पर आपको इनपुट प्राप्त करने के लिए ENTER दबाने की आवश्यकता होती है, क्योंकि प्लेटफ़ॉर्म बफर इनपुट तब तक होता है जब तक कि कुंजी दबाया नहीं जाता है। कई कंपाइलर / प्लेटफ़ॉर्म गैर-मानक getch () का समर्थन करते हैं जो ENTER की परवाह नहीं करता है (प्लेटफ़ॉर्म बफरिंग को बायपास करता है, ENTER को सिर्फ दूसरी कुंजी की तरह मानता है)।

Question 5

I / O एक ऑपरेटिंग सिस्टम फ़ंक्शन है। कई मामलों में, ऑपरेटिंग सिस्टम किसी प्रोग्राम में टाइप किए गए कैरेक्टर को तब तक पास नहीं करेगा जब तक कि एंटर दबाया न जाए। यह उपयोगकर्ता को प्रोग्राम को भेजने से पहले इनपुट (जैसे बैकस्पेसिंग और रिटाइपिंग) को संशोधित करने की अनुमति देता है। अधिकांश उद्देश्यों के लिए, यह अच्छी तरह से काम करता है, उपयोगकर्ता के लिए एक सुसंगत इंटरफ़ेस प्रस्तुत करता है, और इस से निपटने के लिए कार्यक्रम से राहत देता है। कुछ मामलों में, कुंजी से वर्ण प्राप्त करने के लिए एक कार्यक्रम के लिए यह वांछनीय है क्योंकि वे दबाए जाते हैं।

C लाइब्रेरी स्वयं फ़ाइलों से संबंधित है, और इनपुट फ़ाइल में डेटा कैसे प्राप्त होता है, इसके बारे में खुद को चिंता नहीं है। इसलिए, कुंजी दबाने के लिए भाषा में कोई रास्ता नहीं है क्योंकि वे दबाए जाते हैं; इसके बजाय, यह प्लेटफ़ॉर्म-विशिष्ट है। चूंकि आपने ओएस या कंपाइलर निर्दिष्ट नहीं किया है, इसलिए हम इसे आपके लिए नहीं देख सकते हैं।

इसके अलावा, मानक उत्पादन आम तौर पर दक्षता के लिए बफ़र किया जाता है। यह सी पुस्तकालयों द्वारा किया जाता है, और इसलिए एक सी समाधान है, जो fflush(stdout);प्रत्येक वर्ण के लिखे जाने के बाद है। उसके बाद, चाहे वर्ण तुरंत ऑपरेटिंग सिस्टम पर प्रदर्शित होते हैं, लेकिन मैं जिन सभी OS से परिचित हूं, वे तुरंत आउटपुट प्रदर्शित करेंगे, इसलिए यह आमतौर पर कोई समस्या नहीं है।

Question 6

मुझे लुकास जवाब पसंद है, लेकिन मैं इसे थोड़ा विस्तार देना चाहूंगा। वहाँ एक अंतर्निहित है समारोह में termios.hनामित किया गया cfmakeraw()है जो आदमी के रूप में वर्णन करता है:

cfmakeraw() sets the terminal to something like the "raw" mode of the
old Version 7 terminal driver: input is available character by
character, echoing is disabled, and all special processing of
terminal input and output characters is disabled. [...]

यह मूल रूप से लुकास द्वारा सुझाए गए और अधिक के समान है, आप सटीक झंडे इसे मैन पेजों में देख सकते हैं: टर्मिनस (3) ।

उदाहरण

int c = 0;
static struct termios oldTermios, newTermios;

tcgetattr(STDIN_FILENO, &oldTermios);
newTermios = oldTermios;

cfmakeraw(&newTermios);

tcsetattr(STDIN_FILENO, TCSANOW, &newTermios);
c = getchar();
tcsetattr(STDIN_FILENO, TCSANOW, &oldTermios);

switch (c) {
    case 113: // q
        printf("\n\n");
        exit(0);
        break;
    case 105: // i
        printf("insert\n");
        break;
    default:
        break;

Question 7

चूँकि आप एक यूनिक्स व्युत्पन्न (उबंटू) पर काम कर रहे हैं, यहाँ एक तरीका यह है - अनुशंसित नहीं है, लेकिन यह तब तक काम करेगा (जब तक आप सही तरीके से कमांड टाइप कर सकते हैं):

echo "stty -g $(stty -g)" > restore-sanity
stty cbreak
./your_program

जब आप इससे ऊब चुके हों तो प्रोग्राम को रोकने के लिए इंटरप्ट का उपयोग करें।

sh restore-sanity

'इको' लाइन वर्तमान टर्मिनल सेटिंग्स को शेल स्क्रिप्ट के रूप में सहेजती है जो उन्हें पुनर्स्थापित करेगी।
'स्टिकी' लाइन अधिकांश विशेष प्रसंस्करण को बंद कर देती है (इसलिए Control-Dइसका कोई प्रभाव नहीं है, उदाहरण के लिए) और जैसे ही वे उपलब्ध होते हैं, कार्यक्रम में वर्ण भेजते हैं। इसका मतलब है कि आप अपने टाइपिंग को और अधिक संपादित नहीं कर सकते।
'Sh' लाइन आपकी मूल टर्मिनल सेटिंग्स को बहाल करती है।

यदि 'स्टेंट साने' आपकी सेटिंग्स को आपके उद्देश्यों के लिए पर्याप्त रूप से सही ढंग से पुनर्स्थापित करता है, तो आप इसका अर्थ लगा सकते हैं। '-G ’का प्रारूप (स्ट्टी’ के संस्करणों के पार पोर्टेबल नहीं है (इसलिए सोलारिस 10 पर जो उत्पन्न होता है वह लिनक्स, या इसके विपरीत काम नहीं करेगा), लेकिन अवधारणा हर जगह काम करती है। 'स्टेंट साने' विकल्प सार्वभौमिक रूप से उपलब्ध नहीं है, AFAIK (लेकिन लिनक्स पर है)।

Question 8

आप 'ncurses' लाइब्रेरी शामिल कर सकते हैं, और getch()इसके बजाय उपयोग कर सकते हैं getchar()।

Question 9

हाँ, आप इसे विंडोज़ पर भी कर सकते हैं, यहाँ नीचे दिया गया कोड है, जो conio.h लाइब्रेरी का उपयोग कर रहा है

#include <iostream> //basic input/output
#include <conio.h>  //provides non standard getch() function
using namespace std;

int main()
{  
  cout << "Password: ";  
  string pass;
  while(true)
  {
             char ch = getch();    

             if(ch=='\r'){  //when a carriage return is found [enter] key
             cout << endl << "Your password is: " << pass <<endl; 
             break;
             }

             pass+=ch;             
             cout << "*";
             }
  getch();
  return 0;
}

Question 10

मुझे यह समस्या / प्रश्न एक असाइनमेंट में आया है जो मैं वर्तमान में काम कर रहा हूं। यह इस बात पर भी निर्भर करता है कि आप किस इनपुट से हड़प रहे हैं। मै इस्तेमाल कर रहा हूँ

/dev/tty

प्रोग्राम चलने के दौरान इनपुट प्राप्त करने के लिए, ताकि कमांड से जुड़ी फाइलस्ट्रीम की आवश्यकता हो।

उबंटू मशीन पर मुझे परीक्षण / लक्ष्य करना है, इसके लिए बस आवश्यकता से अधिक की आवश्यकता है

system( "stty -raw" );

या

system( "stty -icanon" );

मुझे --फाइल ध्वज, साथ ही कमांड के लिए रास्ता जोड़ना था, जैसे:

system( "/bin/stty --file=/dev/tty -icanon" );

सब कुछ अब कापसी है।

Question 11

इस कोड ने मेरे लिए काम किया। ध्यान दें: यह मानक पुस्तकालय का हिस्सा नहीं है, भले ही अधिकांश कंपाइलर (मैं जीसीसी का उपयोग करता हूं) इसका समर्थन करता है।

#include <stdio.h>
#include <conio.h>
int main(int argc, char const *argv[]) {
    char a = getch();
    printf("You typed a char with an ASCII value of %d, printable as '%c'\n", a, a);
    return 0;
}

यह कोड पहली कुंजी प्रेस का पता लगाता है।

Question 12

" कैसे दबाने से बचने के लिए Enterके साथ getchar()? "

सबसे पहले, टर्मिनल इनपुट या तो लाइन या पूरी तरह से बफर होता है। इसका मतलब है कि ऑपरेशन सिस्टम टर्मिनल से वास्तविक इनपुट को एक बफर में संग्रहीत करता है। आमतौर पर इस बफ़र को प्रोग्राम में फ़्लश किया जाता है जब फ़े \nको संकेतित किया जाता है / प्रदान किया जाता है stdin। यह एक प्रेस द्वारा बनाई गई fe है Enter।

getchar()श्रृंखला के अंत में है। यह वास्तव में बफरिंग प्रक्रिया को प्रभावित करने की कोई क्षमता नहीं है।

" मैं यह कैसे कर सकता हूं? "

getchar()पहली जगह में खाई , यदि आप टर्मिनल के व्यवहार को स्पष्ट रूप से बदलने के लिए विशिष्ट प्रणाली कॉल का उपयोग नहीं करना चाहते हैं जैसे कि अन्य उत्तर में अच्छी तरह से समझाया गया है।

दुर्भाग्य से कोई मानक पुस्तकालय फ़ंक्शन नहीं है और इसके साथ ही एकल चरित्र इनपुट पर बफर को फ्लश करने का कोई पोर्टेबल तरीका नहीं है। हालांकि, कार्यान्वयन-आधारित और गैर-पोर्टेबल समाधान हैं।

विंडोज / एमएस-डॉस में, हेडर फ़ाइल में फ़ंक्शन getch()और getche()फ़ंक्शन होते हैं conio.h, जो बिल्कुल वही काम करते हैं जो आप चाहते हैं - बफर को फ्लश करने के लिए नई लाइन की प्रतीक्षा करने की आवश्यकता के बिना एक भी चरित्र पढ़ें।

के बीच मुख्य अंतर getch()और getche()वह यह है कि getch()जबकि, कंसोल में नहीं तुरंत उत्पादन वास्तविक इनपुट चरित्र करता getche()है। प्रतिध्वनि"e" के लिए अतिरिक्त खड़ा है ।

उदाहरण:

#include <stdio.h>
#include <conio.h>   

int main (void) 
{
    int c;

    while ((c = getche()) != EOF)
    {
        if (c == '\n')
        {
            break;
        }

        printf("\n");
    }

    return 0;
}

लिनक्स, प्रत्यक्ष चरित्र प्रसंस्करण और उत्पादन प्राप्त करने के लिए एक तरह से उपयोग करने के लिए है cbreak()और echo()विकल्प और getch()और refresh()ncurses-पुस्तकालय में दिनचर्या।

ध्यान दें, कि आपको तथाकथित मानक स्क्रीन को आरंभीकरण के साथ initscr()बंद करने की आवश्यकता है endwin()।

उदाहरण:

#include <stdio.h>
#include <ncurses.h>   

int main (void) 
{
    int c;

    cbreak(); 
    echo();

    initscr();

    while ((c = getch()) != ERR)
    {
        if (c == '\n')
        {
            break;
        }

        printf("\n");
        refresh();
    }

    endwin();

    return 0;
}

नोट: आपको -lncursesविकल्प के साथ कंपाइलर को आमंत्रित करना होगा , ताकि लिंकर ncurses-Library को खोज सके और खोज सके।

Question 13

डिफ़ॉल्ट रूप से, C लाइब्रेरी आउटपुट को तब तक बफ़र करती है जब तक कि वह रिटर्न नहीं देखता। तुरंत परिणाम जानने के लिए, उपयोग करें fflush:

while((c=getchar())!= EOF)      
{
    putchar(c);
    fflush(stdout);
}