Why can functions that return values be called without examining the returned value?

Question

I mean without assigning its value into a variable, and using it.

For example:

int foo(void);
void main()
{
    foo();
}
int foo()
{
    return(5);
}

Why I can not get any warning

What warning level have you specified to the compiler ? See https://stackoverflow.com/questions/2870529/g-how-to-get-warning-on-ignoring-function-return-value — hmjd, Mar 07 '19 at 17:30
@RobertHarvey He's asking why the compiler doesn't print a warning when you call a non-void function without using the value. — Barmar, Mar 07 '19 at 17:30
Oh, you mean "can you throw away the return value?" Of course. — Robert Harvey, Mar 07 '19 at 17:30
@EugeneSh. Of course, but compilers often warn about "perfectly valid" code that looks suspicious. They've evolved to include many features that used to be in `lint`. — Barmar, Mar 07 '19 at 17:33
Why are you lingering over this and why would it be a problem if the compiler did not throw a warning? — machine_1, Mar 07 '19 at 17:34
Same reason as using `i++` without using the expression value. — pmg, Mar 07 '19 at 18:27
@user10908164 What compiler are you using that did not warn about `void main()`? E.g. "warning: return type of 'main' is not 'int' [-Wmain]" — chux - Reinstate Monica, Mar 07 '19 at 18:32

Barmar · Answer 1 · 2019-03-07T18:33:10.420

Many functions return a value and also perform side effects, but they're often used just for their side effects.

For instance, printf() prints output and also returns the number of characters that were printed. But most of the time the return value is not interesting, so we don't assign it anywhere. fclose() returns a success indicator, but there's usually nothing a program can do if it fails, so they don't bother checking the result.

It would be tedious to have to write things like:

(void)printf(...);
(void)fclose(f);

all the time, so compilers generally don't warn about calling non-void functions without using the result.

This can be a problem in some cases. There are some functions where you really should use the return value, but it's a common mistake not to use it. For instance, realloc() returns the new pointer, but many beginners just assume that it will always resize the allocation that the old pointer points to.

Some IDEs probably have lists of functions that they should warn about for this reason. But compilers generally aren't as precise as that.

@chux Good point, although another problem with that is that you should assign it to a temporary variable, check for success, and only then reassign the original pointer. `p = realloc(p, new_size);` will pass the "is value used" test, but is still not defensive programming. — Barmar, Mar 07 '19 at 18:35

Govind Parmar · Accepted Answer · 2023-02-17T22:29:37.867

You are not obligated to store or examine a value returned from a function if you don't want to.

For example, printf returns an int representing the number of characters successfully written, but most of the time you just call printf to produce output on the screen; you don't care about the return value. For example:

printf("Hello World!\n");

Is a lot more common than:

if(printf("Hello World!\n") != 13)
    // printf failed

That said, there are a lot of static analysis tools that can enforce that code that calls certain functions must examine their return values. SAL, which I'm most familiar with, allows you to annotate a function with _Check_return_ or _Must_inspect_result_, and if you then call a function annotated as such without checking its return value, analysis will report a warning.

Example:

#include <sal.h>

_Must_inspect_result_
int foo()
{
    return 5;
}

int main(void)
{
    foo();
    return 0;
}

Running SAL analysis on this code produces the warning message:

C6031 Return value ignored: 'foo'.

Why can functions that return values be called without examining the returned value?

2 Answers2