Checking stdin and stdout using external function

Question

Does scope impact, checking for errors while obtaining input from stdin or outputting to stdout? For example if I have a code body built in the following way:

void streamCheck(){
   if (ferror(stdin)){
      fprintf(stderr, "stdin err");
      exit(1);
   }
   if (ferror(stdout)){
      fprintf(stderr, "stdout err");
      exit(2);
   }
}

int main(){
   int c = getchar();
   streamCheck();
   ...
   putchar(c) 
   streamCheck();
}

are the return values of ferror(stdin) / ferror(stdout) impacted by the fact that I am checking them in a function rather than in the main? If there is a better way to do this also let me know I am quite new to C.

`main()` is a function, too. – John Bollinger May 13 '20 at 02:41 — John Bollinger, May 13 '20 at 02:41

score 2 · Answer 1 · answered May 13 '20 at 02:37

2

As long as you call ferror on a particular stream before calling any other function on that stream you should be fine.

It doesn't matter that ferror is being called from a different function that getchar or putchar was called from.

answered May 13 '20 at 02:37

dbush

205,898
23
218
273

Why the "before calling any other function" concern? `ferror()` results reflect history. – chux - Reinstate Monica May 13 '20 at 03:13
@chux-ReinstateMonica If for example you make two function calls that handle `stdout` before calling `ferror` you don't know which call triggered the error. – dbush May 13 '20 at 03:15

score 1 · Answer 2 · answered May 13 '20 at 02:42

There is no problem in your function. ferror() checks the error indicator of the FILE * that is passed as argument. In other words, the error indicator is a property of the file object and is directly obtainable from the FILE * pointer. Therefore, no matter where you call ferror() from, it will be able to determine if an error happened with the FILE * that is passed as argument (that is, of course, if the argument is valid).

score 0 · Answer 3 · answered May 13 '20 at 03:15

are the return values of ferror(stdin) / ferror(stdout) impacted by the fact that I am checking them in a function rather than in the main?

The return value of ferror() is characteristic of the current state of the stream that you provide as an argument. At any given time, the stdin provided by stdio.h refers to the same stream, with the same state, in every function, including main(). Therefore, you will obtain the same result by calling the ferror() function indirectly, via an intermediary function, as you would by calling it directly.

NEVERTHELESS, the approach you present in your example is poor. For the most part, C standard library functions indicate whether an error has occurred via their return values. In particular, getchar() returns a special value, represented by the macro EOF, if either the end of the file is encountered or an error occurs. This is typical of the stdio functions. You should consistently test functions' return values to recognize when exceptional conditions have occurred. For stream functions, you should call ferror() and / or feof() only after detecting such a condition, and only if you want to distinguish between the end-of-file case and the I/O error case (and the "neither" case for some functions). See also "Why is 'while ( !feof (file) )' always wrong?"

Personally, I probably would not write a generic function such as your streamCheck() at all, as error handling is generally situation specific. But if I did write one, then I'd certainly have it test just one stream that I specify to it. Something like this, for example:

void streamCheck(FILE *stream, const char *message, int exit_code) {
   if (ferror(stream)) {
      fputs(message, stderr);
      exit(exit_code);
   }
}

int main(void) {
   int c = getchar();

   if (c == EOF) {
       streamCheck(stdin, "stdin err\n", 1);
   }

   // ...

   if (putchar(c) == EOF) {
       streamCheck("stdout err\n", 2);
   }
}

correct me if I'm wrong but ```getchar()``` returns ```EOF``` for when the end of file is reached OR when an error occurs, but ```ferror(FILE* stream)``` only returns true if an error has occurred but not when end of file has been reached. So you can make less function calls since you are only checking for errors when ```EOF``` is returned? — nutella100, May 13 '20 at 19:17
@nutella100, yes, this answer explicitly observes that `getchar()` and most other stdio functions return EOF both on reaching the end of the file and on encountering an I/O error. You do make *many* fewer calls to `ferror()` if you only call it when an I/O function has returned `EOF`, and that's worthwhile. But I fear that you are missing a key point: as a much more general rule, **you need to check the return values of your function calls** and respond appropriately. The specific handling discussed here is a particular case of a broader principle. — John Bollinger, May 14 '20 at 20:21

Checking stdin and stdout using external function

3 Answers3