C++ 中的只写参考？

Question

有没有办法编写对对象的只写引用？例如，假设有一个互斥类：

template <class T> class mutex {
protected:
   T _data;
public:
   mutex();
   void lock(); //locks the mutex
   void unlock(); //unlocks the mutex
   T& data(); //returns a reference to the data, or throws an exception if lock is unowned
};

是否有一种方法可以保证人们不能这样做：

mutex<type> foo;
type& ref;
foo.lock();
foo.data().do_stuff();
ref = foo.data();
foo.unlock();
//I have a unguarded reference to foo now

另一方面，它是否值得？我知道有些人假设程序员不会故意破坏系统，但是，为什么我们首先要有私有变量，嗯？直接说它是“未定义的行为”就好了，但这似乎有点太不安全了。

编辑：好的，我理解 setter 例程的想法，但是这是如何实现的呢？

mutex<vector<int> > foo;
foo.lock();
for (int i=0; i < 10; i++) {
   foo.data().push_back(i);
}

foo.unlock(); 使用设置例程将需要每次写入都有一个副本：

mutex<vector<int> > foo;
foo.lock();
for (int i=0; i < 10; i++) {
   vector<int> copy = foo.read();
   copy.push_back(i);
   foo.write(copy);
}

虽然您可以在这种特定情况下进行简单的优化，但如果几个不同的线程都在推送元素，甚至可能擦除一些元素，这可能会导致相当多的多余内存复制（即每个关键部分复制一个）。

Answer 1

是的，您可以创建一个包装类，该包装类在调用解锁时变得无效并返回包装器，而不是返回引用，并且您可以重载其赋值运算符以分配给引用。诀窍在于，您需要保留对包装器内部数据的引用，以便在释放锁之前调用解锁时，使您创建的任何包装器无效。

Answer 2

区分 getter 和 setter 的常见方法是通过对象的 const 性：

template <class T> class mutex {
public:
   mutex();
   void lock();
   void unlock();
         T& data();       // cannot be invoked for const objects
   const T& data() const; // can be invoked for const objects
protected:
   T _data;
};

现在，如果您想具有只读访问权限，请将互斥体设置为 const：

void read_data(const mutex< std::vector<int> >& data)
{
   // only const member functions can be called here
}

您可以将非常量对象绑定到 const 引用

// ...
mutex< std::vector<int> > data;
data.lock();
read_data(data);
data.unlock();
// ...

---

： lock() 和 unlock() 函数在面对异常时本质上是不安全的：

void f(const mutex< std::vector<int> >& data)
{
  data.lock();
  data.data().push_back(42); // might throw exception
  data.unlock(); // will never be reached in push_back() throws
}

解决这个问题的常用方法是RAII（资源获取就是初始化）：

template <class T> class lock;

template <class T> class mutex {
public:
   mutex();
protected:
   T _data;
private:
   friend class lock<T>;
   T& data();
   void lock();
   void unlock();
};

template <class T> class lock {
public:
  template <class T> {
  lock(mutex<T>& m) m_(m) {m_.lock();}
  ~lock()                 {m_.unlock();}

         T& data()        {return m_.data();}
   const T& data() const  {return m_.data()}
private:
  mutex<T>& m_;
};

请注意，我还将访问器函数移到了锁类中，这样就无法访问未锁定的数据。

你可以这样使用它：

void f(const mutex< std::vector<int> >& data)
{
  {
    lock< std::vector<int> > lock_1(data);
    std::cout << lock1.data()[0]; // fine, too
    lock1.data().push_back(42);   // fine
  }
  {
    const lock< std::vector<int> > lock_2(data); // note the const
    std::cout << lock1.data()[0];  // fine, too
    // lock1.data().push_back(42); // compiler error
  }
}

Answer 3

您可以将数据封装为私有数据并公开写入例程。在该例程中，您可以锁定互斥锁，从而获得与您所要拍摄的内容类似的行为。

Answer 4

您可以按如下方式使用成员函数：

void set_data(const T& var);

这就是在 C++ 中应用只写访问的方式。

Answer 5

不。没有办法保证在 C++ 等不安全语言中读写内存的任何事情，其中​​所有内存都被视为一个大数组。

---

[编辑] 不确定为什么所有的反对票都投了；这是正确且相关的。

在安全语言（例如 Java 或 C#）中，您当然可以保证正确实现的不可变类型将保持不可变。在 C++ 中永远无法做出这样的保证。

与其说担心的是恶意用户，不如说担心的是意外的无效指针；我曾参与过 C++ 项目，其中不可变类型由于完全不相关的代码中的无效指针而发生了变异，从而导致极难以追踪的错误。这种保证——只有安全语言才能做到——既有用又重要。