const SomeClass& Class::getSomeClassVariable() const
{
    return *(SomeClass*)0;
}

*(SomeClass*)nullptr;

const SomeClass& ref = *(SomeClass*)nullptr;

The unary * operator performs indirection: the expression to which it is applied shall be a pointer to an object type, or a pointer to a function type and the result is an lvalue referring to the object or function to which the expression points.

undefined behavior
behavior for which this International Standard imposes no requirements
[ Note: Undefined behavior may be expected when this International Standard omits any explicit definition of
behavior ....

#include <cstdlib>

int main()
{
    void *p = std::malloc(sizeof(int));
    *(int *)p; // undefined behavior
    std::free(p);
}

#include <cstdlib>

NI>int main()
NI>{
NI>    void *p = std::malloc(sizeof(int));
NI>    *(int *)p; // undefined behavior
NI>    std::free(p);
NI>}

Before the lifetime of an object has started but after the storage which the object will occupy has been allocated or, after the lifetime of an object has ended and before the storage which the object occupied is reused or released, any pointer that represents the address of the storage location where the object will be or was located may be used but only in limited ways. For an object under construction or destruction, see [class.cdtor]. Otherwise, such a pointer refers to allocated storage ([basic.stc.dynamic.deallocation]), and using the pointer as if the pointer were of type void*, is well-defined. Indirection through such a pointer is permitted but the resulting lvalue may only be used in limited ways, as described below.

Similarly, before the lifetime of an object has started but after the storage which the object will occupy has been allocated or, after the lifetime of an object has ended and before the storage which the object occupied is reused or released, any glvalue that refers to the original object may be used but only in limited ways. For an object under construction or destruction, see [class.cdtor]. Otherwise, such a glvalue refers to allocated storage ([basic.stc.dynamic.deallocation]), and using the properties of the glvalue that do not depend on its value is well-defined.

#include <stdlib.h>

struct X
{
    int n;
};

int main()
{
    X *p = (X *)malloc(sizeof(X));
    p->n = 1; // undefined behavior
    free(p);
}

The working group has reached consensus that the issue is not a defect in the Standard. A Rationale statement describes the working group's reasoning.

*p is not an error when p is null unless the lvalue is converted to an rvalue

The lifetime of an object or reference is a runtime property of the object or reference. An object is said to have non-vacuous initialization if it is of a class or aggregate type and it or one of its subobjects is initialized by a constructor other than a trivial default constructor. The lifetime of an object of type T begins when:

• storage with the proper alignment and size for type T is obtained, and
  
• if the object has non-vacuous initialization, its initialization is complete,

struct X { const int n; };
X *p = new X{3};
const int a = p->n;
new (p) X{5}; // p does not point to new object (3.8)
// because X::n is const
const int b = p->n; // undefined behavior
const int c = std::launder(p)->n; // OK

Before the lifetime of an object has started but after the storage which the object will occupy has been allocated or, after the lifetime of an object has ended and before the storage which the object occupied is reused or released, any pointer that represents the address of the storage location where the object will be or was located may be used but only in limited ways.

Any pointer of type cv1 T* that represents the address of a storage location suitable to hold an object of type T, but does not point to any object of type cv2 T whose lifetime has started and not ended, may be used but only in limited ways.

Drafting note: this maintains the status quo that malloc alone is not sufficient to create an object.

   struct X
   {
       int a, b;
   };

   int main()
   {
       X* p = (X*)malloc( sizeof(X) );

       p->b = 1; // undefined behavior
   }

If the operand is the result of a unary * operator, neither that operator nor the & operator is evaluated and the result is as if both were omitted

glvalue expression is obtained by applying the unary * operator to a pointer

Some objects are polymorphic; the implementation generates information associated with
each such object that makes it possible to determine that object’s type during program execution. For other
objects, the interpretation of the values found therein is determined by the type of the expressions
used to access them.

the expression to which it is applied shall be a pointer to an object type, or a pointer to a function type and the result is an lvalue referring to the object or function to which the expression points

This document contains the C++ core language issues for which the Committee (J16 + WG21) has decided that no action is required

The working group has reached consensus that the issue is not a defect in the Standard. A Rationale statement describes the working group's reasoning.

If f is static, however, there seems to be no such rule, and the call is only undefined if the dereference implicit in the -> operator is undefined. IMO it should be.

*p is not an error when p is null unless the lvalue is converted to an rvalue

NI>В таких вопросах я бы ему не стал доверять Вот таким людям, как Майк Миллер, Йенс Маурер и Ричард Смит, я верю.

The difference is that in core issue 315, the member function is a static member function.

This makes more sense if you think of non-static member functions as being passed an implied first parameter that is a reference to the class type. (The fact that 'this' is a pointer rather than a reference is a historical accident.) Just like any other reference parameter, it can't be bound to a dereferenced null pointer. But a static member function has no such parameter; the lvalue expression denoting the object is evaluated and then discarded, and null ("empty") lvalues are OK so long as you don't bind a reference to them or try to access an object through them.

#include <typeinfo>

struct Polymorphic
{
    virtual ~Polymorphic() {}
};

int main()
{
    Polymorphic volatile *p = nullptr;
    *p;         // undefined behavior
    typeid(*p); // well-defined
}

Indirection through an invalid pointer value and passing an invalid pointer value to a deallocation function have undefined behavior. Any other use of an invalid pointer value has implementation-defined behavior.

the expression to which it is applied shall be a pointer to an object type, or a pointer to a function type and the result is an lvalue referring to the object or function to which the expression points

Поведение описано для применения оператора * к выражению, которое имеет тип "указатель на объект (или функцию)". Что происходит при применении к выражению с другим типом? Это не определено, а, значит, по пункту про UB это UB.

Otherwise, if the type of the expression is T, the result has type “pointer to T” and is a prvalue that is the address of the designated object (1.7) or a pointer to the designated function.

int &f()
{
    int local;
    return local;
}

int main()
{
    &f(); // undefined behavior
}

D>>const SomeClass& Class::getSomeClassVariable() const
D>>{
D>>    return *(SomeClass*)0;
D>>}
D>>

const SomeClass& Class::getSomeClassVariable() const
{
   assert(false && "It should never be called");
   static const SomeClass sSomeClass = SomeClass();
   return sSomeClass;
}

D>const SomeClass& Class::getSomeClassVariable() const
D>{
D>    return *(SomeClass*)0;
D>}
D>

 template<typename _Tp>
   struct __array_traits<_Tp, 0>
   {
     struct _Type { };

     static constexpr _Tp&   _S_ref(const _Type&, std::size_t) noexcept  { return *static_cast<_Tp*>(nullptr); }
   };