Question

我最近偶然发现this proxy class使c ++原语成员“只读”（公开充当const引用，但私有非const）。这可能消除了对样板“吸气剂”的需求。代理类看起来像：

template <Container,Primitive>
class RO
{
  friend Container;
public:
                           inline operator Primitive() const             { return x; } 
  template<typename Other> inline bool  operator==(const Other& y) const { return x == y; }       
  template<typename Other> inline bool  operator!=(const Other& y) const { return x != y; }       
  template<typename Other> inline bool  operator< (const Other& y) const { return x < y; }        
  template<typename Other> inline bool  operator> (const Other& y) const { return x > y; }        
  template<typename Other> inline bool  operator<=(const Other& y) const { return x <= y; }       
  template<typename Other> inline bool  operator>=(const Other& y) const { return x >= y; }       
  template<typename Other> inline Other operator+ (const Other& y) const { return x + y; }        
  template<typename Other> inline Other operator- (const Other& y) const { return x - y; }
  ... // all other const operator overloads
protected:       
                           inline RO()                                  :x(){ }
  template<typename Other> inline RO(const Other& y)                    :x(y) { }
  template<typename Other> inline Primitive& operator= (const Other& y) { return x = y; }
  template<typename Other> inline Primitive& operator+=(const Other& y) { return x += y; }
  template<typename Other> inline Primitive& operator-=(const Other& y) { return x -= y; }
  template<typename Other> inline Primitive& operator*=(const Other& y) { return x *= y; }
  template<typename Other> inline Primitive& operator/=(const Other& y) { return x /= y; }
  ... // all other non-const operator overloads
                           inline Primitive* ptr()                      { return &x; }
                           inline Primitive& ref()                      { return x; }
                           inline const Primitive* const_ptr() const    { return &x; }
                           inline const Primitive& const_ref() const    { return x; }
  Primitive x;
};

如果我有一个扁平的类结构，这似乎可以正常工作：只有一些class A，其只读成员有RO个代理。但是，只要我有一些派生class B : public A，我就会遇到麻烦。我希望B读取和写入继承的类RO中定义的只读 A成员。但看到友谊是非继承的。我不知道该如何解决这个问题。同样适用于A的直接朋友：友谊是不可传递的。

是否存在可以写给朋友和派生类的“只读”代理的构造？

c ++中基元的受保护“只读”代理类

0 个答案: