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

This reads input characters until it reaches either the end of the line (i.e., getchar() returned '\n) or end-of-file or an error condition (i.e., getchar() returned EOF).

If stdin is reading from the keyboard, it discards input until you press Enter.

Leaving off the EOF check could give you an infinite loop if there's an input error, or if you trigger an end-of-file condition (on Unix, by typing Ctrl-D twice).

This could be useful, for example, after using scanf() to read an integer. If you execute scanf("%d", &num); and type 123, it will read those 3 digits (and store the value 123 in n), but leave everything after that waiting to be read. The above line can be used to skip the rest of the input line.

(An alternative, likely a better one, is to read whole lines using fgets() and parse them using sscanf().)

This is not equivalent to fflush(stdin). A far as the C standard is concerned, calling fflush on an input stream has undefined behavior.

Some implementations do define the behavior of fflush(stdin). On systems that use GNU libc, for example (most Linux system):

For input streams, fflush() discards any buffered data that has been fetched from the underlying file, but has not been consumed by the application.

That's not the same as discarding input up to the end of the line. And using it makes your code non-portable.

The call to fflush(stdin) is undefined behavior in C (and, consequetly, in C++).

The C language standard, ISO 9899:1999 states in 7.19.5.2/2

If stream points to an output stream or an update stream in which the most recent operation was not input, the fflush function causes any unwritten data for that stream to be delivered to the host environment to be written to the file; otherwise, the behavior is undefined

To discard the entire input up to the next end of line, in C++, the most robust approach is

std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');

As for the program "flashing and going away", are you perhaps executing a console application on a Windows platform? Such applications are best executed from a console window (Start->run->cmd.exe)

This is well explained in the C FAQ. See also: explanation. The proposed solutions:

• Quit using scanf. Use fgets and the sscanf

• Use this to eat the newline

  while((c = getchar()) != '\n' && c != EOF)
  /* discard the character */;
  

The fact that flushing stdin works on some implementations is wrong.

Some vendors do implement fflush so that fflush(stdin) discards unread characters, although portable programs cannot depend on this.

One possibility is to consume the newline left by the scanf via using something like getchar():

printf("Gimme number");
scanf("%d",&number);
getchar();
printf("Gimme string");
gets(string);

Another possibility is to just use scanf's:

printf("Gimme number");
scanf("%d",&number);
printf("Gimme string");
scanf(" %99s", string);

Where you'd replace the 99 by whatever length your string buffer is, note the space before the % to make sure it ignores white space (or tabs or newlines) left on stdin.

You probably want something like this:

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

int main()
{
  int dim = 0;

  for (;;)
  {
    printf("Please enter a number: ");
    char buffer[30];
    fgets(buffer, sizeof(buffer), stdin);

    char *endpointer;
    dim = strtol(buffer, &endpointer, 10);

    if (*endpointer != '\n' || (dim < 1) || (dim > UCHAR_MAX))
    {
      printf("[ERR] Enter a number\n");
      continue;
    }
    break;
  }

  printf("The number you entered is: %d\n", dim);
}

After the call to strtol, endptr points to the first non digit char entered. If only digits have been entered, endptr will point to the \n that terminates the line, otherwise if e.g. 12x has been entered, endptr will point to the 'x'.

You may improve this by writing a GetNumber function so you can just write

dim = GetNumber();

or

dim = GetNumber("Please enter a number: ", "[ERR] Enter a number\n", 1, UCHAR_MAX);

fflush only flush output streams.

If you want to flush stdin, keep reading until you get EOF, something like:

int i;
while (((i = getchar()) != '\n') && (i != EOF));