In what seems like a deliberate design decision, C++ does not have a null value for objects and references. This makes using objects and references very elegant since we don't have to perform null checks. It also means constructors must always return an object:

    // Hypothetical constructor that refuses to return an object:
    Object() { return void }
    void main () {
        Object o = new Object(); // o is guaranteed to be non-null, allowing the constructor above would break that guarantee.

Sometimes object creation has to fail, an easy example being a `Connection` object. Since C++ does not allow this, programmers have developed alternatives: initialization methods (with various names), static builder methods, "Factories" that do not use any polymorphism, and null objects. [One reason for adding exceptions may have been as a way to go around this limitation of C++ constructors][1], but either way, it is a tradeoff - we avoid null checks but sometimes have awkward construction.


But all of this falls apart when we consider newer OOP languages like Java and C#. There, references are allowed to be null, yet constructors work like C++ and must not fail. So we get to write both null checks and alternative construction schemes. Why?