मैं सी (लिनक्स पर) में एक प्रोग्राम लिखने की कोशिश कर रहा हूं जो उपयोगकर्ता को एक कुंजी दबाने तक लूप करता है, लेकिन किसी भी लूप को जारी रखने के लिए कीपर की आवश्यकता नहीं है।
क्या ऐसा करने के लिए एक सरल तरीका है? मुझे select()लगता है कि मैं इसे संभवतः कर सकता हूं लेकिन यह बहुत काम की तरह लगता है।
वैकल्पिक रूप से, क्या गैर-अवरोधक io के बजाय प्रोग्राम बंद होने से पहले ctrl- cसफाई करने के लिए एक - कीपर पकड़ने का एक तरीका है ?
जवाबों:
जैसा कि पहले ही कहा गया है, आप sigactionctrl-c selectको फंसाने के लिए , या किसी भी मानक इनपुट को फंसाने के लिए उपयोग कर सकते हैं ।
ध्यान दें कि बाद की विधि के साथ आपको TTY सेट करने की भी आवश्यकता है ताकि यह लाइन-ऑन-ए-टाइम मोड के बजाय वर्ण-पर-समय में हो। उत्तरार्द्ध डिफ़ॉल्ट है - यदि आप पाठ की एक पंक्ति में टाइप करते हैं, तो यह रनिंग प्रोग्राम के स्टडिन में नहीं भेजा जाता है जब तक कि आप एंटर नहीं करते हैं।
आप का उपयोग करने की आवश्यकता होगी tcsetattr() ICANON मोड को बंद करने के फ़ंक्शन , और संभवतः ECHO को भी अक्षम करना होगा। मेमोरी से, आपको प्रोग्राम को बाहर निकलने पर टर्मिनल को वापस ICANON मोड में सेट करना होगा!
पूर्णता के लिए, यहां कुछ कोड मैंने अभी खटखटाए हैं (nb: no error check!) जो एक Unix TTY सेट <conio.h>करता है kbhit()और DOS फ़ंक्शन का अनुकरण करता है और getch():
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/select.h>
#include <termios.h>
struct termios orig_termios;
void reset_terminal_mode()
{
tcsetattr(0, TCSANOW, &orig_termios);
}
void set_conio_terminal_mode()
{
struct termios new_termios;
/* take two copies - one for now, one for later */
tcgetattr(0, &orig_termios);
memcpy(&new_termios, &orig_termios, sizeof(new_termios));
/* register cleanup handler, and set the new terminal mode */
atexit(reset_terminal_mode);
cfmakeraw(&new_termios);
tcsetattr(0, TCSANOW, &new_termios);
}
int kbhit()
{
struct timeval tv = { 0L, 0L };
fd_set fds;
FD_ZERO(&fds);
FD_SET(0, &fds);
return select(1, &fds, NULL, NULL, &tv);
}
int getch()
{
int r;
unsigned char c;
if ((r = read(0, &c, sizeof(c))) < 0) {
return r;
} else {
return c;
}
}
int main(int argc, char *argv[])
{
set_conio_terminal_mode();
while (!kbhit()) {
/* do some work */
}
(void)getch(); /* consume the character */
}
(void)बिट है जो उस चरित्र को प्राप्त करता है और फिर उसे फेंक देता है।
select()सुविधा के लिए बहुत कम स्तर है। मेरा सुझाव है कि आप ncursesलाइब्ररी का उपयोग करने के लिए लाईब्रेरी को क्रोक मोड और डिले मोड में रखें, फिर कॉल करें getch(), ERRयदि कोई वर्ण तैयार नहीं है, तो वापस आ जाएगा :
WINDOW *w = initscr();
cbreak();
nodelay(w, TRUE);
उस बिंदु पर आप getchबिना रुके कॉल कर सकते हैं ।
UNIX सिस्टम पर, आप sigactionसिग्नल के लिए SIGINTसिग्नल हैंडलर रजिस्टर करने के लिए कॉल का उपयोग कर सकते हैं जो कंट्रोल + सी कुंजी अनुक्रम का प्रतिनिधित्व करता है। सिग्नल हैंडलर एक ध्वज सेट कर सकता है जिसे लूप में चेक किया जाएगा ताकि यह उचित रूप से टूट सके।
आप शायद चाहते हैं kbhit();
//Example will loop until a key is pressed
#include <conio.h>
#include <iostream>
using namespace std;
int main()
{
while(1)
{
if(kbhit())
{
break;
}
}
}
यह सभी वातावरणों पर काम नहीं कर सकता है। एक पोर्टेबल तरीका एक निगरानी धागा बनाने और कुछ ध्वज को सेट करने का होगाgetch();
गैर-अवरोधक कीबोर्ड इनपुट प्राप्त करने का एक और तरीका डिवाइस फ़ाइल को खोलना और इसे पढ़ना है!
आपको उस डिवाइस फ़ाइल को जानना होगा जिसे आप खोज रहे हैं, / dev / input / event * में से एक। आप जिस डिवाइस को चाहते हैं, उसे ढूंढने के लिए आप कैट / प्रॉप / बस / इनपुट / डिवाइस चला सकते हैं।
यह कोड मेरे लिए काम करता है (एक प्रशासक के रूप में चलाएं)।
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <linux/input.h>
int main(int argc, char** argv)
{
int fd, bytes;
struct input_event data;
const char *pDevice = "/dev/input/event2";
// Open Keyboard
fd = open(pDevice, O_RDONLY | O_NONBLOCK);
if(fd == -1)
{
printf("ERROR Opening %s\n", pDevice);
return -1;
}
while(1)
{
// Read Keyboard Data
bytes = read(fd, &data, sizeof(data));
if(bytes > 0)
{
printf("Keypress value=%x, type=%x, code=%x\n", data.value, data.type, data.code);
}
else
{
// Nothing read
sleep(1);
}
}
return 0;
}
इस उद्देश्य के लिए शाप पुस्तकालय का उपयोग किया जा सकता है। बेशक, select()और सिग्नल हैंडलर का उपयोग एक निश्चित सीमा तक भी किया जा सकता है।
यदि आप कंट्रोल-सी को पकड़कर खुश हैं, तो यह एक सौदा है। यदि आप वास्तव में गैर अवरुद्ध I / O चाहते हैं, लेकिन आप शाप पुस्तकालय नहीं चाहते हैं, तो एक और विकल्प AT & T sfioलाइब्रेरी में लॉक, स्टॉक और बैरल को स्थानांतरित करना है । यह अच्छा पुस्तकालय है, जो C stdioपर अधिक लचीला, थ्रेड-सुरक्षित है, और बेहतर प्रदर्शन करता है। (sfio का अर्थ है सुरक्षित, तेज I / O।)
ऐसा करने का कोई पोर्टेबल तरीका नहीं है, लेकिन चयन () एक अच्छा तरीका हो सकता है। अधिक संभावित समाधानों के लिए http://c-faq.com/osdep/readavail.html देखें ।
आप चुन सकते हैं कि अनुसरण के रूप में चयन करें:
int nfds = 0;
fd_set readfds;
FD_ZERO(&readfds);
FD_SET(0, &readfds); /* set the stdin in the set of file descriptors to be selected */
while(1)
{
/* Do what you want */
int count = select(nfds, &readfds, NULL, NULL, NULL);
if (count > 0) {
if (FD_ISSET(0, &readfds)) {
/* If a character was pressed then we get it and exit */
getchar();
break;
}
}
}
बहुत अधिक काम नहीं: डी
nfds1. सेट भी किया जाना चाहिए
यहां आपके लिए यह करने के लिए एक फ़ंक्शन है। आप की जरूरत है termios.hजो POSIX सिस्टम के साथ आता है।
#include <termios.h>
void stdin_set(int cmd)
{
struct termios t;
tcgetattr(1,&t);
switch (cmd) {
case 1:
t.c_lflag &= ~ICANON;
break;
default:
t.c_lflag |= ICANON;
break;
}
tcsetattr(1,0,&t);
}
इसे तोड़ना: tcgetattrवर्तमान टर्मिनल जानकारी प्राप्त करता है और इसे इसमें संग्रहीत करता है t। यदि cmd1 है, तो स्थानीय इनपुट ध्वज tगैर-अवरुद्ध इनपुट पर सेट है। अन्यथा यह रीसेट है। फिर tcsetattrमानक इनपुट में परिवर्तन करता हैt ।
यदि आप अपने कार्यक्रम के अंत में मानक इनपुट को रीसेट नहीं करते हैं तो आपको अपने शेल में समस्याएं होंगी।