How do I use extern to share variables between source files

Question

I know that global variables in C sometimes have the extern keyword  What is an extern variable  What is the declaration like  What is its scope   This is related to sharing variables across source files  but how does that work precisely  Where do I use extern

User · Answer

Extern is the keyword you use to declare that the variable itself resides in another translation unit.

So you can decide to use a variable in a translation unit and then access it from another one, then in the second one you declare it as extern and the symbol will be resolved by the linker.

If you don't declare it as extern you'll get 2 variables named the same but not related at all, and an error of multiple definitions of the variable.

User · Answer

Using extern is only of relevance when the program you re building consists of multiple source files linked together  where some of the variables defined  for example  in source file file1 c need to be referenced in other source files  such as file2 c  It is important to understand the difference between defining a variable and declaring a variable   A variable is declared when the compiler is informed that a variable exists  and this is its type   it does not allocate the storage for the variable at that point   A variable is defined when the compiler allocates the storage for the variable    You may declare a variable multiple times  though once is sufficient   you may only define it once within a given scope  A variable definition is also a declaration  but not all variable declarations are definitions  Best way to declare and define global variables The clean  reliable way to declare and define global variables is to use a header file to contain an extern declaration of the variable  The header is included by the one source file that defines the variable and by all the source files that reference the variable  For each program  one source file  and only one source file  defines the variable  Similarly  one header file  and only one header file  should declare the variable  The header file is crucial  it enables cross-checking between independent TUs  translation units     think source files  and ensures consistency  Although there are other ways of doing it  this method is simple and reliable  It is demonstrated by file3 h  file1 c and file2 c  file3 h extern int global variable      Declaration of the variable     file1 c  include  quot file3 h quot      Declaration made available here     include  quot prog1 h quot      Function declarations        Variable defined here    int global variable   37        Definition checked against declaration     int increment void    return global variable       file2 c  include  quot file3 h quot   include  quot prog1 h quot   include  lt stdio h gt   void use it void        printf  quot Global variable   d n quot   global variable        That s the best way to declare and define global variables   The next two files complete the source for prog1  The complete programs shown use functions  so function declarations have crept in  Both C99 and C11 require functions to be declared or defined before they are used  whereas C90 did not  for good reasons   I use the keyword extern in front of function declarations in headers for consistency      to match the extern in front of variable declarations in headers  Many people prefer not to use extern in front of function declarations  the compiler doesn t care     and ultimately  neither do I as long as you re consistent  at least within a source file  prog1 h extern void use it void   extern int increment void    prog1 c  include  quot file3 h quot   include  quot prog1 h quot   include  lt stdio h gt   int main void        use it        global variable    19      use it        printf  quot Increment   d n quot   increment         return 0      prog1 uses prog1 c  file1 c  file2 c  file3 h and prog1 h   The file prog1 mk is a makefile for prog1 only  It will work with most versions of make produced since about the turn of the millennium  It is not tied specifically to GNU Make  prog1 mk   Minimal makefile for prog1  PROGRAM   prog1 FILES c   prog1 c file1 c file2 c FILES h   prog1 h file3 h FILES o     FILES c  c  o   CC        gcc SFLAGS    -std c11 GFLAGS    -g OFLAGS    -O3 WFLAG1    -Wall WFLAG2    -Wextra WFLAG3    -Werror WFLAG4    -Wstrict-prototypes WFLAG5    -Wmissing-prototypes WFLAGS      WFLAG1    WFLAG2    WFLAG3    WFLAG4    WFLAG5  UFLAGS      Set on command line only  CFLAGS      SFLAGS    GFLAGS    OFLAGS    WFLAGS    UFLAGS  LDFLAGS   LDLIBS     all       PROGRAM     PROGRAM     FILES o        CC  -o      CFLAGS    FILES o    LDFLAGS    LDLIBS   prog1 o    FILES h  file1 o    FILES h  file2 o    FILES h     If it exists  prog1 dSYM is a directory on macOS DEBRIS   a out core      dSYM RM FR    rm -fr  clean        RM FR    FILES o    PROGRAM    DEBRIS     Guidelines Rules to be broken by experts only  and only with good reason   A header file only contains extern declarations of variables     never static or unqualified variable definitions   For any given variable  only one header file declares it  SPOT     Single Point of Truth    A source file never contains extern declarations of variables     source files always include the  sole  header that declares them   For any given variable  exactly one source file defines the variable  preferably initializing it too    Although there is no need to initialize explicitly to zero  it does no harm and can do some good  because there can be only one initialized definition of a particular global variable in a program    The source file that defines the variable also includes the header to ensure that the definition and the declaration are consistent   A function should never need to declare a variable using extern   Avoid global variables whenever possible     use functions instead    The source code and text of this answer are available in my SOQ  Stack Overflow Questions  repository on GitHub in the src so-0143-3204 sub-directory   If you re not an experienced C programmer  you could  and perhaps should  stop reading here   Not so good way to define global variables With some  indeed  many  C compilers  you can get away with what s called a  common  definition of a variable too   Common   here  refers to a technique used in Fortran for sharing variables between source files  using a  possibly named  COMMON block  What happens here is that each of a number of files provides a tentative definition of the variable  As long as no more than one file provides an initialized definition  then the various files end up sharing a common single definition of the variable  file10 c  include  quot prog2 h quot   long l       Do not do this in portable code     void inc void    l       file11 c  include  quot prog2 h quot   long l       Do not do this in portable code     void dec void    l--     file12 c  include  quot prog2 h quot   include  lt stdio h gt   long l   9       Do not do this in portable code     void put void    printf  quot l    ld n quot   l      This technique does not conform to the letter of the C standard and the  one definition rule      it is officially undefined behaviour   J 2 Undefined behavior   An identifier with external linkage is used  but in the program there does not exist exactly one external definition for the identifier  or the identifier is not used and there exist multiple external definitions for the identifier  6 9       6 9 External definitions   5   An external definition is an external declaration that is also a definition of a function  other than an inline definition  or an object  If an identifier declared with external linkage is used in an expression  other than as part of the operand of a sizeof or  Alignof operator whose result is an integer constant   somewhere in the entire program there shall be exactly one external definition for the identifier  otherwise  there shall be no more than one 161    161  Thus  if an identifier declared with external linkage is not used in an expression  there need be no external definition for it   However  the C standard also lists it in informative Annex J as one of the Common extensions   J 5 11 Multiple external definitions   There may be more than one external definition for the identifier of an object  with or without the explicit use of the keyword extern  if the definitions disagree  or more than one is initialized  the behavior is undefined  6 9 2    Because this technique is not always supported  it is best to avoid using it  especially if your code needs to be portable  Using this technique  you can also end up with unintentional type punning  If one of the files above declared l as a double instead of as a long  C s type-unsafe linkers probably would not spot the mismatch  If you re on a machine with 64-bit long and double  you d not even get a warning  on a machine with 32-bit long and 64-bit double  you d probably get a warning about the different sizes     the linker would use the largest size  exactly as a Fortran program would take the largest size of any common blocks  Note that GCC 10 1 0  which was released on 2020-05-07  changes the default compilation options to use -fno-common  which means that by default  the code above no longer links unless you override the default with -fcommon  or use attributes  etc     see the link    The next two files complete the source for prog2  prog2 h extern void dec void   extern void put void   extern void inc void    prog2 c  include  quot prog2 h quot   include  lt stdio h gt   int main void        inc        put        dec        put        dec        put        prog2 uses prog2 c  file10 c  file11 c  file12 c  prog2 h    Warning As noted in comments here  and as stated in my answer to a similar question  using multiple definitions for a global variable leads to undefined behaviour  J 2    6 9   which is the standard s way of saying  quot anything could happen quot   One of the things that can happen is that the program behaves as you expect  and J 5 11 says  approximately   quot you might be lucky more often than you deserve quot   But a program that relies on multiple definitions of an extern variable     with or without the explicit  extern  keyword     is not a strictly conforming program and not guaranteed to work everywhere  Equivalently  it contains a bug which may or may not show itself  Violating the guidelines There are  of course  many ways in which these guidelines can be broken  Occasionally  there may be a good reason to break the guidelines  but such occasions are extremely unusual  faulty header h int some var        Do not do this in a header        Note 1  if the header defines the variable without the extern keyword  then each file that includes the header creates a tentative definition of the variable  As noted previously  this will often work  but the C standard does not guarantee that it will work  broken header h int some var   13        Only one source file in a program can use this     Note 2  if the header defines and initializes the variable  then only one source file in a given program can use the header  Since headers are primarily for sharing information  it is a bit silly to create one that can only be used once  seldom correct h static int hidden global   3       Each source file gets its own copy      Note 3  if the header defines a static variable  with or without initialization   then each source file ends up with its own private version of the  global  variable  If the variable is actually a complex array  for example  this can lead to extreme duplication of code   It can  very occasionally  be a sensible way to achieve some effect  but that is very unusual   Summary Use the header technique I showed first  It works reliably and everywhere  Note  in particular  that the header declaring the global variable is included in every file that uses it     including the one that defines it  This ensures that everything is self-consistent  Similar concerns arise with declaring and defining functions     analogous rules apply  But the question was about variables specifically  so I ve kept the answer to variables only  End of Original Answer If you re not an experienced C programmer  you probably should stop reading here   Late Major Addition Avoiding Code Duplication One concern that is sometimes  and legitimately  raised about the  declarations in headers  definitions in source  mechanism described here is that there are two files to be kept synchronized     the header and the source   This is usually followed up with an observation that a macro can be used so that the header serves double duty     normally declaring the variables  but when a specific macro is set before the header is included  it defines the variables instead  Another concern can be that the variables need to be defined in each of a number of  main programs    This is normally a spurious concern  you can simply introduce a C source file to define the variables and link the object file produced with each of the programs  A typical scheme works like this  using the original global variable illustrated in file3 h  file3a h  ifdef DEFINE VARIABLES  define EXTERN    nothing     else  define EXTERN extern  endif    DEFINE VARIABLES     EXTERN int global variable   file1a c  define DEFINE VARIABLES  include  quot file3a h quot      Variable defined - but not initialized     include  quot prog3 h quot   int increment void    return global variable       file2a c  include  quot file3a h quot   include  quot prog3 h quot   include  lt stdio h gt   void use it void        printf  quot Global variable   d n quot   global variable         The next two files complete the source for prog3  prog3 h extern void use it void   extern int increment void    prog3 c  include  quot file3a h quot   include  quot prog3 h quot   include  lt stdio h gt   int main void        use it        global variable    19      use it        printf  quot Increment   d n quot   increment         return 0      prog3 uses prog3 c  file1a c  file2a c  file3a h  prog3 h    Variable initialization The problem with this scheme as shown is that it does not provide for initialization of the global variable   With C99 or C11 and variable argument lists for macros  you could define a macro to support initialization too   With C89 and no support for variable argument lists in macros  there is no easy way to handle arbitrarily long initializers   file3b h  ifdef DEFINE VARIABLES  define EXTERN                     nothing     define INITIALIZER                 VA ARGS    else  define EXTERN                  extern  define INITIALIZER                nothing     endif    DEFINE VARIABLES     EXTERN int global variable INITIALIZER 37   EXTERN struct   int a  int b    oddball struct INITIALIZER   41  43      Reverse contents of  if and  else blocks  fixing bug identified by Denis Kniazhev file1b c  define DEFINE VARIABLES  include  quot file3b h quot      Variables now defined and initialized     include  quot prog4 h quot   int increment void    return global variable      int oddball value void    return oddball struct a   oddball struct b      file2b c  include  quot file3b h quot   include  quot prog4 h quot   include  lt stdio h gt   void use them void        printf  quot Global variable   d n quot   global variable         oddball struct a    global variable      oddball struct b -  global variable   2     Clearly  the code for the oddball structure is not what you d normally write  but it illustrates the point   The first argument to the second invocation of INITIALIZER is   41 and the remaining argument  singular in this example  is 43     Without C99 or similar support for variable argument lists for macros  initializers that need to contain commas are very problematic  Correct header file3b h included  instead of fileba h  per Denis Kniazhev  The next two files complete the source for prog4  prog4 h extern int increment void   extern int oddball value void   extern void use them void    prog4 c  include  quot file3b h quot   include  quot prog4 h quot   include  lt stdio h gt   int main void        use them        global variable    19      use them        printf  quot Increment   d n quot   increment         printf  quot Oddball     d n quot   oddball value         return 0      prog4 uses prog4 c  file1b c  file2b c  prog4 h  file3b h    Header Guards Any header should be protected against reinclusion  so that type definitions  enum  struct or union types  or typedefs generally  do not cause problems   The standard technique is to wrap the body of the header in a header guard such as   ifndef FILE3B H INCLUDED  define FILE3B H INCLUDED     contents of header      endif    FILE3B H INCLUDED     The header might be included twice indirectly   For example  if file4b h includes file3b h for a type definition that isn t shown  and file1b c needs to use both header file4b h and file3b h  then you have some more tricky issues to resolve   Clearly  you might revise the header list to include just file4b h   However  you might not be aware of the internal dependencies     and the code should  ideally  continue to work  Further  it starts to get tricky because you might include file4b h before including file3b h to generate the definitions  but the normal header guards on file3b h would prevent the header being reincluded  So  you need to include the body of file3b h at most once for declarations  and at most once for definitions  but you might need both in a single translation unit  TU     a combination of a source file and the headers it uses   Multiple inclusion with variable definitions However  it can be done subject to a not too unreasonable constraint  Let s introduce a new set of file names   external h for the EXTERN macro definitions  etc   file1c h to define types  notably  struct oddball  the type of oddball struct    file2c h to define or declare the global variables   file3c c which defines the global variables   file4c c which simply uses the global variables   file5c c which shows that you can declare and then define the global variables   file6c c which shows that you can define and then  attempt to  declare the global variables    In these examples  file5c c and file6c c directly include the header file2c h several times  but that is the simplest way to show that the mechanism works   It means that if the header was indirectly included twice  it would also be safe  The restrictions for this to work are   The header defining or declaring the global variables may not itself define any types   Immediately before you include a header that should define variables  you define the macro DEFINE VARIABLES   The header defining or declaring the variables has stylized contents    external h       This header must not contain header guards  like  lt assert h gt  must not      Each time it is invoked  it redefines the macros EXTERN  INITIALIZE    based on whether macro DEFINE VARIABLES is currently defined      undef EXTERN  undef INITIALIZE   ifdef DEFINE VARIABLES  define EXTERN                 nothing     define INITIALIZE              VA ARGS    else  define EXTERN              extern  define INITIALIZE             nothing     endif    DEFINE VARIABLES     file1c h  ifndef FILE1C H INCLUDED  define FILE1C H INCLUDED  struct oddball       int a      int b      extern void use them void   extern int increment void   extern int oddball value void     endif    FILE1C H INCLUDED      file2c h     Standard prologue     if defined DEFINE VARIABLES   amp  amp   defined FILE2C H DEFINITIONS   undef FILE2C H INCLUDED  endif   ifndef FILE2C H INCLUDED  define FILE2C H INCLUDED   include  quot external h quot       Support macros EXTERN  INITIALIZE     include  quot file1c h quot         Type definition for struct oddball      if  defined DEFINE VARIABLES      defined FILE2C H DEFINITIONS      Global variable declarations   definitions    EXTERN int global variable INITIALIZE 37   EXTERN struct oddball oddball struct INITIALIZE   41  43       endif     DEFINE VARIABLES     FILE2C H DEFINITIONS        Standard epilogue     ifdef DEFINE VARIABLES  define FILE2C H DEFINITIONS  endif    DEFINE VARIABLES      endif    FILE2C H INCLUDED     file3c c  define DEFINE VARIABLES  include  quot file2c h quot      Variables now defined and initialized     int increment void    return global variable      int oddball value void    return oddball struct a   oddball struct b      file4c c  include  quot file2c h quot   include  lt stdio h gt   void use them void        printf  quot Global variable   d n quot   global variable         oddball struct a    global variable      oddball struct b -  global variable   2      file5c c   include  quot file2c h quot         Declare variables      define DEFINE VARIABLES  include  quot file2c h quot      Variables now defined and initialized     int increment void    return global variable      int oddball value void    return oddball struct a   oddball struct b      file6c c   define DEFINE VARIABLES  include  quot file2c h quot         Variables now defined and initialized      include  quot file2c h quot         Declare variables     int increment void    return global variable      int oddball value void    return oddball struct a   oddball struct b       The next source file completes the source  provides a main program  for prog5  prog6 and prog7  prog5 c  include  quot file2c h quot   include  lt stdio h gt   int main void        use them        global variable    19      use them        printf  quot Increment   d n quot   increment         printf  quot Oddball     d n quot   oddball value         return 0      prog5 uses prog5 c  file3c c  file4c c  file1c h  file2c h  external h   prog6 uses prog5 c  file5c c  file4c c  file1c h  file2c h  external h   prog7 uses prog5 c  file6c c  file4c c  file1c h  file2c h  external h     This scheme avoids most problems   You only run into a problem if a header that defines variables  such as file2c h  is included by another header  say file7c h  that defines variables   There isn t an easy way around that other than  quot don t do it quot   You can partially work around the problem by revising file2c h into file2d h  file2d h    Standard prologue     if defined DEFINE VARIABLES   amp  amp   defined FILE2D H DEFINITIONS   undef FILE2D H INCLUDED  endif   ifndef FILE2D H INCLUDED  define FILE2D H INCLUDED   include  quot external h quot       Support macros EXTERN  INITIALIZE     include  quot file1c h quot         Type definition for struct oddball      if  defined DEFINE VARIABLES      defined FILE2D H DEFINITIONS      Global variable declarations   definitions    EXTERN int global variable INITIALIZE 37   EXTERN struct oddball oddball struct INITIALIZE   41  43       endif     DEFINE VARIABLES     FILE2D H DEFINITIONS        Standard epilogue     ifdef DEFINE VARIABLES  define FILE2D H DEFINITIONS  undef DEFINE VARIABLES  endif    DEFINE VARIABLES      endif    FILE2D H INCLUDED     The issue becomes  should the header include  undef DEFINE VARIABLES   If you omit that from the header and wrap any defining invocation with  define and  undef   define DEFINE VARIABLES  include  quot file2c h quot   undef DEFINE VARIABLES  in the source code  so the headers never alter the value of DEFINE VARIABLES   then you should be clean   It is just a nuisance to have to remember to write the the extra line   An alternative might be   define HEADER DEFINING VARIABLES  quot file2c h quot   include  quot externdef h quot   externdef h       This header must not contain header guards  like  lt assert h gt  must not      Each time it is included  the macro HEADER DEFINING VARIABLES should    be defined with the name  in quotes - or possibly angle brackets  of    the header to be included that defines variables when the macro    DEFINE VARIABLES is defined   See also  external h  which uses    DEFINE VARIABLES and defines macros EXTERN and INITIALIZE    appropriately          define HEADER DEFINING VARIABLES  quot file2c h quot      include  quot externdef h quot       if defined HEADER DEFINING VARIABLES   define DEFINE VARIABLES  include HEADER DEFINING VARIABLES  undef DEFINE VARIABLES  undef HEADER DEFINING VARIABLES  endif    HEADER DEFINING VARIABLES      This is getting a tad convoluted  but seems to be secure  using the file2d h  with no  undef DEFINE VARIABLES in the file2d h   file7c c    Declare variables     include  quot file2d h quot      Define variables     define HEADER DEFINING VARIABLES  quot file2d h quot   include  quot externdef h quot      Declare variables - again     include  quot file2d h quot      Define variables - again     define HEADER DEFINING VARIABLES  quot file2d h quot   include  quot externdef h quot   int increment void    return global variable      int oddball value void    return oddball struct a   oddball struct b      file8c h    Standard prologue     if defined DEFINE VARIABLES   amp  amp   defined FILE8C H DEFINITIONS   undef FILE8C H INCLUDED  endif   ifndef FILE8C H INCLUDED  define FILE8C H INCLUDED   include  quot external h quot       Support macros EXTERN  INITIALIZE     include  quot file2d h quot         struct oddball      if  defined DEFINE VARIABLES      defined FILE8C H DEFINITIONS      Global variable declarations   definitions    EXTERN struct oddball another INITIALIZE   14  34       endif     DEFINE VARIABLES     FILE8C H DEFINITIONS        Standard epilogue     ifdef DEFINE VARIABLES  define FILE8C H DEFINITIONS  endif    DEFINE VARIABLES      endif    FILE8C H INCLUDED      file8c c    Define variables     define HEADER DEFINING VARIABLES  quot file2d h quot   include  quot externdef h quot      Define variables     define HEADER DEFINING VARIABLES  quot file8c h quot   include  quot externdef h quot   int increment void    return global variable      int oddball value void    return oddball struct a   oddball struct b       The next two files complete the source for prog8 and prog9  prog8 c  include  quot file2d h quot   include  lt stdio h gt   int main void        use them        global variable    19      use them        printf  quot Increment   d n quot   increment         printf  quot Oddball     d n quot   oddball value         return 0     file9c c  include  quot file2d h quot   include  lt stdio h gt   void use them void        printf  quot Global variable   d n quot   global variable         oddball struct a    global variable      oddball struct b -  global variable   2       prog8 uses prog8 c  file7c c  file9c c   prog9 uses prog8 c  file8c c  file9c c     However  the problems are relatively unlikely to occur in practice  especially if you take the standard advice to A

