_>class A {
_>  List list; // потом могу переделать по другому и в других местах ничего не меняем.
_>  public void Add(object a) { list.Add(); }
_>  property int Count { get { return list.Count; } }
_>}
_>

_>class A {
  List list; // потом могу переделать по другому и в других местах ничего не меняем.
public:
  void Add(object a) { list.Add(); }
  int Count() const { return list.Count; }
};

_>struct SomeInterface {
_>  virtual int getX()=0;
_>  virtual int setX(int x)=0
_>};
_>

_>class A {
_>  public int X;
_>};
_>

template<typename T> class debug_wrapper {
private:
    T data;
protected:
    T& Data() { return data; }
    const T& Data() const { return data; }
public:
    // тут кучка конструкторов, с вынесенным определением тела
    // тут кучка операторов, с вынесенным определением тела

    operator const T&() const { return Data(); }
    operator T&() { return Data(); }
};

class A {
public:
    struct xxx_prop : debug_wrapper<int> {
        void operator = ( int newValue )
        {
            this->Data() = newValue;
        }
    } X;
};

class A {
public:
    struct xxx_prop : debug_wrapper<int, xxx_prop> {
        void OnNewValue() {
            if( this->Data() == 100 ) {
                this->Data() = 200;
            }
        }
    } X;
};

_>class A {
_>  int x;
_>  public int X { get { return x; }
_>    set {
_>      if (value==100) 
_>         Debug.BreakPoint();
_>      x=value;
_>    }
_> }
_>}
_>

_>class A {
_>  int x;
_>  Validator validator;
_>  Notifier notifier;
_>  public int X { get { return x; }
_>    set {
_>      validator.validate(x);
_>      if (x!=value) {
_>        x=value;
_>        notifier.notify_subscribers();
_>      }
_>    }
_> }
_>}
_>

template <class T>
void n1(T& t) {
    ++t;
}

const int i = 10;
n1(i)

template<class T>
void f( const T& t ) { t.Arg_of_f_must_be_mutable(); }
template <class T>
void n1(T& t) {
    ++t;
}

V>const int i = 10;
V>n1(i)

V>

_>>struct SomeInterface {
_>>  virtual int getX()=0;
_>>  virtual int setX(int x)=0
_>>};
_>>

int X { get; set; }

template<typename T> class debug_wrapper {
E>private:
E>    T data;
E>protected:
E>    T& Data() { return data; }
E>    const T& Data() const { return data; }
E>public:
E>    // тут кучка конструкторов, с вынесенным определением тела
E>    // тут кучка операторов, с вынесенным определением тела
E>    operator const T&() const { return Data(); }
E>    operator T&() { return Data(); }
E>};

struct Parent {
  struct _X {
     int v;
     Parent* parent;
     _X() { v=11; }
     operator int () { return v; }
     _X& operator = (int rv) { controller->assign("X",v,rv); return *this; }
  } X;
  SomeController controller;
  Parent() { 
    X.parent=this;
  }
};

struct Obj {
...
ModelField<int> X() DECL_FIELD(int,x,123);
...
};
void usage(Obj *p) {
  int x=p->X();
  p->X()=432;
}

_>>class A {
_>>  int x;
_>>  public int X { get { return x; }
_>>    set {
_>>      if (value==100) 
_>>         Debug.BreakPoint();
_>>      x=value;
_>>    }
_>> }
_>>}
_>>

_>>class A {
_>>  int x;
_>>  Validator validator;
_>>  Notifier notifier;
_>>  public int X { get { return x; }
_>>    set {
_>>      validator.validate(x);
_>>      if (x!=value) {
_>>        x=value;
_>>        notifier.notify_subscribers();
_>>      }
_>>    }
_>> }
_>>}
_>>

E>Мульку с шаблоном можно точно так же.

E>Совсем нет никакого желания, добавить в язык такую граблю, что a.X++ может без объявления войны превратиться в какое-то чудовище...

E>Вот представь себе, например, что надо куда-то отдать int* для заполнения

_>int X { get; set; }
_>

struct XXX {
    int X;
};

#define PROPERTY(PropertyName, OwnerType_, Type, InternalType, GetterName, SetterName)  \
    template<typename OwnerType>
    struct Property##PropertyName : public PropertyValueHolder__<InternalType>
....
... //указатель на родительский класс получается вот так
    const OwnerType* get_owner_this() const
    {
        return (const OwnerType*)(((const char*)this) - OFFSETOF(OwnerType, OwnerType::PropertyName));
    }

.. // класс с уникальным именем
    Property##PropertyName <OwnerType_> PropertyName;

class IService
{
public:
   IMemeber* const Member;

protected:
   IService(IMember* m) : Member(m) {}
};

class CService : public IService
{
    CMemberImpl  member;
public:
    CService() : IService(&member)
    {}
}

class IService
{
    virtual something_else...
};

class CService : public IService, CMemberImpl
{
}