Memory Allocation for Static Variables

Marking a variable as static in C++ affects its memory allocation by changing its storage duration and scope.

Non-Static Variables

• Storage Duration: Automatic (local variables) or dynamic (heap allocation).
• Scope: Limited to the instance of the class.
• Memory Allocation: Each instance of the class gets its own memory allocation for non-static variables.

For example:

1#include <string>
2
3class Vampire {
4public:
5  int Health{100};
6};
7
8int main() {
9  Vampire A;
10  Vampire B;
11  // A and B have separate memory for Health
12}

Here, A and B each have their own Health variable, stored separately in memory.

Static Variables

• Storage Duration: Static (exists for the lifetime of the program).
• Scope: Shared among all instances of the class.
• Memory Allocation: Only one allocation for the static variable, regardless of the number of instances.

For example:

1#include <iostream>
2#include <string>
3
4class Vampire {
5public:
6  static inline std::string Faction{"Undead"};
7};
8
9int main() {
10  Vampire A;
11  Vampire B;
12  // A and B share the same memory for Faction
13}

In this case, Faction is allocated once and shared by all instances of Vampire.

Impact on Memory Allocation

• Efficiency: Static variables save memory when the same data is shared among all instances. Instead of each instance having its own copy, a single copy is shared.
• Lifetime: Static variables persist for the lifetime of the program. They are allocated when the program starts and deallocated when the program ends.
• Access: Static variables can be accessed without creating an instance of the class, using the class name and the scope resolution operator ::.

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

1Undead
2Demonic

In summary, marking a variable as static centralizes memory usage for shared data, providing efficient memory management and consistent data access across all instances of the class.