Variables in C++(PART-II)

Welcome back! If you’ve read our previous article on variables in C++, you already know what variables are, why we need them, how to define and declare them, and the key rules for naming them.

But have you ever wondered where in your program you can access the variables you create? Are they available everywhere, or only in certain sections? And once created, do they exist indefinitely, or do they have a limited lifespan based on their allocation?

If these questions have crossed your mind, you’re in the right place! In this article, we’ll dive into variable scope and lifetime, explore how they differ, and understand how variables are stored in memory. We’ll also see how memory management ties it all together.

Let’s get started!

First things first—what exactly is the scope of a variable?

I recommend opening your favourite code editor, such as VS Code or Atom, or trying out our platform at playground.learnyard.com. Start typing this code, and don’t worry if you don’t fully understand each statement just yet—you’ll get it as we progress further.

Here's the code for you to experiment with:

#include <iostream>
using namespace std;

int main(){

	// Variable declared outside the if block, accessible everywhere in the main() function.
    // -------------------------------------------------------
    int number = 10; 

	if(number > 5){

		cout<<number<<" is accessible inside the IF-BLOCK"<<endl;
	}

	cout<<number<<" is accessible outside the IF-BLOCK"<<endl;

	return 0;

}

Experiment: Move the declaration inside the if Block:

#include <iostream>
using namespace std;

int main(){


	if(true){
		
		// Variable declared inside the if block, accessible only in the IF-BLOCK.
		// -------------------------------------------------------
		int number = 10; 

		cout<<number<<" is accessible inside the IF-BLOCK"<<endl;
	}

	cout<<number<<" is accessible outside the IF-BLOCK"<<endl;

	return 0;

}

Now, after this your screen would be prompting an error like this

But the question comes why?
This is where the concept of scope comes into play. When we declare and initialize a variable (like number) inside an if block, it exists only within that block. Once the closing brace of the if block is reached, the block ends, and everything declared within it, including the number variable, goes out of scope and is removed from memory.

The memory allocated to the block and its variables is freed, meaning the variable no longer exists in memory after the block ends. As a result, when you try to access the variable outside the block, the program doesn’t recognise it, leading to a compilation error.

In order to resolve this compilation error, either move the variable declaration of number outside the IF-BLOCK or comment out the line: cout<<number<<" is accessible outside the IF-BLOCK"<<endl;

Now that you’ve completed the experiment and have a basic understanding of scopes of variables, let’s dive into understanding

What does the scope of a variable actually mean?

In programming, the scope of a variable defines where in your code the variable can be accessed or modified.
For example, if you declare a variable inside a function or block, its scope is limited to that specific function or block. This means the variable can only be used within that area and ceases to exist once you exit it.
Understanding scope helps keep your code organized, prevents unintended modifications, and improves maintainability.
You can think of scope as a "boundary" that determines where a variable can be used.
To better understand this, let’s use an example that many people enjoy—a video game.
Imagine you're playing a multiplayer video game with four friends. The game has five levels, and before starting, you set up some general settings:

• Game Theme (e.g., sci-fi, fantasy, etc.)
• Volume Settings
• User Names – Each player selects a unique user_name, which stays the same throughout all levels.

These settings remain unchanged for the entire game, just like global variables, which are accessible across all levels.
However, some variables change as the game progresses:

• Remaining Lives – Tracks how many lives you have in the current level.
• Level Score – Tracks points earned only in the current level.

Both remainingLives and level_score are examples of local variables. Their scope is limited to the current level, and their values reset or update when you move to the next one.

I hope this example has helped you clearly understand the concept of variable scopes. Now, let’s dive deeper into the different types of scopes to explore them in detail.

Different types of scope of variables

Global Scope

A variable with global scope can be accessed anywhere in the program, regardless of where it's used in the code. These variables are typically declared outside any function, making them accessible throughout the program.
Since they are available globally, any function or block can read or modify their value. Unless explicitly redefined inside a function, the variable retains its value throughout the program.

