extern and global in c

Can anyone please tell me is there any special requirement to use either EXTERN or GLOBAL variables in a C program? I do not see any difference in a program like below, if I change from gloabl to extern.

#include <stdio.h>
#include <stdlib.h>
int myGlobalvar = 10;

int main(int argc, char *argv[])
{
  int myFunc(int);
  int i;
  i = 12;
  myGlobalvar = 100;
  printf("Value of myGlobalvar is %d ,  i = %d\n", myGlobalvar, i);
  i = myFunc(10);
  printf("Value of passed value : %d\n",i);
  printf("again Value of myGlobalvar is %d ,  i = %d\n", myGlobalvar, i);
  system("PAUSE");  
  return 0;
}
int myFunc(int i)
{
    i = 20 + 1000;
//extern int myGlobalvar;
myGlobalvar = 20000;
//    printf("Value of passed value : %d",i);
return i;
}

If uncomment extern int myGlobalvar, the value does not change.

Is there any correct difference between both?

Can开发者_如何转开发 anyone please correct me?

The keyword extern means "the storage for this variable is allocated elsewhere". It tells the compiler "I'm referencing myGlobalvar here, and you haven't seen it before, but that's OK; the linker will know what you are talking about." In your specific example it's not particularly useful, because the compiler does know about myGlobalvar -- it's defined earlier in the same translation unit (.c or .cc file.) You normally use extern when you want to refer to something that is not in the current translation unit, such as a variable that's defined in a library you will be linking to.

(Of course, normally that library would declare the extern variables for you, in a header file that you should include.)

From Here:

A global variable in C/C++ is a variable which can be accessed from any module in your program.

int myGlobalVariable;

This allocates storage for the data, and tells the compiler that you want to access that storage with the name 'myGlobalVariable'.

But what do you do if you want to access that variable from another module in the program? You can't use the same statement given above, because then you'll have 2 variables named 'myGlobalVariable', and that's not allowed. So, the solution is to let your other modules DECLARE the variable without DEFINING it:

extern int myGlobalVariable;

This tells the compiler "there's a variable defined in another module called myGlobalVariable, of type integer. I want you to accept my attempts to access it, but don't allocate storage for it because another module has already done that".

Since myGlobalvar has been defined before the function myFunc. Its declaration inside the function is redundant.

But if the definition was after the function, we must have the declaration.

int myFunc(int i)
{
    i = 20 + 1000;
    extern int myGlobalvar; // Declaration must now.
    myGlobalvar = 20000;
    printf("Value of passed value : %d",i);
    return i;
}

int myGlobalvar = 10; // Def after the function.

In short: GLOBAL variables are declared in one file. But they can be accessed in another file only with the EXTERN word before (in this another file). In the same file, no need of EXTERN.

for example:

my_file.cpp

int global_var = 3;
int main(){
}

You can access the global variable in the same file. No need to use EXTERN:

my_file.cpp

int global_var = 3;
int main(){
    ++global_var;
    std::cout << global_var; // Displays '4'
}

Global variable, by definition, can also be accessed by all the other files. BUT, in this case, you need to access the global variable using EXTERN.

So, with my_file.cpp declaring the global_var, in other_file.cpp if you try this:

other_file.cpp

int main(){
    ++global_var; // ERROR!!! Compiler is complaining of a 'non-declared' variable
    std::cout << global_var; 
}

Instead, do:

int main(){
    extern int global_var;//Note: 'int global_var' without 'extern' would
                          // simply create a separate different variable
    ++global_var;         // and '++global_var' wouldn't work since it'll
                          // complain that the variable was not initiazed.
    std::cout << global_var; // WORKING: it shows '4'
}

myGlobalVar as you've defined it is a global variable, visible from all the places in your program. There's no need declaring it extern in the same .c file . That is useful for other .c files to let the compiler know this variable is going to be used.