To force output to the screen, please see the first section below. The second and third options below are also good for debugging program crashes like these.

Using printf with fflush (refinement of Vishal Kumar's answer)

Vishal Kumar's answer worked for me, but I had to do a little research to find out how to use fflush. I had a problem where my program was crashing "in the middle" of a printf statement which did not make sense. Here is my refinement of his answer. In cases where a debugger is difficult to use (e.g. multithreading), you can use fflush after every printf (or fprintf) statement. For example, "pepper your code" with:

... // code
printf("Part 1 executed successfully");
fflush(stdout); // flushes the stdout buffer
... // further code
printf("Part 2 executed successfully");
fflush(stdout);
... // repeat as necessary

Run, observe the output, and put more print statements between the last statement that prints, and the first statement that doesn't print, until you isolate the problem.

Debugger

If you are able to use a debugger, it is a more efficient choice than peppering your code with output statements as described above, but there are cases where you have to resort to that.

Valgrind

If you are using Linux (which I gather you are not because it is in MS Visual C++), valgrind is another option to see where your code is crashing (and for detecting memory leaks). If your code is compiled for debug, if your program is called "myProgram", you can just call from the terminal window as follows:

valgrind myProgram

On many systems printf is buffered, i.e. when you call printf the output is placed in a buffer instead of being printed immediately. The buffer will be flushed (aka the output printed) when you print a newline \n.

On all systems, your program will print despite the missing \n as the buffer is flushed when your program ends.

Typically you would still add the \n like:

printf ("%s\n", a);

An alternative way to get the output immediately is to call fflush to flush the buffer. From the man page:

For output streams, fflush() forces a write of all user-space buffered data for the given output or update stream via the stream's underlying write function.

Source: http://man7.org/linux/man-pages/man3/fflush.3.html

EDIT

As pointed out by @Barmar and quoted by @Alter Mann it is required that the buffer is flushed when the program ends.

Quote from @Alter Mann:

If the main function returns to its original caller, or if the exit function is called, all open files are closed (hence all output streams are flushed) before program termination.

See calling main() in main() in c

Like @thejh said your stream seems to be buffered. Data is not yet written to the controlled sequence.

Instead of fiddling with the buffer setting you could call fflush after each write to profit from the buffer and still enforce the desired behavior/display explicitly.

printf( "Enter first integer\n" );
fflush( stdout );
scanf( "%d", &i1 );

for (nc=0; getchar() !=EOF; ++nc);

the ';' at the end of the line is perhaps not what you want, because of it the body of the for is empty

so printf("%d\n", nc); is executed only one time, not several, and for that you need first to go out of the for, so to reach EOF

What is your OS, what are you doing to have EOF ?

If you never reach EOF it is normal to have nothing print

If you are under Linux/Unix you can do echo blahblah | ./yourprog and yes in that case you will print 9 (because of the newline, 8 if echo -n blahblah)

Under Windows do not execute your code through codeblocks, execute it directly in a terminal, codeblocks and other IDE have unexpected behavior on the input/output

This will (hopefully) explain this specific problem in main and perhaps the overriding problem. The output buffer is not "flushed" until a new line (or explicit flush). The answer provided here explains it. If the added debugging printfs are "not executing" it could be for the same reason, since the first "\n" that is encountered would likely be after "MISSPELLED WORDS". Changing this printf("start main"); to this printf("start main\n"); will change the result.

Here is the output, of your program:

The text from printf ("test"); is printed and you can see it before the line shubham@shubham-pc:~$

Since there is no \n in your program, a newline is not printed at end and hence the default line of console gets printed after it

To solve this your program should look like:

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

int main()
{
    printf("%s \n","test");
    return 0;
}

The thing I've done here is that, I used a format string (%s) to print test and added a newline (\n) after it.

Here is the output after the edits:

First, main returning void is illegal, please activate warning. Secondly, one of your printf lacks a \n which may explain why it isn't flushed into your terminal by default.

Output is buffered.

stdout is line-buffered by default, which means that '\n' is supposed to flush the buffer. Why is it not happening in your case? I don't know. I need more info about your application/environment.

However, you can control buffering with setvbuf():

setvbuf(stdout, NULL, _IOLBF, 0);

This will force stdout to be line-buffered.

setvbuf(stdout, NULL, _IONBF, 0);

This will force stdout to be unbuffered, so you won't need to use fflush(). Note that it will severely affect application performance if you have lots of prints.