2

I was reading an article on how C++ does not have field accessors as part of the language.

At the end of the post, the author gives a macro based solution that emulates field accessors for classes: 

// a little trick to fool compiler we are not accessing NULL pointer here
#define property_offset(type, name) \
  (((char*)&((type*)(0xffff))->name) - (char*)(0xffff))

#define property_parent(type, name) \
  ((type*)((char*)(this) - property_offset(type, name)))

// macro defining property
#define property(type, name, parent)                                         \
  struct name##_property {                                                   \
    operator type() { return property_parent(parent, name)->get_##name(); }  \
    void operator=(type v) { property_parent(parent, name)->set_##name(v); } \
                                                                             \
   private:                                                                  \
    char zero[0];                                                            \
  } name

// our main class
class Node {

  /* visitCount will act as a field accessor */
  property(int, visitCount, Node);
};

When I run this through the preprocessor, I get: 

class Node {

  struct visitCount_property {
    operator int() { return ((Node*)((char*)(this) - (((char*)&((Node*)(0xffff))->visitCount) - (char*)(0xffff))))->get_visitCount(); }
    void operator=(int v) { ((Node*)((char*)(this) - (((char*)&((Node*)(0xffff))->visitCount) - (char*)(0xffff))))->set_visitCount(v); }    
    private: char zero[0];
    } visitCount;
};

The idea being that I would have also added my own implementations of: 

int get_visitCount();
void set_visitCount(int v);

And it would look as if visitCount was being directly accessed.
However, the functions would actually be called behind the scenes: 

Node n;
n.visitCount = 1;     //actually calls set method
cout << n.VisitCount; //actually calls get method

I'd like to know more about this trick of accessing the enclosing class: 

((Node*)((char*)(this) - (((char*)&((Node*)(0xffff))

What is the relevance of 0xffff?
In decimal that is: 65535.

How does this trick the compiler to accessing the class that encloses the visitCount class?

I also see that this does not work on MSVC, so I was wondering if there was a standard way of accomplishing what this hack is doing.

Trevor Hickey
  • 36,288
  • 32
  • 162
  • 271
  • 1
    Well his proposed hack is quite ugly compared to a trick to replace the assignements with function calls. He says it doesn't work because the strict standard implementation doesn't allow a structure taking 0 bytes so the pointer address trick doesn't work. – meneldal May 26 '15 at 03:25
  • 1
    @ShafikYaghmour in the link it's explicitely stated that `offsetof` doesn't work (see caveats in the link) – meneldal May 26 '15 at 03:26
  • @meneldal it is using a very similar trick at is core with all the same issues which make offsetof not portable. There are a number of SO questions that cover this is some detail. – Shafik Yaghmour May 26 '15 at 03:28
  • 2
    That implementation's a disgusting mess (0 length arrays are non-Standard, macro hackery etc., the casting and `0xffff`); I'd suggest considering the code at the end of [this document](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1615.pdf) instead. – Tony Delroy May 26 '15 at 04:31

1 Answers1

3

There is no relevance of 0xffff. It's just some number. It could be zero (and in fact would be easier if it were). Let's break this up into pieces and rewrite 0xffff to be addr:

(((char*)&((type*)(addr))->name) - (char*)(addr))

(type*)(addr) just gives us some type* that starts at addr. It's a reinterpret_cast. So let's call that obj:

 (((char*)&obj->name) - (char*)(addr))

We can even replace the second addr with obj - it's the wrong type, but we're casting anyway, and it adds clarity to what's going on: 

 (((char*)&obj->name) - (char*)(obj))

&obj->name just gives us a pointer to that particular member, so let's call that mem_ptr

((char*)mem_ptr) - (char*)(obj)

Now it's clear - we're taking the address of the member (as a char*) and subtracting the address of the parent object (as a char*). We used 0xffff just to have the same initial address in both places.

Note that the C++ standard also defines a macro for this directly. It's called offsetof. With the caveat "If type is not a standard-layout class (Clause 9), the results are undefined."

Barry
  • 286,269
  • 29
  • 621
  • 977