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 object gets a 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};
7
8int main(){
9  Vampire A;
10  A.Health = 50;
11
12  Vampire B;
13  B.Health = 200;
14}

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

However, what if we want all objects in our class to share a variable? For example, all Vampires will have the same Faction - we don’t need to have every object getting a separate copy of this std::string:

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

In this lesson, we’ll introduce the concept of static members, 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};

Why do we need inline?

C++ assumes a class definition is going to be included in multiple files. This is a reasonable assumption as, in a real program, it’s almost always true.

Static class variables are part of the class, rather than as part of objects of that class. Therefore, when a class declaration defines a static variable, that is very similar to defining a global variable. Static class members like the Vampire::Faction symbol will have external/global linkage. We covered linkage in more detail in the previous lesson

Internal and External Linkage

A deeper look at the C++ linker and how it interacts with our variables and functions. We also cover how we can change those interactions, using the extern and inline keywords

Once a header containing a static class variable definition is included in multiple other files, each of those files would be defining that symbol.

This breaches the one definition rule (ODR), so the compiler pre-emptively asks us to mark in-class static declarations as inline.

For variables, keeping the definition and declaration in the same place and marking it as inline is generally recommended. But, as an alternative, we can move the definition to an implementation file file. Assuming we’re not going to be using the #include directive to insert implementation files, this removes the need for inline:

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

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

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}

1They're the same

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}

1Demonic

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}

1error C2678: binary '=': no operator found which takes a left-hand operand of type 'const std::string'

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:

1class Vampire {
2 public:
3  static constexpr char Faction[] {"Undead"}; 
4};

Note that as of C++23, a std::string cannot be used as a constexpr in this way. Therefore, we’ve also changed the type to a C-style string. We cover strings in more detail later in the course.

1class Vampire {
2 public:
3  constexpr char Faction[] {"Undead"};
4};

1error C2178: 'Vampire::Faction' cannot be declared with 'constexpr' specifier

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}

1All Vampires are Undead
2They're now Demonic

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};

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}

1All Vampires are Undead

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 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.

Summary

In this lesson, we explored static class members, demonstrating how they allow for shared values and behaviors across instances

Main Points Learned

• Static class variables and functions are shared across all instances of a class
• The static keyword is used to declare static class members
• Using inline with static variables in header files helps avoid multiple definitions across different translation units.
• Static variables can be accessed using the scope resolution operator :: without needing to instantiate an object.
• Static member functions can access static variables, but cannot access non-static members.
• The concept of a "static class" in C++ is effectively a class with only static members, serving different purposes than namespaces but sometimes used to group related static members.
• constexpr with static members enables the definition of compile-time constants

Next Lesson

Friend Classes and Functions

An introduction to the friend keyword, which allows classes to give other objects and functions enhanced access to its members

ContinueView Course