Ошибка при работе с мютексом

template <class Type> class locked_stack
{
private:
    mutex m;
    stack<Type> stck;
public:
    locked_stack(){}
public: 
void lck_pop()
    {
        lock_guard<mutex>lock(m);
        if( !stck.empty())
            stck.pop();
    }
 
Type lck_top()
    {
        lock_guard<mutex>lock(m);
        return stck.top();
    }
 
Type& top_pop()
    {
        lock_guard<mutex>lock(m);
        if(stck.empty()) return NULL;
        Type obj = new Type();
        obj=top.stck();
        pop.stck();
        return obj; ///?????
    }
 
Type top_pop1()
    {
        lock_guard<mutex>lock(m);
        if(stck.empty()) return stck.top();
        Type obj=stck.top();
        stck.pop();
        return obj;
    }
 
void lck_push(Type obj)
    {
        lock_guard<mutex>lock(m);
        stck.push(obj);
    }
};

struct empty_stack: std::exception
{
    const char* what() const throw()
    {
        return "empty stack";
    }
    
};
 
template<typename T>
class threadsafe_stack
{
private:
    std::stack<T> data;
    mutable std::mutex m;
public:
    threadsafe_stack(){}
    threadsafe_stack(const threadsafe_stack& other)
    {
        std::lock_guard<std::mutex> lock(other.m);
        data=other.data;
    }
    threadsafe_stack& operator=(const threadsafe_stack&) = delete;
 
    void push(T new_value)
    {
        std::lock_guard<std::mutex> lock(m);
        data.push(new_value);
    }
    std::shared_ptr<T> pop()
    {
        std::lock_guard<std::mutex> lock(m);
        if(data.empty()) throw empty_stack();
        std::shared_ptr<T> const res(std::make_shared<T>(data.top()));
        data.pop();
        return res;
    }
    void pop(T& value)
    {
        std::lock_guard<std::mutex> lock(m);
        if(data.empty()) throw empty_stack();
        value=data.top();
        data.pop();
    }
    bool empty() const
    {
        std::lock_guard<std::mutex> lock(m);
        return data.empty();
    }
};