Why is a function prototype not needed in C if there is no return in a function defined after main()?

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

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.)

> 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.