What does static mean in C

Question

I ve seen the word static used in different places in C code  is this like a static function class in C   where the implementation is shared across objects

User · Answer

In C  static has two meanings  depending on scope of its use  In the global scope  when an object is declared at the file level  it means that that object is only visible within that file   At any other scope it declares an object that will retain its value between the different times that the particular scope is entered  For example  if an int is delcared within a procedure   void procedure void       static int i   0      i        the value of  i  is initialized to zero on the first call to the procedure  and the value is retained each subsequent time the procedure is called  if  i  were printed it would output a sequence of 0  1  2  3

User · Answer

If you declare a variable in a function static  its value will not be stored on the function call stack and will still be available when you call the function again   If you declare a global variable static  its scope will be restricted to within the file in which you declared it  This is slightly safer than a regular global which can be read and modified throughout your entire program

User · Answer

Static variables have a property of preserving their value even after they are out of their scope Hence  static variables preserve their previous value in their previous scope and are not initialized again in the new scope   Look at this for example -  A static int variable remains in memory while the program is running  A normal or auto variable is destroyed when a function call where the variable was declared is over    include lt stdio h gt   int fun         static int count   0     count       return count       int main         printf   d    fun        printf   d    fun        return 0       This will output   1 2  As 1 stays in the memory as it was declared static  Static variables  like global variables  are initialized as 0 if not initialized explicitly  For example in the below program  value of x is printed as 0  while value of y is something garbage  See this for more details    include  lt stdio h gt   int main           static int x       int y       printf   d  n  d   x  y        This will output   0                     some garbage value   These are the major ones I found that weren t explained above for a newbie

User · Answer

Static variables in C have the lifetime of the program   If defined in a function  they have local scope  i e  they can be accessed only inside those functions  The value of static variables is preserved between function calls   For example   void function         static int var   1      var        printf   d   var      int main         function       Call 1     function       Call 2     In the above program  var is stored in the data segment  Its lifetime is the whole C program   After function call 1  var becomes 2  After function call 2  var becomes 3   The value of var is not destroyed between functions calls   If var had between non static and local variable  it would be stored in the stack segment in the C program  Since the stack frame of the function is destroyed after the function returns  the value of var is also destroyed   Initialized static variables are stored in the data segment of the C program whereas uninitialized ones are stored in the BSS segment   Another information about static  If a variable is global and static  it has the life time of the C program  but it has file scope  It is visible only in that file   To try this   file1 c  static int x   int main         printf  Accessing in same file d   x       file2 c      extern int x      func                 printf  accessing in different file  d  x      Not allowed  x has the file scope of file1 c        run gcc -c file1 c  gcc -c file2 c   Now try to link them using   gcc -o output file1 o file2 o   It would give a linker error as x has the file scope of file1 c and the linker would not be able to resolve the reference to variable x used in file2 c   References    http   en wikipedia org wiki Translation unit  programming  http   en wikipedia org wiki Call stack

User · Answer

A static variable value persists between different function calls andits scope is limited to the local block a static var always initializes with value 0

User · Answer

It depends  int foo        static int x     return   x     The function would return 1  2  3  etc  --- the variable is not on the stack  a c  static int foo        It means that this function has scope only in this file  So a c and b c can have different foo  s  and foo is not exposed to shared objects  So if you defined foo in a c you couldn t access it from b c or from any other places  In most C libraries all  quot private quot  functions are static and most  quot public quot  are not

User · Answer

A static variable is a special variable that you can use in a function  and it saves the data between calls  and it does not delete it between calls  For example  void func void        static int count     If you don t declare its value  it is initialized with zero     printf  quot  d   quot   count         count     int main void        while true            func              return 0     The output   0  1  2  3  4  5

User · Answer

There is one more use not covered here  and that is as part of an array type declaration as an argument to a function   int someFunction char arg static 10                 In this context  this specifies that arguments passed to this function must be an array of type char with at least 10 elements in it  For more info see my question here

User · Answer

It is important to note that static variables in functions get initialized at the first entry into that function  and persist even after their call has been finished  in case of recursive functions the static variable gets initialized only once and persists as well over all recursive calls and even after the call of the function has been finished   If the variable has been created outside a function  it means that the programmer is only able to use the variable in the source-file the variable has been declared

User · Answer

