Question

以下是一个非常简单的类示例。这个类用在一个多线程系统中，我想确保每次访问_x（以及其他开发人员将来的类扩展）都将受到互斥锁的保护。这样做的一种方法是将互斥锁置于setter和getter中，并从类方法中强制使用它们，这意味着任何直接访问都会产生编译错误。有可能吗？

class Myclass
{
public:
   int getX() const
   {
      boost::mutex::scoped_lock lock(_lock);
      return _x;
   }

   void setX(int x)
   {
      boost::mutex::scoped_lock lock(_lock);
      _x = x;
   }

   void foo()
   {
      //accessing _x; 
   }
private:
   mutable boost::mutex _lock;
   int _x;
};

Answer 1

你不能直接这样做。

一种方法是创建一个基础class MyBaseClass，其成员_x标记为private，并在MyBaseClass中对访问者以及互斥对象进行编码。

然后定义class Myclass : public MyBaseClass

在您的具体情况下，使用相当简单的std::atomic<int> _x可能就足够了。

Answer 2

你无法阻止类访问其成员，这是有道理的;你怎么能让setter和getter去做呢？

但是你有一个很好的保护财产的语义概念。我建议制作一个类似locked_variable<T>的模板类，它封装了这样的属性。原始属性为私有属性，setter和getter为public。

类似的东西：

template <typename T>
class locked_property {
public:
  locked_property(boost::mutex& lock) : _lock(lock) {}

  void set(const &T value) {
    boost::mutex::scoped_lock lock(_lock);
    _val = value;
  }

  // you return a copy, maybe a reference or const ref should be used here
  T get() {
    boost::mutex::scoped_lock lock(_lock);
    return _val;
  }

private:
  boost::mutex& _lock;
  T val;
}

然后在MyClass中使用它。根据您的需要，移动设定器可能是合适的。

强制类方法使用自己的私有成员

2 个答案: