From: Keith.S.Thompson+u@gmail.com   
      
   "James Russell Kuyper Jr."  writes:   
   > On 2026-01-13 16:54, Tristan Wibberley wrote:   
   [...]   
   >> IIRC indexing a table follows the rules of pointers and doing so   
   >> outside of a table's bounds is generally U/B except for very peculiar   
   >> specific cases. You can do it in a struct across members /sometimes/   
   >> because a struct is a single object. ...   
   >   
   > No, there is no such exception in the standard. It is still undefined   
   > behavior. One of the most annoying ways undefined behavior can   
   > manifest is that you get exactly the same behavior that you   
   > incorrectly thought you were guaranteed to get. That's a problem,   
   > because it can leave you unaware of your error.   
   [...]   
      
   Perhaps the exception Tristan was referring to (though it doesn't apply   
   to indexing) is this, in N3220 6.5.10p7:   
      
       Two pointers compare equal if and only if both are null pointers,   
       both are pointers to the same object (including a pointer to an   
       object and a subobject at its beginning) or function, both are   
       pointers to one past the last element of the same array object,   
       or one is a pointer to one past the end of one array object and   
       the other is a pointer to the start of a different array object   
       that happens to immediately follow the first array object in   
       the address space.   
      
   with a footnote:   
      
       Two objects can be adjacent in memory because they are adjacent   
       elements of a larger array or adjacent members of a structure   
       with no padding between them, or because the implementation   
       chose to place them so, even though they are unrelated. If prior   
       invalid pointer operations (such as accesses outside array   
       bounds) produced undefined behavior, subsequent comparisons   
       also produce undefined behavior.   
      
   The idea, I think, is that without that paragraph, given something like   
   this:   
      
   #include    
   int main(void) {   
       struct {   
           int a[10];   
           int b[10];   
       } obj;   
      
       printf("obj.a+10 %s obj.b\n",   
              obj.a+10 == obj.b ? "==" : "!=");   
   }   
      
   the compiler would have to go out of its way to treat obj.a+10 and obj.b   
   as unequal.  (The output on my system is "obj.a+10 == obj.b", but the   
   pointers could be unequal if there's padding between a and b -- which is   
   unlikely.)   
      
   (I reported a relevant bug in gcc, where for objects that happen to be   
   adjacent the addresses are reported as unequal with -O1 or higher; the   
   gcc maintainers disagreed.   
   )   
      
   --   
   Keith Thompson (The_Other_Keith) Keith.S.Thompson+u@gmail.com   
   void Void(void) { Void(); } /* The recursive call of the void */   
      
   --- SoupGate-Win32 v1.05   
    * Origin: you cannot sedate... all the things you hate (1:229/2)