Short answer     it depends    Static defined local variables do not lose their value between function calls  In other words they are global variables  but scoped to the local function they are defined in  Static global variables are not visible outside of the C file they are defined in  Static functions are not visible outside of the C file they are defined in

User · Answer

A static variable inside a function keeps its value between invocations  A static global variable or a function is  seen  only in the file it s declared in    1  is the more foreign topic if you re a newbie  so here s an example    include  lt stdio h gt   void foo         int a   10      static int sa   10       a    5      sa    5       printf  a    d  sa    d n   a  sa       int main         int i       for  i   0  i  lt  10    i          foo        This prints   a   15  sa   15 a   15  sa   20 a   15  sa   25 a   15  sa   30 a   15  sa   35 a   15  sa   40 a   15  sa   45 a   15  sa   50 a   15  sa   55 a   15  sa   60   This is useful for cases where a function needs to keep some state between invocations  and you don t want to use global variables  Beware  however  this feature should be used very sparingly - it makes your code not thread-safe and harder to understand    2  Is used widely as an  access control  feature  If you have a  c file implementing some functionality  it usually exposes only a few  public  functions to users  The rest of its functions should be made static  so that the user won t be able to access them  This is encapsulation  a good practice   Quoting Wikipedia      In the C programming language  static   is used with global variables and   functions to set their scope to the   containing file  In local variables    static is used to store the variable   in the statically allocated memory   instead of the automatically allocated   memory  While the language does not   dictate the implementation of either   type of memory  statically allocated   memory is typically reserved in data   segment of the program at compile   time  while the automatically   allocated memory is normally   implemented as a transient call stack    And to answer your second question  it s not like in C    In C    however  static is also used to define class attributes  shared between all objects of the same class  and methods  In C there are no classes  so this feature is irrelevant

User · Answer

From Wikipedia      In the C programming language  static is used with global variables and functions to set their scope to the containing file  In local variables  static is used to store the variable in the statically allocated memory instead of the automatically allocated memory  While the language does not dictate the implementation of either type of memory  statically allocated memory is typically reserved in data segment of the program at compile time  while the automatically allocated memory is normally implemented as a transient call stack

User · Answer

If you declare this in a mytest c file   static int my variable    Then this variable can only be seen from this file  The variable cannot be exported anywhere else   If you declare inside a function the value of the variable will keep its value each time the function is called   A static function cannot be exported from outside the file  So in a   c file  you are hiding the functions and the variables if you declare them static

User · Answer

People keep saying that  static  in C has two meanings   I offer an alternate way of viewing it that gives it a single meaning    Applying  static  to an item forces that item to have two properties   a  It is not visible outside the current scope   b  It is persistent    The reason it seems to have two meanings is that  in C  every item to which  static  may be applied already has one of these two properties  so it seems as if that particular usage only involves the other   For example  consider variables   Variables declared outside of functions already have persistence  in the data segment   so applying  static  can only make them not visible outside the current scope  compilation unit    Contrariwise  variables declared inside of functions already have non-visibility outside the current scope  function   so applying  static  can only make them persistent   Applying  static  to functions is just like applying it to global variables - code is necessarily persistent  at least within the language   so only visibility can be altered   NOTE  These comments only apply to C   In C    applying  static  to class methods is truly giving the keyword a different meaning   Similarly for the C99 array-argument extension

User · Answer

There are 2 cases    1  Local variables declared static  Allocated in data segment instead of stack  Its value retains when you call the function again    2  Global variables or functions declared static  Invisible outside compilation unit  i e  are local symbols in symbol table during linking

User · Answer