User · Answer

declare   define     initialize                   ----------------------------------  extern int a     yes          no           no ------------- int a   2019     yes          yes          yes ------------- int a            yes          yes          no -------------   Declaration won t allocate memory  the variable must be defined for memory allocation  but the definition will   This is just another simple view on the extern keyword since the other answers are really great

User · Answer

extern keyword is used with the variable for its identification as a global variable        It also represents that you can use the variable declared using extern   keyword in any file though it is declared defined in other file

User · Answer

In C a variable inside a file say example c is given local scope  The compiler expects that the variable would have its definition inside the same file example c and when it does not find the same   it would throw an error A function on the other hand has by default global scope   Thus you do not have to explicitly mention to the compiler  look dude   you might find the definition of this function here   For a function including the file which contains its declaration is enough  The file which you actually call a header file       For example consider the following 2 files    example c    include lt stdio h gt  extern int a  main           printf  The value of a is  lt  d gt  n  a       example1 c  int a   5    Now when you compile the two files together  using the following commands    step 1 cc -o ex example c example1 c step 2   ex   You get the following output   The value of a is  lt 5

User · Answer

extern simply means a variable is defined elsewhere  e g   in another file

User · Answer

extern tells the compiler to trust you that the memory for this variable is declared elsewhere  so it doesnt try to allocate check memory     Therefore  you can compile a file that has reference to an extern  but you can not link if that memory is not declared somewhere   Useful for global variables and libraries  but dangerous because the linker does not type check

