Does the standard mandate an lvalue-to-rvalue conversion of the pointer variable when applying indirection?

by

I think you’re approaching this from a rather oblique angle, so to speak. According to §5.3.1/1:

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. If the type of the expression is “pointer to T,” the type of the result is “T.”

Although this doesn’t talk about the lvalue-to-rvalue conversion, it requires that the expression be a pointer to an object or function. An uninitialized pointer won’t (except, perhaps by accident) be any such thing so the attempt at dereferencing gives undefined behavior.

More Related Contents:

  1. How many levels of pointers can we have?
  2. Is a pointer with the right address and type still always a valid pointer since C++17?
  3. Is it legal to compare dangling pointers?
  4. Do all pointers have the same size in C++?
  5. Get pointer to object from pointer to some member
  6. Understanding the example on lvalue-to-rvalue conversion
  7. Pointer interconvertibility vs having the same address
  8. Does accessing a declared non-volatile object through a volatile reference/pointer confer volatile rules upon said accesses?
  9. Are non dereferenced iterators past the “one past-the-end” iterator of an array undefined behavior?
  10. Are pointer variables just integers with some operators or are they “symbolic”?
  11. Are pointers to non-static member function “formally” not considered pointers
  12. Is incrementing a null pointer well-defined?
  13. Why is sizeof giving incorrect number of bytes in C++?
  14. Changing the object a pointer points to in c++
  15. Testing pointers for validity (C/C++)
  16. Where exactly does C++ standard say dereferencing an uninitialized pointer is undefined behavior?
  17. Address of an array
  18. Can I take the address of a function defined in standard library?
  19. “constructing” a trivially-copyable object with memcpy
  20. static_assert dependent on non-type template parameter (different behavior on gcc and clang)
  21. Passing references to pointers in C++
  22. Is floating point addition commutative in C++?
  23. structured bindings: when something looks like a reference and behaves similarly to a reference, but it’s not a reference
  24. casting via void* instead of using reinterpret_cast [duplicate]
  25. Is sizeof(*ptr) undefined behavior when pointing to invalid memory?
  26. The behaviour of floating point division by zero
  27. Is writing to &str[0] buffer (of a std:string) well-defined behaviour in C++11?
  28. About Pointers To Functions in function declarations
  29. C++11 cross compiler/standard library random distribution reproducibility
  30. Is a struct’s address the same as its first member’s address?

Leave a Comment