True -- but this is only possible if you accept layering violations. To take an extreme example, how is printf() supposed to know that if a string parameter is NULL then it should error out without printing anything?
You should test return values, not parameters.
You don't have to check all possible instances of spurious arguments--you should be allowed to specify some preconditions--but you definitely have to check for error codes!
Example: Suppose we're writing a basic filesystem. We have the following primitive functions:
unsigned long getino(char pathname): For a given designated device and path, get the inode number of the designated file. Return 0 (there is no inode number 0) in case of error.
MINODE iget(unsigned long ino): For a given designated inode number, return a pointer to a data structure in memory containing the INODE data; allocated if necessary. Return NULL in case of error.
You can either test your return values from these functions, in which case you will do this:
unsigned long myIno = getino(path);
//error check myIno
MINODE * myMINODE = iget(myIno);
//error check myMINODE
or put some argument checking in iget() and do this: MINODE * myMINODE = iget(getino(path));
//error check myMINODE
How much argument checking has to go into iget()? Exactly this much: if (!ino) return NULL
It seemed like a neat idea at the time, and considering I called that particular composition of functions a dozen times in that project, there was a lot less repeating myself in teaching my functions to understand error codes. unsigned long getino(char * pathname):
For a given designated device and path, get the
inode number of the designated file. Return 0
(there is no inode number 0) in case of error.
Completely off-topic, but there is a bug in this prototype: Inode numbers have type ino_t, not type unsigned long.(Ok, two bugs, if you count the fact that there can theoretically be an inode number 0. And three bugs if you count the fact that pathname should be declared as a (const char *). But the ino_t vs. unsigned long bug is really bad if you care about portability.)
(edited to add paragraph:) Nothing I've said in this discussion should be taken as a strongly held opinion about anything--I'm rather shy about sharing these thoughts in the first place, but considered this particular example illustrative of a possibility I take seriously.
You do not want to see the other horrors that particular professor of mine has perpetrated, incidentally.
But that's C code, so I have to agree with you.
There is definitely waste involved in this--when composing functions this way, you have extra function calls and error-code checking on your parameters rather than checking data along the way and bailing out if there's a problem. Your functions have to check the arguments rather than having their preconditions enforced outside of them, which makes the composed functions less elegant. I don't know how practical it is in the end, but pushing most of the error-checking complexity into lower level functions and writing your upper level code in a compositional style sure seemed elegant every time I tried it.