File pointer is valid

Question

I'm curious if any of NI's efforts at enhancing memory management has provided the ability to determine if a file pointer (stream handle) is valid prior to using it?
fopen is of type FILE *, and if fclose is called on it, then it's no longer valid but it's not NULL either.  I believe this is usually implemented as a malloc of a struct to hold the file info, so it's maybe the same issue as trying to determine if a malloc pointer is valid or not.
Is there any way to tell if a value of type FILE * is valid other than to try using it?  It's a fatal error if it's bad and you use it in an fclose, fread, fwrite, etc.  In std C, it's especially problematic since we can't catch the exception - you're guaranteed a program crash.
This may be an argument for using the WinAPI file functions Vs. the C std library file functions.
Thanks for any insight into this.

Answer 1

Actually, it would have been nice if fclose set the stream to NULL on its own, but I do set it to NULL after an fclose, and I check for the stream being NULL prior to every use.
My problem was with a multi-threaded app that could catch the file closed but the stream not yet NULL.
So I had to use a lock to coordinate access between the threads to prevent this.
fopen, fclose, fwrite etc are part of the C std library (as implemented by NI), as opposed to the OpenFile, CloseFile, WriteFile calls which use handles, as do the WinAPI file i/o calls.  The handle abstraction allows the implementation to avoid using a raw pointer that can be improperly dereferenced and cause an exception that a CVI C app can't catch.
It might be that the C89 / C99 std requires the std lib implementation to use a pointer for the stream, as the language calls it a "stream" but it's type is actually FILE *.
So I'm complaining about C std lib more so than the CVI std lib implementation I suppose.
After all, NI came up with its own CVI file I/O package separate from the C std lib file i/o, and NI did use handles for this other library.  If you misuse a handle, you don't get a fatal error, you get a return status indicating an error.  The issue is that the C std lib calls are standard (i.e. portable), and fairly easy to understand and use, so it'd be nice to use them.