#define PROPERTY(OWNERNAME, TYPE, NAME, FNGET, FNPUT) \
struct propclass_##NAME { \
    inline operator TYPE() { \
        CONTAINING_RECORD(this, OWNERNAME, NAME)->FNGET(); \
    } \
    inline void operator=(TYPE src) { \
        CONTAINING_RECORD(this, OWNERNAME, NAME)->FNPUT(src); \
    } \
} NAME;

#define PROPERTY_DEF(OWNERNAME, TYPE, NAME) \
    PROPERTY(OWNERNAME, TYPE, NAME, Get_##NAME, Put_##NAME)

    class C
    {
    public:
        int Get_i() { cout << "Get = 1" << endl; return 1; }
        void Put_i(int n) { cout << "Put(" << n << ')' << endl; }
        PROPERTY_DEF(C, int, i);
    };

    C c;
    cout << c.i << endl;
    c.i = 1;

class A
{
public:
  class B
  {
  public:
    inline A * Container() 
    {
      // вычисляем смещение поля b_ внутри A
      B A::*pB = &A::b;
      // базируемся относительно своего this
      return (A*) ( size_t(this) - *((size_t *)&pB) );
    }
    //...
  }
  B b_;
  //...
}

A a;
cout << ( & A == A.b_.Container() );

//----------------------------------------------------------------------
//да, property без изменения бинарной раскладки класса 
//вызов через указатель на член убивает оптимизирующий компилятор.
//VS2003 распознает эти property в IntelliSense 

//сразу возникает вопрос, как разрулить это - 
//T Owner::GetX() const
//T Owner::GetX() const volatile
//T Owner::GetX() volatile
//Owner::x
//T Owner::GetX() 
//T &Owner::GetX() 
//мне кажется, что это можно сделать через 
//sizeof(overloaded_function(MakeT())) трюк, но мне лень это проверять

//тут еще подводные камни с константностью функции NAME(), 
//без парочки const_cast видимо не обойдется, если доводить до ума.

template <
  class Owner, 
  class PropT, 
  void (Owner::*Setter)(PropT), 
  PropT (Owner::*Getter)()>
struct Property
{
  Owner &owner;
  Property(Owner &owner): owner(owner) {};
  //да, void. Не хочу мозг парить.
  void operator =(const PropT &x) { (owner .* Setter)(x); }
  operator const PropT () { return (owner .* Getter)(); }
};

//можно сделать PROPERTY_RW, PROPERTY_R, PROPERTY_W, 

#define PROPERTY(NAME, Owner, T, Setter, Getter)\
Property<Owner, T, &Owner::Setter, &Owner::Getter> NAME() \
{ \
  return Property<Owner, T, &Owner::Setter, &Owner::Getter>(*this);\
}

//----------------------------------------------------------------------


#include <fstream>
#include <iostream>
#include <string>

struct MegaClass
{
private:
  int GetFromFile()
  {
    int i;
    std::ifstream f("config.txt");
    f >> i;
    return i*2;
  }

  void SetValueInFile(int i)
  {
    std::ofstream f("config.txt");
    f << i;
  }

  std::string GetS() { return "hello"; }
  void SetS(std::string sss) { std::cout <<sss; }

public:


  PROPERTY(X, MegaClass, int, SetValueInFile, GetFromFile);
  PROPERTY(Y, MegaClass, int, SetValueInFile, GetFromFile);
  PROPERTY(Sss, MegaClass, std::string, SetS, GetS);


  MegaClass()
  {
    this->X() = 0;
  }
  
};


volatile int i;


class Test2
{
private:
  void SetI(int i) { ::i = i; } 
  int GetI() { return ::i; }
public:
  PROPERTY(I, Test2, int, SetI, GetI);
};


int main()
{
  std::cout <<sizeof(MegaClass) <<"\n"; //empty class

  MegaClass mc;
  mc.X() = 10;
  int i = mc.Y();

  std::string s = mc.Sss();
  mc.Sss() = "world";

  //проверяю в листинге на asm, что компилятор уничтожает лишние вызовы.
  Test2 t;
  t.I() = 10;
  i = t.I();

  std::cout <<i;
}

_W>int main()
_W>{
_W>  std::cout <<sizeof(MegaClass) <<"\n"; //empty class

_W>  MegaClass mc;
_W>  mc.X() = 10;
_W>  int i = mc.Y();

_W>  std::string s = mc.Sss();
_W>  mc.Sss() = "world";

_W>  //проверяю в листинге на asm, что компилятор уничтожает лишние вызовы.
_W>  Test2 t;
_W>  t.I() = 10;
_W>  i = t.I();

_W>  std::cout <<i;
_W>}

_W>

  //...
  const PropT operator () () { return (owner .* Getter)(); }
  //...

//...
  cout << "Length is " << ms.Sss()().length() << endl;
//...

#include <stdio.h>

#define PROPERTY(T,__type,__set,__get,__name) \
  \
  __type value() const { return resolve_(this,1)->__get(); } \
  \
  __type operator+() const { return value(); } \
  \
  operator __type () const { return value(); } \
  \
  void \
    operator = (__type const& a) { resolve_(this,1)->__set(a); } \
  \
  template <class fake> static T* resolve_(const void* p,fake) {\
    T* _ = 0; \
    return (T*)( (char*)p - ( (char*)(&_->__name) - (char*)(_) ) );\
  } 


struct Obj1 
{
  void SetP1(int a) { printf("SetP1(%d)\n",a); }
  int  GetP1() const { printf("GetP1()\n"); return 0; }
  void SetP2(int a) { printf("SetP2(%d)\n",a); }
  int  GetP2() const { printf("GetP2()\n"); return 0; }
  //union { ещё одна причина не любить gcc, 
    struct __Property_a { PROPERTY(Obj1,int,SetP1,GetP1,a) } a;
    struct __Property_b { PROPERTY(Obj1,int,SetP2,GetP2,b) } b;
  //};
};

int main ()
{
  Obj1 o;
  printf("sizeof(Obj1) = %d\n",sizeof(Obj1));
  o.a = 1;
  printf("o.a + 1 = %d\n", o.a + 1);
  o.b = 0;
  printf("o.b + 1 = %d\n", o.b + 1);
  return 0;
}