Let’s relate this to our video game example.
In a multiplayer game, every player has a user name that stays the same across all levels. Whether you're in Level 1, Level 3, or checking the scoreboard, your user name remains unchanged.
Similarly, in C++, a global variable is accessible from any part of the program because it's declared outside all functions. This means it can be used anywhere in the code, just like a user name that remains consistent across the entire game.

Check out this coding example to see how it works:

#include <iostream>
#include <string>
using namespace std;

// Global variable
//-------------------------------------------------------
string user_name = "@LearnYardYT"; 

void DisplayUserName(){

	cout<<user_name<<" is accessed inside the DisplayUserName() function"<<endl;
}
int main() {

    // Accessing the global variable in the main function
    // -------------------------------------------------------
    cout << user_name<<" is accessed inside the main() function"<<endl;
    
    // Calling the function to display the name of the channel
    // -------------------------------------------------------
    DisplayUserName();
    return 0;
}

Output:

@LearnYardYT is accessed inside the main() function
@LearnYardYT is accessed inside the DisplayUserName() function

Now that we’ve seen how the user_name remains the same throughout the game, let’s look at how the theme and language settings we set before starting the game are also global. These settings apply universally to the game and remain unchanged.

Check out this coding example:

#include <iostream>
#include <string>
using namespace std;

// Global Variables
// -------------------------------------------------------
string difficulty = "Normal";
int sound_volume = 50;

// Function to display the current settings of the game
// -------------------------------------------------------
void ShowSettings(){
    cout<<"Current Game Settings :"<<endl;
    cout<<"Difficulty: "<<difficulty<<endl;
    cout<<"Sound Volume: "<<sound_volume<<endl;
}

int main(){

    ShowSettings();
    
   // Accessing global variables from the main function()
   // -------------------------------------------------------
   cout<<"Display the settings from the main() function: "<<endl;
   cout<<"Difficulty: "<<difficulty<<endl;
   cout<<"Sound Volume: "<<sound_volume<<endl;
   
   return 0;
   
}

Output:

Current Game Settings :
Difficulty: Normal
Sound Volume: 50
Display the settings from the main() function: 
Difficulty: Normal
Sound Volume: 50

Now, the question is: Can we modify global variables from any part of the code?
The answer is yes! Global variables can be modified from anywhere in the program, as long as they are accessible.

Let’s go back to our gaming analogy. Imagine you decide to change your user name while playing. The moment you update it, the new name is reflected everywhere—in the game lobby, during matches, and even on the scoreboard.
Similarly, in C++, if you modify a global variable in one part of the program, that change instantly applies to all other parts that use it. Since global variables exist outside all functions, any function or block can access and update them.

Check out this coding example:

#include <iostream>
#include <string>
using namespace std;

// Global variable - user name
string user_name = "@LearnYardYT"; // Initial user name

int main() {
    cout << "Original User Name: " << user_name << endl;  // Output: @LearnYardYT

    // Modifying the global variable
    user_name = "@mohammadfraz";  // Updating the channel name

    // Accessing the modified global variable in the same block
    cout << "Updated User Name (Main): " << user_name << endl;  // Output: @mohammadfraz

    // Another part of the program accessing the modified global variable
    cout << "Updated User Name (After Change): " << user_name << endl;  // Output: @mohammadfraz

    return 0;
}

Output:

Original User Name: @LearnYardYT
Updated User Name (Main): @mohammadfraz
Updated User Name (After Change): @mohammadfraz

Now, the question arises: Why do we actually need global variables? Why are they important?
Global variables are useful because they can be accessed and modified from any function or block in a program. This makes it easier to share data across different parts of the program without having to pass the variable repeatedly.

Imagine you're playing a multiplayer game. Certain settings—like game theme, volume level, and difficulty—stay the same throughout the game. Instead of manually setting these preferences every time you enter a new level, the game automatically applies them globally.
Similarly, in C++, global variables store important information that needs to be accessed by multiple functions—such as game settings, player scores, or connection status. Without global variables, you would have to pass the same data to every function that needs it, making the code more complex and harder to manage.

