#include <stdio.h>

class MyLock
{
public:
    MyLock() {}
    ~MyLock() {}

    void Lock()
    {
        puts(__FUNCTION__);
    }

    void Unlock()
    {
        puts(__FUNCTION__);
    }

private:
    /// @name Not copyable, not assignable
    /// @{
    MyLock(const MyLock&);
    MyLock& operator=(const MyLock&);
    /// @}
};

class ScopeLocker
{
public:
    virtual void Lock() const = 0;
    virtual void Unlock() const = 0;
};

template<typename T>
class ConcreteScopeLocker : public ScopeLocker
{
public:
    ConcreteScopeLocker(T& lock) : m_lock(lock)
    {
        Lock();
    }

    ~ConcreteScopeLocker()
    {
        Unlock();
    }

    /// @fn ConcreteScopeLocker(const ConcreteScopeLocker&)
    /// Copy constructor is implicit

    virtual void Lock() const
    {
        m_lock.Lock();
    }

    virtual void Unlock() const
    {
        m_lock.Unlock();
    }

private:
    ConcreteScopeLocker& operator=(const ConcreteScopeLocker&);

    mutable T& m_lock;
};

template<typename T>
ConcreteScopeLocker<T> LockScope(T& lock)
{
    return ConcreteScopeLocker<T>(lock);
}

int main()
{
    {
        MyLock ml;
        const ScopeLocker& lockScope = LockScope(ml); // Не нужно указывать конкретный тип переменной

        int i = 1;
        puts("Inside block");

        lockScope.Unlock();


        lockScope.Lock();
    }

    return 0;
}

Lock
Unlock
Inside block
Unlock
Lock
Unlock