这次这篇就讲一下怎么把之前定义的属性变平滑，我之前就说了，把能重载的运算符都重载一遍就行了

单目运算符：

#define OPERATOR1(op) \template
     
          \auto operator op (const Property
      
       & l) -> decltype(op l->get()){    \    return op l.get();    \}OPERATOR1(!);OPERATOR1(~);OPERATOR1(*);//不建议重载取地址运算符，如果你确实需要的话也可以重载//OPERATOR1(&);#undef OPERATOR1
      
     

双目运算符：

#define OPERATOR2(op) \template
     
       \auto operator op (const Property
      
       & l, const R& r) -> decltype(l.get() op r) { \    return l.get() op r; \} \template
       
         \auto operator op (const Property
        
         & l, const Property
         
          & r) -> decltype(l.get() op r.get()) { \    return l.get() op r.get(); \}     OPERATOR2(+);    OPERATOR2(-);    OPERATOR2(*);    OPERATOR2(/);    OPERATOR2(%);    OPERATOR2(>>);    OPERATOR2(<<);    OPERATOR2(|);    OPERATOR2(||);    OPERATOR2(&);    OPERATOR2(&&);    OPERATOR2(^);    OPERATOR2(>);    OPERATOR2(<);    OPERATOR2(>=);    OPERATOR2(<=);    OPERATOR2(==);    OPERATOR2(!=);#undef OPERATOR2
         
        
       
      
     

复合运算符：

#define OPERATOREX(op) \template
     
       \Property
      
       & operator op##=(Property
       
        &l, const R& r) { \    auto v=l.get();\    v op##= r;\    l.set(v); \    return l; \} \template
        
          \Property
         
          & operator op##=(Property
          
           &l, const Property
           
            & r) { \ auto v=l.get();\ v op##= r.get();\ l.set(v); \ return l; \} OPERATOREX(+); OPERATOREX(-); OPERATOREX(*); OPERATOREX(/); OPERATOREX(%); OPERATOREX(>>); OPERATOREX(<<); OPERATOREX(|); OPERATOREX(&); OPERATOREX(^);#undef OPERATOREX
           
          
         
        
       
      
     

 自增自减运算符：

　　template
     
          auto operator++(Property
      
       & l, int) -> decltype(l.get()++) {        auto x = l.get();        auto ret = x++;        l.set(x);        return ret;    }    template
       
            auto operator++(Property
        
         & l) -> decltype(++l.get()) {        auto x = l.get();        ++x;        l.set(x);        return x;    }    template
         
              auto operator--(Property
          
           & l, int) -> decltype(l.get()--) { auto x = l.get(); auto ret = x--; l.set(ret); return ret; } template
           
             auto operator--(Property
            
             & l) -> decltype(--l.get()) { auto x = l.get(); --x; l.set(x); return x; }
            
           
          
         
        
       
      
     

重载中括号（写在类里面）

//作左值template 
     
      auto operator[](I i) -> decltype(_value[i])&{    return _value[i];}//作右值template 
      
       auto operator[](I i) const -> const decltype(_value[i])& {    return _value[i];}
      
     

 

 重载箭头（写在类里面）

const T operator->() const{    return get();}T operator->() {    return get();}

 

重载圆括号（写在类里面）

template
     
      auto operator()(Types...args) -> decltype(_value(args...)){    return _value(args...);}template
      
       auto operator()(Types...args) const -> decltype(_value(args...)) {    return _value(args...);}
      
     

 

好了，现在能重载的运算符就都重载了，剩下还有一些不能重载的运算符，那些也无能为力了，不过除了点号"."其余要么不常用，要么没重载的必要，而点号禁止重载我们也没办法，但是我们可以重载箭头运算符，我们可以在被包装类型不是指针型的时候用箭头进行被包装类型的成员调用，点号进行属性类型的成员调用。而被包装类型时指针时保持原含义。

那么上面的重载箭头需要改改了，运用模板类型的特化：

template
     
      class Property{...    const T* operator->() const{        return &get();    }    T* operator->() {        return &get();    }...}template
      
       class Property<_T*>{...    typedef _T* T;...    const T operator->() const{        return get();    }    T operator->() {        return get();    }...}
      
     

 

不过这种写法有个缺点，就是如果被包装的类型重载了箭头运算符，那么将无法调用，虽然这种情况较少，但到底怎么重载箭头运算符还是看个人喜好吧。

关于属性的东西就暂时这样了，当然，还没完，还记得C#有个依赖项属性么，还有属性绑定之类的东西，不过那个东西需要处理事件，所以下一章不出意外的话就是类似Event或者Delegate之类的东西的实现。