Why is there an extra "*" in the output of this program?

Question

#include <stdio.h>

int main () 
{ 
  int c; 
  while ((c = getchar ()) != EOF) 
    { 
      putchar (c); 
      printf ("*"); 
    }


  return 0; 
}

when I run this program, the output I get is as

qwerty                                          

q * w * e * r * t * y *
* 

#I'm not getting how this last "*" is getting printed.

It has something to do with the return of putchar(). So how does putchar() function actually returns. I know that it returns after EOF is reached, so in that case, it won't print anything and printf("*") will get executed. But the thing is, why the last * is getting printed in the next line. Is it like putchar() returns and shift the printing pointer to new line?

One theory I get over this doubt is that, if I don't press 'enter' after giving input, * will not be printed. But it again created a question as of how do I get output (after giving the input), without pressing enter? And why is it like that the last * is there due to pressing 'enter'?

Answer 1

When you give input "qwerty" and press enter key, the new line character \n appended to the input. So, the input to program would be:

"qwerty\n"
       ^^

When loop process the last (newline) character i.e. the \n character printed which actually moves the cursor to next line and the last star is getting printed after it.

To not to get the trailing new line character along with input, you can add check for new line character in while loop condition:

while ((c = getchar ()) != EOF && c != '\n')

Alternatively, you can give end of file EOF character instead of pressing enter key after entering input. For EOF, on Unix press Control+D and on Windows press Control+Z.

Answer 2

#include <stdio.h>
int main () 
{ 
  int c; 
  while ((c = getchar ()) != EOF) 
    { 
      putchar (c); 
      printf ("*"); 
    }
  return 0; 
}

OUTPUT:

QWERTY<Enter>

Enter also Taking as Character 
last '*' for <Enter> Character..

Answer 3

Your code will print one * for each other letter printed.
A newline is printed, note how the last * is alone in the last line.
The last * is for the \n, which is read when you enter the input with the return key.

You might want to stop the loop already at that newline, i.e.

while (((c = getchar ()) != EOF) && (c!='\n'))

Answer 4

how do I get output( after giving the input), without pressing enter?

You can press Ctrl-D after "qwerty" instead of pressing Enter.

Answer 5

Welcome to the site. H.S. has answered your main question. Nonetheless I wanted to add a little more explanation and address one of your other questions directly.

Terminal attributes

But it again created a question as of how do I get output (after giving the input), without pressing enter?

The reason you need to press enter is that your terminal is in 'canonical' mode by default. From the UNIX manual for tcsetattr:

In canonical mode:

Input is made available line by line. An input line is available when one of the line delimiters is typed (NL, EOL, EOL2; or EOF at the start of line). Except in the case of EOF, the line delimiter is included in the buffer returned by read(2).

Note the fact that 'the line delimiter is included' also indirectly answers your question

And why is it like that the last * is there due to pressing 'enter'?

(as pressing enter inserts the NL line delimiter - which the program just places in the input buffer along with the rest of the characters).

Depending on your platform, you may be able to disable canonical mode.

Disabling canonical mode

NOTE: The information below may be platform-specific. The tcsetattr functions et. al are part of the POSIX standard - but I don't know if they will work on Windows.

On Linux, for example, the following disables canonical mode and instructs the program to read input as soon as the user types a character.

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

int main(void) {
    char c = '\0';
    struct termios orig_attr, new_attr;

    tcgetattr(fileno(stdin), &orig_attr);
    memcpy(&new_attr, &orig_attr, sizeof(struct termios));
    new_attr.c_lflag &= ~(ICANON | ECHO);  // Disable canonical mode
    tcsetattr(fileno(stdin), TCSANOW, &new_attr);

    while ((c = getchar()) != '\n') {
        printf("%c * ", c);
    }
    puts("");

    // Restore original terminal attributes
    tcsetattr(fileno(stdin), TCSANOW, &orig_attr);

    return 0;
}

Notes:

• The above code also disables terminal 'echo' (Otherwise you would see each of the characters printed twice).
• You may also want to set new_attr.c_cc[VTIME] and new_attr.c_cc[VMIN] for finer control of the read buffer. (See man page for details.)
• Ultimately - depending on your ultimate goal - maybe it is easier to just use fgets or getline?

Answer 6

It has something to do with the return of putchar(). So how does putchar() function actually returns. I know that it returns after EOF is reached, so in that case, it won't print anything and printf("*") will get executed.

This is very confused and you're completely on the wrong path here. putchar() just outputs a single character and returns as soon as this output is done. In fact, you could write the same code like this:

while ((c = getchar()) != EOF) 
{ 
   putchar(c); 
   putchar('*'); 
}

This means as long as getchar() is successful (no end of file), output the character you received and then immediately output an asterisk.

In fact, what you should expect to see when hitting the keys qwerty is something like this:

qq*ww*ee*rr*tt*yy*

This is assuming your terminal does "local echo", which means it shows anything you type.

The reason you don't see any output before hitting enter (or the platform-dependent control key for EOF, e.g. on *nix systems Ctrl-D) is simply that stdin, your input stream in C, is by default line buffered. This means that in your loop above, getchar() won't ever return unless you have a whole line of input or reach EOF.

As soon as getchar() returns, your loop will run. If you pressed enter, there will be a newline character in the input buffer and getchar() will read this as well, so it will also be output by the putchar() inside your loop, followed by an asterisk.

Note however that buffering modes can be changed ... if you disable buffering on stdin, you will probably see what I described above.

---

A sane way to implement what you want reliably is to read a whole line in your code and iterate over the characters you read. This could look for example like the following:

char buffer[1024];
if (fgets(buffer, 1024, stdin))
{
    for (char *c = buffer; *c; ++c)
    {
        putchar(*c);
        if (*c != '\n') putchar('*');
    }
}

With code like this, you have your own buffer and don't depend on the buffering mode of your input stream.