template<class Guard, class Data>
struct guarded {
    Guard g;
    Data d;

    template<size_t I> auto& get() requires (I==0) {
        return d;
    }
    template<size_t I> auto& get() const requires (I==0) {
        return d;
    }
};

namespace std {
template<class G, class D> struct tuple_size<guarded<G,D>> {
    static constexpr size_t value = 1;
};
template<class G, class D> struct tuple_element<0, guarded<G,D>> {
    using type = D&;
};
}  // namespace std

struct lock {
    lock() { std::cout << "lock!" << std::endl; }
    lock(const lock&) = delete;
    ~lock() { std::cout << "unlock!" << std::endl; }
};

struct value {
    void touch() { std::cout << "touch " << this << std::endl; }
};

int main() {
    value x;
    std::cout << "value " << &x << std::endl;

    using G = guarded<lock,value&>;

    std::cout << "===" << std::endl;
    {
        G{{}, x}.d.touch();
    }
    std::cout << "===" << std::endl;
    {
        auto [y] = G{{}, x};
        y.touch();
    }
    std::cout << "===" << std::endl;

    auto g = [&x]() { return G{{}, x}; };
    {
        auto [y] = g();
        y.touch();
    }
    std::cout << "===" << std::endl;
}

#include <type_traits>
#include <iostream>
#include <functional>
#include <mutex>


class TS
{
  public:
    TS(int x) : m_x{x}{};
    std::pair<std::lock_guard<std::mutex>, int&> Ref()
    {
        return std::pair<std::lock_guard<std::mutex>, int&>{m_mtx, m_x};
    }
    int GetX() 
    {
        std::lock_guard lock(m_mtx);
        return m_x;
    };
  private:
    std::mutex m_mtx{};  
    int m_x{};
};

int main()
{
    TS ts{1};
    {
      auto [lock, x] = ts.Ref();
      x+=1;
    }
    ts.Ref().second++;
    std::cout << ts.GetX() << std::endl;
    return 0;
}

A>Другой вопрос в том, что если из modify() вылетит птичка Т.е. в первую очередь это код с разной семантикой, а не простой и сложный.

std::lock_guard lock{this->mutex};

auto& data = ts.Ref().second;
++data; // oops

#include <type_traits>
#include <iostream>
#include <functional>
#include <mutex>


int main()
{
    int a = 1;
    int b = 2;
    
    std::pair<int&, int&> ab{a,b};

    auto [a_, b_] = ab;
    a_ += 8;

    std::cout << "a=" << a << std::endl;
    std::cout << std::boolalpha;
    std::cout << "std::is_same<int&, decltype(a_)>::value = " << std::is_same<int&, decltype(a_)>::value << std::endl;

    return 0;
}

Given the type Ti designated by std​::​tuple_­element<i, E>​::​type

auto [lock, x] = ts.Ref();

auto copy = ts.Ref();
auto& lock = copy.first;
auto& x = copy.second;

BFE>>- так это и есть ссылка для std::pair<int&, int&>

    int a = 1;
    int b = 2;
    
    std::pair<int&, int&> ab{a,b};

    auto [a_, b_] = ab;
    a_ += 8;

template<typename T>
class SafeData
{
   public:
      ...
      T Get()
      {
         std::lock_guard<std::mutex> lock(mtx);
         return data;
      }
      void Set(const T& value)
      {
         std::lock_guard<std::mutex> lock(mtx);
         data = value;
      }

      template<class Fn>
      auto Access(Fn&& fnAccess)
      {
         std::lock_guard<std::mutex> lock( mtx );
         return const_access(std::forward<Fn>(fnAccess));
      }

      template<class Fn>
      auto Transform(Fn&& op)
      {
         std::lock_guard<std::mutex> lock( mtx );
         return op(data);
      }
   private:
      std::mutex  mtx;
      T           data;
};

    std::pair<std::lock_guard<std::mutex>, T&> LockWrite()
    {
      return std::pair<std::lock_guard<std::mutex>, int&>{mtx, data};
    }

    std::pair<std::lock_guard<std::mutex>, const T&> LockRead()
    {
      return std::pair<std::lock_guard<std::mutex>, const int&>{mtx, data};
    }

К>auto [lock, x] = ts.Ref();

К>auto copy = ts.Ref();
К>auto& lock = copy.first;
К>auto& x = copy.second;
К>

void c::f() {
  std::lock_guard lock{this->mutex};
  this->data.modify();
}

void c::f() {
  this->mutex.lock();
  this->data.modify();
  this->mutex.unlock();
}

auto [x, y] = foo();

[x]() {} ();

auto hidden = foo();
decltype(auto) x = std::get<0>(hidden);
decltype(auto) y = std::get<1>(hidden);

[auto x, auto& y] = foo();

void c::f() {
  this->mutex.lock();
  this->data.modify();
  this->mutex.unlock();
}

template<typename Obj>
void modify(Obj & obj) {
  std::lock_guard lock{obj.lock_}; // ХЗ что там за тип mutex-а, но нам фиолетово.
  ...
}

template<typename Obj>
void modify(Obj & obj) {
  std::lock_guard< std::decay_t<decltype(obj.lock_)> > lock{obj.lock_}; // ХЗ что там за тип mutex-а,
                                                                        // но приходится выяснять это
                                                                        // чтобы удовлетворить компилятор.
  ...
}

class data_holder {
  std::mutex lock_;
  ...
public:
  void update(int x) {
    std::lock_guard lock{lock_};
    ...
  }
  int get() {
    std::lock_guard lock{lock_};
    return ...;
  }
};

class data_holder {
  some_spin_lock lock_;
  ...
  // Все остальное остается без изменений.
};

A>Ну это стрёмный конечно поход, но очень широко распространенный. Полно внутриконторских гайдлайнов, ограничивающих использование тех или иных фич в языке. Я даже не могу кого-то в этом сильно винить — людям надо выкатывать работающий код с теми программистами, которые у них есть, бюджета и времени на дополнительное обучение у них тоже нет. Им виднее

Technologies: C++14 (primary) and python (scripting, automation, CI) on Linux (Qnx on-vehicle). Bonus points if you know Bazel.