Pointer interconvertibility vs having the same address

by

There are apparently existing implementations that optimize based on this. Consider:

struct A {
    double x[4];
    int n;
};

void g(double* p);

int f() {
    A a { {}, 42 };
    g(&a.x[1]);
    return a.n; // optimized to return 42;
                // valid only if you can't validly obtain &a.n from &a.x[1]
}

Given p = &a.x[1];, g might attempt to obtain access to a.n by reinterpret_cast<A*>(reinterpret_cast<double(*)[4]>(p - 1))->n. If the inner cast successfully yielded a pointer to a.x, then the outer cast will yield a pointer to a, giving the class member access defined behavior and thus outlawing the optimization.

More Related Contents:

  1. Is a pointer with the right address and type still always a valid pointer since C++17?
  2. Are non dereferenced iterators past the “one past-the-end” iterator of an array undefined behavior?
  3. What is the difference between '.' and '->' when used in array? [closed]
  4. Why is sizeof giving incorrect number of bytes in C++?
  5. determine size of array if passed to function
  6. May I treat a 2D array as a contiguous 1D array?
  7. Why does cout print char arrays differently from other arrays?
  8. C++ pass an array by reference
  9. Address of an array
  10. Is stateful metaprogramming ill-formed (yet)?
  11. May I take the address of the one-past-the-end element of an array? [duplicate]
  12. C++ correct way to return pointer to array from function
  13. Store an int in a char array?
  14. structured bindings: when something looks like a reference and behaves similarly to a reference, but it’s not a reference
  15. Pointer-to-pointer dynamic two-dimensional array
  16. How to get the real and total length of char * (char array)?
  17. Casting double array to a struct of doubles
  18. Does accessing a declared non-volatile object through a volatile reference/pointer confer volatile rules upon said accesses?
  19. Pointer to array with const qualifier in C & C++
  20. Are pointer variables just integers with some operators or are they “symbolic”?
  21. Pointer to array of unspecified size “(*p)[]” illegal in C++ but legal in C
  22. array decay to pointer and overload resolution
  23. array of pointers as function parameter
  24. Is it allowed for a compiler to optimize away a local volatile variable?
  25. Difference between passing array, fixed-sized array and base address of array as a function parameter
  26. how do arrays work internally in c/c++
  27. Will I be able to declare a constexpr lambda inside a template parameter?
  28. How can a char pointer be initialized with a string (Array of characters) but an int pointer not with an array of integer? [duplicate]
  29. Polymorphism & Pointers to arrays [duplicate]
  30. Does the standard mandate an lvalue-to-rvalue conversion of the pointer variable when applying indirection?

Leave a Comment