The notion of invariants was introduced nearly 30 years ago. In essence, an invariant is the property that makes the state of an object well-defined. Usually, the invariant of a class is achieved by executing its constructor. A program assumes that an object’s invariant holds true once the object has been fully constructed, as long as it hasn’t been destroyed. In other words, when you call an object’s member function, you assume that the object is in a well-defined state without having to check its state every time. Let’s look at a concrete example, a string class. You can initialize a string object in several ways, e.g., by invoking its default constructor, as in:

  std::string s;

or by initializing it with another string object:

  std::string s1(s2);

From this moment on, you can use the string object safely, knowing it’s in a well-defined state, e.g., it doesn’t hold a dangling pointer or a null pointer, and that its member functions perform the desired operations.

Designing a class usually consists of defining an invariant that is simple enough to express in terms of a constructor. Note that C++ defines other invariants: a reference variable, for instance, is always bound to a valid object; unlike a pointer, you don’t have to check whether it’s null nor do you have to release it. Likewise, the stream objects cin and cout are created before the program’s outset without necessitating any assistance from the user.