public: Type a;

public: 
Type getA() {return a;}
void setA(const Type& a_) { a = a_;}
private:
A a;

auto Object::GetNextObjectId() -> decltype(++_nextObjectId)
{
  return (++_nextObjectId);
}

auto Object::GetNextObjectId() -> decltype(_nextObjectId)
{
  return (_nextObjectId += 4);
}

К>Проперти, будучи в языке, внесли бы строгость. Но их нет, и они не внесли.

template<class C, class T>
bool field_manipulator(T C::* field, C* obj, what_t what) {
     if (what == read) {
         obj->field = get_user_input<T>();
         return true;
     }
     if (what == write) {
         output_to_user(obj->field);
         return true;
     }
...

template<class C, class T>
bool field_manipulator(T (C::*get)() /* const? */, void (C::*set)(/* const& ? plain? something else?*/ const& T), C* obj, what_t what) {
...
      obj->(*set)(get_user_input<T>());
...
}

struct Foo
{
    int state;
};

struct Foo
{
    __declspec(property(get=get_state)) int state;
    int m_state;
    int get_state() const { return m_state; }   
};

struct GodStructure
{
    // ...
    // очень много полей
    int state;
};

struct GodStructure
{
    SmallStructure ss;

    // ...
    int m_state;
    void set_state(int newState)
    {
        m_state = newState;
        ss.set_isStateFoo(m_state == STATE_FOO);
    }
};

struct Foo
{
    int state;
};

struct Foo
{
    __declspec(property(get=get_state, put=set_state)) int state;
    int m_state;
    int get_state() const { return m_state; }   
    void set_state(int newState)
    {
       if (m_state == X)
           assert(newState != Y);

       m_state = newState;
    }
};

  property foo {
    void resize(size_t newsize) { this->resize_foo(newsize); }
  };

Имена функций (любых, членов и свободных) должны сводиться к ГЛАГОЛУ — этот глагол не должен быть set или get. А когда я вижу аксессоры, я хватаюсь за пистолет.

Ops>Имена функций (любых, членов и свободных) должны сводиться к ГЛАГОЛУ — этот глагол не должен быть set или get. А когда я вижу аксессоры, я хватаюсь за пистолет.

Ops>http://www.rsdn.ru/forum/cpp/4725651.1.aspx

Автор: Vamp
Дата: 04.05.12

К>>Проперти, будучи в языке, внесли бы строгость. Но их нет, и они не внесли.

template<class C, class Getter, class Setter>
void manipulate(C* obj, Gettter getter, Setter setter, what_t what)
{
  typedef PLEASE_EXTRACT_VALUE_TYPE_FROM_MEMBER_FUNCTION(getter) T;
  switch(what)
  {
  case read:  (obj->*setter)(get_user_input<T>());
  case write: output_to_user(obj->*getter());
  }
}

J>Ну так если это сложный зверь, зачем еще дополнительно усложнять себе жизнь, оборачивая его в проперти?

private:
  std::string m_title;
public:
  property {
    const std::string& operator std::string() { return m_title; }
    std::string& operator =(const std::string& src) {
      assert_correct_title(src);
      m_title = src;
    }
    std::string& operator += (const std::string& src) { m_title += src; }
  } title;

struct ModelExample2 : SimpleModel {
    ModelField<double> g() DECL_FIELD(double,g,9.81);
    ModelExample1 submodel1;
    ModelExample1 submodel2;    
    void Assign(ModelExample2 &src) {
        ModelLocker lock(this);
        g()=src.g();
        submodel1.Assign(src.submodel1);
        submodel2.Assign(src.submodel2);
    }
    ModelExample2() {
        AnyChange()<<submodel1<<submodel2;
    }
    ~ModelExample2() {
        AnyChange()>>submodel1>>submodel2;
    }
};

void fn(ModelExample2 &m) { ModelLocker lock(m);
  m.g()=m.g()+0.1;
  m.g()=m.g()+0.2;
}

// Notifier.h
#pragma once

#include <set>

struct NotifyListener {
    virtual void NotifyChange()=0;
};

struct Notifier : protected NotifyListener {
    void Modified();
    void Lock();
    void Unlock();
    void AttachChild(Notifier& child);
    void DetachChild(Notifier& child);
    void Subscribe(NotifyListener &listener,bool notify_attach=true);
    void Unsubscribe(NotifyListener &listener);
    Notifier();
    ~Notifier();
    
    bool IsModified() const { return modified; }
    bool IsLocked()   const { return lock_level>0; }
    bool IsReadOnly() const { return lock_level<0; }
    // for debug only
    int  ChildCount() const { return (int)children.size(); }
    int  ListenerCount() const { return (int)listeners.size(); }
    int  GetDeepLevel() const;
    bool IsDeepUnlocked() const;
protected:
    typedef std::set<Notifier*>         children_t;
    typedef children_t::iterator        children_it;
    typedef children_t::const_iterator  children_cit;
    typedef std::set<NotifyListener*>   listeners_t;
    typedef listeners_t::iterator       listeners_it;
    typedef listeners_t::const_iterator listeners_cit;
    int lock_level;
    bool modified;
    children_t children;
    listeners_t listeners;
    void NotifyAll();
    void NotifyChange();
    void LockChildren();
    void UnlockChildren();
};

struct ModelBase {
    virtual Notifier& AnyChange()=0;
    virtual Notifier& ScopeChange() { return AnyChange(); }
    virtual ~ModelBase() {}
};

inline Notifier& operator << (Notifier& parent,ModelBase& child) {
    parent.AttachChild(child.AnyChange());
    return parent;
}

inline Notifier& operator >> (Notifier& parent,ModelBase& child) {
    parent.DetachChild(child.AnyChange());
    return parent;
}

struct SimpleModel : ModelBase {
    Notifier& AnyChange()   { return scope_notifier; }
    Notifier& ScopeChange() { return scope_notifier; }
protected:
    Notifier scope_notifier;
};

struct Model : ModelBase {
    Notifier& AnyChange()   { return root_notifier; }
    Notifier& ScopeChange() { return scope_notifier; }
    Model() { root_notifier.AttachChild(scope_notifier); }
    ~Model() { root_notifier.DetachChild(scope_notifier); }
protected:
    Notifier root_notifier;
    Notifier scope_notifier;
};

struct ModelLocker {
    ModelLocker(ModelBase* model) : model(model)  { if (model) model->AnyChange().Lock(); }
    ModelLocker(ModelBase& model) : model(&model) { if (&model) model.AnyChange().Lock(); }
    ~ModelLocker() {
        if (model) { 
            model->AnyChange().Unlock();
            model=0;
        }
    }
private:
    ModelBase* model;
};

struct NotifyLocker {
    NotifyLocker(Notifier* notifier) : notifier(notifier)  { if (notifier) notifier->Lock(); }
    NotifyLocker(Notifier& notifier) : notifier(&notifier) { if (&notifier) notifier.Lock(); }
    ~NotifyLocker() { 
        if (notifier) {
            notifier->Unlock();
            notifier=0;
        }
    }
private:
    Notifier* notifier;    
};

template<class T>struct ModelField {
    operator T () const { return data; }
    T value() const { return data; }
    ModelField& operator = (const T& rv) { 
        if (rv!=data) { data=rv; notifier.Modified(); } 
        return *this;
    }
    ModelField& Modified() { notifier.Modified(); }
    ModelField(Notifier& notifier,T& data) : notifier(notifier), data(data) {}
private:
    Notifier& notifier;
    T& data;
};

#define DECL_FIELD(type,name,def_val) \
    { return ModelField<type>(ScopeChange(),field_##name.val); } \
    private: struct field_##name##_t { \
        type val; \
        field_##name##_t() : val(def_val) {} \
    } field_##name; \
    public:

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

struct ModelExample1 : SimpleModel {
    ModelField<int> X() { return ModelField<int>(ScopeChange(),field_X.val); }
    private: struct field_X_t {
        int val;
        field_X_t() : val(0) {}        
    } field_X;
    public:
    ModelField<int> Y() DECL_FIELD(int,Y,10);
    void Assign(ModelExample1 &src) {
        ModelLocker lock(this);
        X()=src.X();
        Y()=src.Y();
    }
};

struct ModelExample2 : SimpleModel {
    ModelField<double> g() DECL_FIELD(double,g,9.81);
    ModelExample1 submodel1;
    ModelExample1 submodel2;    
    void Assign(ModelExample2 &src) {
        ModelLocker lock(this);
        g()=src.g();
        submodel1.Assign(src.submodel1);
        submodel2.Assign(src.submodel2);
    }
    ModelExample2() {
        AnyChange()<<submodel1<<submodel2;
    }
    ~ModelExample2() {
        AnyChange()>>submodel1>>submodel2;
    }
};

J>>они мономорфные, типы надо явно указывать, что тут еще обосновывать...

[...](auto _1, auto _2) { return _1 < _2; }

struct Lambda
{
  ... // captures

  template <class T1, class T2>
  operator()(T1 _1, T2 _2) const { return _1 < _2; }
};

E>>Ну заводишь пачку интерфейсов и вперёд

class Master {
//  bla-bla-bla 
    class { 
        //  тут описание
    } slaver;
}

_>struct ModelExample2 : SimpleModel {
_>    ModelField<double> g() DECL_FIELD(double,g,9.81);
_>    ModelExample1 submodel1;
_>    ModelExample1 submodel2;    
_>    void Assign(ModelExample2 &src) {
_>        ModelLocker lock(this);
_>        g()=src.g();
_>        submodel1.Assign(src.submodel1);
_>        submodel2.Assign(src.submodel2);
_>    }
_>    ModelExample2() {
_>        AnyChange()<<submodel1<<submodel2;
_>    }
_>    ~ModelExample2() {
_>        AnyChange()>>submodel1>>submodel2;
_>    }
_>};
_>

_>#define DECL_FIELD(type,name,def_val) \
_>    { return ModelField<type>(ScopeChange(),field_##name.val); } \
_>    private: struct field_##name##_t { \
_>        type val; \
_>        field_##name##_t() : val(def_val) {} \
_>    } field_##name; \
_>    public:

ModelExample2 a;
ModelExample2 b;
a.g() = b.g();

было бы замечательно добавить в C++:
— нумерацию statement-ов
— убрать контроль типов (а то только жить мешает)
— ну и возможность интерпретации на виртуальной машине

BFE>>ModelExample2 a;
BFE>>ModelExample2 b;
BFE>>a.g() = b.g();
BFE>>

a.g()=10;
a.g()=b.g();

#include "Notifier.h"

#define ERR_MODIFY_READONLY    "modify in readonly mode"
#define ERR_LOCK_READONLY      "unable to lock in readonly mode"
#define ERR_ALREADY_SUBSCRIBED "listener already subscibed"
#define ERR_NOT_SUBSCRIBED     "listener not registered"
#define ERR_HAS_CHILD          "this node already attached"
#define ERR_NO_CHILD           "no such child node found"
#define ERR_BAD_LOCK_LEVEL     "lock_level must be 0"
#define ERR_BAD_LOCK_LEVEL_RO  "lock_level<0 must be 0"
void throw_exception(const char* reason) {
    throw reason;
}

Notifier::Notifier() {
    lock_level=0;
    modified=false;
}
Notifier::~Notifier() {
    if (lock_level!=0) {
        // fatal error!
        lock_level=lock_level;
    }
}
void Notifier::Modified() {
    modified=true; 
    if (lock_level>0) return;
    if (lock_level<0) throw_exception(ERR_MODIFY_READONLY);
    NotifyAll(); 
}
void Notifier::NotifyChange() {
    Modified();
}
void Notifier::Lock() {
    if (lock_level<0) throw_exception(ERR_LOCK_READONLY);
    if (++lock_level==1) LockChildren();
}
void Notifier::Unlock() {
    if (--lock_level==0) {        
        lock_level++;
        UnlockChildren();
        lock_level--;
        if (modified) NotifyAll();
    }
}
void Notifier::AttachChild(Notifier& child) {
    if (children.find(&child)!=children.end()) throw_exception(ERR_HAS_CHILD);
    children.insert(&child);
    if (lock_level>0) child.Lock();
    child.Subscribe(*this,!modified && child.IsModified());
}
void Notifier::DetachChild(Notifier& child) {
    children_it it=children.find(&child);
    if (it==children.end()) throw_exception(ERR_NO_CHILD);
    children.erase(it);
    child.Unsubscribe(*this);
    if (lock_level>0) child.Unlock();
}
void Notifier::Subscribe(NotifyListener &listener,bool notify_attach) {
    if (listeners.find(&listener)!=listeners.end()) throw_exception(ERR_ALREADY_SUBSCRIBED);
    listeners.insert(&listener);
    if (notify_attach) listener.NotifyChange();
}
void Notifier::Unsubscribe(NotifyListener &listener) {
    listeners_it it=listeners.find(&listener);
    if (it==listeners.end()) throw_exception(ERR_NOT_SUBSCRIBED);
    listeners.erase(it);
}
void Notifier::LockChildren() {
    for(children_it it=children.begin();it!=children.end();++it) {
        (*it)->Lock();
    }
}
void Notifier::UnlockChildren() {
    for(children_it it=children.begin();it!=children.end();++it) {
        (*it)->Unlock();
    }
}
void Notifier::NotifyAll() {
    if (lock_level!=0) {
        if (lock_level<0) throw_exception(ERR_BAD_LOCK_LEVEL_RO);
        else throw_exception(ERR_BAD_LOCK_LEVEL);
    }
    lock_level=-1; // enter read only mode
    for(listeners_it it=listeners.begin();it!=listeners.end();++it) {
        (*it)->NotifyChange();
    }
    modified=false;
    lock_level=0; // leave readonly mode
}
int  Notifier::GetDeepLevel() const {
    int deep=0;
    for(children_cit it=children.begin();it!=children.end();++it) {
        int d=(*it)->GetDeepLevel();
        if (deep<d) deep=d;
    }
    return deep+1;
}
bool Notifier::IsDeepUnlocked() const {
    for(children_cit it=children.begin();it!=children.end();++it) {
        if (!(*it)->IsDeepUnlocked()) return false;
    }
    return true;
}

delegate<signature> - оператор объявления типа делегата с сигнатурой signature

delegate(function, оbject, (arg1, arg2, ... argN | _1, _2, ... _N) ) - оператор создания функционального объекта для делегата с сигнатурой function,
из функции function и (если function - член-функция) указателя на объект оbject
//короче std::bind-like синтаксис, пусть только дедукцией занимается компилятор, а не костыли вида std::bind

enum class EventType
{
  Test  = 0x0001,
};

struct Object
{
  void OnEvent(EventType event)
  {
    //1st subscriber callback
  }
};

void OnEvent(EventType event)
{
  //2nd subscriber callback
}

int main()
{
  Object object;
  delegate<void(EventType event)> d = delegate(&Object::OnEvent, &object); //делегат d инициализируется первым подписчиком
  d += delegate(OnEvent); //добавляется второй подписчик
  d += [](EventType event) { /*3rd subscriber callback*/ }; //добавляется третий подписчик

  d -= delegate(OnEvent); //второй, пожалуй, лишний
  d(EventType::Test); //вызов подписчиков 1 и 3: метода Object::OnEvent объекта object и анонимной функции
  //???
  //ENJOY!!1
}

struct S
{
  virtual void f()
};

struct C : S
{
  void f();
};

typedef void (### PF)();

S* s = new C;

PF pf = &s->f; // тут генерируется код, который лезет в vtbl и находит C::f()

pf(); // в pf лежат два указателя - адрес C::f и s. В результате произойдет вызов s->C::f()

// declspec_property.cpp
struct S {
   int i;
   void putprop(int j) { 
      i = j;
   }

   int getprop() {
      return i;
   }

   __declspec(property(get = getprop, put = putprop)) int the_prop;
};

int main() {
   S s;
   s.the_prop = 5;
   return s.the_prop;
}