User · Answer

Adding an extern turns a variable definition into a variable declaration  See this thread as to what s the difference between a declaration and a definition

User · Answer

With xc8 you have to be careful about declaring a variable as the same type in each file as you could   erroneously  declare something an int in one file and a char say in another  This could lead to corruption of variables   This problem was elegantly solved in a microchip forum some 15 years ago        See  http www htsoft com                                                     forum all showflat php Cat 0 Number 18766 an 0 page 0 18766    But this link seems to no longer work     So I ll quickly try to explain it  make a file called global h   In it declare the following   ifdef MAIN C  define GLOBAL      warning COMPILING MAIN C     else  define GLOBAL extern  endif GLOBAL unsigned char testing mode     example var used in several C files   Now in the file main c   define MAIN C 1  include  global h   undef MAIN C   This means in main c the variable will be declared as an unsigned char   Now in other files simply including global h will have it declared as an extern for that file   extern unsigned char testing mode    But it will be correctly declared as an unsigned char   The old forum post probably explained this a bit more clearly  But this is a real potential gotcha when using a compiler that allows you to declare a variable in one file and then declare it extern as a different type in another  The problems associated with that are if you say declared testing mode as an int in another file it would think it was a 16 bit var and overwrite some other part of ram  potentially corrupting another variable  Difficult to debug

