Forcing class methods use setter/getter of its own private member

Question

Below is a very simple example of a class. This class is used in a multi-threaded system and I want to ensure that every access to _x (also in a future extensions of the class by other developers) will be protected by mutex. One way doing so, is to put the mutex in the setter and getter and enforce using them also from the class methods, meaning, any direct access will generate a compilation error. Is it possible?

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;
};

I removed the C tag, methods are a feature found only in C++. Please tag carefully next time. (And no "Stackoverflow suggested it" is not a good excuse :P) — Borgleader, Aug 12 '15 at 12:24
Is it even something you'd want to do? If your code does anything more complex than `get/set` members, even simple calculations won't be thread-safe, such as `set_y( get_x() * get_x() );` to set y to the square of x. Even if your method can be implemented, that's not thread-safe. — Andrew Henle, Aug 12 '15 at 12:28

score 5 · Accepted Answer · answered Aug 12 '15 at 12:24

You can't do this directly.

One approach would be to create a base class MyBaseClass which has the member _x marked private and code the accessors, along with the mutual exclusion object, in MyBaseClass.

Then define class Myclass : public MyBaseClass

In your specific case though, using the considerably simpler std::atomic<int> _x might be adequate.

luk32 · Answer 2 · 2015-08-12T12:43:13.683

You cannot prevent class from accessing its members, which makes sense; how would you allow setter and getter to do it?

But you have a nice semantic concept of a guarded property. I would suggest making a template class like locked_variable<T> which encapsulates such a property. The original property would be private, and setter and getter would be public.

Something like:

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;
}

Then use it in MyClass. Depending on your needs maybe a move-setter would be appropriate.

Forcing class methods use setter/getter of its own private member

2 Answers2