When to use static keyword before global variables?

Question

Can someone explain when you\'re supposed to use the static keyword before global variables or constants defined in header files?

For example, lets say I have a head

Answer 1

Rule of thumb for header files:

• declare the variable as extern int foo; and put a corresponding intialization in a single source file to get a modifiable value shared across translation units
• use static const int foo = 42; to get a constant which can be inlined

Answer 2

The static keyword is used in C to restrict the visibility of a function or variable to its translation unit. Translation unit is the ultimate input to a C compiler from which an object file is generated.

Check this: Linkage | Translation unit

Answer 3

The correct mechanism for C++ in anonymous namespaces. If you want something that is local to your file, you should use an anonymous namespace rather than the static modifier.

Answer 4

global static variables are initialized at compile-time unlike automatic

Answer 5

You should not define global variables in header files. You should define them in .c source file.

• If global variable is to be visible within only one .c file, you should declare it static.

• If global variable is to be used across multiple .c files, you should not declare it static. Instead you should declare it extern in header file included by all .c files that need it.

Example:

• example.h

  extern int global_foo;
  

• foo.c

  #include "example.h"
  
  int global_foo = 0;
  static int local_foo = 0;
  
  int foo_function()
  {
     /* sees: global_foo and local_foo
        cannot see: local_bar  */
     return 0;
  }
  

• bar.c

  #include "example.h"
  
  static int local_bar = 0;
  static int local_foo = 0;
  
  int bar_function()
  {
      /* sees: global_foo, local_bar */
      /* sees also local_foo, but it's not the same local_foo as in foo.c
         it's another variable which happen to have the same name.
         this function cannot access local_foo defined in foo.c
      */
      return 0;
  }
  

Answer 6

static renders variable local to the file which is generally a good thing, see for example this Wikipedia entry.