Example: Settings in a Program
For instance, in a program with settings that need to be accessible across various functions—such as theme ( light or dark mode ), language preferences, or volume settings—global variables simplify managing these settings.Here's how global variables can help simplify the process:

#include <iostream>
#include <string>
using namespace std;

// Global variables
// -------------------------------------------------------
string theme = "Light Mode";  // Default theme
string language = "English";  // Default language

int main() {
    cout << "Current Theme: " << theme << endl;  
    cout << "Current Language: " << language << endl;  

    // Changing the theme globally
	// -------------------------------------------------------
    theme = "Dark Mode";  // Now theme is updated everywhere

    cout << "Updated Theme: " << theme << endl;  
    return 0;
}

Output:

Current Theme: Light Mode
Current Language: English
Updated Theme: Dark Mode

Here, theme and language are global variables, and updating them once changes them everywhere in the program, ensuring consistency.

What if we don't declare them as global variables ?
In a program without global variables, the necessary data must be passed explicitly to each function that requires it. This process is known as passing parameters to functions. We will explore this concept in more detail when we learn about functions.

Now, let's move to discussing about local scope of variables.

A local variable is accessible only within the function or block where it is declared. Once the program execution leaves that block, the variable ceases to exist—it is destroyed and can no longer be accessed.
In C++, local variables are typically declared inside a block of code (enclosed by {} ) and exist only for the duration of that block. They are temporary, meaning they are created when the block starts and are automatically destroyed when the block ends.

Let’s relate this to our multiplayer video game!
Think of the game program as your entire code and each level as a separate block of code. Within a specific level, you have details such as remaining lives and level score—but these details are relevant only to that level. These are just like local variables in programming.

Here’s how the comparison works:
They exist only for that level – remainingLives and level_score apply only to the level you're currently playing. They have no effect on other levels.
They are inaccessible outside the level – Once you move to the next level, the previous level's remainingLives and level_score are gone. You cannot access them anymore.
They reset or disappear when switching levels – As soon as you enter a new level, fresh values are initialized, and the old ones are discarded.
This is exactly how local variables work in C++—they exist only within the block where they are defined and cannot be accessed outside of it.

Let’s See It in Action!

Now, check out this C++ example to see how local variables work:

#include <iostream>
#include <string>
using namespace std;
   
int main(){
    
    // Block of code for Level-1
	// -------------------------------------------------------
	{
		int remaining_lives = 3; 
		cout<<"Starting Life: "<<remaining_lives<<endl;
		
		// Simulate losing of a life in a particular level
		// -------------------------------------------------------
		remaining_lives--;
		cout<<"Lost a Life ! Remaining Lives: "<<remaining_lives<<endl;
    
	}
	cout<<"\n"<<endl;
	cout<<"___________________ NEW LEVEL ____________________"<<endl;
	cout<<"\n"<<endl;
	// Block of code for Level-2
	// -------------------------------------------------------
	{
		int remaining_lives = 3; 
		cout<<"Starting Life: "<<remaining_lives<<endl;
		
		// Simulate losing of a life in a particular level
		// -------------------------------------------------------
		remaining_lives--;
		cout<<"Lost a Life ! Remaining Lives: "<<remaining_lives<<endl;
	}
    
    return 0;
}

Output:

Starting Life: 3
Lost a Life ! Remaining Lives: 2


___________________ NEW LEVEL ____________________


Starting Life: 3
Lost a Life ! Remaining Lives: 2

Local Variables and Memory Storage in C++

In C++, local variables are stored in a special area of memory called the stack. The stack is responsible for managing function calls and the variables created within those functions or blocks.

(Don’t worry—we’ll explore memory allocation in more detail later!)
How Does It Work?

• When a program enters a function or block of code, memory is allocated for local variables on the stack.
• When the program exits the function or block, this memory is automatically freed, and the variables cease to exist.
• This ensures that local variables are temporary and exist only during the execution of the function or block they belong to.

Can We Modify Local Variables from Anywhere?
The answer is No —local variables cannot be modified from just anywhere in the code.
Their scope is strictly limited to the block or function in which they are declared. This means:
You can access or modify a local variable only within the block where it is defined.
If you try to modify it outside its block, the program will throw a compilation error because the variable is not recognized in that context.

