A function's prototype is similar to declaring the function in the calling routine?

Question

If there is no function prototype, a function is implicitly declared by its first appearance in an expression.

In C, if a function return anything else than int it is a good habit to declare the function inside the caller function like 1st example of code.

But you are always constrained by the compiler to write the prototype, the reason is that he does not know who the function is because it is declared underneath the main() function.

The question is: These two are equivalent? Will either writing the prototype or declaring explicitly the function inside the main() return the wanted result? How can it return a bad value if you are constrained always to use one of this two ways?

1. if the function is declared in the same script as the caller function is (here main())
   • prototype
   • declare explicitly function in main().
2. if the function is declared in another file
   • prototype
   • declare explicitly function in main()

E.g:

int main()
{
    double doSomething(int a);
    printf("%d", doSomething(2) );
}
double doSomething(int a)
{
     return a * 2.0;
}

vs

double doSomething(int a);

int main()
{
    printf("%d", doSomething(2) );
}
double doSomething(int a)
{
     return a * 2.0;
}

This thread is almost what i needed but it did not answer all my questions. C language - calling functions without function prototype

Answer 1

These two declarations are equivalent until in the first case the function doSomething will be required in some other function except main.

In this code snippet

int main()
{
    double doSomething(int a);
    //..

there is a function prototype of the function doSomething.

From the C Standard

A function prototype is a declaration of a function that declares the types of its parameters

That is before the function definition that is also its declaration the name of the function will be visible only in the block scope of main.

Consider the following program

#include <stdio.h>

void g( void )
{
    f( 20 );
}

int main(void) 
{
    void f( int );

    f( 10 );

    return 0;
}

void f( int x )
{
    printf( "x = %d\n", x );
}

The compiler will issue an error for this statement

    f( 20 );

because the name f is not yet declared.

But this statement

    f( 10 );

is correct because the name inside the block scope of main is already declared.

To make it more clear take into account that functions always has a linkage opposite to variables declared in a block scope without a storage class specifier.

So this declaration in main

    double doSomething(int a);

is equivalent to the declaration

    extern double doSomething(int a);

And the linker will find the function definition even if the function initially is declared in a block scope.

Answer 2

In modern C, you should always declare a function before using it. (That includes defining a function before using it, because a definition is a declaration.) Implicit declaration of functions to return int is a behavior of very old verions of C. It should not be used, compilers should at least warn about it, and you should set your compiler to make it an error, not a warning.

Functions are usually declared outside of other functions. There is nothing explicitly wrong about declaring a function inside another function, but we rarely do it because we generally want functions to be visible throughout a translation unit, not just in one specific place. (A translation unit is one source file together with all the files it includes via #include directives.) The names of functions obey the same scope rules as object names: If it appears outside of any function, it has file scope. If it appears inside a block (a list of statements inside braces, { … }, which includes function bodies), it has block scope and is only visible in that block.

Whether a function is declared at file scope or block scope will not affect how it behaves.

main is not special in this regard. You are likely asking about main because you are early in your programming education, and you mostly call functions just from main. However, functions may be called from other functions, and the rules about scope and name visibility are not particular to main. If a function is declared at file scope, its name is visible throughout the rest of the translation unit. If a function is declared at block scope, whether inside main or another function, its name is visible throughout the rest of that block.

If a function is defined to return double but you use it without declaring it, and your compiler allows that, then you can expect your program to work incorrectly. The compiler will not automatically convert double to int. The function type is important to tell the compiler what the function returns because the compiler expects certain bits to be in certain places when the function returns, and it writes instructions relying on that.