User · Answer

GCC ELF Linux implementation  Other answers have covered the language usage side of view  so now let s have a look at how it is implemented in this implementation    main c   include  lt stdio h gt   int not extern int   1  extern int extern int   void main         printf   d n   not extern int       printf   d n   extern int       Compile and decompile   gcc -c main c readelf -s main o   Output contains   Num     Value          Size Type    Bind   Vis      Ndx Name  9  0000000000000000     4 OBJECT  GLOBAL DEFAULT    3 not extern int 12  0000000000000000     0 NOTYPE  GLOBAL DEFAULT  UND extern int   The System V ABI Update ELF spec  Symbol Table  chapter explains      SHN UNDEF This section table index means the symbol is undefined  When the link editor combines this object file with another that defines the indicated symbol  this file s references to the symbol will be linked to the actual definition    which is basically the behavior the C standard gives to extern variables   From now on  it is the job of the linker to make the final program  but the extern information has already been extracted from the source code into the object file   Tested on GCC 4 8   C  17 inline variables  In C  17  you might want to use inline variables instead of extern ones  as they are simple to use  can be defined just once on header  and more powerful  support constexpr   See  What does   39 const static  39  mean in C and C

User · Answer

A very short solution I use to allow a header file to contain the extern reference or actual implementation of an object  The file that actually contains the object just does  define GLOBAL FOO IMPLEMENTATION  Then when I add a new object to this file it shows up in that file also without me having to copy and paste the definition   I use this pattern across multiple files  So in order to keep things as self contained as possible  I just reuse the single GLOBAL macro in each header  My header looks like this     file foo globals h  pragma once    include  foo h     contains definition of foo   ifdef GLOBAL    undef GLOBAL    endif     ifdef GLOBAL FOO IMPLEMENTATION    define GLOBAL    else    define GLOBAL extern    endif    GLOBAL Foo foo1    GLOBAL Foo foo2      file main cpp  define GLOBAL FOO IMPLEMENTATION  include  foo globals h     file uses extern foo cpp  include  foo globals h

