Static vs Global Variables

Static variables and global variables in C++ both have static storage duration, meaning they exist for the lifetime of the program. However, there are key differences between them in terms of scope, usage, and encapsulation.

• Scope: Global variables are accessible from any part of the program. They are defined outside of any class or function.
• Visibility: By default, global variables have external linkage, meaning they can be accessed from any translation unit in the program.
• Encapsulation: Global variables are not encapsulated within a class, which can lead to potential naming conflicts and unintended modifications.

Example of a global variable:

1#include <iostream>
2
3int globalVar{100}; 
4
5void printGlobal() {
6  std::cout << "Global Variable: "
7    << globalVar << "\n";
8}
9
10int main() {
11  printGlobal();
12  globalVar = 200;
13  printGlobal();
14}

1Global Variable: 100
2Global Variable: 200

• Scope: Static variables within a class are only accessible through the class. They do not have global scope.
• Visibility: Static variables have internal linkage when defined within a class, meaning they are only accessible within the scope of the class.
• Encapsulation: Static variables are encapsulated within the class, promoting better organization and reducing the risk of naming conflicts.

Example of a static variable:

1#include <iostream>
2#include <string>
3
4class Vampire {
5public:
6  static inline std::string Faction{"Undead"}; 
7};
8
9void printFaction() {
10  std::cout << "Faction: "
11    << Vampire::Faction << "\n";
12}
13
14int main() {
15  printFaction();
16  Vampire::Faction = "Demonic";
17  printFaction();
18}

1Faction: Undead
2Faction: Demonic

• Scope: Global variables are accessible everywhere, while static variables are scoped to the class.
• Encapsulation: Static variables are encapsulated within the class, improving organization and maintainability.
• Visibility: Global variables have external linkage by default, whereas static variables within a class have internal linkage.

• Global Variables: Use global variables sparingly, typically for constants or configurations that need to be accessed globally.
• Static Variables: Use static variables within classes to share data among all instances of the class while maintaining encapsulation.

In summary, static variables provide better encapsulation and scope control compared to global variables, making them preferable for shared data within classes.