Global variable initialized to 1 instead of 0 in my C program - c

Question

If I have, suppose, initialized a global variable F, and print its value in main function, 0 will be printed (as it should be).
But when i pass the argument int F in the main function while declaring the global variable F in exact same way as before, printing the value of F using gcc prints 1.
Can anyone explain why is that?
This is my code below.
#include<stdio.h>
int F;
int main(int F){
printf("F is %d\n", F);
return 0;
}

Answer 1

When your main function contains an argument with the same name as a global variable then the stub is refered to the local variable .. not the global variable
#include <stdio.h>
static int F;
int main(){
printf("F is %d", F);
return 0;
}

Answer 2

But when i pass the argument int F in the main function  ? that F is nothing but argument count i.e argc.
In particular case you mentioned global F and F you declared in main() argument are different.
int main(int F){ printf("F is %d\n", F); return 0; }
Here printf() prints 1 because when you run your executable like ./a.out no of command line input is 1, it's similar to argc.
Your compiler could have warn you about argument provided to main(), compile with -Wall flag and read the warning. Also check the main() prototype. From the C standard
ISO/IEC 9899:1999
§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 intand 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[]) { / ... */ }
or equivalent;9) or in some other implementation-defined manner.

Answer 3

In your posted code, main has an argument named F. Inside main, any references to F refer that variable, not the global one.
You make life unnecessarily harder by using improper names of variables. Most of the time, the arguments to main are named argc and argv -- argument count and argument values.
int main(int argc, char** argv) { ... }
It's good to use variable names that have meaning. Using int F; as a global variable is not meaningful either. Name it such that it is meaningful. Then, you will run into problems like you did a lot less.

Answer 4

You should make main() conform to the requirements of the standard, and you should print the global F as well as the argument F:
#include <stdio.h>
int F;
int main(int F, char **G)
{
printf("F is %d\n", F);
{
extern int F;
printf("%s: F is %d\n", G[0], F);
}
return 0;
}
When compiled (from source file quirky43.c to program quirky43), and run, I get:
$ gcc -O3 -g -std=c11 -Wall -Wextra -Werror quirky43.c -o quirky43
$ ./quirky43
F is 1
quirky43: F is 0
$ ./quirky43 this is why you get command line arguments
F is 9
quirky43: F is 0
$
The first printf() is printing the first argument to main() (conventionally called argc, but there's nothing wrong with calling it F except that it is unexpected). The second one prints the global variable F (and also the program name, conventionally argv[0] but again there's nothing wrong with using G except that it is unexpected). The extern int F; inside a set of braces means that F in that statement block refers to a variable F defined outside the enclosing scope, which means the file scope variable F — which, it may be noted, is correctly initialized to 0. The 1 comes because you invoked the program without arguments, and the argument count includes the program name. It's also why the value printed was 9 when 8 arguments were added to the command line.
Note that another good compilation option to use is -Wshadow:
$ gcc -O3 -g -std=c11 -Wall -Wextra -Werror -Wshadow quirky43.c -o quirky43
quirky43.c: In function ‘main’:
quirky43.c:6:14: error: declaration of ‘F’ shadows a global declaration [-Werror=shadow]
int main(int F, char **G)
~~~~^
quirky43.c:4:5: note: shadowed declaration is here
int F;
^
cc1: all warnings being treated as errors
$
(Compilation with GCC 8.1.0 on a Mac running macOS High Sierra 10.13.5.)