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