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

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

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

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