🚀 go-pugleaf

erik@kroete2.freinet.de (Erik Corry) wrote:

>Richard Krehbiel (rich@kastle.com) wrote:
>: I wrote:
>: 
>: >Well, actually I'd probably use a macro that I've declared for my own
>: >use...
>: 
>: >#define CONTAINER_P(p,s,m) (s*)((char *)(p)-offsetof(s,m))
>: 
>: >...which, for pointer p which is assumed to be a pointer to member m
>: >of aggregate s, gives a pointer to s.  There's a slight bit more type
>: >checking than the simple cast (I'd love it if I could also be assured
>:                                 --------------------------------------
>: >that p is really the same type as &s.m).  If the member is first,
>:  --------------------------------------
>: >typically the subtraction is optimized away since the offset is a
>: >constant zero.
>: 
>: I've tested the following and it does just what I want:
>: 
>: #define CONTAINER_PTR(p,s,m)  \
>:   ((sizeof(&((s *)0)->m == (p))), \
>:    (s *) ((char *)(p) - offsetof(s,m)))

>Er... That's really quite clever. Keep the old version around
>in case you hit a compiler that doesn't agree.

All I have to do is remove the second line and I have my original
macro back.

>The '==' makes sure the pointer types agree, but why the
>sizeof?

sizeof prevents the first invocation of (p) from really being
evaluated, so I can use an expression for (p) with side effects
without fear.

Run this and see.

#include <stdio.h>

int report(void)
{
    puts("report called.");
    return 1;
}

int main(void)
{
    printf("sizeof int = %d bytes\n",  sizeof(report()));

    return 0;
}

--
Richard Krehbiel, Kastle Systems, Arlington VA USA
rich@kastle.com (work) or richk@cais.com (personal)