2

So I'm learning about functions in a book.

  1. It says we need to prototype or declare functions so the compiler can understand if they are correctly called or not.

But why does the main function works without a prototype?

  1. I used to write main functions in my learning process like this:

    int main(void)

    So it will not get any argument because of (void)

    I tried to run my program with argument for example > ./a.out 2

    int main(int y){ printf("%s %d\n","y is",y); }

    When I run it normally y is 1, when run it with > ./a.out 1 y is 2, when there is more than one argument it increases by one. So it's not the right way but what causes this?

    Declaring y as char says nothing so my guess is it works like the return value of scanf(). It returns number of successful inputs.

Improve this question
5
  • 1
    I think here contains some of your questions' answers, you can look. Commented Mar 31, 2021 at 12:43
  • Ask the questions separately. When you ask several different questions at the same time, people knowing answers to only some of them might be reluctant to reply as they aren't able to provide the full answer. Commented Mar 31, 2021 at 12:43
  • Spend several days in reading Advanced Linux Programming and syscalls(2). I guess you are using Linux. Like GNU bash, the Linux kernel is free software and you are allowed to download and study its source code Commented Mar 31, 2021 at 13:13
  • @BasileStarynkevitch yeah im using linux. btw thanks for that book recommendation. seems like what i was looking for my last question Commented Mar 31, 2021 at 14:18
  • Read documentation of GCC and of GDB then compile your C code with gcc -Wall -Wextra -g Commented Mar 31, 2021 at 16:46

2 Answers 2

Reset to default
3

A function must be either declared (i.e. a prototype) or defined before it is called. The main function is different from other functions in that it's called by the program startup code and not some other function.

There are however restrictions on what the signature of main can be. On a regular hosted implementation, the C standard says it can be either:

int main(void)

Or:

int main(int argc, char **argv)

The latter case is used to read command line arguments. argc contains the number of arguments passes, including the program name. argv contains the actual arguments as an array of char *.

Many systems also support:

int main(int argc, char **argv, char **envp)

Where envp contains the environment variables known to the program.

The prototype you're using: int main(int y) is not supported in any implementation I'm aware of, so attempting to use such a prototype for main invokes undefined behavior.

Improve this answer
Sign up to request clarification or add additional context in comments.

4 Comments

thank you. but argc and y both works as number of arguments
main being called by the startup code has nothing to do with whether a “prototype” is needed. (“Prototype” is the wrong term; the C standard defines this as a function declaration that includes the parameter types, in contrast to (). What is really at issue here is a function declaration.) In modern C, all function identifiers must be declared before they are used. main is declared in its definition and does not need any separate declaration because it is not usually otherwise used in the C source code of a program. If it is used, it needs a declaration, the same as any other identifier.
@IMIEEET The name given to the arguments can be freely changed. The part that's important is the number and types of the arguments.
@IMIEEET: The standard declarations for main that the C standard provides are int main(void) and int main(int, char **), where any parameter names can be filled in after the int and the char **. The names are irrelevant, but the specific forms are relevant: To match one of these forms, you must either have void or you must have two parameters, the first of type int and the second of type char **. int main(int) does not match one of those, so using it violates a rule in the C standard unless your implementation defines it.
1

When I run it normally y is 1, when run it with > ./a.out 1 y is 2, when there is more than one argument it increases by one. So it's not the right way but what causes this?

The standard entry for program startup kind of answers both your questions:

N1570 § 5.1.2.2.1 Program startup

1 The function called at program startup is named main. The implementation declares no prototype for this function. It shall be defined with a return type of int and with no parameters:

 int main(void) { /* ... */ }

or with two parameters (referred to here as argc and argv, though any names may be used, as they are local to the function in which they are declared):

 int main(int argc, char *argv[]) { /* ... */ }

[...]

As dbush already stated in the accepted answer these are the only two main implementations allowed by the standard.

The standard leaves the responsability of dealing with undefined constructs opened and imposes no requirements for what the behavior should be, a given implementation may deal with the situation in any way it considers appropriate, this is known as undefined behavior.

What seems to be happening is that your compiler is assuming that y is argc, which is allowed (as you can see in the second snippet of highlighted citation above), and argc stores the number of arguments in the command line, which is consistent with the results you're having, but again, this behavior may differ in different compilers, systems or even versions of the same compiler.

Improve this answer

Comments

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.