Overview

The static keyword in C is a storage class specifier that impacts the visibility, lifetime, and linkage of variables and functions within C programs. Understanding its usage is crucial for managing memory, optimizing program efficiency, and implementing software design patterns in C.

Key Concepts

1. Static Variables - Variables with extended lifetime and scope limited to their compilation unit.
2. Static Functions - Functions whose scope is restricted to the file in which they are declared.
3. Storage Classes - Understanding how static affects the storage duration and linkage of variables and functions.

Common Interview Questions

Basic Level

1. What does the static keyword do when applied to a variable inside a function?
2. How does the static keyword affect the scope and lifetime of a global variable?

Intermediate Level

3. Explain the difference between a static global variable and a non-static global variable.

Advanced Level

4. Discuss how the static keyword can be used to optimize memory usage in a C program.

Detailed Answers

1. What does the static keyword do when applied to a variable inside a function?

Answer: When the static keyword is applied to a variable inside a function, it changes the variable's storage duration from automatic duration to static duration. This means the variable is initialized only once, and its value persists between function calls.

Key Points:
- Static variables inside functions retain their value between function calls.
- They are initialized to zero by default if no explicit initializer is provided.
- Their scope remains local to the function, but unlike automatic variables, they do not get destroyed when the function exits.

Example:

#include <stdio.h>

void counterFunction() {
    static int counter = 0;  // Static variable declaration
    counter++;
    printf("Counter: %d\n", counter);
}

int main() {
    for(int i = 0; i < 5; i++) {
        counterFunction();  // Function call
    }
    return 0;
}

This code will output:

Counter: 1
Counter: 2
Counter: 3
Counter: 4
Counter: 5

2. How does the static keyword affect the scope and lifetime of a global variable?

Answer: For global variables, the static keyword limits their scope to the file in which they are declared, making them inaccessible from other files. However, their lifetime remains for the duration of the program.

Key Points:
- Static global variables cannot be accessed or modified by functions in other files.
- They help in implementing module-private variables.
- The variable is initialized only once and retains its value across function calls and file accesses within the same file.

Example:

// File1.c
static int fileScopedVariable = 10;  // Static global variable

void printVariable() {
    printf("%d\n", fileScopedVariable);
}

// File2.c
extern void printVariable();  // Attempt to access fileScopedVariable

int main() {
    printVariable();  // This will work, but accessing fileScopedVariable directly here will not.
    return 0;
}

In this example, fileScopedVariable is only accessible within File1.c, and not from File2.c or any other file.

3. Explain the difference between a static global variable and a non-static global variable.

Answer: A static global variable is limited in scope to the file in which it is declared, whereas a non-static global variable (or an external variable) can be accessed from any file that declares it as extern.

Key Points:
- Static global variables help in encapsulating data within a single file, enhancing modularity and reducing potential naming conflicts.
- Non-static global variables are useful for sharing data across multiple files but can lead to issues with encapsulation and name clashes.
- Both types have a lifetime that lasts the duration of the program.

Example:

// File1.c
static int internalVariable = 5;  // Only accessible within File1.c

int externalVariable = 10;  // Accessible from other files if declared as extern

void printInternal() {
    printf("Internal: %d\n", internalVariable);
}

// File2.c
extern int externalVariable;  // Declaration of an external variable

void printExternal() {
    printf("External: %d\n", externalVariable);
}

internalVariable is encapsulated within File1.c, while externalVariable can be accessed from File2.c.

4. Discuss how the static keyword can be used to optimize memory usage in a C program.

Answer: The static keyword can contribute to memory optimization by limiting variable scope, reducing the need for allocating and deallocating memory dynamically, and by maintaining state across function calls without using global variables.

Key Points:
- Static variables inside functions can be used instead of global variables to maintain state, reducing the memory footprint by avoiding unnecessary global scope.
- By limiting the scope of variables and functions to the file level, it prevents polluting the global namespace, which can lead to more efficient linking and smaller executable sizes.
- Static variables are initialized only once, which can be more efficient than variables with automatic storage duration in cases where the initialization cost is high.

Example:

void efficientFunction() {
    static int largeArray[1000] = {0};  // Static array
    // Use largeArray for some computation
    // Its state will be preserved between calls without reinitialization
}

In this example, largeArray is only initialized once and retains its state across function calls, which can be more efficient than reinitializing a large local array on each call.