Multi-file variable scope example  Here I illustrate how static affects the scope of function definitions across multiple files   a c   include  lt stdio h gt      Undefined behavior  already defined in main  Binutils 2 24 gives an error and refuses to link  https   stackoverflow com questions 27667277 why-does-borland-compile-with-multiple-definitions-of-same-object-in-different-c      int i   0        Works in GCC as an extension  https   stackoverflow com a 3692486 895245      int i        OK  extern  Will use the one in main     extern int i      OK  only visible to this file     static int si   0   void a         i        si        puts  a          printf  i    d n   i       printf  si    d n   si       puts          main c   include  lt stdio h gt   int i   0  static int si   0   void a         void m         i        si        puts  m          printf  i    d n   i       printf  si    d n   si       puts         int main         m        m        a        a        return 0      GitHub upstream   Compile and run   gcc -c a c -o a o gcc -c main c -o main o gcc -o main main o a o   Output   m   i   1 si   1  m   i   2 si   2  a   i   3 si   1  a   i   4 si   2   Interpretation   there are two separate variables for si  one for each file there is a single shared variable for i   As usual  the smaller the scope  the better  so always declare variables static if you can   In C programming  files are often used to represent  classes   and static variables represent private static members of the class   What standards say about it  C99 N1256 draft 6 7 1  Storage-class specifiers  says that static is a  storage-class specifier    6 2 2 3  Linkages of identifiers  says static implies internal linkage      If the declaration of a file scope identifier for an object or a function contains the storage-class specifier static  the identifier has internal linkage    and 6 2 2 2 says that internal linkage behaves like in our example      In the set of translation units and libraries that constitutes an entire program  each declaration of a particular identifier with external linkage denotes the same object or function  Within one translation unit  each declaration of an identifier with internal linkage denotes the same object or function     where  translation unit is a source file after preprocessing   How GCC implements it for ELF  Linux    With the STB LOCAL binding   If we compile   int i   0  static int si   0    and disassemble the symbol table with   readelf -s main o   the output contains   Num     Value          Size Type    Bind   Vis      Ndx Name   5  0000000000000004     4 OBJECT  LOCAL  DEFAULT    4 si  10  0000000000000000     4 OBJECT  GLOBAL DEFAULT    4 i   so the binding is the only significant difference between them  Value is just their offset into the  bss section  so we expect it to differ   STB LOCAL is documented on the ELF spec at http   www sco com developers gabi 2003-12-17 ch4 symtab html      STB LOCAL Local symbols are not visible outside the object file containing their definition  Local symbols of the same name may exist in multiple files without interfering with each other   which makes it a perfect choice to represent static   Variables without static are STB GLOBAL  and the spec says      When the link editor combines several relocatable object files  it does not allow multiple definitions of STB GLOBAL symbols with the same name     which is coherent with the link errors on multiple non static definitions   If we crank up the optimization with -O3  the si symbol is removed entirely from the symbol table  it cannot be used from outside anyways  TODO why keep static variables on the symbol table at all when there is no optimization  Can they be used for anything  Maybe for debugging   See also   analogous for static functions  https   stackoverflow com a 30319812 895245 compare static with extern  which does  the opposite   How do I use extern to share variables between source files    C   anonymous namespaces  In C    you might want to use anonymous namespaces instead of static  which achieves a similar effect  but further hides type definitions  Unnamed anonymous namespaces vs  static functions

User · Answer

I hate to answer an old question  but I don t think anybody has mentioned how K amp R explain it in section A4 1 of  The C Programming Language    In short  the word static is used with two meanings    Static is one of the two storage classes  the other being automatic   A static object keeps its value between invocations  The objects declared outside all blocks are always static and cannot be made automatic  But  when the static keyword  big emphasis on it being used in code as a keyword  is used with a declaration  it gives that object internal linkage so it can only be used within that translation unit  But if the keyword is used in a function  it changes the storage class of the object  the object would only be visible within that function anyway   The opposite of static is the extern keyword  which gives an object external linkage    Peter Van Der Linden gives these two meanings in  Expert C Programming     Inside a function  retains its value between calls  At the function level  visible only in this file

User · Answer

static means different things in different contexts    You can declare a static variable in a C function  This variable is only visible in the function however it behaves like a global in that it is only initialized once and it retains its value  In this example  everytime you call foo   it will print an increasing number  The static variable is initialized only once   void foo      static int i   0  printf   d   i   i      Another use of static is when you implement a function or global variable in a  c file but don t want its symbol to be visible outside of the  obj generated by the file  e g   static void foo

User · Answer

In C programming  static is a reserved keyword which controls both lifetime as well as visibility  If we declare a variable as static inside a function then it will only visible throughout that function  In this usage  this static variable s lifetime will start when a function call and it will destroy after the execution of that function  you can see the following example    include lt stdio h gt   int counterFunction         static int count   0     count       return count       int main         printf  First Counter Output    d n   counterFunction        printf  Second Counter Output    d    counterFunction        return 0       Above program will give us this Output   First Counter Output   1  Second Counter Output   1    Because as soon as we call the function it will initialize the count   0  And while we execute the counterFunction it will destroy the count variable

[c] What does "static" mean in C?

Examples related to c

Examples related to syntax

Examples related to static