C++ Static Variable

In C++, static variables are a type of variable whose lifetime extends the whole program's execution but whose scope can be restricted based on where they are defined. We recently covered how the static keyword changes the behaviour of a variable, which ensures that its value remains long after the block or function in which it is defined has completed execution.

Static variables are very useful when we need to save a common property or track shared data across multiple objects. They contribute to less redundancy and greater consistency across all instances.

C Static Variable Example

Let us take an example to illustrate the Static variable in C.

Output:

Account Holder Name: Joseph, Balance: $50000
Account Holder Name: John, Balance: $40000
Account Holder Name: Mary, Balance: $20000
Total Bank Accounts Created: 3

Explanation:

In this example, we define a tpointTech class that represents a bank account and a static variable total_accounts, which keeps track of the total number of accounts created. When a tpointTech object is created, the constructor sets the account information and increases total_accounts, which is shared by all instances. After creating three accounts and presenting their information, the program uses the static variable to calculate the overall number of accounts created.

Types of Static Variables in C++

There are several static variables that can also be categorized into three essential categories:

• Static Variables Inside Functions
• Static Member Variables in Classes
• Global Static Variables

Static Variables Inside Functions

In C++, when a variable is declared as static inside the function, its value is retained across successive calls to the function. Generally, local variables are created when a function begins and removed when it ends. However, a static local variable is initialized only once the first time the function is called and lives until the program ends. Each successive call to the function sees the static variable's most recent modified value.

C++ Static Variable Inside Functions Example

Let us take an example to illustrate the Static variables inside functions in C++.

Output:

Count is: 1
Count is: 2
Count is: 3

Explanation:

In this program, we have taken a display() function that contains a static variable c, which is initialized only once and preserves its value between functions. Each time the display() function is called, c is incremented by one and printed. As a result, running the display() function three times produces the outputs 1, 2, and 3 in order.

Static Member Variables in Classes

When a variable is specified as static within a class, it belongs to the class rather than a specific object. It signifies that all instances of the class use the same static variable. Static members are initialized outside of the class and exist independently of any of its objects.

C++ Static Member Variables in Classes Example

Let us take an example to illustrate the Static member variable in Classes in C++.

Output:

Total objects created are: 3

Explanation:

In this example, we have taken the tpointTech class that includes a static member object_count function that keeps track of how many objects of the class have been created. After that, the object_count function is updated every time the constructor is called. Three objects (a, b, and c) are created in the main() function.

Global Static Variables

In C++, when a global variable is declared in the program with the static keyword, its scope is limited to the source file. It means that the variable cannot be accessed from other files. It is also useful to encapsulate and helps to hide implementation details and prevent naming conflicts in huge programs with several source files.

C++ Global Static Variables Example

Let us take an instance to demonstrate the Global static variable in C++.

Output:

Connecting to database... 
Connection count: 1
Connecting to database... 
Connection count: 2
Database connection closed. 
Remaining connections: 1

Explanation:

In this example, we simulate a simple database connection tracker using a global static variable db_connection_count. After that, every call to ConnectToDatabase() function helps to increases the count, and CloseDatabaseConnection() function helps to decreases the cout, which ensures that only active connections are closed. Finally, the output displays the connection and disconnection process in sequence.

Storage of Static Variables in C++

In C++, the static variable is used to allocate memory once during the program's lifetime, and it retains its value between function calls. Unlike local variable that are stored on the stack, static variables are mainly stored in a special memory area that is known as data segment.

If a static variable is clearly initialized in the program, its value is stored in the initialized data segment. If it is not clearly initialized in the program, it is automatically set to 0 and placed in the BSS (Block Started by Symbol) segment, which holds uninitialized static or global variables. It means that the memory used by static variables is kept throughout the program, regardless of whether the function or scope in which they were defined has ended.

Applications of Static Variables in C++

Several applications of static variables in C++ are as follows:

• Preserving state between function calls: Static variables store their values between calls to the same function. It allows a function to "remember" what happened in earlier calls and apply that information to the present execution.
• Restricting scope to a function or file: A static variable specified within a function or file is linked internally. It means that it cannot be accessed from outside the function or file, which helps with logic encapsulation and preventing name conflicts.
• Efficient memory usage in classes: Static data members of a class are shared by all instances. When the same data is used across multiple objects, only one copy is made, which optimizes memory use.
• Counting Instances of a Class: Static variables are commonly used to display how many objects of a class have been produced because all instances share them and can be updated without the requirement for an object.
• Implementing Singleton Pattern:Static variables are important in the Singleton design pattern because they store a single instance of a class that is reused during the program.

C++ Static Variables MCQs

1) What is the lifetime of a static variable defined within a function in C++?

1. Until the function terminates.
2. Until an object is destroyed.
3. Until the program ends.
4. It depends on the scope.

2) Which of the following options correctly declares a static variable inside a class in C++?

1. int static count;
2. static int count = 0;
3. int count static;
4. count static int;

3) Which of the following options shows the scope of a global static variable in C++?

1. Class only
2. Entire program
3. The file in which it is declared
4. Main function only.

4) When a static variable is initialized inside a function in C++?

1. After the program ends
2. Only once, on the first function call
3. At compile time
4. Every time the function is called

5) What happens if a static variable is accessed without first being initialized in C++?

1. It automatically gets garbage value
2. It causes a runtime error
3. It throws a compile error
4. It is initialized to zero by default