Thread: Capturing keyboard input, one character at a time

How would I go about creating a function where when the user hits one key on their keyboard (except for the enter key) and the function adds that character to an array, then preps the user for another character (and so on and so forth until the user hits enter)?

FAQ > How can I get input without having the user hit [Enter]? - Cprogramming.com

I'm using GCC on Redhat 6.3, it doesn't seem to include conio.h.

Here's the assignment, it's pretty basic:

Write a program that prompts the user for characters (not strings!). As the user enters characters your program must call the "vector function" (that you must write) to automatically adjust the character array size to hold the input. The function must use malloc/calloc to create/adjust the array size. You CANNOT use realloc! The function must return a pointer (to the array) to the main routine (you will probably want to pass in the array also). You can adjust the array in chunks of 5 or 10 characters (vs 1 character) if you want. When the user enters "return" (in place of a character) your program must append the '\0' character to the end (making it a string). Your program must then append the new string to the text/string "HW 3 input: " (be carefull here). Your program must then print out the resulting string.

I'm pretty sure I understand the logic behind this, I made up this pseudocode

Code:

function1
{
  //is called when the user hits a key that isn't the enter key
  //throws the passed in character into an array of characters
  //if needed assigns the old array into a new, larger array using memcpy
}

main
{
   //initialize some pointers and an array
   //use malloc to assign pointers
   //ask for keyboard input 
   //something (loop maybe?) to grab each key as the user presses it and passes it as a character into the above function (quits loop when enter key is presssed)
   //takes entire character array and converts it into a string and prints it
}

And here is the recommended approach, using a curses library:

Code:

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

int main(void)
{
    WINDOW *w;
    int     c;

    /* This is optional. This tells the C libraries to use user's locale settings. */
    setlocale(LC_ALL, "");

    /* Initialize curses. */
    w = initscr();
    if (w == NULL) {
        fprintf(stderr, "Error initializing curses library.\n");
        return EXIT_FAILURE;
    }
    raw();              /* Terminal in raw mode, no buffering */
    noecho();           /* Disable echoing */
    nonl();             /* Disable newline/return mapping */
    keypad(w, FALSE);   /* FALSE: CSI codes, TRUE: curses codes for keys */

    printw("Press Q to quit.\n");
 
    do {

        c = getch();

        if (isprint(c))
            printw("Received character '%c', code %d = 0%03o = 0x%02x\n", c, c, c, c);
        else
            printw("Received code %d = 0%03o = 0x%02x\n", c, c, c);

    } while (c != 'Q');

    /* Done. */
    endwin();

    return EXIT_SUCCESS;
}

In Linux, make sure you have a curses development package installed (ncurses-devel or libncurses5-dev or similar). For Windows, you can use PDcurses, or, if using MingW, ncurses (there are some binaries linked at the end of the page).

ncurses is very common on non-Windows systems; it is practically always available.

The development libraries, however, are not always installed; you may have to the admin to install them. In other words, compiled programs work, but to compile new programs, you need the development libraries. In Red Hat and similar distributions, it is usually called ncurses-devel, in Debian/Ubuntu it is libncurses5-dev, I believe.

In most operating systems you can compile the above (ctest.c) using

Code:

cc ctest.c -lcurses -o ctest

but in Linux, I recommend

Code:

gcc -W -Wall ctest.c -lncurses -o ctest

Finally, note the keypad(w,FALSE); line. If you change it to TRUE, curses will interpret CSI/ANSI escape sequences internally, and provide you with single-character constants listed for example here (man 3 curs_getch).

Thanks for the info, I was able to find an example that accomplishes it with standard C libraries. Now the only problem is when it gets to the printf statements in lines 59-69, it prints NULLs instead of the actual values. What am I missing?

Code:

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

int getch(void) //Dynamic String Input function from Daniweb.com
{ 
    int ch;
    struct termios oldt;
    struct termios newt;
    tcgetattr(STDIN_FILENO, &oldt); /*store old settings */
    newt = oldt; /* copy old settings to new settings */
    newt.c_lflag &= ~(ICANON | ECHO); /* make one change to old settings in new settings */
    tcsetattr(STDIN_FILENO, TCSANOW, &newt); /*apply the new settings immediatly */
    ch = getchar(); /* standard getchar call */
    tcsetattr(STDIN_FILENO, TCSANOW, &oldt); /*reapply the old settings */
    return ch; /*return received char */
}

