我们可以在C中的main函数中定义函数原型吗？

Question

in my university our teacher taught us "we define function prototype before main function. Like:

#include<stdio.h>
void findmax(float, float);
int main()
{
    //code goes here
}

But today my friend showed me they learned they put prototype inside main function. Like:

#include<stdio.h>
int main()
{
    void findmax(float, float);

    float firstnum, secondnum;

    printf("Enter first:");
    scanf("%f", &firstnum);

    printf("Enter second:");
    scanf("%f", &secondnum);

    findmax(firstnum, secondnum);
}

void findmax(float x, float y)
{
    float maxnum;

    if(x>y)
    {
            maxnum=x;
    }

    else
    {
       maxnum=y;
    }

    printf("The max is %f", maxnum);
}

They both works.I wonder if there are differences between them. Thanks.

Answer 1

Can we define function prototype in main function in C?

Yes.

I wonder if there are differences between them

The difference is that in first snippet prototype is global while in second it is local to main . findmax will be visible after its declaration and/or definition.

#include<stdio.h>
void foo();
int main()
{
    void findmax(float, float); 
    foo();
    findmax(10, 20);  // It knows findmax by the prototype declared above
}

void findmax(float x, float y)
{
    float maxnum;

    if(x>y)
        maxnum=x;
    else
        maxnum=y;

    printf("The max is %f", maxnum);
}

void foo(){   // foo is using findmax after its definition.
    findmax(12, 30);
}

Answer 2

If you declare the function in main() it is scoped in the main() and you cannot access it in another function. But if you declare it at the start of the file or in a header file you can use it in any function.

Answer 3

If foo is declared in outside a function, it can be called from any function in the same file:

void foo(); // <-- global declaration

int main() {
  foo();    // <-- works, foo() is declared globally
}

void otherfunc() {
  foo();    // <-- works, foo() is declared globally
}

However, if foo is declared inside a function, it can only be used within the same scope:

int main() {
  void foo(); // <-- scoped declaration
  foo();      // works, foo() is declared in same scope
}

void otherfunc() {
  foo();      // ERROR: foo() is not declared in scope of otherfunc()
}

In either case, foo must be declared before it is used.

Answer 4

A straightforward answer to your question would simply be a YES. But when it comes to the scope, I'd like to add more.

What others suggest is right -- if you declare a function inside another function, the first one's scope is usually limited to the second one. For the example you provided, it is perfectly safe to say so. But that may not be the case always. Consider the following code:

#include <stdio.h>

/* Can be accessed from anywhere in this file
 * because defined before anything else.
 */
void print_hello() {
        puts("Hello!");
}

int main() {
        void print_hello(); /* Not needed actually */
        void print_namaste();
        void print_hi();

        print_namaste();
        print_hi();
}

/* The following two functions cannot be
 * accessed from within the above two functions
 * unless these two are declared inside them
 * or at the starting of this file
 */
void print_namaste() {
        puts("Namaste!");
        print_hello();
}

void print_hi() {
        puts("Hi!");
}

Here you can see that print_hello() is declared inside main() . But that is redundant. print_hello() has already been introduced into the compiler. There is no need of declaration to use it inside this file (if you use it inside other files and compile them independently, then you'll have to declare it inside those files or write a header file to do so). What my point is, declaring print_hello() inside main() has not rendered it local, at least in this example . You can see print_namaste() calling it successfully without any additional declaration.

But that is not the case with print_namaste() and print_hi() . They require declaration to be used from within main() because they are introduced to the compiler only after main() has been defined.

print_namaste() will only be visible to the functions inside which we declare it, and to those functions which are defined after print_namaste() . In this example, print_namaste() is not visible to print_hello() (unless declared inside it or before it), but visible to main() because declared inside it, and visible to print_hi because its definition comes only after the definition of print_namaste() .

Answer 5

In VC2008 the following is valid:

int main(void)
{
    void foo(void);
    //...
}
void test(void)
{
    foo();
}

My believe was that prototype declarations are valid anywhere and their scope is at least from the point of declaration to the end of file.

Looking at the C99 standard:

6.2.1 Scope of Identifiers

An identifier can denote an object; a function; a tag or a member of a structure, union, or enumeration; a typedef name; a label name; a macro name; or a macro parameter... For each different entity that an identifier designates, the identifier is visible (ie, can be used) only within a region of program text called its scope... identifier has scope determined by the placement of its declaration (in a declarator or type specifier). If the declarator or type specifier that declares the identifier appears outside of any block or list of parameters, the identifier has file scope, which terminates at the end of the translation unit. If the declarator or type specifier that declares the identifier appears inside a block or within the list of parameter declarations in a function definition, the identifier has block scope, which terminates at the end of the associated block.

This would mean that VC2008 is wrong.