Now, check out this C++ example to see how local variables work:

#include <iostream>
using namespace std;

int main() {
    if (true) {

		// Local variable
		// -------------------------------------------------------
        int chapter_timestamp = 30; 
        cout << "Timestamp of current chapter: " << chapter_timestamp << " seconds" << endl;

        // Modifying the local variable
		// -------------------------------------------------------
        chapter_timestamp = 45; 
        cout << "Updated Timestamp: " << chapter_timestamp << " seconds" << endl;
		// The local variable 'chapter_timestamp' is destroyed here
    } 

    // Trying to access or modify 'chapter_timestamp' here will cause an error
    // cout << chapter_timestamp; // Uncommenting this line will cause a compilation error

    return 0;
}

Output:

Timestamp of current chapter: 30 seconds
Updated Timestamp: 45 seconds

Let's now move to other important concepts related to scope of variables.
You’ll often hear that global variables are not preferred. But why?

Well, there are various reasons why are global variables avoided. Some of them are:

• Since global variables can be accessed from anywhere, any function can change their value. This makes it hard to track what part of the program is modifying the variable, leading to unexpected errors.
• In a big program, too many global variables make it hard to understand and manage the code. Local variables keep things organized and clear.
• If two different parts of the program use the same variable name, it can lead to confusing results. Local variables avoid this issue by keeping variable names separate in different functions.

Variable Shadowing

Variable shadowing occurs when a local variable inside a function or block has the same name as a global variable. In this case, the local variable "shadows" or "hides" the global variable within that specific scope, meaning the program prioritizes the local variable over the global one.

Understanding Shadowing with an Example
Imagine you have two variables with the same name—one declared globally and the other inside a function or block. Within that function or block, the local variable takes precedence, and the global variable is ignored, even though it still exists in the program.

In order to understand this better run this program in your editor and see what happens:

#include <iostream>
using namespace std;

int global_variable = 10;

void PrintFunction(){

    // Local variable with same name as global variable
    // -------------------------------------------------------
    int global_variable = 20;
    cout<<"Value: "<< global_variable<<endl;
}

int main(){
    
    cout<<"Global Variable: "<<global_variable<<endl;
    PrintFunction();
    return 0;
}

Output:

Global Variable: 10
Value: 20

Why does local variables takes precedence over global variables if variable shadowing happens?

Local variables take precedence over global variables when variable shadowing occurs because the function or block where the local variable is declared becomes the active scope. In this active scope, the program focuses on the variables defined within it, as they are directly relevant to the function's logic. When a local variable has the same name as a global variable, the program will use the local variable because it is the most specific definition available within that scope.

The active scope ensures that the program uses the data defined inside that function or block, without inadvertently relying on or modifying global variables. This behavior makes the function self-contained and prevents unintended interference from global variables.
Essentially, the local variable is considered more relevant for the current task, and the program gives it priority to maintain clarity and control over the data being used.

How does the program know which variable to use and where?
In order to understand this concept we need to understand the concept of scope resolution.

• When the program starts executing, it determines which scope( region of the code ) is currently active based on where the program's execution flow is at the moment. This can be a global scope, or the scope of a specific function or block( like if or while )
  • Example: If the program is inside a function, the function's scope is considered "active". If it's inside a loop or if block, that block's scope becomes active.
• As the program runs, it moves through the active scope. When it encounters a variable name, it performs a variable lookup. It first checks if the variable exists in the current active scope ( the most specific scope, like inside the function or block ). If the program finds the variable there, it uses that version of the variable. In other words, when we want to use a particular variable, the program will use the one declared within that block or function.
• If the program doesn't find the variable in the active scope, it will move outward and search in the next outer scope. It continues looking in progressively broader scopes ( for example, from block → function → global ) until it either finds the variable or has checked all possible scopes.
• Now, here's something special: If there is a local variable with the same name as a global variable, the local variable "shadows" the global one inside its active scope. This means the program will use the local variable in that specific block or function, even though the global variable exists outside of it.

