Different Kinds of Data Members in C++

static Data Members

Sometimes giving each object of a class a copy of a variable is overkill or won't work. The data member might be specific to the class, but not appropriate for each object to have its own copy.

A common situation is for each object of a class to have a unique numerical identifier. You would also need a counter that starts at 0 from which each new object could obtain its ID. This counter really belongs to the class, and it doesn't make sense for each object to have a copy of it, because you would have to keep all the counters synchronized somehow. C++ provides a solution with static data members. A static data member is a data member associated with a class instead of an object. You can think of static data members as global variables specific to a class. Here is the MyClass class definition, including the new static counter data member:

export class MyClass
{
// Omitted for brevity
private:
  static std::size_t counter;
};

In addition to listing static class members in the class definition, you will have to allocate space for them in a source file, usually the source file in which you place your class member function definitions. You can initialize them at the same time, but note that unlike normal variables and data members, they are initialized to 0 by default. Static pointers are initialized to nullptr. Here is the code to allocate space for, and zero-initialize, variable counter:

size_t MyClass::counter;

Static data members are zero-initialized by default, but if you want, you can explicitly initialize them to 0 as follows:

size_t MyClass::counter { 0 };

This code appears outside of any function or member function bodies. It's almost like declaring a global variable, except that the MyClass:: scope resolution specifies that it's part of the MyClass class.

Just as for normal data members, access control specifiers apply to static data members as well. You could make the counter data member public, but, as you already know, it's not recommended to have public data members (const static data members discussed in an upcoming section are an exception). You should grant access to data members through public getters and setters. If you want to grant access to static data members, you can provide public static get/set member functions.

export class MyClass
{
  // Omitted for brevity
private:
  static inline std::size_t counter { 0 };
};

size_t MyClass::counter; // redundant, actually

export class MyClass
{
public:
  // Omitted for brevity
  std::size_t getId() const;
private:
  // Omitted for brevity
  static inline std::size_t counter { 0 };
  std::size_t m_id { 0 };
};

MyClass::MyClass(size_t width, size_t height)
: m_id { counter++ } // , ... (omitted)
{
  // Omitted for brevity
}

export class MyClass
{
private:
  // Omitted for brevity
  const std::size_t m_id { 0 };
};

export class MyClass
{
public:
  // Omitted for brevity
  static constexpr std::size_t MaxHeight { 100 };
  static constexpr std::size_t MaxWidth { 100 };
};

MyClass::MyClass(size_t width, size_t height)
: m_id { ms_counter++ }
, m_width { std::min(width, MaxWidth) }// std::min() defined in <algorithm>
, m_height { std::min(height, MaxHeight) }
{
  // Omitted for brevity
}

export class MyClass
{
public:
  explicit MyClass(
    std::size_t width = MaxWidth, std::size_t height = MaxHeight);
  // Omitted for brevity
};

println("Maximum height is: {}", MyClass::MaxHeight);

Reference Data Members

MyClass's and such are great, but they don't make a useful application by themselves. You need code to control the entire MyClass program, which you could package into a MyClassApplication class. Suppose further that we want each MyClass to store a reference to the application object. The exact definition of the MyClassApplication class is not important at this moment, so the following code simply defines it as an empty class. The MyClass class is modified to include a new reference data member called m_theApp:

export class MyClassApplication { };

export class MyClass
{
public:
  MyClass(std::size_t width, std::size_t height,
  MyClassApplication& theApp);
  // Code omitted for brevity.
private:
  // Code omitted for brevity.
  MyClassApplication& m_theApp;
};

This definition adds a MyClassApplication reference as a data member. It's recommended to use a reference in this case instead of a pointer because a MyClass should always refer to a MyClassApplication. This would not be guaranteed with a pointer.

Note that storing a reference to the application is done only to demonstrate the use of references as data members. It's not recommended to couple the MyClass and MyClassApplication classes together in this way, but instead to use a paradigm such as Model-View-Controller (MVC).

The application reference is given to each MyClass in its constructor. A reference cannot exist without referring to something, so m_theApp must be given a value in the ctor-initializer of the constructor.

MyClass::MyClass(size_t width, size_t height,
MyClassApplication& theApp)
: m_id { ms_counter++ }
, m_width { std::min(width, MaxWidth) }
, m_height { std::min(height, MaxHeight) }
, m_theApp { theApp }
{
  // Code omitted for brevity.
}

You must also initialize the reference member in the copy constructor. This is handled automatically because the MyClass copy constructor delegates to the non-copy constructor, which initializes the reference data member.

Remember that after you have initialized a reference, you cannot change the object to which it refers. It's not possible to assign to references in the assignment operator. Depending on your use case, this might mean that an assignment operator cannot be provided for your class with reference data members. If that's the case, the assignment operator is typically marked as deleted.

Finally, a reference data member can also be marked as const. For example, you might decide that MyClasss should only have a reference-to-const to the application object. You can simply change the class definition to declare m_theApp as a reference-to-const:

export class MyClass
{
public:
  MyClass(std::size_t width, std::size_t height,
    const MyClassApplication& theApp);
  // Code omitted for brevity.
private:
  // Code omitted for brevity.
  const MyClassApplication& m_theApp;
};