Lately, I started using lint for static code analysis. One of the warning I get sometimes is regarding this issue. Let's say for instance that I've got the following function:
uint32_t foo( void );
And let's say that I delibertly ignore the return value of the function. To make the warning dissapear, one can write
(void) foo();
My question is, what is the "proper" way to write code like this, should I continue as I always did, since the compiler doesn't complain about it, or should I use the void for clarity, so other code maintainer will know that I delibertly ignored the return value.
When I look at the code like this ( with the void ), it looks pretty strange to me...
The common way is to just call foo(); without casting into (void).
He who has never ignored printf()'s return value, cast the first stone.
I personally like the "unused" warnings, but on occasion there are instances where I have to ignore them (e.g., the write() to user, or fscanf(...,"%*s\n") or strtol() where the return value is unimportant and I just want the side effect of [maybe] moving the file pointer along.)
With gcc 4.6, it's getting quite tricky.
- Casting to
(void)no longer works. - Re-writing functions (especially variadic) is tedious and clumsy.
{ssize_t ignore; ignore=write(...);}throws up another warning (assigned-not-used).write(...)+1throws up yet another warning (computed-value-not-used).
The only good (if ugly) way to suppress these is to convert the return value into something that the compiler agrees that you can ignore.
E.g., (void)(write(...)+1).
This is apparently progress. (And +0 does not work, BTW.)
One way to do this with Clang and GCC compilers is with a pragma:
/* ... */
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-result"
foo(); /* this specific unused-result warning gets ignored during compilation */
#pragma GCC diagnostic pop
/* ... */
The push-pop combination wraps the ignored directive so that warnings can be triggered elsewhere in your code. It should be easier for anyone reading your source code down the road to see what this code block does.
For a static code checker to be useful, it should report also the ignored return values, which can lead very often to difficult to track errors - or missing error handling.
So you should keep the (void) or deactivate the check for printf. Now you have several options for doing it in a readable manner. I use to wrap the function inside a new function like for example
void printf_unchecked(const char* format, ...)
where the not so nice cast takes place. Perhaps it's more practical to do it using a preprocessor macro in this case because of the varargs...
One slightly more "beautiful" way of indicating unused results would be this:
/**
* Wrapping your function call with ignore_result makes it more clear to
* readers, compilers and linters that you are, in fact, ignoring the
* function's return value on purpose.
*/
static inline void ignore_result(long long int unused_result) {
(void) unused_result;
}
...
ignore_result(foo());
With C++, this may be extended to:
template<typename T>
inline void ignore_result(T /* unused result */) {}
I like to compile my codes with the flags:
$gcc prog1.c -o prog1.x -Wall -Wextra -ansi -pedantic-errors -g -O0 -DDEBUG=1
And to avoid -Wunused-result I don't like the idea of adding another flag: -Wno-unused-result (if you do, thats one solution).
I used to cast to (void) for some functions (not printf or other famous, as the compilers dont warn about them, just the strange ones). Now casting to (void) does not work anymore (GCC 4.7.2)
Funny splint advises:
Result returned by function call is not used. If this is intended,
can cast result to (void) to eliminate message. (Use -retvalother to
inhibit warning)
But this is not a solution anymore. Splint needs an update regarding this issue.
So, to get rid of the warning in a very compatible way, here is a good MACRO:
/** Turn off -Wunused-result for a specific function call */
#define igr(M) if(1==((int)M)){;}
And call it like this:
igr(PL_get_chars(t, &s, CVT_VARIABLE));
Its a clean look, and any compiler will eliminate the code. Bellow a picture of my preferred editor vi: left window, no igr(); middle window, using igr(); right window, source.
You can see, its exactly the same, a completely innocuous code that let C do what gcc won't let: ignore the return code.
The comparison 1==... is necessary only to avoid splint warning that this conditional is no BOOL. GCC couldn't care less. Depending on the function, you might get a cast warning. I did a test ignoring a double with this MACRO and it was good, but somehow I'm not fully convinced. Specially if the function returns a pointer or something more complex.
In this case you will also need:
#define pigr(M) if(NULL==((void *)M)){;}
Last thing: the {;} is necessary because of the -Wempty-body warning (suggest braces around empty body in an ‘if’ statement).
And (now the last thing) the ; after the function call is not (strictly) necessary, but its good practice. Makes your code lines more homogeneous, all of them ending in a ;. (It's translated as a NOP mnemonic, and after optimization, disappear).
Running the compiler gives no warning or errors. Runing splint gives:
$ splint ./teste.c -I/usr/lib/swi-prolog/include/ -strict-lib
Splint 3.1.2 --- 20 Feb 2009
Finished checking --- no warnings
See also this answer
gnulib has this: http://git.savannah.gnu.org/cgit/gnulib.git/tree/lib/ignore-value.h
/* Normally casting an expression to void discards its value, but GCC
versions 3.4 and newer have __attribute__ ((__warn_unused_result__))
which may cause unwanted diagnostics in that case. Use __typeof__
and __extension__ to work around the problem, if the workaround is
known to be needed. */
#if 3 < __GNUC__ + (4 <= __GNUC_MINOR__)
# define ignore_value(x) \
(__extension__ ({ __typeof__ (x) __x = (x); (void) __x; }))
#else
# define ignore_value(x) ((void) (x))
#endif
Usually there are not too many functions the value of which you want to ignore. Splint, for example, allows to add a special comment that would let it know, that a return value of a specific function might be ignored. Unfortunately, this in effect disables all 'ignored returned value' warning related to that particular function.
Here is an example of Splint-clean program:
#include <stdio.h>
FILE /*@alt void@*/ *fopen(const char *path, const char *mode);
static int /*@alt void@*/ test(void)
{
printf( "test called\n" );
fopen( "test", "a" );
return 0;
}
int main(void)
{
test();
return 0;
}
The unpleasant part is that you need to add an additional prototype to a system function with a comment somewhere.
Btw,by default Splint doesn't complain about the return value of printf and of some other libc functions being unused. However, a stricter mode can be activated.
LINT allows something similar, but I have never used it. Here is what a documentation says.
LINT lets you mark functions with optional return values by using a directive similar to the #directives of the C preprocessor.
#pragma optresult
can be placed immediately before the definition of a function that returns an optional result. LINT then recognizes that this function returns a result that can be ignored; LINT does not give error messages if the result is ignored.
Other solution would be to actually use a value. Then you could remove the unused variable warning with a macro.
#define _unused(x) ((void)(x))
Then in your example, you'd have:
val = foo();
_unused(val);
It is entirely legal and acceptable to write code that ignores the return value in some cases. The program below has very little reason to check the return value of printf().
int main(void) {
printf("Hello world\n");
return 0;
}
来源：https://stackoverflow.com/questions/11888594/ignoring-return-values-in-c