Static Global Variables in C++

[Linux Hint]

The variables in the C++ programming language serve as fundamental building blocks to handle and manage the data which plays an essential role in manipulating the variables within a C++ program. The C++ programming language offers a robust way to manage the variable visibility across different scopes and compilation units using static global variables. A static global variable that is declared at the global scope is restricted to the file in which it is defined due to the “static” specifier. The “static” keyword ensures that the variable retains its value across function calls within that file yet remains inaccessible and invisible to other files. Static global variables in C++ are crucial in managing the program’s state. This article explores the intricacies of static global variables, highlighting their characteristics, use cases, and potential challenges.

Static Variables in C++

In C++, a static variable can be instantiated within various scopes including global, local, namespace, or within classes. Its existence spans the entire program runtime from start to finish, ensuring that its allocation is maintained throughout. In simple words, the memory is allocated to these variables at the beginning of the program and deallocated when the program execution ends. When the static is used with a variable, it limits the variable’s visibility in terms of linkage, and it is only accessible for the program where it is declared.

Applications of Static Variables in C++

The static global variable provides a controlled mechanism to maintain a state or configuration that is pertinent only to the defining file. The concept of file scope that is imposed by static global variables facilitates a cleaner modular programming by preventing unwanted side effects from external linkage, thereby leading to a more maintainable and error-resistant code. The static variable can be used in various scenarios and they are listed in the following:

Scenario 1: Counter Across Multiple Functions

When a variable is declared with the static keyword inside a function, it preserves its state across multiple calls to the same function. This ability to maintain the state of a variable can be advantageous under specific circumstances. Let us look at an example to understand the counter across multiple functions using a C++ static global variable. The example code is given as follows:

#include <iostream>
class Counter {
private:
  static int globalCounter;
public:
  void incrementCounter() {
    ++globalCounter;
  }
  int getCounterValue() const {
    return globalCounter;
  }
};
int Counter::globalCounter = 0;
int main() {
  Counter counter;
  for (int i = 0; i < 5; ++i) {
    counter.incrementCounter();
  }
  int counterValue = counter.getCounterValue();
  std::cout << "The value of the counter is: " << counterValue << std::endl;
  return 0;
}

 

This code defines a simple “Counter” class with two functions: “incrementCounter” which increases the global counter by 1 and “getCounterValue” which returns the global counter's current value. The code also includes a main function that explains how to use the “Counter” class. It creates a “Counter” object, increments the counter five times, retrieves its value, and prints it to the console. This implementation uses a single global counter that is shared by all “Counter” objects. It is simple and easy to understand, but it may not be suitable for situations where you need multiple independent counters. See the following output of the program:

In this example, you can observe that the “globalCounter” static variable retains its state between calls to functions like “incrementCounter” and “getCounterValue” which act as a persistent counter across multiple functions in the same file.

Scenario 2: Utility Function Shared Across Instances

When a member function in the class is defined as static, it becomes available to all the class instances. However, it cannot access an instance member as it does not have a pointer. Let us dig into the following relevant example to have a better understanding of this scenario:

#include <iostream>
class UtilityClass {
public:
  static void utilityFunction() {
    std::cout << "The Utility function is called." << std::endl;
  }
};
class MyClass {
public:
  void callUtilityFunction() {
    UtilityClass::utilityFunction();
  }
};
int main() {
  MyClass obj;
  obj.callUtilityFunction();
  return 0;
}

 

This code defines two classes: “UtilityClass” and “MyClass”. The “UtilityClass” has a public static function called “utilityFunction” that prints "The Utility function is called" to the console. The “MyClass” has a public function called “callUtilityFunction” that calls the “utilityFunction” function of the “UtilityClass”.

The main function creates an object of the “MyClass” called “obj”. It then calls the “callUtilityFunction” function of the “obj” object. This causes the “utilityFunction” function of the “UtilityClass” to be called which prints "The Utility function is called" to the console. See the following output of the code:

This approach eliminates the need for separate objects and simplifies the code structure. The class provides two ways to access the “utilityFunction”. One way is directly which is using the UtilityClass::utilityFunction() syntax which is accessible without creating an object. The other way is through an object that uses the obj.callUtilityFunction() member function which allows more context and potential additional functionality within the class. This approach balances simplicity and flexibility, depending on your desired usage pattern for the utility function.

Scenario 3: Class Scope in Static Global Variable

Regardless of the number of instances of the class, a member that is declared as static within a class only exists in one copy. This applies to both data members (variables) and member functions. Importantly, the definition of a static data member must occur outside the class declaration, typically at file scope.

Here’s an example of static that is applied to both a data member and a member function in C++:

#include <iostream>
class Counter {
public:
    static int globalCount;
    Counter() {
        ++globalCount;
    }
static void printGlobalCount() {
    std::cout << "The Global count is: "<< globalCount << std::endl;
    }
};
int Counter::globalCount = 0;
int main(){
    Counter counter1;
    Counter counter2;
    Counter::printGlobalCount();
    return 0;
}

 

The code defines a class called “Counter” with a private static member variable named “globalCount” and two public member functions. One is Counter() which is a constructor function that increments the “globalCount” variable. The other one is a “printGlobalCount” that returns the current value of the “globalCount” variable. The code also includes a main function. This function creates two objects of the “Counter” class that is identified by “counter1” and “counter2” names. After the variable declaration, it calls the “Counter::printGlobalCount” function which presumably prints the current value of the “globalCount” variable. See the following output snippet:

In this example, a “globalCount” variable is declared as a static data member inside the “Counter” class. This means that only one copy of this variable exists, regardless of how many “Counter” objects are created. The counter()constructor increments the “globalCount” for each instance, demonstrating its shared nature across objects. The “printGlobalCount” is a static member function. Remember, it is done using the name of the class directly (Counter::printGlobalCount). The output shows that the “globalCount” is incremented as expected, reflecting the shared state across all instances of the “Counter” class.

Conclusion

In conclusion, static global variables in C++ emerge as a versatile tool to manage the state across functions and files. Their internal linkage, persistent nature, and controlled information sharing make them valuable assets in certain programming scenarios. By understanding their characteristics, exploring the diverse use cases, and acknowledging the potential pitfalls, the developers can wield the static global variables effectively, enhancing the code modularity and facilitating a communication between different parts of their projects. Through thoughtful consideration and adherence to the best practices, static global variables can be harnessed to contribute positively to the design and functionality of C++ programs.

View the full article