int main(void)
{
    char *x;
    x = malloc(sizeof(int));
    if (x == NULL) exit(1);
    int *temp, *temp2;
    *x = ' ';
    printf("Enter characters: ");
    int arraySize = 0;
    temp=calloc(1, sizeof(int));
    if (temp == NULL) exit(1); 
    temp2=calloc(1, sizeof(int));
    if (temp2 == NULL) exit(1); 
    int c, i;
    while (*x != '\n')
    { 
        *x = getch();
        printf("%c", *x);
        if (arraySize % 2) //if arraySize is odd
        {
            temp[arraySize]=*x;
            //printf("%s", &temp[arraySize]);
            arraySize++;
            temp2=calloc(arraySize, sizeof(int));
            memcpy(temp2, temp, sizeof(temp2));
            printf("%s", &temp2[arraySize]);
        }
        else //if arraySize is even
        {
            temp2[arraySize]=*x;
            //printf("%s", &temp2[arraySize]);
            arraySize++;
            temp=calloc(arraySize, sizeof(int));
            memcpy(temp, temp2, sizeof(temp));
            printf("%s", &temp[arraySize]);
        }
    }
    //printf("%d\n", arraySize);
    if (arraySize % 2)
    {
        for (i=1; i < arraySize; i++) {
            printf("%s", temp[i]);
        }
    }
    else
    {
        for (i=1; i < arraySize; i++) {
            printf("%s", temp2[i]);
        }
    }
}

Originally Posted by Codeplug

There are implementations that are known to crash when you do this.

Poppycock. I do not believe that for a second.

That implementation would crash if the user had run e.g. stty -icanon before running any application. So, name at least one such implementation, please.

(Yes, I am aware of the possibility of an internal library bug for c_cc[VMIN]==0. Those implementations also crash if the user has run stty -icanon min 0 time 1 or similar before running the application. In particular, I fail to see how any implementation could have any issues with c_cc[VMIN]>0, since the syscall behaviour is unchanged wrt. to normal, canonical terminal.)

The key here is that we are not modifying the internals of anything. The only thing we do that cannot be done by standard commands prior to running the process is setting the stream to unbuffered. And we use a standard library setvbuf() call to do that.

The only problematic cases for any implementations are when the minimum number of characters returned by the read is zero:

• c_cc[VMIN] = 0, c_cc[VTIME] = 0
  If data is available, reads return immediately.
  Otherwise, reads return zero -- which normally means an end of input.
• c_cc[VMIN] = 0, c_cc[VTIME] > 0
  If data is available within the timeout, it is returned.
  Otherwise, reads return zero -- which normally means an end of input.

It is possible that a library does extra cleanup, and gets confused if it sees more than one end of input. So, I concede that setting c_cc[VMIN]=0 in the terminal settings might cause problems to some implementations, but that is all.

Note:

If you want Ctrl+C to work, omit the

Code:

    raw.c_iflag |= IGNBRK;
    raw.c_iflag &= ~BRKINT;
    raw.c_lflag &= ~ISIG;

