The Life Cycle and Scope of Variables in C Language: Unveiling the Underlying Logic

In the last lesson, we explored the concept of “scope”, which refers to where a variable is visible in the code.

Today, we will introduce the time dimension and discuss the lifetime of variables.

Some may laugh:“Are you talking about software engineering or biology? Why is there a life cycle?”

Don’t rush, in the world of programming, variables really do have a complete process from “birth” to “death”. Understanding this is a key step in advancing from “writing runnable code” to “writing efficient and safe code”.

What is Lifetime? (Lifetime)

The lifetime describes the entire period from when a variable is created (initialized) to when it is destroyed (memory reclaimed).

We can use a person’s life as an analogy:

Memory Allocation: Just like a person is born from the womb, gaining a physical form.
Using Variables: Going through childhood, adolescence, and adulthood, fulfilling their role.
Memory Release: Life ends, dust returns to dust, and resources return to nature.

Depending on the type of variable defined, their “way of living” can be completely different. We will focus on two types:local variables and global variables.

Local Variables: A Brief but Brilliant Life

Local variables (Local Variables) are typically defined within a function or a code block {}.

1. Automatic Storage Duration

This is a very technical term. Local variables have an “automatic storage duration”, which means:

Automatically Born: When the program execution flow enters the function or code block where the variable is located, the system automatically allocates memory for it on the stack (Stack
Automatically Destroyed: When the program execution flow leaves this code block (for example, when the function execution is completedreturn, or encounters a right brace}), this memory will be immediately reclaimed.

This is also why when we try to access demonstrateLocalVariable ‘s local_var in the main function, the compiler will report an error——because that variable has already “died”.

2. The Trap of Uninitialized Values (Technical Deep Dive)

Professional correction and addition:

It was specifically mentioned that “initial value is undefined”. This is very critical!

Local variables are stored in stack memory. When the operating system allocates stack memory, it does not automatically clear it. This means that if you declare a local variable but do not assign it a value, its value will be the leftover garbage data in memory (Garbage Value).

Incorrect Example:

int x; // x's value could be -858993460 or any random numberprintf("%d", x);

Correct Example:

int x = 0; // Explicit initialization, safety first

3. Code Practical Analysis

Let’s look at a standard code demonstration. Note that here we use int32_t type, which requires including <inttypes.h> header file, which is a more rigorous embedded or cross-platform programming practice.

#include &lt;stdio.h&gt;#include &lt;inttypes.h&gt; // Supports int32_t and PRId32
// Function prototype declarationvoid demonstrateLocalVariable(void);
int main(void) {    // Local variable demonstration
    printf("--- First function call ---\n");    demonstrateLocalVariable();
    printf("--- Second function call ---\n");    // Each call will recreate the variable, destroyed at the end of the function    demonstrateLocalVariable();
    // ❌ Incorrect example: Uncommenting the line below will cause a compilation error    // Reason: local_var's scope is limited to the demonstrateLocalVariable function    // and its lifetime has ended with the function return    // printf("Attempting to access in main: %" PRId32 "\n", local_var);
    return 0;}
void demonstrateLocalVariable(void) {    // Local variable declaration    // Lifetime starts here    int32_t local_var = 100;
    printf("Local variable inside function local_var = %" PRId32 "\n", local_var);
    // Modify the value to prove it is alive    local_var += 50;    printf("Modified value = %" PRId32 "\n", local_var);
} // ⬅️ Upon encountering this brace, local_var is immediately destroyed (death)

Global Variables: The “Immortal” that Lives as Long as the Universe

Global variables (Global Variables) are defined outside of all functions, usually at the top of the file.

1. Static Storage Duration

Global variables have a “static storage duration”. Their lifetime is extremely long:

Birth: They are initialized at the moment the program starts (before the main function executes).
Death: They are only destroyed when the entire program closes (process ends).

2. Risks of Global Variables

Since global variables are so convenient and can be used everywhere, why should we use them cautiously? We have summarized the following points of “side effects”:

Long-term Resource Occupation: They occupy memory without releasing it, and if there are too many global variables, it can lead to excessive memory consumption.
Naming Conflicts: Naming Conflicts: Just like there are many people named “Zhang San” in reality. If your project is large, global variables can easily have the same name, leading to unexpected errors.
Unpredictable Modifications: Any function can modify them, making code maintenance very difficult. You don’t know which function secretly changed your data.

3. Code Practical Analysis

The following code demonstrates how global variables exist across function boundaries.

#include &lt;stdio.h&gt;#include &lt;inttypes.h&gt;
// Global variable// Scope: Global// Lifetime: From program start to program endint32_t g_global_var = 10;
// Macro definition constant#define SIZE 5
void demoFunction(void);
int main(void) {    printf("--- Main function starts ---\n");
    // Can access global variable in main    printf("Accessing global variable in Main: %" PRId32 "\n", g_global_var);
    demoFunction();
    // After the function call, the global variable still exists and retains the modified value    printf("After function call, Main accesses again: %" PRId32 "\n", g_global_var);
    return 0;}
void demoFunction(void) {    // Can also access the same global variable in other functions    printf("Accessing global variable in demoFunction: %" PRId32 "\n", g_global_var);
    // Modify global variable    g_global_var += SIZE; // Using macro definition    printf("demoFunction modified the global variable...\n");}

Conclusion

To write efficient and reliable programs, we need to strictly manage the lifetime of variables:

Local Variables (Local):

Recommended for use.
Short lifetime, used and then discarded, saving memory.
If you forget to initialize, since it is stack memory, you may get dirty data (Garbage Value), be careful!

Global Variables (Global):

Use with caution.
Lifetime spans the entire program.
Abuse can lead to logical memory leaks, naming conflicts, and hard-to-debug bugs.

Remember the old saying: Keep the scope of variables as small as possible and their lifetime as short as possible. This is the way of expert programming.

Related posts

Leave a Comment Cancel reply