C Console Input

Question

I can't seem to google this because everything turns up as C++ or C# (Side note: any easy way to search for C specific?). All I'm trying to figure out is how to accept a console string input in such a way that I know it's length so I can return it in reverse order by indexing backwards through it with a for loop. I've had a little C++ experience in the past, but never really used console IO. Any help appreciated, thanks.

Answer 1

1. Read with fgets().
2. Cope with a possible trailing \n.
3. Find length

4. print in reverse.

   char buf[100];
   if (fgets(buf, sizeof buf, stdin) == NULL) Handle_EOF();
   buf[strcspn(buf, "\n")] = '\0';  // lop off potential trailing \n
   size_t len = strlen(buf);
   while (len) {
     putc(buf[--len], stdout);
   }
   

Answer 2

You can use the fgets function to read from the standard input.

char buf[80];

if (fgets(buf, 80, stdin) != NULL)
    /* buf now contains the first 80 chars of the input */

Note: Do NOT use gets because it is dangerous--it can overflow the input buffer.

Answer 3

You'll need to set aside some space to store the input; since you don't know ahead of time how big the input will be, you'll have to get a little creative with the storage.

A common strategy is to use a smallish, fixed-size buffer to read from the input stream, and a dynamic, resizable buffer to store the complete string if it winds up being longer than what the fixed-size buffer can handle. This way you can read an arbitrarily long input line in discrete chunks, and then paste the chunks together, resizing the target buffer as necessary.

You'll read the fixed-size chunks from the console in a loop and store it to the dynamic buffer until you see a newline, at which point you exit the input loop. Ideally, your fixed-size buffer should be large enough to handle most reasonable cases, such that you don't need to extend the dynamic buffer.

Excessively wordy (untested!) example:

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

#define INPUT_BUF_SIZE 21 // handle strings up to 20 characters in length

int main( void )
{
  /**
   * Set aside a fixed-size buffer to store input from the console.  This
   * buffer cannot be resized after it has been allocated.
   */
  char inputBuf[INPUT_BUF_SIZE]; 

  /**
   * Dynamically allocate a buffer to store the final string; 
   * its initial size is the same as the fixed buffer.  If necessary,
   * this buffer may be extended with the realloc function.  We're using
   * calloc instead of malloc to make sure the initial array contents
   * are set to 0.
   */
  char *finalBuf = calloc( INPUT_BUF_SIZE, sizeof *finalBuf ); 

  /**
   * finalBufSize tracks the total size of the dynamic buffer; finalBufLen
   * tracks the length of the string currently stored in the buffer.
   * These are not the same thing.  
   */
  size_t finalBufSize = INPUT_BUF_SIZE;
  size_t finalBufLen = 0; // initially no string stored in the buffer

  /**
   * Read from standard input into the fixed-size buffer; loop until
   * we see EOF or there's an error on input.
   */
  while ( fgets( inputBuf, sizeof inputBuf, stdin ) )
  {
    /**
     * If there isn't enough space left in finalBuf to store
     * the latest chunk, double the size of finalBuf.  This strategy
     * minimizes the number of times you have to call realloc (which
     * can be expensive).  
     */
    if ( strlen( inputBuf ) + finalBufLen > finalBufSize )
    {
      /**
       * *Always* assign the result of realloc to a temp variable; if the
       * call fails it will return NULL, and if you overwrite the value
       * of finalBuf with NULL, you'll lose your only reference to any
       * previously allocated memory.  
       */
      char *tmp = realloc( finalBuf, finalBufSize * 2 );
      if ( tmp )
      {
        finalBuf = tmp;
        finalBufSize *= 2;
      }
      else
      {
        /**
         * We can't extend the buffer anymore, so we'll exit the
         * loop and work with what we have.
         */
        fprintf( stderr, "Could not extend storage buffer, exiting input loop\n" );
        break;
      }
    }

    /** 
     * Append the input string to the target buffer.
     */
    strcat( finalBuf, inputBuf );
    finalBufLen = strlen( finalBuf );

    /**
     * Did we see a newline in the last input chunk?  If so,
     * remove that newline from the final string (unless you
     * want to include that in your reversal) and exit
     * the loop.
     */
    char *newline = strchr( finalString, '\n' );
    if ( newline )
    {
      *newline = 0; // overwrite the newline character with the string terminator
      break;
    }
  }

At this point, finalBuf contains the input from the console, and you can reverse this string for output. Once you're done with it, release the memory that's been allocated with the free function like so:

free( finalBuf );

Ideally you'd separate all that input handling into its own function, but this is a good enough illustration for now.

Answer 4

I wrote this function to put input from stdin into a buffer, for a cli project in uni.

It reads stdin char by char, it has no buffer overflow.

/*max line lenght*/
#define CLI_MAX_CMD_LEN 1024

/*get_line copies characters from stdin to buffer pointed by buf, stopping when a
  carriage return or newline is encountered. It returns -1 on errors, otherwise strlen count */
int get_line(char *buf) {
    int i,c;
    for (i=0;i<CLI_MAX_CMD_LEN;i++) {
        c = getchar();
        switch (c) {
            /*if terminating char is found an error has occurred*/
            case '\0':
                printf("found '\\0' instead of '\\n'\n");
                return -1;
            case '\t':
                /*show possible commands*/
                autocomplete(buf);
                break;
            case EOF:
                /* prints the warning to stdout */
                printf("End of file reached\n");
                /* continue to execute following cases code */ 
            case '\n':
            case '\r':
                buf[i] = '\0';
                return i;
            default :
                buf[i] = c;
        }
    }

    /*if end of buffer is reached put terminating char on last element
      means that an error has occurred*/
    buf[CLI_MAX_CMD_LEN] = '\0';
    return -1;
}

Answer 5

This is my solution but with recursion:

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

#define N 20

void reverseW(char *, int);

int main()
{
char tmp[N], *string;

printf("Type a String:\n");
scanf("%s", tmp);

string=(char*)malloc((strlen(tmp)+1)*sizeof(char));
if (string==NULL)
{
    printf("Error !\n");
    exit(0);
}
strcpy(string, tmp);

reverseW(string, strlen(string));
printf("\nThe reverse of %s is %s !\n", tmp, string);

free(string);
return 0;
}

void reverseW(char *word, int size)
{
char tmp;
if (size>1)
{
    tmp=word[0];
    word[0]=word[size-1];
    word[size-1]=tmp;
    reverseW(word+1, size-2);
}
return;
}