in the raw termios case, or use cbreak() instead of raw() in curses. In that case you should also install your own SIGINT handler to restore the terminal state, and exit the program. If you don't, you'll leave the terminal in raw state, and the user will think you broke something. (And most users don't know to run the 'reset' or 'tput reset' command, which would reset things back to normal.)

Originally Posted by Paul Omans

Code:

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

int getch(void) //Dynamic String Input function from Daniweb.com
{ 
    int ch;
    struct termios oldt;
    struct termios newt;
    tcgetattr(STDIN_FILENO, &oldt); /*store old settings */
    newt = oldt; /* copy old settings to new settings */
    newt.c_lflag &= ~(ICANON | ECHO); /* make one change to old settings in new settings */
    tcsetattr(STDIN_FILENO, TCSANOW, &newt); /*apply the new settings immediatly */
    ch = getchar(); /* standard getchar call */
    tcsetattr(STDIN_FILENO, TCSANOW, &oldt); /*reapply the old settings */
    return ch; /*return received char */
}

This does very much the same thing as my code does, just with less care, and for every single my_getch() call. You still should call setvbuf() once at the start like I do, to tell your C library to not buffer standard input.

Ok, here's my program:

Code:

 #include <stdio.h> 
#include <stdlib.h> 
#include <unistd.h> 
#include <termios.h> 
#include <string.h> 
 
int getch(void) //Dynamic String Input function from Daniweb.com
{  
    int ch; 
    struct termios oldt; 
    struct termios newt; 
    tcgetattr(STDIN_FILENO, &oldt); //store old settings 
    newt = oldt; // copy old settings to new settings 
    newt.c_lflag &= ~(ICANON | ECHO); // make one change to old settings in new settings 
    tcsetattr(STDIN_FILENO, TCSANOW, &newt); //apply the new settings immediatly 
    ch = getchar(); // standard getchar call 
    tcsetattr(STDIN_FILENO, TCSANOW, &oldt); // reapply the old settings 
    return ch; // return received char  
} 
 
int main(void) 
{ 
    char x; 
    int *temp, *temp2;
    char outputTemp[] = {'H','W',' ','3',' ','i','n','p','u','t',':',' '};
    char *output; 
    x = ' ';
    int i; 
    printf("Enter characters: "); 
    int arraySize = 0; 
    temp=calloc(1, sizeof(int)); 
    if (temp == NULL) exit(1);  
    temp2=calloc(1, sizeof(int)); 
    if (temp2 == NULL) exit(1);  
    while (x != '\n') 
    {  
        x = getch(); 
        printf("%c", x); 
        if (arraySize % 2) //if arraySize is odd 
        { 
            temp[arraySize]=x; 
            //printf("%s", &temp[arraySize]); 
            arraySize++;
            free(temp2); 
            temp2=calloc(arraySize, sizeof(arraySize)); 
            memcpy(temp2, temp, sizeof(temp2)); 
        } 
        else //if arraySize is even 
        { 
            temp2[arraySize]=x; 
            //printf("%s", &temp2[arraySize]); 
            arraySize++;
            free(temp); 
            temp=calloc(arraySize, sizeof(arraySize)); 
            memcpy(temp, temp2, sizeof(temp)); 
        } 
    } 
    printf("Total Characters: %d\n", arraySize-1); 
    if (arraySize % 2) 
    { 
       arraySize++;
       free(temp); 
       temp=calloc(arraySize, sizeof(arraySize)); 
       memcpy(temp, temp2, sizeof(temp));
       temp[arraySize] = '\0';
       int totalSize = arraySize + 12;
       output=calloc(totalSize, sizeof(totalSize));
       memcpy(output, temp, sizeof(arraySize));
       memcpy(output, outputTemp, sizeof(12));
       for (i = 0; i < totalSize; i++) {
          printf("%s", output[i]);
       } 
    } 
    else 
    { 
       arraySize++;
       free(temp2); 
       temp2=calloc(arraySize, sizeof(arraySize)); 
       memcpy(temp2, temp, sizeof(temp2));
       temp2[arraySize] = '\0';
       int totalSize = arraySize + 12;
       output = calloc(totalSize, sizeof(totalSize));
       memcpy(output, temp2, sizeof(arraySize));
       memcpy(output, outputTemp, sizeof(12));
       for (i = 0; i < totalSize; i++) {
          printf("%s", output[i]);
       } 
    } 
}

The logic looks right to me, although it seg faults somewhere in the last if/else statement (lines 59-86) and I can't figure out why.

Originally Posted by Codeplug

It was some linux-distro-VM many years ago - I forget. It crashed and the fix was not to go through the CRT (a simple read() is all that's needed anyways).

I think I recall a bug years ago, where an unexpected EOF (read() returning zero) followed by a successful data read did crash the library. But that wasn't normal or acceptable behaviour, that was a serious bug.

Originally Posted by Codeplug

It's also how the glibc manual does it: Noncanon Example - The GNU C Library

It's pretty bad code for an example! The name variable is unused. The code does not even bother to check the return value from read(), causing c to retain its previous value, yielding unexpected results, in certain cases!

If you change even tattr.c_cc[VMIN]=0, it will dump the initial (undefined) value of c to standard output continuously. It's easy to miss, since most terminals just ignore the NUL bytes output, but dump the output to e.g. od -t x1 and you'll see. Or, install a signal handler, and start wondering why you get duplicated bytes on input when signals are delivered.

Finally, mixing stdio.h and low-level unistd.h I/O to the same terminal is often tricky, since many of the struct termios settings affect output. Canonical/noncanonical/raw mode and disabling echo should not affect any output functionality, though.

I do personally use a lot of low-level unistd.h I/O, with custom numerical data parsers, for large amounts of data; I do have some low-level input routines if someone is interested. I'd use those only for something like a CLI password dialog, or other tricky/sensitive/special cases.

For normal terminal applications, the sane and portable approach is to use curses.

In any case, it is a good thing to keep a sharp eye on the suggestions and examples.

Originally Posted by Paul Omans

The logic looks right to me, although it seg faults somewhere in the last if/else statement (lines 59-86) and I can't figure out why.

The compiler is really helpful:

Code:

$ make foo
cc -ggdb3 -Wall -Wextra   -c -o foo.o foo.c
foo.c: In function ‘main’:
foo.c:71:11: warning: format ‘%s’ expects argument of type ‘char *’, but argument 2 has type ‘int’ [-Wformat]
foo.c:86:11: warning: format ‘%s’ expects argument of type ‘char *’, but argument 2 has type ‘int’ [-Wformat]
foo.c:89:1: warning: control reaches end of non-void function [-Wreturn-type]
cc   foo.o   -o foo

But you have other problems too:

Code:

$ valgrind -q ./foo
Enter characters: X==2667== Invalid write of size 4
==2667==    at 0x8048777: main (foo.c:41)
==2667==  Address 0x41f209c is 0 bytes after a block of size 4 alloc'd
==2667==    at 0x402A56B: calloc (vg_replace_malloc.c:566)
==2667==    by 0x80487E6: main (foo.c:54)
==2667== 
X

Code:

temp[arraySize]=x;   // line 41
...
arraySize++;
free(temp);
temp=calloc(arraySize, sizeof(arraySize));  // line 54

How many elements are in "temp"?

Bye, Andreas

"temp" and "temp2" are arrays that increase as the user enters in characters.
so, the user enters in one character -> the character gets put into temp with size one -> temp2 is increased by 1 (now its size is 2) -> temp's values are thrown into temp2
then the process is reversed for the next character and so on and so forth