Object properties for C++

 

说明就劳烦大家点击下面的链接,让希腊小伙来解释下

http://www.codeproject.com/KB/library/cpp_object_properties.aspx

 

咳咳

编译了上面希腊小伙的代码...

没编译过去.VS2005/2008

 

一番"#$%&*!sasd&^&*()"之后

 

于是乎编过了.

 

原理比较简单,都在酒里(都在代码里 :) )

贴出来....能用就用.

 

 

有哥们有新的建议.欢迎交流...

哈哈

 

 

 

   22 

   23         class variable {};

   24         class interface {};

   25         class read_write {};

   26         class read_only {};

   27         class write_only {};

   28 

   29         template <class C, class T, class A, class S>

   30         class _property

   31         {

   32         };

   33 

   34         template <class C, class T>

   35         class _property<C,T,read_write,variable>

   36         {

   37         public:

   38             _property<C,T,read_write,variable>(C* o,void (C::*m)(),const T& v = T())

   39                 :object_(o)

   40                 ,method_(m)

   41                 ,value_(v)

   42             {

   43             }

   44             const T& get() const

   45             {

   46                 return value_;

   47             }

   48             void set(const T& v)

   49             {

   50                 if (v == value_) return;

   51                 value_ = v;

   52                 if (0!=method_)

   53                 {

   54                     (object_->*method_)();

   55                 }

   56             }

   57         private:

   58             C* object_;

   59             void (C::*method_)();

   60             T value_;

   61         };

   62 

   63         template <class C, class T>

   64         class _property<C,T,read_write,interface>

   65         {

   66         public:

   67             _property<C,T,read_write,interface>

   68                 (C* o, const T&(C::*g)() const, void (C::*s)(const T&))

   69                 :object_(o)

   70                 ,getter_(g)

   71                 ,setter_(s)

   72             {

   73             }

   74             const T& get() const

   75             {

   76                 return (object_->*getter_)();

   77             }

   78             void set(const T& v)

   79             {

   80                 (object_->*setter_)(v);

   81             }

   82         private:

   83             C* object_;

   84             const T& (C::*getter_)() const;

   85             void (C::*setter_)(const T&);

   86         };

   87 

   88 

   89         template <class C, class T>

   90         class _property<C,T,read_only,variable>

   91         {

   92         public:

   93             _property<C,T,read_only,variable>(const T& v = T())

   94                 :value_(v)

   95             {

   96             }

   97             const T& get() const

   98             {

   99                 return value_;

  100             }

  101         private:

  102             T value_;

  103         };

  104 

  105 

  106         template <class C, class T>

  107         class _property<C,T,read_only,interface>

  108         {

  109         public:

  110             _property<C,T,read_only,interface>(C* o, const T& (C::*g)() const)

  111                 :object_(o)

  112                 ,getter_(g)

  113             {

  114             }

  115             const T& get() const

  116             {

  117                 return (object_->*getter_)();

  118             }

  119         private:

  120             C* object_;

  121             const T& (C::*getter_)() const;

  122         };

  123 

  124 

  125         template <class C, class T>

  126         class _property<C,T,write_only,variable>

  127         {

  128         public:

  129             _property<C,T,write_only,variable>(C* o, void (C::*m)(), const T& v = T())

  130                 :object_(o)

  131                 ,method_(m)

  132                 ,value_(v)

  133             {

  134             }

  135             void set(const T& v)

  136             {

  137                 if (v == value_) return;

  138                 value_ = v;

  139                 if (0!=method_)

  140                 {

  141                     (object_->*method_)();

  142                 }

  143             }

  144         private:

  145             C* object_;

  146             void (C::*method_)();

  147             T value_;

  148         };

  149 

  150         template <class C, class T>

  151         class _property<C,T,write_only,interface>

  152         {

  153         public:

  154             _property<C,T,write_only,interface>(C* o, void (C::*s)(const T&))

  155                 :object_(o)

  156                 ,setter_(s)

  157             {

  158             }

  159             void set(const T& v)

  160             {

  161                 (object_->*setter_)(v);

  162             }

  163         private:

  164             C* object_;

  165             void (C::*setter_)(const T&);

  166         };

  167 

  168         template <class C, class T, class A = read_write, class S = variable>

  169         class property : public _property<C,T,A,S>

  170         {

  171         public:

  172             property(C* o, void (C::*m)(), const T& v = T())

  173                 :_property(o, m, v)

  174             {

  175             }

  176             property(C* o, const T &(C::*g)() const, void (C::*s)(const T&))

  177                 :_property(o, g, s)

  178             {

  179             }

  180             property(const T& v = T())

  181                 :_property(v)

  182             {

  183             }

  184             property(C* o, const T& (C::*g)() const)

  185                 :_property(o, g)

  186             {

  187             }

  188             property(C* o, void (C::*s)(const T&))

  189                 :_property(o, s)

  190             {

  191             }

  192             operator const T &() const 

  193             {

  194                 return get();

  195             }

  196             const T &operator () () const

  197             {

  198                 return get();

  199             }

  200             property<C, T, A, S>& operator = (const T &v)

  201             {

  202                 set(v);

  203                 return *this;

  204             }

  205             template <class A1, class S1>

  206             property<C, T, A, S>& operator = (const property<C, T, A1, S1> &p)

  207             {

  208                 set(p.get());

  209                 return *this;

  210             }

  211         private:

  212             property(const property<C, T, A, S> &p);

  213         };