User · Answer

I like to think of an extern variable as a promise that you make to the compiler   When encountering an extern  the compiler can only find out its type  not where it  lives   so it can t resolve the reference   You are telling it   Trust me   At link time this reference will be resolvable

User · Answer

The correct interpretation of extern is that you tell something to the compiler  You tell the compiler that  despite not being present right now  the variable declared will somehow be found by the linker  typically in another object  file    The linker will then be the lucky guy to find everything and put it together  whether you had some extern declarations or not

User · Answer

First off  the extern keyword is not used for defining a variable  rather it is used for declaring a variable  I can say extern is a storage class  not a data type   extern is used to let other C files or external components know this variable is already defined somewhere  Example  if  you are building a library  no need to define global variable mandatorily somewhere in library itself  The library will be compiled directly  but while linking the file  it checks for the definition

User · Answer

extern is used so one first c file can have full access to a global parameter in another second c file   The extern can be declared in the first c file or in any of the header files first c includes

User · Answer

extern allows one module of your program to access a global variable or function declared in another module of your program  You usually have extern variables declared in header files   If you don t want a program to access your variables or functions  you use static which tells the compiler that this variable or function cannot be used outside of this module

User · Answer

An extern variable is a declaration  thanks to sbi for the correction  of a variable which is defined in another translation unit  That means the storage for the variable is allocated in another file   Say you have two  c-files test1 c and test2 c  If you define a global variable int test1 var  in test1 c and you d like to access this variable in test2 c you have to use extern int test1 var  in test2 c   Complete sample     cat test1 c  int test1 var   5    cat test2 c  include  lt stdio h gt   extern int test1 var   int main void        printf  test1 var    d n   test1 var       return 0      gcc test1 c test2 c -o test     test test1 var   5

[c] How do I use extern to share variables between source files?

Examples related to c

Examples related to global-variables

Examples related to extern