Static in C | Differences b/w static local and static global variable

 

Static in C

In C, the term "static" can have different meanings and uses depending on where it is used within your code. Here are some of the common uses of the "static" keyword in C:

1. Static Variables:

   a. When you declare a variable as static inside a function, it retains its value between function calls. This means that the variable's value persists across multiple invocations of the function.
   
   b. Static variables are initialized only once, and their values are preserved across function calls.
   
   c. Static variables are typically stored in a special area of memory separate from automatic (stack) variables

   c
   void myFunction() {
       static int count = 0;  // Static variable
       count++;
       printf("Count: %d\n", count);
   }

2. Static Functions:

   a. When you declare a function as static, it limits the scope of that function to the current source file. Other source files cannot access this function using external linkage.
   
   b. This is often used to create helper functions that are only needed within a single source file and do not need to be exposed to other parts of the program

   c
   static void myStaticFunction() {
       // Function code
   }

3. Static Global Variables:

   a. When you declare a global variable as static, it limits the scope of that variable to the current source file. Other source files cannot access this variable using external linkage.
   
   b. Static global variables are not visible outside the file in which they are declared

   c
   // In one.c
   static int globalVar = 10;  // Static global variable
   
   // In another.c
   // You cannot access globalVar here; it's not visible.

   4. Static Data Members (in C++):

   a. In C++, the "static" keyword can also be used with class data members to make them shared across all instances of the class. These are often referred to as "static data members" or "class-level variables."
   
   b. This is a C++ feature and not available in traditional C

   cpp
   class MyClass {
   public:
       static int sharedVar;  // Static data member
   };
   
   int MyClass::sharedVar = 0;  // Initialization of the static data member

   Differences b/w static local and static global variable

   Static local variables and static global variables share the "static" keyword, but they have distinct differences in terms of scope, lifetime, and accessibility:

   1. Scope:

      1. Static Global Variables:

      Static global variables are declared outside of any function and have file scope, meaning they are accessible from any part of the source file in which they are defined and, with proper linkage, from other source files as well.

      2. Static Local Variables:

      Static local variables are declared within a function and have function scope, meaning they are only accessible within the block of code (function) in which they are defined.

   2. Lifetime:

      1. Static Global Variables:

      Static global variables have a lifetime that spans the entire execution of the program. They are initialized once when the program starts and retain their values until the program terminates.

      2. Static Local Variables:

      Static local variables also have a lifetime that spans the entire execution of the program, but they are initialized only once when the program starts and retain their values between function calls. This means they persist across multiple invocations of the function.

   3. Access Control:

      1. Static Global Variables:

      Static global variables are accessible from any function in the program, including functions defined in other source files if they have proper linkage declarations.

      2. Static Local Variables:

      Static local variables are only accessible within the function in which they are defined. They are not visible or accessible from other functions or source files.

   4. Initialization:

      1. Static Global Variables:

      Static global variables are initialized once when the program starts, and their initial values are preserved throughout the program's execution.

      2. Static Local Variables:

      Static local variables are initialized once when the program starts, but their initial values are preserved across multiple calls to the function in which they are defined.
      
      Here's an example illustrating the differences:

   c
   #include <stdio.h>
   
   // Static global variable
   static int globalVar = 10;
   
   void myFunction() {
       // Static local variable
       static int localVar = 5;
       
       printf("GlobalVar: %d\n", globalVar);
       printf("LocalVar: %d\n", localVar);
       
       // Modify the static local variable
       localVar++;
   }
   
   int main() {
       myFunction();  // Call the function
       myFunction();  // Call the function again
   
       return 0;
   }

   In this example, globalVar is a static global variable with file scope, and localVar is a static local variable with function scope. globalVar is accessible from both main and myFunction, while localVar is only accessible within myFunction. The static local variable localVar retains its value between calls to myFunction, as demonstrated in the output.

   Differences b/w static and global variable

   Static and global variables in C have several differences in terms of scope, lifetime, and accessibility:

   1. Scope:

      1. Global Variables:

      Global variables are declared outside of any function, at the top of a source file, or in a header file with external linkage.
      
      They have file scope, meaning they are accessible from any part of the source file in which they are defined and, with proper linkage, from other source files as well.

      2. Static Variables (Static Global or Static Local):

      Static variables can be declared either at the file scope (static global) or within a function (static local).Static global variables have file scope, similar to global variables. Static local variables have function scope, meaning they are only accessible within the function in which they are defined.

   2. Lifetime:

      1. Global Variables:

      Global variables have a lifetime that spans the entire execution of the program. They are initialized once when the program starts and retain their values until the program terminates.

      2 . Static Variables (Static Global or Static Local):

      Both static global and static local variables have a lifetime that spans the entire execution of the program.
      
      Static global variables are initialized once when the program starts, and their values persist until program termination.
      
      Static local variables are initialized only once when the program starts, but their values persist across multiple function calls.
      
      
      Access Control:

   3. 1. Global Variables:

      Global variables are accessible from any function in the program, including functions defined in other source files if they have proper linkage declarations.

      2. Static Variables (Static Global or Static Local):

      Static global variables are accessible from any part of the source file in which they are defined and, with proper linkage, from other source files.
      
      Static local variables are only accessible within the function in which they are defined.

   4. Name Collisions:

      1. Global Variables:

      Because global variables are visible across multiple source files, there is a risk of naming collisions if multiple source files define global variables with the same name. To mitigate this, it's common to use the static keyword with global variables to give them internal linkage, limiting their scope to the source file.

      2. Static Variables (Static Global or Static Local):

      Static variables, by default, have internal linkage (for static globals) or function scope (for static locals), so there is no risk of name collisions with variables of the same name in other source files.