Question

我想创建一个用于存储数据的对象，限制读/写访问。

例如：

OBJ obj1;
OBJ obj2;

// DataOBJ has 2 methods : read() and write()
DataOBJ dataOBJ1 (obj1);

使用上面的代码，我希望obj1访问write()方法，而其他OBJ个对象（在这种情况下为obj2）应仅访问read()方法。

是否可以创建DataOBJ类来限制这样的权限？

经典的“吸气剂装置”并不适合我的需要。

感谢。

Answer 1

我认为最好的办法是为read和write方法定义一个接口，并传递一个只读的包装器对象（通过抛出异常来实现write）而不是任何不应该获得写入权限的人的真实对象。

请注意，这并不能阻止恶意代码解析您的包装器对象 - 如果您想这样做，DataOBJ应该生活在与只读客户端不同的进程中，并且RPC机制位于流程边界需要强制执行访问权限。

Answer 2

您可以使用一组不同的类来执行此操作，“禁用”方法会抛出异常。

类似的东西：

struct DataInterface
{
    virtual void read(...) = 0;
    virtual void write(...) = 0;
};

struct DataReadOnly : public DataInterface
{
    void read(...) { ... }
    void write(...) { throw write_not_allowed(); }
};

struct DataReadWrite : public DataInterface
{
    void read(...) { ... }
    void write(...) { ... }
};

Answer 3

我有一个想法，可能是不好的做法。不过，我会回答这个问题时会想到一些问题：

静态变量。

class Foo
{
    private:

      int y;
    public:
     Foo();
     ~Foo();
     void set(int);
     int get(void);
};

Foo::Foo()
{
   static int c = 0;
   ++c;

   y = c;
}

Foo::~Foo()
{
    --y;
}

int Foo::get(void )
{
  if(y == 1)
    return y;
  else
    //do return an error code or something
}

void Foo::set(int r)
{
  if(y== 2)
   y = r;
  else
   //Do nothing
}

int main()
{
    Foo *x1 = new Foo(); //Gets assigned 1
    Foo *x2 = new Foo(); //Gets assigned 2


    return 0;
}

编辑：为了澄清 - 我省略了删除，以及正确减少破坏的逻辑，因为我的答案是在那里散布一个想法，而不是编写OP。

Answer 4

您可以通过模板全局引用obj1 / obj2控制对写入/读取的访问，如下例所示：

class OBJ {
};

OBJ obj1;
OBJ obj2;

// RESTRICTED ACCESS
class DataOBJBase {
protected:
   void write() {}
   void read() {}
};

template <OBJ&>
class DataOBJ;

// ALLOW WRITE IF FOR obj1
template <>
class DataOBJ<obj1> : public DataOBJBase {
public:
   using DataOBJBase::write;
};

// ALLOW READ IF FOR obj2
template <>
class DataOBJ<obj2> : public DataOBJBase {
public:
   using DataOBJBase::read;
};


int main() {
   DataOBJ<obj1> dobj1;
   dobj1.write(); // cannot read
   DataOBJ<obj2> dobj2;
   dobj2.read(); // cannot write
}

具体的“getter setter”专用对象

4 个答案: