Mutex as a container in C++

my_mutex.cpp

#include <iostream>
#include <mutex>
#include <thread>
#include <vector>

template <typename T> class MyMutex;
template <typename T> class MyMutexGuard;

template <typename T> class MyMutex {
  friend class MyMutexGuard<T>;

private:
  std::mutex m_mutex;
  T m_data;

public:
  // Construct by defaulting, copying, or moving a T.
  MyMutex() {}
  MyMutex(const T &data) : m_data(data) {}
  MyMutex(T &&data) : m_data(std::move(data)) {}

  // Obtain a lock guard, which is also a smart pointer to T.
  MyMutexGuard<T> lock() {
    return {this};
  }
};

template <typename T> class MyMutexGuard {
  friend class MyMutex<T>;

private:
  std::unique_lock<std::mutex> m_guard;
  T *m_data_ptr;
  MyMutexGuard(MyMutex<T> *mymutex)
      : m_guard(mymutex->m_mutex), m_data_ptr(&mymutex->m_data) {}

public:
  T &operator*() {
    return *m_data_ptr;
  }
  T operator->() {
    return m_data_ptr;
  }
};

int main() {
  MyMutex<std::vector<int>> myvec;

  // Spawn a couple threads to append to the vector.
  std::vector<std::thread> thread_handles;
  for (int i = 0; i < 2; i++) {
    std::thread thread_handle([&]() {
      // On each thread, append a million ints.
      for (int n = 0; n < 1'000'000; n++) {
        // BUG: This retains a reference without retaining the lock.
        std::vector<int> &vec_ref = *myvec.lock();
        vec_ref.push_back(n);
      }
    });
    thread_handles.push_back(std::move(thread_handle));
  }
  for (auto &handle : thread_handles) {
    handle.join();
  }
}