Can I use a global variable within a function or scope when a local variable with the same name exists?

The short answer is yes, it's possible! But how?
You may have seen something like this in previous C++ code examples:

std::cout<<"Welcome to LearnYard !"<<endl;

But we never really explained the :: operator. So, let's dive into it now.

The :: operator, also known as the scope resolution operator, is a tool in C++ that specifies the scope in which a function or variable belongs. It's particularly helpful in resolving conflicts that occur when variables or functions in different scopes share the same name.
In simpler terms, the scope resolution operator allows you to access the global version of a variable or function, even if there is a local version with the same name.

Basic Syntax: :: ( without prefix ): refers to global variable.
When you use ::, you're telling the program to explicitly access the global variable or function, bypassing any local version of the same name that may exist within the current function or block.

Check out this coding example to get a better idea

#include <iostream>
using namespace std;

// Global Variable
// -------------------------------------------------------
int number = 100;

void Display(){
    
    // Local Variable
    // -------------------------------------------------------
    int number = 200;
    cout<<"Local Variable: "<<number<<endl;
    cout<<Global Variable: "<<::number<<endl;
    
}

int main(){

    Display();
    return 0;
}

Output:

Local Variable: 200
Global Variable: 100

Now that we've covered the basics of scope, variable shadowing, and scope resolution, let's explore a few specialized variations of these scopes that determine a variable's accessibility and visibility in different contexts.

What is a Namespace?

Before diving into namespace scope, let’s first understand what a namespace is.
Imagine you’re playing a video game with different zones or regions, each containing unique characters or items. While some characters or items might share the same name, you can still tell them apart because they belong to different zones.
In this analogy, the entire game represents your C++ program, and each zone or region acts as a namespace.

Why Do We Need Namespaces?

In C++, a namespace allows you to group related code—such as variables, functions, and classes—under a single name.

Prevents Naming Conflicts: In large programs, different libraries or modules might use the same names for variables or functions. A namespace ensures that these names don’t clash.
Improves Code Organization: Namespaces help structure code, making it more readable and maintainable.

Defining a Namespace in C++ : To create a namespace, use the namespace keyword, followed by the namespace name, and wrap its contents inside {}curly braces.

namespace NamespaceName {
    int variable = 10;
    void PrintVariable(){
        std::cout<<variable<<std::endl;
    }
}

To access the members of a namespace, you use the namespace name followed by the :: scope resolution operator which we just studied.

int main(){

    // Access variable 'variable' from NamespaceName 
    // -------------------------------------------------------
    std::cout<<NamespaceName::variable;
    NamespaceName::PrintVariable();
    return 0;
}

When a variable, function, or class is declared inside a namespace, its scope is limited to that namespace. This means that the variable is part of the namespace and cannot be directly accessed from outside unless explicitly referenced.
Despite the restricted scope within the namespace, you can still access its variables from other parts of the program by qualifying it with the namespace name. This qualification tells the program exactly where to find the variable.
There are two ways to access variables within a specified namespace:

Using the namespace name explicitly

• You can access a variable by prefixing it with the namespace name.
• Example: namespace_name::variable_name;

Using the using keyword

• Instead of qualifying each variable with the namespace name, you can use the using keyword to bring the variable into the current scope.
• Example: using namespace namespace_name;

A commonly used example is using namespace std; which imports all entities from the std namespace into the current scope, eliminating the need to specify std:: every time you use standard library components.

Another example considering using keyword:

#include <iostream>
using namespace std;
namespace NamespaceName{
    int x = 10; 
}
using namespace NamespaceName;
int main(){

    // Now after `using` keyword we can access x directly qualify it to namepsace name
    // -------------------------------------------------------
    cout<<x<<std::endl;
    cout<<x<<std::endl;
    
    return 0;
}

Output:

10
10

I’m sure you have some curious questions swirling in your mind—let’s take a moment to address and clarify them!

