3.2) Scope and lifetime of variables in C

Scope and lifetime are fundamental concepts in C that determine where a variable is accessible and how long it exists in memory.

Understanding these concepts is essential for writing correct and efficient programs. Let’s explore each concept in detail with code examples and comments.

Scope of Variables

Scope refers to the region of the program where a variable is accessible and can be used.

C has three main scopes for variables:

1. Block Scope: Variables declared within a block of code (within curly braces {}) are accessible only within that block and its nested blocks.
2. Function Scope: Variables declared within a function are accessible within that function, including any nested blocks.
3. File Scope (Global Scope): Variables declared outside of any function or block have global scope and can be accessed throughout the entire file.

Example of Variable Scopes

#include <stdio.h>

int globalVar = 10;  // Global scope

void exampleFunction() {
    int localVarFunc = 20;  // Function scope

    if (1) {
        int localVarBlock = 30;  // Block scope
        printf("Local block variable: %d\n", localVarBlock);
    }

    printf("Local function variable: %d\n", localVarFunc);
}

int main() {
    printf("Global variable: %d\n", globalVar);
    exampleFunction();

    // printf("Local block variable: %d\n", localVarBlock);  // This line would cause an error

    return 0;
}

Explanation

• The globalVar has global scope and can be accessed from both the main function and exampleFunction.
• The localVarFunc is local to the exampleFunction and can be accessed only within that function.
• The localVarBlock is local to the inner block and can be accessed only within that block.
• Attempting to access localVarBlock outside its block or outside the exampleFunction will result in an error.

Lifetime of Variables

Lifetime refers to the period during which a variable exists in memory. It begins when the variable is declared and initialized and ends when the variable goes out of scope.

• For variables with block scope, their lifetime is limited to the block in which they are defined.
• For variables with function scope, their lifetime extends from the moment they are declared to the end of the function.
• For variables with global scope, their lifetime is the entire duration of the program.

Example of Variable Lifetimes

#include <stdio.h>

void exampleFunction() {
    int localVarFunc = 20;  // Created when function is called
    printf("Local function variable: %d\n", localVarFunc);
}  // localVarFunc is destroyed when the function ends

int main() {
    int localVarMain = 30;  // Created when program starts
    printf("Local main variable: %d\n", localVarMain);

    exampleFunction();

    return 0;  // localVarMain is destroyed when program ends
}

Explanation:

• The localVarMain in the main function is created when the program starts and exists until the program ends.
• The localVarFunc in the exampleFunction is created when the function is called and exists until the function ends.

Understanding the scope and lifetime of variables is crucial for managing memory efficiently and ensuring correct behavior in your programs.