Static Class Variables and Functions

Previously, we've talked about how classes are blueprints for creating objects. These objects, or instances, will all have the same structure. They have the same variables and the same functions that can access and update those variables.

Each individual object gets its own copy of the class variables. As such, different objects can have different values for each variable:

1#include <string>
2
3class Vampire {
4public:
5  int Health{100};
6  std::string Faction{"Undead"};
7};
8
9int main(){
10  Vampire A;
11  A.Health = 50;
12  
13  Vampire B;
14  B.Health = 200;
15}
16

In the above example, all instances of Vampire will have a Health and Level value, and those values can be different for each object.

But what if we don’t want this behavior? What if we want the Faction of all Vampire objects to remain the same?

In this lesson, we’ll introduce the concept of static class variables, which achieves exactly this.

Static Class Variables

Whilst a variable like Health can vary from object to object, all of the objects of this class should share the same Faction

We can do this by marking the Faction variable as static and inline:

1#include <string>
2
3class Vampire {
4public:
5  int Health{100};
6  static inline std::string Faction{"Undead"};
7};
8

1// Vampire.h
2#pragma once
3#include <string>
4
5class Vampire {
6public:
7  // Declaration
8  static std::string Faction;
9};
10

1// Vampire.cpp
2#include "Vampire.h"
3
4// Definition
5std::string Vampire::Faction{"Undead"};
6

Static variables are shared across all instances of a class. In other words, any time we access the Faction property of one of our Vampire objects, we are accessing the same location in memory.

We can verify this by checking what is returned by &, the address-of operator:

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  if (&A.Faction == &B.Faction) {
13    std::cout << "They're the same";
14  }
15}
16

1They're the same
2

Updating Static Variables

Given that all instances of a class share the same static variable, updating it on one object will have the effect of updating it on all objects of that class:

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
13  // Setting A.Faction
14  A.Faction = "Demonic";
15
16  // Getting B.Faction
17  std::cout << B.Faction;
18}
19

1Demonic
2

We can prevent a static variable from being updated in the usual ways, by marking it as a constant:

1#include <string>
2
3class Vampire {
4public:
5  const static inline std::string Faction{
6    "Undead"};
7};
8
9int main(){
10  Vampire A;
11
12  // Cannot update a const
13  A.Faction = "Demonic";
14}
15

constexpr Static Variables

Another implication of a class variable being static is that it can also be marked as a compile-time constant, using the constexpr keyword.

A constexpr variable is implicitly inline, so we can simultaneously remove the inline specifier:

1#include <string>
2
3class Vampire {
4public:
5  static constexpr std::string Faction
6    {"Undead"};
7};
8

It might seem like Faction could have been a compile-time constant even before it was marked as static. After all, the value of "Undead" was known at compile time.

However, before we marked it as static, the variable itself did not exist at compile time. Because it was a regular class variable, it is only created when objects of that class are created. For this class, that can only happen at run time.

However, we can consider static variables as being part of the class, rather than part of the object. The class is known at compile time, so static class variables can be constexpr.

Accessing Static Variables from the Class

Aside from these memory savings and the fact that our code now makes our intentions explicit, there is a further benefit to using static when appropriate.

Due to the fact every static class member is shared across all instances of a class, we can find out what that value is without needing to create an object.

We can access a static class member directly from the class, using 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 << "All Vampires are " <<
11    Vampire::Faction;
12
13  Vampire::Faction = "Demonic";
14  std::cout << "\nThey're now " <<
15    Vampire::Faction;
16}
17

1All Vampires are Undead
2They're now Demonic
3

static Functions

We've seen how classes can have const functions, which do not write to the properties of the object on which those functions are called.

We can also have static functions. Static functions do not read nor write to the properties of the object, unless those properties are also static.

1#include <string>
2
3class Vampire {
4public:
5  static std::string GetFaction(){
6    return Faction;
7  }
8
9private:
10  static inline std::string Faction{"Undead"};
11};
12

Static class functions can call other static functions. Attempting to call a non-static class function from a static class function will result in a compilation error.

Similar to static variables, static functions can be called from an object of the class using the . operator.

But they can also be called from the class itself, using the :: operator:

1#include <iostream>
2#include <string>
3
4class Vampire {
5public:
6  static std::string GetFaction(){
7    return Faction;
8  }
9
10private:
11  static inline std::string Faction{"Undead"};
12};
13
14int main(){
15  std::cout << "All Vampires are "
16    << Vampire::GetFaction();
17}
18

1All Vampires are Undead
2

Static Classes vs Namespaces

Accessing static class members through the :: operator bears some similarities to how we access members of a namespace.

To an extent, static members of a class can accomplish similar goals as namespaces, and the concept of a “static class” (a class that contains only static members) is a common pattern in other programming languages.

However, it tends to be less useful in C++. Namespaces achieve the goal in a simpler, more direct way. For the most part, we should only create classes (or structs) if we plan to instantiate objects from them.

But, sometimes a class really is the most intuitive place to put a variable or a function, even if won’t change from object to object. So, for those scenarios, we can just add the code to our class, and mark it as static.