Can variables declared inside a namespace be modified from anywhere in the program?
The simpler answer to the question is YES! provided you have access to the variable. You can change the value of namespace variable by explicitly qualifying it with the namespace name.

Here is an example:

#include <iostream>

namespace NamespaceName{

    // Variable declared inside the namespace
    // -------------------------------------------------------
    int variable =10;
}

int main(){
    std::cout<<"Before Modification: "<<NamespaceName::variable<<std::endl;
    
    // Modifying the value of variable inside NamespaceName
    // -------------------------------------------------------
    std::cout<<"After Modification: "<<NamespaceName::variable<<std::endl;
    
    return 0;
    
}

 Output:

Before modification: 10
After modification: 20

However, there are a few important considerations to keep in mind when modifying a variable inside a namespace.

• Variable inside a namespace can be changed as long as they are not declared as const or constexpr.
• In multithread programs, modifying namespace variables can lead to race conditions if multiple threads attempt to modify them simultaneously.
• Namespace variables act somewhat like global variables. Modifying them from multiple locations in a program can make it harder to track changes and debug issues.

Why do we say that the scope of a namespace variable is limited to the namespace in which it is defined, if it can be accessed and modified from anywhere in the program?
To understand why we say a variable’s “scope is limited to the namespace,” let’s first clarify what this actually means:
Variables in a namespace are grouped together with other members of that namespace. Outside the namespace, these variables are not directly accessible—you must use their fully qualified name (e.g., NamespaceName::x) to access them.
While it’s true that namespace variables can be accessed and modified from anywhere in the program because they exist in the program's overall memory space, you must explicitly refer to the namespace unless you bring them into the current scope using the using keyword.
This scope limitation is more about how you refer to the variables rather than their accessibility. Without qualification or the using keyword, namespace variables don’t exist in the current scope, unlike global variables, which are accessible directly from any part of the program.

Now, let's consider an example where global variable and the variable inside the namespace have the same name.

#include <iostream>

// Global variable
// -------------------------------------------------------
int value = 100;

namespace MyNamespace {

    // Namespace variable
    // -------------------------------------------------------
    int value = 200;
}

int main() {
    // Accessing the global variable
    // -------------------------------------------------------
    std::cout << "Global value: " << value << std::endl;

    // Accessing the namespace variable using namespace qualification
    // -------------------------------------------------------
    std::cout << "Namespace value: " << MyNamespace::value << std::endl;

    // Bringing the namespace variable into the current scope using the 'using' keyword
    // -------------------------------------------------------
    using MyNamespace::value;

    // Accessing the namespace variable directly (causes ambiguity if not carefully used)
    // -------------------------------------------------------
    std::cout << "Namespace value (using keyword): " << value << std::endl;

    // To explicitly access the global variable after using 'using', use scope resolution operator
    // -------------------------------------------------------
    std::cout << "Global value (explicitly): " << ::value << std::endl;

    return 0;
}

Output:

Global value: 100
Namespace value: 200
Namespace value (using keyword): 200
Global value (explicitly): 100

Important thing to note over here is, after the using MyNamespace::value statement brings the namespace variables into the current scope and the value in the current scope refers to namespace variables. It shadows the global variable in unqualified access, however the global variable can still be accessed explicitly using the scope resolution operator(::).

Now, lets look into the common mistakes we make when it comes to using local and global variables.

Common Mistakes When Using Local and Global Variables

Both local and global variables are important in programming, but there are common mistakes that developers—especially beginners—tend to make when working with them. Here are some of them.

Mistakes with local variables

• Trying to access local variables outside their scope
  Issue: Local variables only exist within the function or block where they are declared. Trying to access them outside their scope will result in a compiler error because the variable is not recognized.
  
  Solution: Always ensure that local variables are accessed only within their defined scope.
• Overusing local variables
  Issue: While local variables are important, creating too many in large functions can make your code hard to read and maintain.
• Solution:Keep functions short and focused.Use local variables only when necessary.Break large functions into smaller, more manageable ones to improve clarity and maintainability.

Mistakes with global variables

