How to simulate Rust's Mutex<Object> in C++? - c++

Question

Having an object and a mutex as 2 different variables is kinda error prone
MyObject myObject;
std::mutex myObjectMutex;
I tend to forget to lock it sometimes.
On Rust, a shared object is required to be inside a mutex:
std::sync::Mutex<MyObject> mySharedObject
So I have to use like this:
mySharedObject.lock().unwrap().objectMethod()
What would be the less error prone way to simulate something like this in C++ so I don't forget to lock it?
I thought of an std::tuple<std::mutex, MyObject> but it's not very good and I can forget to lock.

Answer 1

One way to do it is have your Mutex<T> only allow access to the contained T via a lambda:
template <typename T>
class Mutex {
private:
T value;
std::mutex mutex;
public:
// Fill out some constructors, probably some kind of emplacement constructor too.
// For simplicity of the example, this should be okay:
explicit Mutex(T value)
: value(std::move(value))
{}
template <typename F>
auto locked(F&& fn) const& -> std::invoke_result_t<F&&, T const&> {
// Lock the mutex while invoking the function.
// scoped_lock automatically unlocks at the end of the scope
std::scoped_lock lock(mutex);
return std::invoke(std::forward<F>(fn), value);
}
template <typename F>
auto locked(F&& fn) & -> std::invoke_result_t<F&&, T&> {
std::scoped_lock lock(mutex);
return std::invoke(std::forward<F>(fn), value);
}
// Can be worth repeating for const&& and && as well
};
Usage:
mySharedObject.locked([] (MyObject& obj) { return obj.objectMethod(); });
It's still possible to defeat this by stashing a reference to the obj inside a .locked(...) call and using the reference outside of .locked(...), but that would almost require deliberately trying to do the wrong thing.
Also, be aware that it being in a lambda can be quite limiting, as regular control flow no longer works (return doesn't return from the outer scope, continue/break don't work, etc.)

Answer 2

I think the following is very near regardless of the lifetime parameter
#include <atomic>
template<class T>
class MutexGuard{
T& inner;
std::atomic_flag & locked;
public:
MutexGuard(T& inner, std::atomic_flag& locked): inner{inner}, locked{locked}{}
operator T&()&{
return inner;
}
~MutexGuard(){
locked.clear();
}
};
template<class T>
class Mutex{
std::atomic_flag locked{false};
T inner;
public:
Mutex(T&& inner):inner{std::move(inner)}{}
Mutex(const T&) = delete;
MutexGuard<T> lock(){
while(locked.test_and_set());
return MutexGuard<T>{inner, locked};
}
};
Demo