如果在 main() 之后定义的函数中没有返回值，为什么 C 中不需要函数原型？

Question

As expected following code generates an error if prototype double cubenum(); is not declared as required in C.

#include <stdio.h>
#include <stdlib.h>

int main()
{
    printf("Answer is: %f", cubenum(3.0));
    return 0;
}

double cubenum(double number){
    double result = number * number * number;
    return result;
}

Whereas if cubenum definition is above is replaced with following definition without return then it does not generate any error when cubenum prototype is not declared:

void cubenum(double number){
    double result = number * number * number;
    printf("Answer is: %f", result);
}

And when prototype is declared as void cubenum(); with above cubenum definition without return it generates following error:

||=== Build: Debug in xxx(compiler: GNU GCC Compiler) ===|
C:\xxx\main.c||In function 'main':|
C:\xxx\main.c|10|error: invalid use of void expression|
||=== Build failed: 1 error(s), 0 warning(s) (0 minute(s), 0 second(s)) ===|

Line 10 was when tested: printf("Answer is: %f", cubenum(3.0));

So, question is:

Why a function which does not have a return, prototype declaration is not required and if declared gives error in the above example?

GCC version info

gcc (MinGW.org GCC-6.3.0-1) 6.3.0

Answer 1

You have written your program in a way that is characteristic of very old C programs, dating to the 1980s or 1990s, before "prototyped" function declarations became preferred style. C compilers, to this day, bend over backwards to keep those very old programs working, preserving language features that they rely on, but that were never standardized or have been removed from the C standard since 1989.

Perfectly correct modern style for your first program would look like this:

#include <stdio.h>

double cubenum(double);

int main(void)
{
    printf("Answer is: %f", cubenum(3.0));
    return 0;
}

double cubenum(double number)
{
    double result = number * number * number;
    return result;
}

with a prototyped forward declaration of cubenum , double cubenum(double);

It's important to understand that double cubenum(); is NOT a prototyped declaration in C, but rather a declaration that says cubenum takes any number and type of arguments. If you wanted to specify that cubenum takes no arguments, you would have to write double cubenum(void); This is also why I changed int main() to int main(void) .

When you leave the forward declaration out entirely,

#include <stdio.h>

int main(void)
{
    printf("Answer is: %f", cubenum(3.0));
    return 0;
}

double cubenum(double number)
{
    double result = number * number * number;
    return result;
}

the C compiler sees a call to cubenum with no previous declaration for it at all. This was common in those very old C programs I mentioned. They relied on a feature called implicit declaration that was part of the original C standard but removed from its 1999 revision (commonly known as "C99"). Basically, the compiler assumes that the programmer meant to write int cubenum(); above main , but lazily left it out. This means cubenum takes any number and type of arguments (NOT that it takes no arguments) and returns int . So, leaving main out of it for now, it's like you wrote

int cubenum();
double cubenum(double number) { ... }

and the compiler rejects the program because the definition of cubenum has a different return type from the (implicit) forward declaration. That part I think you already understood.

Now, when you change cubenum to return nothing, so your complete program is

#include <stdio.h>

int main(void)
{
    printf("Answer is: %f", cubenum(3.0));
    return 0;
}

void cubenum(double number)
{
    double result = number * number * number;
    printf("Answer is: %f", result);
}

the implicit function declaration is still int cubenum() and the prototype from the function definition is void cubenum(double) . As another compatibility feature for those very old C programs, these are considered not to be conflicting return types, and the compiler accepts the program. This is because the type void was invented in the 1989 C standard. Programs written before then would have instead given cubenum no return type at all...

cubenum(number)
    double number;
{
    double result = number * number * number;
    printf("Answer is: %f", result);
}

... which technically declares it to return int ! Immediately post-C89, those programs got updated to give their functions with no return value the type void , but it was too much work to stop relying on implicit declarations for them at the same time, so compilers grew a special case where int foo() and void foo() are considered not to be in conflict.

(Incidentally, because of yet another backward compatibility consideration — "old-style function definitions", which you can see in the above code fragment — preferred style in C is to put the opening curly brace of a function definition on its own line, even if all other opening braces are "cuddled".)

And finally, when you do put void cubenum(); above main , only then is the compiler officially aware that cubenum returns nothing. When it does know that, it knows that printf("%f", cubenum(3.0)); is incorrect because it's using the nonexistent return value of cubenum , and it rejects the program for that reason.

---

You shouldn't be relying on any of these backward compatibility features in a new program. I see that you are using GCC, so set your compilation options to something like this:

-std=gnu11 -g -Og -Wall -Wpedantic -Wstrict-prototypes -Wold-style-definition -Werror

which will disable almost all of the backward compatibility features. (There are a whole lot more warning options and you may want to consider turning on more of them. -Wwrite-strings and -Wextra are particularly useful for new code IMNSHO.) (Do NOT use the hyper-conformant mode, -std=c11 , until you know considerably more about what you are doing; it can break the system headers, and it enables the "trigraph" misfeature that you almost certainly don't want.)

Answer 2

Whereas if cubenum definition is above is replaced with following definition without return then it does not generate any error when cubenum prototype is not declared:

Because when you don't have explicit declaration for a function, some C compilers will do it implicitly. Normally, it gives int for both return type and arguments.

A good-enough compiler should inform you about implicit declaration.

It's dangerous, because compiler won't know the exact prototype of the function.So you may have a very unpredictable result.

And when prototype is declared as void cubenum(); with above cubenum definition without return it generates following error:

This is another problem, since you try to printf the return value of a void function.