Unintentional modification of global variables
Issue: Global variables can be modified from anywhere, leading to hard-to-trace bugs and unexpected behavior.

Solution:

• Use functions to control access to global variables.
• Limit the use of global variables whenever possible to maintain better structure and reliability.

Variable name conflicts
Issue: Reusing the same variable name in different parts of the program can lead to confusion and bugs, especially in large projects.

Solution:

• Use clear and descriptive names for global variables.
• Consider using namespaces or prefixing global variables to distinguish them (e.g., global_score).

Understanding Variable Lifetime in C++

Every variable in C++ has a lifetime—a period during which it exists in memory before being removed. But how does C++ decide when to create and destroy a variable? Does it stay in memory forever, or does it disappear once it’s no longer needed?

Many beginners confuse scope and lifetime, but they are different:

• Scope defines where a variable can be accessed.
• Lifetime defines how long a variable exists in memory.

Imagine you're playing a Real Playing Game (RPG) where your character progresses through different levels:

• When you reach a checkpoint, your progress is saved—this is like scope in programming. You can only access the saved data from that checkpoint.
• Your saved game exists until you overwrite or delete it—this is like lifetime. Once you start a new game, the old save might be erased, just like how variables are removed from memory when they are no longer needed.

Why Does Lifetime Matter?

If variables lived forever, programs would run out of memory and crash. C++ efficiently manages variable lifetimes, ensuring memory is freed when it's no longer required.

Now that we understand what variable lifetime is, let’s dive deeper into how it works for different types of variables in C++!

Types of Variable Lifetime

In C++, variables don’t last forever! Some exist only for a short duration, some stay throughout the entire program, and others are created and removed dynamically. To understand this better, let’s compare variable lifetimes to different elements in a video game.

1. Automatic (Local) Lifetime

Variables with automatic lifetime are created when a function (or block) starts and are destroyed when the function (or block) ends. These variables are stored in the stack, which efficiently manages function calls and local variables.

Imagine you pick up a side quest in an RPG. You get a temporary objective and maybe a special item to complete the mission. However, once the quest ends, the objective disappears, and any temporary quest items are removed from your inventory.

Similarly, an automatic variable exists only while the function is running. Once the function ends, the variable is "discarded," just like a completed side quest.

void myFunction() {
    int x = 10; // Created when the function is called
    cout << x << endl;
} // x is destroyed when the function ends

2. Static Lifetime

Variables with static lifetime exist for the entire duration of the program. They are stored in the data segment of memory and retain their value between function calls. This means they are initialized only once and persist throughout the execution of the program.

In an RPG, your character gains experience points (XP), skill levels, and abilities as they progress. Even if you leave a dungeon or log out of the game, your progress remains intact when you return.

Similarly, a static variable retains its value across function calls. It is only initialized once and remembers past changes, just like how an RPG character remembers their progress.

void myFunction() {
    static int count = 0; // Created once, persists between function calls
    count++;
    cout << count << endl;
}

3. Dynamic Lifetime

Variables with dynamic lifetime are created manually using new and must be explicitly deleted using delete. These variables are stored in the heap, a memory segment used for dynamic memory allocation. If not managed properly, they can cause memory leaks.

In an RPG, you can summon allies or creatures to help you in battle. They stay with you until you send them away or they get defeated. But if you forget to send them away when they are no longer needed, they keep using up your resources.

Similarly, dynamically allocated variables stay in memory until you manually delete them. If you forget to delete them, they keep using memory, which can slow down your program—just like having too many unnecessary summons can slow down your game.

int* createNumber() {
    int* ptr = new int(100); // Created on the heap
    return ptr;
}

int main() {
    int* num = createNumber();
    cout << *num << endl;
    delete num; // Must be manually deleted
    return 0;
}

Conclusion

In this article, we’ve explored variable scope in depth—covering its definition, types, specialized scopes, variable shadowing, scope resolution, and more. We also delved into variable lifetime, understanding how long variables exist in memory and how C++ manages their creation and destruction.

In the next article, we’ll dive into the concept of memory allocation and how it ties into variable lifetime and scope. Stay tuned!