Scope and Lifetime of Variables

In C, the scope and lifetime of a variable determine where a variable can be accessed in the code and how long it retains its value in memory. Let’s break these down into different types of scopes and storage classes, each with different characteristics.

Types of Variable Scope

1. Local Scope: Variables declared inside a function or block.
2. Global Scope: Variables declared outside all functions.
3. Block Scope: Variables declared within a specific block, such as inside loops or conditionals.
4. File Scope: Variables declared at the file level (outside functions) and limited to the file when marked as static.

Lifetime of Variables

• The lifetime refers to how long the variable retains its value in memory.
• Variables can have automatic, static, or dynamic lifetimes depending on where and how they’re declared.

Let’s look at examples that illustrate scope and lifetime.

Example 1: Local Scope and Automatic Lifetime

Local variables declared within a function have local scope and automatic lifetime. This means they are created when the function is called and destroyed when the function exits.

#include <stdio.h>

void exampleFunction() {
    int localVar = 10;  // Local to exampleFunction
    printf("Local variable: %d\n", localVar);
}

int main() {
    exampleFunction();
    // printf("%d", localVar);  // Error: localVar not accessible here
    return 0;
}

In this example, localVar exists only within exampleFunction. When exampleFunction is called, localVar is created, and when the function exits, it is destroyed.

Example 2: Global Scope and Lifetime

Global variables are declared outside of any function and have global scope. They are accessible from any function in the same file and have a static lifetime, meaning they exist for the entire runtime of the program.

#include <stdio.h>

int globalVar = 20;  // Global variable

void display() {
    printf("Global variable: %d\n", globalVar);
}

int main() {
    printf("Accessing global variable in main: %d\n", globalVar);
    display();  // Also accesses globalVar
    return 0;
}

In this case, globalVar is accessible both in main and display functions and remains in memory for the program’s lifetime.

Example 3: Block Scope and Limited Lifetime

Block scope applies to variables declared within specific blocks like loops, conditionals, or other code blocks.

#include <stdio.h>

int main() {
    for (int i = 0; i < 3; i++) {  // i has block scope
        printf("i in loop: %d\n", i);
    }
    // printf("%d", i);  // Error: i is not accessible here
    return 0;
}

Here, the variable i has block scope, limited to the for loop. It is created when the loop starts and destroyed when the loop ends.

Example 4: Static Local Variable

A static local variable has a local scope (accessible only within the function) but a static lifetime (it retains its value between function calls).

#include <stdio.h>

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

int main() {
    staticExample();  // Output: 1
    staticExample();  // Output: 2
    staticExample();  // Output: 3
    return 0;
}

Here, count is a local variable with static storage, so it retains its value between calls to staticExample.

Example 5: extern Keyword for Global Variables Across Files

The extern keyword is used to declare a global variable in another file, allowing access across multiple files.

File 1 (file1.c):

#include <stdio.h>

int globalVar = 100;  // Global variable definition

void display() {
    printf("Global variable in file1: %d\n", globalVar);
}

File 2 (file2.c):

#include <stdio.h>

extern int globalVar;  // Declaration of global variable in another file

int main() {
    printf("Accessing globalVar from file2: %d\n", globalVar);
    return 0;
}

In file2.c, we declare globalVar with extern, indicating that it is defined in another file. This allows file2.c to access globalVar from file1.c.

Summary Table